Objektinitialisierer für Objektsammlungen

Question

Ich möchte herausfinden, ob es eine Möglichkeit gibt, eine List<T> zu initialisieren, wobei T eine object ist, ähnlich wie eine einfache Sammlung initialisiert wird?

Simple Collection Initializer:

List<int> digits = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; 

Object Collection Initilizer:

List<ChildObject> childObjects = new List<ChildObject> 
{  
     new ChildObject(){ Name = "Sylvester", Age=8 }, 
     new ChildObject(){ Name = "Whiskers", Age=2 }, 
     new ChildObject(){ Name = "Sasha", Age=14 } 
}; 

Die Frage ist, wie und ob man etwas tun kann?

Answer 1

Sie können tu dies, ohne deine eigene Klasse zu erstellen, abgeleitet von List<ChildObject>, wie in Lee's Antwort. Es ist bedauerlich, dass Erweiterungsmethoden nicht für die Sammlung initalizers berücksichtigt werden, sonst würde dies funktionieren:

// This doesn't work, but it would if collection initializers checked 
// extension methods. 
using System; 
using System.Collections.Generic; 

public class ChildObject 
{ 
    public string Name { get; set; } 
    public int Age { get; set; } 
} 

public static class Extensions 
{ 
    public static void Add(this List<ChildObject> children, 
          string name, int age) 
    { 
     children.Add(new ChildObject { Name = name, Age = age }); 
    } 
} 

class Test 
{ 
    static void Main(string[] args) 
    { 
     List<ChildObject> children = new List<ChildObject> 
     { 
      { "Sylvester", 8 }, 
      { "Whiskers", 2 }, 
      { "Sasha", 14 } 
     }; 
    } 
} 

Answer 2

Am nächsten kommt man dazu, einen parametrisierten Konstruktor für Ihre Klasse zu erstellen, der diese Argumente akzeptiert. Das wird erhalten Sie den ganzen Weg nicht, aber man kann dies zumindest tun:

List<ChildObject> childObjects = new List<ChildObject> 
{  
     new ChildObject("Sylvester", 8) , 
     new ChildObject("Whiskers", 2), 
     new ChildObject("Sasha", 14) 
}; 

Answer 3

Wenn Sie bei the docs für Auflistungsinitialisierer aussehen, es ist alles über die Add-Methode der Sammlung. Unterteilen Sie die geschlossene generische Liste einfach über Ihren Typ und erstellen Sie eine Add-Methode mit den nackten Parametern. Wie

public class MyColl : List<ChildObject> 
{ 
    public void Add(string s1, int a1, int a2) 
    { 
     base.Add(new ChildObject(s1, a1, a2)); 
    } 
} 

public class ChildObject 
{ 
    public ChildObject(string s1, int a1, int a2) 
    { 
     //... 
    } 
} 

Dann ruft er wie folgt aussieht:

static void Main(string[] args) 
    { 
     MyColl x = new MyColl 
     { 
      {"boo", 2, 4}, 
      {"mang", 3, 5}, 
     }; 
    } 

Answer 4

Das Beste, was Sie wahrscheinlich tun können, so etwas wie dieses:

public class MyListOfChildObjects : List<ChildObject> 
{ 
    public void Add(string name, int age) 
    { 
     Add (new ChildObject { Name = name, Age = age }); 
    } 
} 

var childObjects = new MyListOfChildObjects 
{ 
    { "Sylvester", 8 } , { "Whiskers", 2 }, { "Sasha", 14 } 
}; 

Sie es allgemeinere machen könnte, aber wie würden Sie wissen, welche Argumente an jede Eigenschaft gebunden sein sollten?

public class MyList<T> : List<T> 
{ 
    public void Add(params object[] arguments) 
    { 
     // what order should I bind the values to? 
    } 
} 

var childObjects = new MyList<ChildObject> 
{ 
    { "Sylvester", 8 } , { "Whiskers", 2 }, { "Sasha", 14 } 
}; 

Answer 5

Sie können in der Nähe erhalten, indem Sie Ihre eigene Sammlung zu schaffen, die Ihre eigenen Add-Methode List<ChildObject> und bieten erweitert:

public class ChildObjectCollection : List<ChildObject> 
{ 
    public void Add(string name, int age) 
    { 
     this.Add(new ChildObject(name, age)); 
    } 
} 

können Sie dann es wie folgt initialisieren:

var childObjects = new ChildObjectCollection 
{ 
    { "Sylvester", 8} , {"Whiskers", 2}, {"Sasha", 1 } 
};