使用 C# 可以在单个语句中实例化对象或集合并执行成员分配。
对象初始值设定项
使用对象初始值设定项，可以在创建对象时为对象的任何可访问字段或属性赋值。 无需调用构造函数，然后使用赋值语句。 使用对象初始值设定项语法可以指定构造函数的参数或省略参数和括号。 有关一致使用对象初始值设定项的指导，请参阅“使用对象初始值设定项”（样式规则IDE0017）。 以下示例演示如何使用具有命名类型的 Cat对象初始值设定项，以及如何调用无参数构造函数。 注意 Cat 类中自动实现的属性的使用。 有关详细信息，请参阅自动实现的属性。
public class Cat
{
// Automatically implemented properties.
public int Age { get; set; }
public string? Name { get; set; }
public Cat()
{
}
public Cat(string name)
{
this.Name = name;
}
}
Cat cat = new Cat { Age = 10, Name = "Fluffy" };
Cat sameCat = new Cat("Fluffy"){ Age = 10 };
通过对象初始值设定项语法，可以创建一个实例，并将新创建的对象及其分配的属性分配给赋值中的变量。
从嵌套对象属性开始，可以使用没有 new 关键字的对象初始值设定项语法。 使用此语法 Property = { ... }可以初始化现有嵌套对象的成员，这对于只读属性很有用。 有关详细信息，请参阅 具有类类型属性的对象初始值设定项。
除了分配字段和属性外，对象初始值设定项还可以设置索引器。 请思考这个基本的 Matrix 类：
public class Matrix
{
private double[,] storage = new double[3, 3];
public double this[int row, int column]
{
// The embedded array will throw out of range exceptions as appropriate.
get { return storage[row, column]; }
set { storage[row, column] = value; }
}
}
可以使用以下代码初始化标识矩阵：
var identity = new Matrix
{
[0, 0] = 1.0,
[0, 1] = 0.0,
[0, 2] = 0.0,
[1, 0] = 0.0,
[1, 1] = 1.0,
[1, 2] = 0.0,
[2, 0] = 0.0,
[2, 1] = 0.0,
[2, 2] = 1.0,
};
包含可访问资源库的任何可访问索引器都可以用作对象初始值设定项中的表达式之一，这与参数的数量或类型无关。 索引参数构成左侧赋值，而表达式右侧是值。 例如，如果 IndexersExample 具有适当的索引器，则以下初始值设定项都是有效的：
var thing = new IndexersExample
{
name = "object one",
[1] = '1',
[2] = '4',
[3] = '9',
Size = Math.PI,
['C',4] = "Middle C"
}
对于要进行编译的前面的代码，IndexersExample 类型必须具有以下成员：
public string name;
public double Size { set { ... }; }
public char this[int i] { set { ... }; }
public string this[char c, int i] { set { ... }; }
具有匿名类型的对象初始值设定项
尽管可以在任何上下文中使用对象初始化器，但它们在语言集成查询（LINQ）表达式中特别有用。 查询表达式经常使用 匿名类型，只能使用对象初始值设定项进行初始化，如以下声明所示。
var pet = new { Age = 10, Name = "Fluffy" };
通过使用匿名类型， select LINQ 查询表达式中的子句可以将原始序列的对象转换为其值和形状不同于原始对象的对象。 建议只存储某个序列中每个对象的部分信息。 在下面的示例中，假定产品对象 (p) 包含很多字段和方法，而你只想创建包含产品名和单价的对象序列。
var productInfos =
from p in products
select new { p.ProductName, p.UnitPrice };
执行此查询时，变量 productInfos 包含可在语句中 foreach 访问的对象序列，如以下示例所示：
foreach(var p in productInfos){...}
新的匿名类型中的每个对象都具有两个公共属性，这两个属性接收与原始对象中的属性或字段相同的名称。 还可以在创建匿名类型时重命名字段。 以下示例将 UnitPrice 字段重命名为 Price。
select new {p.ProductName, Price = p.UnitPrice};
具有 required 修饰符的对象初始化器
使用required关键字强制调用方通过对象初始值设定项来设置属性或字段的值。 无需将所需的属性设置为构造函数参数。 编译器可确保所有调用方初始化这些值。
public class Pet
{
public required int Age;
public string Name;
}
// `Age` field is necessary to be initialized.
// You don't need to initialize `Name` property
var pet = new Pet() { Age = 10};
// Compiler error:
// Error CS9035 Required member 'Pet.Age' must be set in the object initializer or attribute constructor.
// var pet = new Pet();
通常的做法是保证对象正确初始化，尤其是在要管理多个字段或属性，并且不希望将它们全部包含在构造函数中时。
使用 init 访问器的对象初始值设定项
通过使用 init 访问器，可以确保对象在初始化后不会更改。 它有助于限制属性值的设置。
public class Person
{
public string FirstName { get; set; }
public string LastName { get; init; }
}
// The `LastName` property can be set only during initialization. It CAN'T be modified afterwards.
// The `FirstName` property can be modified after initialization.
var pet = new Person() { FirstName = "Joe", LastName = "Doe"};
// You can assign the FirstName property to a different value.
pet.FirstName = "Jane";
// Compiler error:
// Error CS8852 Init - only property or indexer 'Person.LastName' can only be assigned in an object initializer,
// or on 'this' or 'base' in an instance constructor or an 'init' accessor.
// pet.LastName = "Kowalski";
必需的仅限 init 的属性支持不可变结构，同时允许该类型用户使用自然语法。
具有类类型属性的对象初始值设定项
使用类类型属性初始化对象时，可以使用两种不同的语法：
-
不带
new关键字的对象初始值设定项：Property = { ... } -
带有关键字
new的对象初始值设定项：Property = new() { ... }
这些语法的行为方式不同。 以下示例演示了这两种方法：
public class HowToClassTypedInitializer
{
public class EmbeddedClassTypeA
{
public int I { get; set; }
public bool B { get; set; }
public string S { get; set; }
public EmbeddedClassTypeB ClassB { get; set; }
public override string ToString() => $"{I}|{B}|{S}|||{ClassB}";
public EmbeddedClassTypeA()
{
Console.WriteLine($"Entering EmbeddedClassTypeA constructor. Values are: {this}");
I = 3;
B = true;
S = "abc";
ClassB = new() { BB = true, BI = 43 };
Console.WriteLine($"Exiting EmbeddedClassTypeA constructor. Values are: {this})");
}
}
public class EmbeddedClassTypeB
{
public int BI { get; set; }
public bool BB { get; set; }
public string BS { get; set; }
public override string ToString() => $"{BI}|{BB}|{BS}";
public EmbeddedClassTypeB()
{
Console.WriteLine($"Entering EmbeddedClassTypeB constructor. Values are: {this}");
BI = 23;
BB = false;
BS = "BBBabc";
Console.WriteLine($"Exiting EmbeddedClassTypeB constructor. Values are: {this})");
}
}
public static void Main()
{
var a = new EmbeddedClassTypeA
{
I = 103,
B = false,
ClassB = { BI = 100003 }
};
Console.WriteLine($"After initializing EmbeddedClassTypeA: {a}");
var a2 = new EmbeddedClassTypeA
{
I = 103,
B = false,
ClassB = new() { BI = 100003 } //New instance
};
Console.WriteLine($"After initializing EmbeddedClassTypeA a2: {a2}");
}
// Output:
//Entering EmbeddedClassTypeA constructor Values are: 0|False||||
//Entering EmbeddedClassTypeB constructor Values are: 0|False|
//Exiting EmbeddedClassTypeB constructor Values are: 23|False|BBBabc)
//Exiting EmbeddedClassTypeA constructor Values are: 3|True|abc|||43|True|BBBabc)
//After initializing EmbeddedClassTypeA: 103|False|abc|||100003|True|BBBabc
//Entering EmbeddedClassTypeA constructor Values are: 0|False||||
//Entering EmbeddedClassTypeB constructor Values are: 0|False|
//Exiting EmbeddedClassTypeB constructor Values are: 23|False|BBBabc)
//Exiting EmbeddedClassTypeA constructor Values are: 3|True|abc|||43|True|BBBabc)
//Entering EmbeddedClassTypeB constructor Values are: 0|False|
//Exiting EmbeddedClassTypeB constructor Values are: 23|False|BBBabc)
//After initializing EmbeddedClassTypeA a2: 103|False|abc|||100003|False|BBBabc
}
主要差异
没有
new关键字 （ClassB = { BI = 100003 }）：此语法修改对象构造函数创建的属性的现有实例。 它在现有对象上调用成员初始化器。使用
new关键字 （ClassB = new() { BI = 100003 }）： 此语法将创建一个新实例并将其分配给该属性，并替换任何现有实例。
初始化器在没有new时会复用当前实例。 在前面的示例中，ClassB 的值为： 100003 （分配的新值）、 true （保留自 EmbeddedClassTypeA 的初始化）、 BBBabc （与 EmbeddedClassTypeB 的默认值保持不变）。
不带new的只读属性对象初始值
不带 new 的语法对于只读属性是有用的。 无法分配新实例，但仍可以初始化现有实例的成员：
public class ReadOnlyPropertyExample
{
public class Settings
{
public string Theme { get; set; } = "Light";
public int FontSize { get; set; } = 12;
}
public class Application
{
public string Name { get; set; } = "";
// This property is read-only - it can only be set during construction
public Settings AppSettings { get; } = new();
}
public static void Example()
{
// You can still initialize the nested object's properties
// even though AppSettings property has no setter
var app = new Application
{
Name = "MyApp",
AppSettings = { Theme = "Dark", FontSize = 14 }
};
// This would cause a compile error because AppSettings has no setter:
// app.AppSettings = new Settings { Theme = "Dark", FontSize = 14 };
Console.WriteLine($"App: {app.Name}, Theme: {app.AppSettings.Theme}, Font Size: {app.AppSettings.FontSize}");
}
}
此方法使你能够初始化嵌套对象，即便所含属性没有设置器。
集合初始值设定项
集合初始值设定项允许在初始化实现 IEnumerable 的集合类型时指定一 Add 个或多个元素初始值设定项，并将具有相应签名的方法用作实例方法或扩展方法。 元素初始值设定项可以是值、表达式或对象初始值设定项。 通过使用集合初始值设定项，无需指定多个调用；编译器将自动添加这些调用。 有关一致使用集合初始值设定项的指导，请参阅“使用集合初始值设定项”（样式规则IDE0028）。 集合初始值设定项在 LINQ 查询中也很有用。
下面的示例演示了两个简单的集合初始值设定项：
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() };
下面的集合初始值设定项使用对象初始值设定项来初始化上一个示例中定义的 Cat 类的对象。 各个对象初始值设定项括在大括号中且用逗号隔开。
List<Cat> cats =
[
new Cat { Name = "Sylvester", Age = 8 },
new Cat { Name = "Whiskers", Age = 2 },
new Cat { Name = "Sasha", Age = 14 }
];
如果集合的 方法允许，则可以将 Add 指定为集合初始值设定项中的一个元素。
List<Cat?> moreCats = new List<Cat?>
{
new Cat{ Name = "Furrytail", Age=5 },
new Cat{ Name = "Peaches", Age=4 },
null
};
你可以使用分布元素创建一个列表来复制其他一个或多个列表。
List<Cat> allCats = [.. cats, .. moreCats];
并包括其他元素以及使用展开运算符。
List<Cat> additionalCats = [.. cats, new Cat { Name = "Furrytail", Age = 5 }, .. moreCats];
如果集合支持读取/写入索引，可以指定索引元素。
var numbers = new Dictionary<int, string>
{
[7] = "seven",
[9] = "nine",
[13] = "thirteen"
};
前面的示例生成调用 Item[TKey] 以设置值的代码。 还可以使用以下语法初始化字典和其他关联容器。 它使用具有多个值的对象，而不是使用带括号和赋值的索引器语法：
var moreNumbers = new Dictionary<int, string>
{
{19, "nineteen" },
{23, "twenty-three" },
{42, "forty-two" }
};
此初始值设定项示例调用 Add(TKey, TValue)，将这三个项添加到字典中。 由于编译器生成的方法调用不同，这两种初始化关联集合的不同方法的行为略有不同。 这两种变量都适用于 Dictionary 类。 其他类型根据它们的公共 API 可能只支持两者中的一种。
集合表达式参数
从 C# 15 开始，使用 with(...) 元素作为 集合表达式 中的第一个元素，将参数传递给集合的构造函数。 通过使用此功能，可以直接在集合表达式语法中指定容量、比较器或其他构造函数参数：
public static void CollectionExpressionWithArgumentsExample()
{
string[] values = ["one", "two", "three"];
// Use with() to pass capacity to the List<T> constructor
List<string> names = [with(capacity: values.Length * 2), .. values];
Console.WriteLine($"Created List<string> with capacity: {names.Capacity}");
Console.WriteLine($"List contains {names.Count} elements: [{string.Join(", ", names)}]");
// Use with() to pass a comparer to the HashSet<T> constructor
HashSet<string> caseInsensitiveSet = [with(StringComparer.OrdinalIgnoreCase), "Hello", "HELLO"];
// caseInsensitiveSet contains only one element because "Hello" and "HELLO" are equal
Console.WriteLine($"HashSet with case-insensitive comparer contains {caseInsensitiveSet.Count} elements: [{string.Join(", ", caseInsensitiveSet)}]");
Console.WriteLine("Note: 'Hello' and 'HELLO' are treated as the same element due to OrdinalIgnoreCase comparer");
}
有关集合表达式参数（包括支持的目标类型和限制）的详细信息，请参阅 集合表达式参数。
具有集合只读属性初始化的对象初始值设定项
某些类具有只读的集合属性，如以下情况中的Cats的CatOwner属性：
public class CatOwner
{
public IList<Cat> Cats { get; } = new List<Cat>();
}
由于无法为属性分配新列表，因此无法使用前面讨论的集合初始值设定项语法：
CatOwner owner = new CatOwner
{
Cats = new List<Cat>
{
new Cat{ Name = "Sylvester", Age=8 },
new Cat{ Name = "Whiskers", Age=2 },
new Cat{ Name = "Sasha", Age=14 }
}
};
但是，可以使用初始化语法来向Cats添加新条目，并省略列表创建（new List<Cat>），如以下示例所示：
CatOwner owner = new CatOwner
{
Cats =
{
new Cat{ Name = "Sylvester", Age=8 },
new Cat{ Name = "Whiskers", Age=2 },
new Cat{ Name = "Sasha", Age=14 }
}
};
要添加的条目集将用大括号括起来。 上述代码与编写代码相同：
CatOwner owner = new ();
owner.Cats.Add(new Cat{ Name = "Sylvester", Age=8 });
owner.Cats.Add(new Cat{ Name = "Whiskers", Age=2 });
owner.Cats.Add(new Cat{ Name = "Sasha", Age=14 });
示例
下例结合了对象和集合初始值设定项的概念。
public class InitializationSample
{
public class Cat
{
// Automatically implemented properties.
public int Age { get; set; }
public string? Name { get; set; }
public Cat() { }
public Cat(string name)
{
Name = name;
}
}
public static void Main()
{
Cat cat = new Cat { Age = 10, Name = "Fluffy" };
Cat sameCat = new Cat("Fluffy"){ Age = 10 };
List<Cat> cats =
[
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
};
List<Cat> allCats = [.. cats, new Cat { Name = "Łapka", Age = 5 }, cat, .. moreCats];
// Display results.
foreach (Cat? c in allCats)
{
if (c != null)
{
System.Console.WriteLine(c.Name);
}
else
{
System.Console.WriteLine("List element has null value.");
}
}
}
// Output:
// Sylvester
// Whiskers
// Sasha
// Łapka
// Fluffy
// Furrytail
// Peaches
// List element has null value.
}
以下示例演示了一个对象，该对象实现 IEnumerable 并包含具有多个参数的 Add 方法。 它使用一个集合初始值设定项，其中列表中的每个项都有多个元素，这些元素对应于 Add 方法的签名。
public class FullExample
{
class FormattedAddresses : IEnumerable<string>
{
private List<string> internalList = new();
public IEnumerator<string> GetEnumerator() => internalList.GetEnumerator();
System.Collections.IEnumerator System.Collections.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}
"""
);
}
public static void Main()
{
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 方法可使用 params 关键字来获取可变数量的自变量，如下例中所示。 此示例还演示了索引器的自定义实现，以使用索引初始化集合。 从 C# 13 开始， params 参数不限于数组。 它可以是集合类型或接口。
public class DictionaryExample
{
class RudimentaryMultiValuedDictionary<TKey, TValue> : IEnumerable<KeyValuePair<TKey, List<TValue>>> where TKey : notnull
{
private Dictionary<TKey, List<TValue>> internalDictionary = new Dictionary<TKey, List<TValue>>();
public IEnumerator<KeyValuePair<TKey, List<TValue>>> GetEnumerator() => internalDictionary.GetEnumerator();
System.Collections.IEnumerator System.Collections.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());
}
storedValues.AddRange(values);
}
}
public static void Main()
{
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" }
};
RudimentaryMultiValuedDictionary<string, string> rudimentaryMultiValuedDictionary3
= new RudimentaryMultiValuedDictionary<string, string>()
{
{"Group1", new string []{ "Bob", "John", "Mary" } },
{ "Group2", new 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);
}
}
Console.WriteLine("\r\nUsing third multi-valued dictionary created with a collection initializer using indexing:");
foreach (KeyValuePair<string, List<string>> group in rudimentaryMultiValuedDictionary3)
{
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
Using third 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
*/
}
