Bonjour les 0

Voilà j'ai une toute petite hiérarchie
une classe Administrateur et utilisateur héritant tout deux de Personne.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Generique
{
    public abstract class Personne
    {
        protected string _Nom;
        protected string _Prenom;
        protected string _Fonction;

        public Personne(){}
        public abstract void Affiche();
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Generique
{
    public class Administrateur : Personne
    {
        public Administrateur()
        {
            _Nom = "Dubois";
            _Prenom = "Alain";
            _Fonction = "Administrateur";
        }

        public override void Affiche()
        {
            System.Console.Out.WriteLine("Nom : " + _Nom);
            System.Console.Out.WriteLine("Prenom : " + _Prenom);
            System.Console.Out.WriteLine("Fonction : " + _Fonction);
            System.Console.Out.WriteLine();
        }

        public void identification()
        {
            System.Console.Out.WriteLine(_Nom + "#" + _Prenom + "#" + _Fonction);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Generique
{
    public class Utilisateur : Personne
    {
        public Utilisateur() : base()
        {
            _Nom = "Dupont";
            _Prenom = "Alain";
            _Fonction = "Utilisateur";
        }



        public override void Affiche()
        {
            System.Console.Out.WriteLine("Nom : " + _Nom);
            System.Console.Out.WriteLine("Prenom : " + _Prenom);
            System.Console.Out.WriteLine("Fonction : " + _Fonction);
            System.Console.Out.WriteLine();

        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Generique
{
    class Program
    {
        static void Main(string[] args)
        {
            List<Personne> Personnes = new List<Personne>();

            Personnes.Add(new Administrateur());
            Personnes.Add(new Utilisateur());
            Personnes.Add(new Utilisateur());
            Personnes.Add(new Administrateur());

        }
    }
}

Maintenant je souhaite récupérer l'élément 0 et afficher son identification mais un problème s'impose car si je tape

Personnes.ElementAt(0)

, je retourne une personne alors ce qui m'intéresse c'est de retourner un administrateur, est ce que je dois faire un casting ?

Merci de vos réponses

oui

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Generique
{
    class Program
    {
        static void Main(string[] args)
        {
            List<Personne> Personnes = new List<Personne>();

            Personnes.Add(new Administrateur());
            Personnes.Add(new Utilisateur());
            Personnes.Add(new Utilisateur());
            Personnes.Add(new Administrateur());
            
            Administrateur a = (Administrateur)Personnes.ElementAt(0);

        }
    }
}

A moins que tu ne sois sûr que l'élément en position 0 est un Administrateur, utilise plutôt as :

var admin = Personnes[0] as Administrateur;
if(admin != null)
{
    // faire quelque chose
}
else
{
    // La personne à l'index 0 n'est pas un administrateur
}

PS :

• Pourquoi indiquer System.Console.Out.WriteLine et pas Console.WriteLine ? Ton code est inutilement long...
• ElementAt est surtout utile pour certains types d'Enumerable ; tu as une List, tu peux donc utiliser les crochets []
• Ta méthode "Affiche" est la même pour Utilisateur et Administrateur ; tu pourrais directement l'inclure dans Personne.

Tu peux remplacer le var par Administrateur non?

Justement le but de var c'est de pas faire de répétitions inutiles...

Dictionary<string, Func<List<string>, string, int>> dic = new Dictionary<string, Func<List<string>, string, int>>();
// ou
var dic = new Dictionary<string, Func<List<string>, string, int>>();

ok merci mais niveau temps d’exécution ça ralentis pas?

Attention, faut pas confondre var en C# avec var dans des langages comme JavaScript.
En C#, le type de var est déterminé à la compilation :

var n = 42; // int
var s = "Hello, World"; // string
var dic = new Dictionary<string, int>(); // Dictionary<string, int>

Après, impossible de le changer :

var n = 42; // n est un int
n = "Hello, World"; // ne compile pas

Il n'y a aucune différence entre une déclaration avec var et une avec le type, pour peu que ce dernier soit explicite :

var s = "Hello, ";
string s2 = "World";
var result = s + s2;

Mais, comme je l'ai dit, le type doit être explicite. Il est impossible de faire ceci :

var n; // erreur
n = 42;

Dans cet exemple, le compilateur ne peut pas savoir le type de n au moment où il est déclaré, ça ne marche donc pas.

Var est d'ailleurs le seul moyen d'utiliser une fonctionnalité du C# assez spéciale, les types anonymes :

var john = new { Name="John", LastName="Doe"};

Ce code crée un type sans nom possédant une propriété "Name" de type string et une "LastName" de type string.

A noter que :

Citation : unknown77

Maintenant je souhaite récupérer l'élément 0 et afficher son identification mais un problème s'impose car si je tape

Personnes.ElementAt(0)

, je retourne une personne alors ce qui m'intéresse c'est de retourner un administrateur, est ce que je dois faire un casting ?

Tu es ici dans un cas typique où le polymorphisme est à considérer. Tu gères une collection de Personnes, et tu sais que chaque personne est capable de s'identifier, qu'il s'agisse d'un Utilisateur ou d'un Administrateur - même si la façon de s'identifier peut être différente, mais ça ça n'a pas d'importance : ils répondent tous au même message "identifie-toi".

Donc ici typiquement ta classe Personnage devrait avoir une méthode virtuelle ou abstraite "Identification" qui sera "overridée" par Utilisateur et Administrateur. De cette manière l'appel à cette méthode peut se faire sans casting sur tout élément de ta collection de Personnes.

En conclusion, chaque fois que tu gères une collection d'objets de types différents et que tu dois recourir au casting pour les manipuler, il y a des chances que tu passes à coté d'un polymorphisme.

Je pense avoir confondu avec dynamic