Comment utiliser les types anonymes en C #

Un type anonyme est un type qui n'a pas de nom. Vous pouvez utiliser un type anonyme pour encapsuler un ensemble de propriétés en lecture seule dans une seule unité - et vous n'avez pas besoin de définir le type anonyme au préalable. Cet article explique ce que sont les types anonymes, pourquoi ils sont importants et comment nous pouvons travailler avec des types anonymes en C #.

Pour utiliser les exemples de code fournis dans cet article, vous devez disposer de Visual Studio 2019 installé sur votre système. Si vous n'en avez pas déjà une copie, vous pouvez télécharger Visual Studio 2019 ici. 

Créer un projet d'application console dans Visual Studio

Tout d'abord, créons un projet d'application console .NET Core dans Visual Studio. En supposant que Visual Studio 2019 est installé sur votre système, suivez les étapes décrites ci-dessous pour créer un nouveau projet d'application console .NET Core dans Visual Studio.

  1. Lancez l'IDE de Visual Studio.
  2. Cliquez sur "Créer un nouveau projet".
  3. Dans la fenêtre «Créer un nouveau projet», sélectionnez «Application console (.NET Core)» dans la liste des modèles affichés.
  4. Cliquez sur Suivant.
  5. Dans la fenêtre «Configurer votre nouveau projet» ci-dessous, spécifiez le nom et l'emplacement du nouveau projet.
  6. Cliquez sur Créer.

Cela créera un nouveau projet d'application console .NET Core dans Visual Studio 2019. Nous utiliserons ce projet dans les sections suivantes de cet article pour illustrer comment nous pouvons travailler avec des types anonymes en C #.

Comprendre les types anonymes en C #

Un type anonyme est essentiellement un type de référence et peut être défini à l'aide du mot-clé var. Vous pouvez avoir une ou plusieurs propriétés dans un type anonyme, mais elles sont toutes en lecture seule. Contrairement à une classe C #, un type anonyme ne peut pas avoir de champ ou de méthode - il ne peut avoir que des propriétés.

Vous pouvez accéder à un type anonyme ou à ses propriétés dans la méthode où le type anonyme a été défini. En d'autres termes, l'accessibilité d'un type anonyme est limitée à la portée où il a été défini.

Utilisez un type anonyme en C #

Voyons maintenant un peu de code. Considérez le type anonyme suivant.

var auteur = nouveau

{

  FirstName = "Joydip",

  LastName = "Kanjilal",

  Adresse = "Hyderabad, INDE"

};

Dans l'extrait de code précédent, author est le nom d'une instance d'un type anonyme créée à l'aide du nouveau mot clé. (Le nom du type anonyme lui-même n'est connu que du compilateur.) Ce type anonyme contient trois propriétés, à savoir FirstName, LastName et Address. Toutes ces propriétés sont du type chaîne. Notez que lorsque vous travaillez avec un type anonyme, vous n'avez pas à spécifier le type d'une propriété avant de l'initialiser.

Vous pouvez utiliser l'extrait de code suivant pour accéder aux trois propriétés du type anonyme ci-dessus.

Console.WriteLine ("Nom: {0} {1}", auteur.Prénom, auteur.LastName);

Console.WriteLine ("Adresse: {0}", author.Address);

Utilisez un type anonyme imbriqué en C #

Les types anonymes peuvent également être imbriqués. Autrement dit, vous pouvez avoir un type anonyme comme propriété dans un autre type anonyme. Voici un exemple qui illustre cela.

var auteur = nouveau

{

  FirstName = "Joydip",

  LastName = "Kanjilal",

  Address = new {City = "Hyderabad", Country = "INDIA"}

};

Vous pouvez accéder aux propriétés de ce type anonyme imbriqué comme indiqué dans l'extrait de code ci-dessous.

Console.WriteLine ("Nom: {0} {1}", auteur.Prénom, auteur.LastName);

Console.WriteLine ("Adresse: {0}", author.Address.City);

Le programme complet est donné ci-dessous pour votre référence.

static void Main (string [] args)

{

  var auteur = nouveau

  {

     FirstName = "Joydip",

     LastName = "Kanjilal",

     Address = new {City = "Hyderabad", Country = "INDIA"}

  };

  Console.WriteLine ("Nom: {0} {1}", auteur.Prénom, auteur.LastName);

  Console.WriteLine ("Adresse: {0}", author.Address.City);

  Console.Read ();

}

Utiliser des types anonymes avec LINQ 

La clause Select dans LINQ crée et renvoie un type anonyme en conséquence. L'extrait de code suivant illustre cela.

Considérez la classe suivante nommée Author.

public class Auteur

{

  public int Id {get; ensemble; }

  chaîne publique FirstName {get; ensemble; }

  chaîne publique LastName {get; ensemble; }

}

L'extrait de code suivant montre comment créer une liste d'auteurs.

Auteurs IList =

Nouvelle liste()

{

  nouvel auteur () {Id = 1, FirstName = "John", LastName = "Willey"},

  nouvel auteur () {Id = 2, FirstName = "Steve", LastName = "Smith"},

  nouvel auteur () {Id = 3, FirstName = "Bill", LastName = "Ruffner"},

  nouvel auteur () {Id = 4, FirstName = "Joydip", LastName = "Kanjilal"}

};

Et l'extrait de code suivant montre comment vous pouvez tirer parti de la clause Select dans LINQ avec un type anonyme pour renvoyer le résultat lors de l'exécution d'une requête.

var result = from a in authors select new

{

   Id = a.Id,

   Nom = a.Prénom + "\ t" + a.Nom

};

Vous pouvez maintenant afficher les identifiants et noms des auteurs dans la fenêtre de la console, comme indiqué dans l'extrait de code ci-dessous.

foreach (var données dans le résultat)

      Console.WriteLine (data.Name);

Le programme complet est donné ci-dessous pour votre référence.

public class Auteur

    {

        public int Id {get; ensemble; }

        chaîne publique FirstName {get; ensemble; }

        chaîne publique LastName {get; ensemble; }

    }

    programme de classe

    {

        static void Main (string [] args)

        {

            Auteurs IList = nouvelle liste () {

                        nouvel auteur () {Id = 1, FirstName = "John",

                                      LastName = "Willey"},

                        nouvel auteur () {Id = 2, FirstName = "Steve",

                                      LastName = "Smith"},

                        nouvel auteur () {Id = 3, FirstName = "Bill",

                                      LastName = "Ruffner"},

                        nouvel auteur () {Id = 4, FirstName = "Joydip",

                                      LastName = "Kanjilal"}

                };

            var result = de a dans auteurs

                         sélectionner nouveau

                         {

                             Id = a.Id,

                             Nom = a.Prénom + "\ t" + a.Nom

                         };

            foreach (var données dans le résultat)

                Console.WriteLine (data.Name);

            Console.Read ();

        }

    }

Les types anonymes vous permettent de créer un type et de l'instancier rapidement sans avoir à déclarer le type plus tôt. Du point de vue du CLR, un type anonyme n'est qu'un autre type de référence. Le compilateur fournit un nom à chaque type anonyme sous les couvertures.

Les types anonymes dérivent de la classe Object. C'est pourquoi vous ne pouvez convertir un type anonyme qu'en une instance de type Object. Notez également que le type de retour d'une méthode, d'une propriété, d'un événement, d'un délégué, etc. ne peut pas être un type anonyme.

Comment faire plus en C #:

  • Quand utiliser une classe abstraite ou une interface en C #
  • Comment travailler avec AutoMapper en C #
  • Comment utiliser les expressions lambda en C #
  • Comment travailler avec les délégués Action, Func et Predicate en C #
  • Comment utiliser l'ORM Dapper en C #
  • Comment implémenter un simple logger en C #
  • Comment travailler avec log4net en C #
  • Comment travailler avec des délégués en C #
  • Comment travailler avec des attributs en C #
  • Comment utiliser le modèle de conception de poids mouche en C #
  • Comment implémenter le modèle de conception de référentiel en C #
  • Explorer les méthodes virtuelles et abstraites en C #
  • Comment travailler avec la réflexion en C #
  • Comment travailler avec Filesystemwatcher en C #