Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
Mit Objektinitialisierern können Sie deklarativ Typenobjekte initialisieren, ohne explizit einen Konstruktor für den Typ aufzurufen.
Die folgenden Beispiele zeigen, wie Objektinitialisierer mit benannten Objekten verwendet werden. Der Compiler verarbeitet Objektinitialisierer, indem zuerst auf den parameterlosen Instanzinstruktor zugegriffen wird und anschließend die Memeberinitialisierungen verarbeitet werden. Wenn der parameterlose Konstruktor daher wie private in der Klasse deklariert wird, schlägt objektinitialisierer, die öffentlichen Zugriff erfordern, fehl.
Sie müssen einen Objektinitialisierer verwenden, wenn Sie einen anonymen Typ definieren. Weitere Informationen finden Sie unter How to return subsets of element properties in a query.
Beispiel
Das folgende Beispiel zeigt, wie Sie einen neuen StudentName Typ mithilfe von Objektinitialisierern initialisieren. Dieses Beispiel legt Eigenschaften für den Typ StudentName fest:
public class HowToObjectInitializers
{
public static void Main()
{
// Declare a StudentName by using the constructor that has two parameters.
StudentName student1 = new StudentName("Craig", "Playstead");
// Make the same declaration by using an object initializer and sending
// arguments for the first and last names. The parameterless constructor is
// invoked in processing this declaration, not the constructor that has
// two parameters.
StudentName student2 = new StudentName
{
FirstName = "Craig",
LastName = "Playstead"
};
// Declare a StudentName by using an object initializer and sending
// an argument for only the ID property. No corresponding constructor is
// necessary. Only the parameterless constructor is used to process object
// initializers.
StudentName student3 = new StudentName
{
ID = 183
};
// Declare a StudentName by using an object initializer and sending
// arguments for all three properties. No corresponding constructor is
// defined in the class.
StudentName student4 = new StudentName
{
FirstName = "Craig",
LastName = "Playstead",
ID = 116
};
Console.WriteLine(student1.ToString());
Console.WriteLine(student2.ToString());
Console.WriteLine(student3.ToString());
Console.WriteLine(student4.ToString());
}
// Output:
// Craig 0
// Craig 0
// 183
// Craig 116
public class StudentName
{
// This constructor has no parameters. The parameterless constructor
// is invoked in the processing of object initializers.
// You can test this by changing the access modifier from public to
// private. The declarations in Main that use object initializers will
// fail.
public StudentName() { }
// The following constructor has parameters for two of the three
// properties.
public StudentName(string first, string last)
{
FirstName = first;
LastName = last;
}
// Properties.
public string? FirstName { get; set; }
public string? LastName { get; set; }
public int ID { get; set; }
public override string ToString() => FirstName + " " + ID;
}
}
Objektinitialisierer können zum Festlegen von Indexern in einem Objekt verwendet werden. Das folgende Beispiel definiert eine BaseballTeam-Klasse, die einen Indexer verwendet, um Player an verschiedenen Positionen abzurufen und festzulegen. Der Initialisator kann Spieler basierend auf der Abkürzung für die Position oder der Nummer zuweisen, die für jede Position auf Baseball-Punktetafeln verwendet wird:
public class HowToIndexInitializer
{
public class BaseballTeam
{
private string[] players = new string[9];
private readonly List<string> positionAbbreviations = new List<string>
{
"P", "C", "1B", "2B", "3B", "SS", "LF", "CF", "RF"
};
public string this[int position]
{
// Baseball positions are 1 - 9.
get { return players[position-1]; }
set { players[position-1] = value; }
}
public string this[string position]
{
get { return players[positionAbbreviations.IndexOf(position)]; }
set { players[positionAbbreviations.IndexOf(position)] = value; }
}
}
public static void Main()
{
var team = new BaseballTeam
{
["RF"] = "Mookie Betts",
[4] = "Jose Altuve",
["CF"] = "Mike Trout"
};
Console.WriteLine(team["2B"]);
}
}
Das nächste Beispiel zeigt die Reihenfolge der Ausführung von Konstruktor- und Memberinitialisierungen mithilfe des Konstruktors mit und ohne Parameter:
public class ObjectInitializersExecutionOrder
{
public static void Main()
{
new Person { FirstName = "Paisley", LastName = "Smith", City = "Dallas" };
new Dog(2) { Name = "Mike" };
}
public class Dog
{
private int age;
private string name;
public Dog(int age)
{
Console.WriteLine("Hello from Dog's non-parameterless constructor");
this.age = age;
}
public required string Name
{
get { return name; }
set
{
Console.WriteLine("Hello from setter of Dog's required property 'Name'");
name = value;
}
}
}
public class Person
{
private string firstName;
private string lastName;
private string city;
public Person()
{
Console.WriteLine("Hello from Person's parameterless constructor");
}
public required string FirstName
{
get { return firstName; }
set
{
Console.WriteLine("Hello from setter of Person's required property 'FirstName'");
firstName = value;
}
}
public string LastName
{
get { return lastName; }
init
{
Console.WriteLine("Hello from setter of Person's init property 'LastName'");
lastName = value;
}
}
public string City
{
get { return city; }
set
{
Console.WriteLine("Hello from setter of Person's property 'City'");
city = value;
}
}
}
// Output:
// Hello from Person's parameterless constructor
// Hello from setter of Person's required property 'FirstName'
// Hello from setter of Person's init property 'LastName'
// Hello from setter of Person's property 'City'
// Hello from Dog's non-parameterless constructor
// Hello from setter of Dog's required property 'Name'
}
Objektinitialisierer ohne das new Schlüsselwort
Sie können auch die Objektinitialisierungssyntax ohne das new Schlüsselwort verwenden, um Eigenschaften von geschachtelten Objekten zu initialisieren. Diese Syntax ist besonders nützlich bei schreibgeschützten Eigenschaften:
public class ObjectInitializerWithoutNew
{
public class Address
{
public string Street { get; set; } = "";
public string City { get; set; } = "";
public string State { get; set; } = "";
}
public class Person
{
public string Name { get; set; } = "";
public Address HomeAddress { get; set; } = new(); // Property with setter
}
public static void Examples()
{
// Example 1: Using object initializer WITHOUT 'new' keyword
// This modifies the existing Address instance created in the constructor
var person1 = new Person
{
Name = "Alice",
HomeAddress = { Street = "123 Main St", City = "Anytown", State = "CA" }
};
// Example 2: Using object initializer WITH 'new' keyword
// This creates a completely new Address instance
var person2 = new Person
{
Name = "Bob",
HomeAddress = new Address { Street = "456 Oak Ave", City = "Somewhere", State = "NY" }
};
// Both approaches work, but they behave differently:
// - person1.HomeAddress is the same instance that was created in Person's constructor
// - person2.HomeAddress is a new instance, replacing the one from the constructor
Console.WriteLine($"Person 1: {person1.Name} at {person1.HomeAddress.Street}, {person1.HomeAddress.City}, {person1.HomeAddress.State}");
Console.WriteLine($"Person 2: {person2.Name} at {person2.HomeAddress.Street}, {person2.HomeAddress.City}, {person2.HomeAddress.State}");
}
}
Bei diesem Ansatz wird die vorhandene Instanz des geschachtelten Objekts geändert, anstatt ein neues Objekt zu erstellen. Weitere Einzelheiten und Beispiele finden Sie unter Objekt-Initialisierer mit klassentypischen Eigenschaften.
Siehe auch
Zusammenarbeit auf GitHub
Die Quelle für diesen Inhalt finden Sie auf GitHub, wo Sie auch Issues und Pull Requests erstellen und überprüfen können. Weitere Informationen finden Sie in unserem Leitfaden für Mitwirkende.
