Quelle est la bonne façon d'initialiser un non-vide statique de la collection en C# 2.0?

Je veux initialiser une statique de la collection au sein de la classe C# - quelque chose comme cela:

public class Foo {
  private static readonly ICollection<string> g_collection = ???
}

Je ne suis pas sûr de la bonne façon de le faire; en Java, je pourrais faire quelque chose comme:

private static final Collection<String> g_collection = Arrays.asList("A", "B");

est-il similaire construire en C# 2.0?

Je sais que dans les versions ultérieures de C#/.NET, vous pouvez faire des initialiseurs de la collection (http://msdn.microsoft.com/en-us/library/bb384062.aspx), mais la migration n'est pas une option pour notre système à l'instant.

Pour préciser ma question d'origine: je suis à la recherche d'un moyen pour succinctement déclarer un simple statique de la collection, comme un simple constante de la collection de chaînes de caractères. La statique-initialiseur de style est vraiment bon à savoir pour les collections d'objets plus complexes.

Merci!

InformationsquelleAutor Aaron Whittier | 2009-01-05
  1. 27

    Si j'ai bien compris ta question, il semble que certaines autres ont manqué le point, vous cherchez à créer une statique de la collection dans une manière similaire à Java que vous pouvez déclarer et de le remplir en une seule ligne de code, sans avoir à créer une méthode spécifique pour le faire (comme pour certains autres suggestions). Cela peut être fait en utilisant un littéral de tableau (écrit sur deux lignes, pour éviter le défilement):

    private static readonly ICollection<string> Strings = 
  new string[] { "Hello", "World" };

    Cette fois déclare et remplit le nouveau readonly collection avec l'élément de la liste en une seule fois. Travaille en 2.0 et 3.5, je l'ai testé juste pour être doublement sûr.

    En 3.5 si vous pouvez utiliser l'inférence de type, de sorte que vous n'avez plus besoin d'utiliser le string[] tableau qui enlève encore plus de touches:

    private static readonly ICollection<string> Strings = 
  new[] { "Hello", "World" };

    Avis le manque de "chaîne de type" à la deuxième ligne, ligne. La chaîne est automatiquement déduit à partir du contenu du tableau de l'initialiseur.

    Si vous voulez remplir comme une liste, il suffit de modifier le new string[] pour la nouvelle Liste à la:

    private static readonly ICollection<string> Strings = 
  new List<string>() { "Hello", "World" };

    Bien sûr, parce que votre est de type IEnumerable plutôt que d'une mise en œuvre spécifique, si vous souhaitez accéder à des méthodes spécifiques à l'List< string> comme .ForEach(), vous aurez besoin de les convertir à la Liste:

    ((List<string>)Strings).ForEach(Console.WriteLine);

    Mais c'est un petit prix à payer pour migratability [est-ce un mot?].

    • Oui, c'était mon intention, je vais modifier la question pour le rendre plus clair. Merci!
    InformationsquelleAutor BenAlabaster
  2. 9

    Statique de la construction:

    public class Foo
{
    private static readonly ICollection<string> _collection;

    static Foo()
    {
        _collection = new List<string>();
        _collection.Add("One");
        _collection.Add("Two");
    }
}

    Mais notez que dans ce cas, vous pouvez initialiser la collecte en ligne (recommandé pour les des raisons de performances):

    private static readonly ICollection<string> _collection = new List<string>(new string[] { "One", "Two" });

    Cela dépend vraiment de la complexité de votre code d'initialisation de l'est.

    • Vous pouvez améliorer la lisibilité du code en modifiant l'initialisation d'un peu plus loin: ... = new List<string>() { "un", "deux" };
    • +1 pour la deuxième proposition.
    InformationsquelleAutor Kent Boogaart
  3. 5

    Peut-être vous pouvez appeler une méthode statique:

    public class Foo
{
    private static readonly ICollection<string> g_collection = initializeCollection();

    private static ICollection<string> initializeCollection()
    {
        ... TODO allocate and return something here ...
    }
}

    Ou, avoir un constructeur statique (comme d'autres personnes ont suggéré) peuvent être équivalentes, voire plus idiomatiques.

    InformationsquelleAutor ChrisW
  4. 1

    en plus de constructeur statique, ce sera également le travail

        public class Foo
    {
        private static readonly ICollection<string> _collection = 
              new List<string>(new string[] { "elem1", "elem2", "...", "elemn" });
    }
    InformationsquelleAutor Pablo Retyk
  5. 0

    La seule façon que je peux penser serait d'avoir un constructeur statique. Alors d'abord vous nouvelle une nouvelle collection au niveau de la classe, puis dans votre constructeur statique, ajouter toutes les valeurs.

    InformationsquelleAutor BFree
  6. 0

    vous pouvez déclarer une classe de collection personnalisée et ajouter votre propre ctor à elle...

      public class MyFooCollection: Collection<string>
   {
      public MyFooCollection(string[] values)
      {
          foreach (string s in values)  base.Add(s); 
      }
   }

    ensuite dans votre code client, vous pouvez écrire des 

      private static final MyFooCollection g_collection = 
         new MyFooCollection(new string[] {"A", "B"});
    InformationsquelleAutor Charles Bretana
  7. 0

    Utiliser un constructeur statique comme suit:

    public class Foo
{
    static readonly ICollection<string> g_collection;

    //Static constructor
    static Foo()
    {
        g_collection = new List<string>();
        g_collection.Add("Hello");
        g_collection.Add("World!");
    }
}
    InformationsquelleAutor Juliet
  8. 0

    J'aime utiliser IEnumerable<T>.ToList().

    Aussi, si votre collection doit être en lecture seule, vous pouvez utiliser un System.Collections.ObjectModel.ReadOnlyCollection.

    private readonly ICollection<string> collection = new string[] { "a", "b", "c" }.ToList();

private readonly ReadOnlyCollection<string> collection2 = new ReadOnlyCollection<string>(new string[] { "a", "b", "c" });

    EDIT:

    Et puis, si vous l'utilisez comme une ICollection, vous pouvez simplement utiliser le constructeur array (depuis T[] est un IList<T> et un ICollection<T>). Gardez à l'esprit que, dans ce cas, de nombreux alterring des méthodes telles que Ajouter échouerait:

    private readonly ICollection<string> = new string[] { "a", "b", "c" };

    EDIT #2:
    Je viens de réaliser ToList est une extension de la fonction et ne peut être utilisé en C# 3.0. Vous pouvez toujours utiliser la Liste constructeur de bien:

    private readonly IList<string> = new List<string>(new string[] { "a", "b", "c" });

    Encore, je préfère ReadOnlyCollection pour lire uniquement les listes.

    InformationsquelleAutor configurator
  9. 0

    Vous avez deux options:

    1. Utiliser la valeur de retour d'une méthode statique pour initialiser la collection.

    2. Utiliser un constructeur statique pour créer la collection, le remplir et initialiser la variable statique.

    À partir d'un point de vue des performances de l'option 1 est mieux, car dans le cas de la statique des constructeurs, la durée de fonctionnement est de vérifier si le constructeur statique a été appelée avant chaque accès à la classe.

    InformationsquelleAutor vboctor