Objekt- und Auflistungsinitialisierer (C#-Programmierhandbuch)Object and Collection Initializers (C# Programming Guide)

Mit Objektinitialisierern können Sie allen verfügbaren Feldern oder Eigenschaften eines Objekts zum Erstellungszeitpunkt Werte zuweisen, ohne einen Konstruktor gefolgt von Zeilen mit Zuweisungsanweisungen aufrufen zu müssen.Object initializers let you assign values to any accessible fields or properties of an object at creation time without having to invoke a constructor followed by lines of assignment statements. Mit der Objektinitialisierersyntax können Sie Argumente für einen Konstruktor angeben oder die Argumente (und Klammersyntax) weglassen.The object initializer syntax enables you to specify arguments for a constructor or omit the arguments (and parentheses syntax). Im folgenden Beispiel werden die Verwendung eines Objektinitialisierers mit einem benannten Typ, Cat, und das Aufrufen des Standardkonstruktors veranschaulicht.The following example shows how to use an object initializer with a named type, Cat and how to invoke the default constructor. Beachten Sie die Verwendung automatisch implementierter Eigenschaften in der Cat-Klasse.Note the use of auto-implemented properties in the Cat class. Weitere Informationen finden Sie unter Automatisch implementierte Eigenschaften.For more information, see Auto-Implemented Properties.

class Cat
{
    // Auto-implemented properties.
    public int Age { get; set; }
    public string Name { get; set; }
}
Cat cat = new Cat { Age = 10, Name = "Fluffy" };

Die Syntax von Objektinitialisierern ermöglicht Ihnen die Erstellung einer Instanz und weist danach das neu erstellte Objekt mit seinen zugewiesenen Eigenschaften der Variable in der Zuweisung zu.The object initializers syntax allows you to create an instance, and after that it assigns the newly created object, with its assigned properties, to the variable in the assignment.

Objektinitialisierer mit anonymen TypenObject Initializers with anonymous types

Obwohl Objektinitialisierer in jedem Kontext verwendet werden können, sind sie vor allem in LINQLINQ-Abfrageausdrücken nützlich.Although object initializers can be used in any context, they are especially useful in LINQLINQ query expressions. Abfrageausdrücke verwenden häufig anonyme Typen, die nur mit einem Objektinitialisierer initialisiert werden können, wie in der folgenden Deklaration veranschaulicht.Query expressions make frequent use of anonymous types, which can only be initialized by using an object initializer, as shown in the following declaration.

var pet = new { Age = 10, Name = "Fluffy" };  

Anonyme Typen ermöglichen der select-Klausel in einem LINQLINQ-Abfrageausdruck, Objekte der ursprünglichen Sequenz in Objekte zu transformieren, deren Wert und Form sich vom Original unterscheiden können.Anonymous types enable the select clause in a LINQLINQ query expression to transform objects of the original sequence into objects whose value and shape may differ from the original. Dies ist nützlich, wenn Sie nur einen Teil der Informationen aus jedem Objekt in einer Sequenz speichern möchten.This is useful if you want to store only a part of the information from each object in a sequence. Im folgenden Beispiel wird angenommen, dass ein Produktobjekt (p) viele Felder und Methoden enthält und dass Sie nur eine Sequenz von Objekten erstellen möchten, die den Produktnamen und den Einzelpreis enthalten.In the following example, assume that a product object (p) contains many fields and methods, and that you are only interested in creating a sequence of objects that contain the product name and the unit price.

var productInfos =
    from p in products
    select new { p.ProductName, p.UnitPrice };

Wenn diese Abfrage ausgeführt wird, enthält die productInfos-Variable eine Sequenz von Objekten, auf die Sie über eine foreach-Anweisung, wie im folgenden Beispiel gezeigt, zugreifen können:When this query is executed, the productInfos variable will contain a sequence of objects that can be accessed in a foreach statement as shown in this example:

foreach(var p in productInfos){...}  

Jedes Objekt im neuen anonymen Typ hat zwei öffentliche Eigenschaften, die die gleichen Namen wie die Eigenschaften oder Felder im ursprünglichen Objekt erhalten.Each object in the new anonymous type has two public properties which receive the same names as the properties or fields in the original object. Sie können ein Feld auch umbenennen, wenn Sie einen anonymen Typ erstellen. Im folgenden Beispiel wird das UnitPrice-Feld in Price umbenannt.You can also rename a field when you are creating an anonymous type; the following example renames the UnitPrice field to Price.

select new {p.ProductName, Price = p.UnitPrice};  

Objektinitialisierer mit dem Typ, der NULL-Werte zulässtObject initializers with nullable types

Die Verwendung eines Objektinitialisierers mit einer Struktur, die NULL-Werte zulässt, ist ein Fehler, der zum Zeitpunkt der Kompilierung auftritt.It is a compile-time error to use an object initializer with a nullable struct.

AuflistungsinitialisiererCollection initializers

Mit Auflistungsinitialisierern können Sie einen oder mehrere Elementinitialisierer festlegen, wenn Sie einen Auflistungstyp initialisieren, der IEnumerable implementiert und über Add mit der entsprechenden Signatur als Instanzmethode oder Erweiterungsmethode verfügt.Collection initializers let you specify one or more element initializers when you initialize a collection type that implements IEnumerable and has Add with the appropriate signature as an instance method or an extension method. Die Elementinitialisierer können ein einfacher Wert, ein Ausdruck oder ein Objektinitialisierer sein.The element initializers can be a simple value, an expression or an object initializer. Durch den Einsatz eines Auflistungsinitialisierers müssen Sie nicht mehrere Aufrufe der Add-Methode für die Klasse in Ihrem Quellcode angeben; der Compiler fügt die Aufrufe hinzu.By using a collection initializer you do not have to specify multiple calls to the Add method of the class in your source code; the compiler adds the calls.

In den folgenden Beispielen werden zwei einfache Auflistungsinitialisierer dargestellt:The following examples shows two simple collection initializers:

List<int> digits = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };  
List<int> digits2 = new List<int> { 0 + 1, 12 % 3, MakeInt() };  

Der folgende Auflistungsinitialisierer verwendet Objektinitialisierer, um Objekte der Cat-Klasse, die in einem vorherigen Beispiel definiert wurden, zu initialisieren.The following collection initializer uses object initializers to initialize objects of the Cat class defined in a previous example. Beachten Sie, dass die einzelnen Objektinitialisierer in geschweifte Klammern eingeschlossen und durch Kommas voneinander getrennt werden.Note that the individual object initializers are enclosed in braces and separated by commas.

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

Sie können NULL als ein Element in einem Auflistungsinitialisierer festlegen, wenn die Add-Methode der Auflistung dies zulässt.You can specify null as an element in a collection initializer if the collection's Add method allows it.

List<Cat> moreCats = new List<Cat>
{
    new Cat(){ Name = "Furrytail", Age=5 },
    new Cat(){ Name = "Peaches", Age=4 },
    null
};

Sie können indizierte Elemente angeben, falls die Auflistung die Indizierung unterstützt.You can specify indexed elements if the collection supports indexing.

var numbers = new Dictionary<int, string> {   
    [7] = "seven",   
    [9] = "nine",   
    [13] = "thirteen"   
};  

BeispieleExamples

Im folgenden Beispiel werden die Konzepte des Objekt- und Auflistungsinitialisierers verbunden.The following example combines the concepts of object and collection initializers.

// The following code consolidates examples from the topic.
class ObjInitializers
{
    class Cat
    {
        // Auto-implemented properties.
        public int Age { get; set; }
        public string Name { get; set; }
    }

    static void Main()
    {
        Cat cat = new Cat { Age = 10, Name = "Fluffy" };

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

        List<Cat> moreCats = new List<Cat>
        {
            new Cat(){ Name = "Furrytail", Age=5 },
            new Cat(){ Name = "Peaches", Age=4 },
            null
        };

        // Display results.
        System.Console.WriteLine(cat.Name);

        foreach (Cat c in cats)
            System.Console.WriteLine(c.Name);

        foreach (Cat c in moreCats)
            if (c != null)
                System.Console.WriteLine(c.Name);
            else
                System.Console.WriteLine("List element has null value.");
    }
    // Output:
    //Fluffy
    //Sylvester
    //Whiskers
    //Sasha
    //Furrytail
    //Peaches
    //List element has null value.
}

Wie im folgenden Beispiel gezeigt wird, ermöglicht ein Objekt, das IEnumerable mit einer Add-Methode mit mehreren Parametern implementiert, Auflistungsinitialisierer mit mehreren Elementen pro Element in der Liste, die der Signatur der Add-Methode entsprechen.Shown in the following example, an object which implements IEnumerable containing an Add method with multiple parameters allows for collection initializers with multiple elements per item in the list corresponding to the signature of the Add method.

using System;
using System.Collections;
using System.Collections.Generic;

namespace ExampleProject
{
    class FormattedAddresses : IEnumerable<string>
    {
        private List<string> internalList = new List<string>();
        public IEnumerator<string> GetEnumerator() => internalList.GetEnumerator();

        IEnumerator IEnumerable.GetEnumerator() => internalList.GetEnumerator();

        public void Add(string firstname, string lastname, string street, string city, string state, string zipcode) => internalList.Add(
                $@"{firstname} {lastname}
{street}
{city}, {state} {zipcode}"
            );
    }

    class Program
    {
        static void Main(string[] args)
        {
            FormattedAddresses addresses = new FormattedAddresses()
            {
                {"John", "Doe", "123 Street", "Topeka", "KS", "00000" },
                {"Jane", "Smith", "456 Street", "Topeka", "KS", "00000" }
            };

            Console.WriteLine("Address Entries:");

            foreach(string addressEntry in addresses)
            {
                Console.WriteLine("\r\n" + addressEntry);
            }
        }

        /*
         * Prints:
         
            Address Entries:

            John Doe
            123 Street
            Topeka, KS 00000

            Jane Smith
            456 Street
            Topeka, KS 00000
         */
    }
}

Add-Methoden können durch das Schlüsselwort params eine variable Anzahl von Argumenten akzeptieren, wie im folgenden Beispiel gezeigt wird.Add methods can use the params keyword to take a variable number of arguments as shown in the following example. Dieses Beispiel zeigt die benutzerdefinierte Implementierung eines Indexers sowie die Initialisierung einer Auflistung mithilfe von Indizes.This example demonstrates the custom implementation of an indexer as well to initialize a collection using indexes.

using System;
using System.Collections;
using System.Collections.Generic;

namespace ExampleProject
{
    class RudimentaryMultiValuedDictionary<TKey, TValue> : IEnumerable<KeyValuePair<TKey, List<TValue>>>
    {
        private Dictionary<TKey, List<TValue>> internalDictionary = new Dictionary<TKey, List<TValue>>();

        public IEnumerator<KeyValuePair<TKey, List<TValue>>> GetEnumerator() => internalDictionary.GetEnumerator();

        IEnumerator IEnumerable.GetEnumerator() => internalDictionary.GetEnumerator();

        public List<TValue> this[TKey key]
        {
            get => internalDictionary[key];
            set => Add(key, value);
        }

        public void Add(TKey key, params TValue[] values) => Add(key, (IEnumerable<TValue>)values);

        public void Add(TKey key, IEnumerable<TValue> values)
        {
            if (!internalDictionary.TryGetValue(key, out List<TValue> storedValues))
                internalDictionary.Add(key, storedValues = new List<TValue>());

            storedValues.AddRange(values);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            RudimentaryMultiValuedDictionary<string, string> rudimentaryMultiValuedDictionary1
                = new RudimentaryMultiValuedDictionary<string, string>()
                {
                    {"Group1", "Bob", "John", "Mary" },
                    {"Group2", "Eric", "Emily", "Debbie", "Jesse" }
                };
            RudimentaryMultiValuedDictionary<string, string> rudimentaryMultiValuedDictionary2
                = new RudimentaryMultiValuedDictionary<string, string>()
                {
                    ["Group1"] = new List<string>() { "Bob", "John", "Mary" },
                    ["Group2"] = new List<string>() { "Eric", "Emily", "Debbie", "Jesse" }
                };

            Console.WriteLine("Using first multi-valued dictionary created with a collection initializer:");

            foreach(KeyValuePair<string, List<string>> group in rudimentaryMultiValuedDictionary1)
            {
                Console.WriteLine($"\r\nMembers of group {group.Key}: ");

                foreach(string member in group.Value)
                {
                    Console.WriteLine(member);
                }
            }

            Console.WriteLine("\r\nUsing second multi-valued dictionary created with a collection initializer using indexing:");

            foreach (KeyValuePair<string, List<string>> group in rudimentaryMultiValuedDictionary2)
            {
                Console.WriteLine($"\r\nMembers of group {group.Key}: ");

                foreach (string member in group.Value)
                {
                    Console.WriteLine(member);
                }
            }
        }

        /*
         * Prints:
         
            Using first multi-valued dictionary created with a collection initializer:

            Members of group Group1:
            Bob
            John
            Mary

            Members of group Group2:
            Eric
            Emily
            Debbie
            Jesse

            Using second multi-valued dictionary created with a collection initializer using indexing:

            Members of group Group1:
            Bob
            John
            Mary

            Members of group Group2:
            Eric
            Emily
            Debbie
            Jesse
         */
    }
}

Siehe auchSee Also

C#-ProgrammierhandbuchC# Programming Guide
LINQ-AbfrageausdrückeLINQ Query Expressions
Anonyme TypenAnonymous Types