将字段设置为只读

通常，对于不应更改的字段，将其标记为只读是一个更好的选择：

1. 在 Person.cs 中，添加一个声明来声明一个实例只读字段以存储一个人的家园星球，如下所示代码：

// Read-only fields: Values that can be set at runtime.
public readonly string HomePlanet = "Earth";

在 Program.cs 中，添加一条语句将 Bob 的名字和家园星球写入控制台，如下所示：

// Read-only fields are accessible via the variable.
WriteLine(#34;{bob.Name} was born on {bob.HomePlanet}.");

1. 运行 PeopleApp 项目并查看结果，如下所示输出：

Bob Smith was born on Earth.

良好实践：使用只读字段而非常量字段，有两个重要原因：值可以在运行时计算或加载，并且可以使用任何可执行语句表示。因此，只读字段可以使用构造函数或字段赋值来设置。对只读字段的每个引用都是活动引用，因此任何未来的更改都将被调用代码正确反映。

您也可以声明 static readonly 字段，其值将在该类型的所有实例之间共享。

要求在实例化时设置字段

C# 11 引入了 required 修饰符。如果您在字段或属性上使用它，编译器将确保在实例化时设置字段或属性的值。它需要针对.NET 7 或更高版本，因此我们需要首先创建一个新的类库：

1. 在 Chapter05 解决方案中，添加一个名为 PacktLibraryModern 的新类库项目，目标为.NET 9。（支持 required 修饰符的最旧版本是.NET 7。）
2. 在 PacktLibraryModern 项目中，将 Class1.cs 重命名为 Book.cs 。
3. 修改代码文件内容，使类具有四个字段，其中两个字段设置为 required ，如下所示代码：

namespace Packt.Shared;
public class Book
{
  // Needs .NET 7 or later as well as C# 11 or later.
  public required string? Isbn;
  public required string? Title;
  // Works with any version of .NET.
  public string? Author;
  public int PageCount;
}

请注意，所有 three 字符串属性都是可空的。将属性或字段设置为 required 并不意味着它不能是 null 。它只是意味着它必须显式设置为 null 。

1. 在 PeopleApp 控制台应用程序项目中，添加对 PacktLibraryModern 类库项目的引用：如果您使用 Visual Studio，则在解决方案资源管理器中，选择 PeopleApp 项目，转到项目 | 添加项目引用…，勾选复选框以选择 PacktLibraryModern 项目，然后单击确定。如果您使用 VS Code，请编辑 PeopleApp.csproj 以添加对 PacktLibraryModern 的项目引用，如以下标记所示：

<ItemGroup>
  <ProjectReference Include=
"..\PacktLibraryNet2\PacktLibraryNet2.csproj" />
  <ProjectReference Include=
    "..\PacktLibraryModern\PacktLibraryModern.csproj" />
</ItemGroup>

1. 构建 PeopleApp 项目。这将编译其引用的依赖项并将类库 .dll 复制到本地 bin 文件夹的正确子目录中。
2. 在 PeopleApp 项目中，在 Program.cs 中，尝试实例化一个 Book 而不设置 Isbn 和 Title 字段，如下所示代码：

Book book = new();

请注意，您将看到编译器错误，如下所示输出：

C:\cs13net9\Chapter05\PeopleApp\Program.cs(137,13): error CS9035: Required member 'Book.Isbn' must be set in the object initializer or attribute constructor. [C:\cs13net9\Chapter05\PeopleApp\PeopleApp.csproj]
C:\cs13net9\Chapter05\PeopleApp\Program.cs(137,13): error CS9035: Required member 'Book.Title' must be set in the object initializer or attribute constructor. [C:\cs13net9\Chapter05\PeopleApp\PeopleApp.csproj]
    0 Warning(s)
    2 Error(s)

在 Program.cs 中，修改语句以使用对象初始化语法设置两个必需的属性，如下所示代码中突出显示：

Book book = new()
{
  Isbn = "978-1803237800",
  Title = "C# 12 and .NET 8 - Modern Cross-Platform Development Fundamentals"
};

1. 请注意，现在该语句编译无误。
2. 在 Program.cs 中，添加一条输出关于书籍信息的语句，如下所示代码：

WriteLine("{0}: {1} written by {2} has {3:N0} pages.",
  book.Isbn, book.Title, book.Author, book.PageCount);

在运行项目并查看输出之前，让我们谈谈一种初始化类型（或属性）字段的替代方法。

初始化字段使用构造函数

字段通常需要在运行时初始化。您可以在创建类实例时调用的构造函数中执行此操作，使用 new 关键字。构造函数在代码设置任何字段之前执行：

1. 在 Person.cs 中，在现有的只读 HomePlanet 字段之后添加语句以定义第二个只读字段，然后在构造函数中设置 Name 和 Instantiated 字段，如下代码所示：

// Read-only fields: Values that can be set at runtime.
public readonly string HomePlanet = "Earth";
public readonly DateTime Instantiated;
#endregion
#region Constructors: Called when using new to instantiate a type.
public Person()
{
  // Constructors can set default values for fields
  // including any read-only fields like Instantiated.
  Name = "Unknown";
  Instantiated = DateTime.Now;
}
#endregion

在 Program.cs 中，添加语句以实例化一个新的 Person 对象，然后输出其初始字段值，如下所示：

Person blankPerson = new();
WriteLine(format:
  "{0} of {1} was created at {2:hh:mm:ss} on a {2:dddd}.",
  arg0: blankPerson.Name,
  arg1: blankPerson.HomePlanet,
  arg2: blankPerson.Instantiated);

运行 PeopleApp 项目，并从关于书籍的代码以及空白人物两方面查看结果，如下所示输出：

978-1803237800: C# 12 and .NET 8 - Modern Cross-Platform Development Fundamentals written by  has 0 pages.
Unknown of Earth was created at 11:58:12 on a Sunday

定义多个构造函数

您可以在一个类型中拥有多个构造函数。这特别有助于鼓励开发者为字段设置初始值：

1. 在 Person.cs 中，添加语句以定义第二个构造函数，允许开发者设置人的姓名和家园行星的初始值，如下所示代码：

public Person(string initialName, string homePlanet)
{
  Name = initialName;
  HomePlanet = homePlanet;
  Instantiated = DateTime.Now;
}

在 Program.cs 中，添加语句使用两个参数的构造函数创建另一个人，如下所示代码：

Person gunny = new(initialName: "Gunny", homePlanet: "Mars");
WriteLine(format:
  "{0} of {1} was created at {2:hh:mm:ss} on a {2:dddd}.",
  arg0: gunny.Name,
  arg1: gunny.HomePlanet,
  arg2: gunny.Instantiated);

1. 运行 PeopleApp 项目并查看结果：

Gunny of Mars was created at 11:59:25 on a Sunday

设置构造函数中的必填字段

现在，让我们回到 Book 类示例及其 required 字段：

1. 在 PacktLibraryModern 项目中，在 Book.cs 中，添加语句定义一对构造函数，一个支持对象初始化语法，另一个用于设置两个必需的属性，如下代码所示：

public class Book
{
  // Constructor for use with object initializer syntax.
  public Book() { }
  // Constructor with parameters to set required fields.
  public Book(string? isbn, string? title)
  {
    Isbn = isbn;
    Title = title;
  }

在 Program.cs 中，取消注释使用对象初始化语法实例化书籍的语句，添加使用构造函数实例化书籍的语句，然后设置书籍的非 required 属性，如下代码所示：

/*
// Instantiate a book using object initializer syntax.
Book book = new()
{
  Isbn = "978-1803237800",
  Title = "C# 12 and .NET 8 - Modern Cross-Platform Development Fundamentals"
};
*/
Book book = new(isbn: "978-1803237800", title:
  "C# 12 and .NET 8 - Modern Cross-Platform Development Fundamentals")
{
  Author = "Mark J. Price",
  PageCount = 821
};

1. 请注意，您将像之前一样看到编译器错误，因为编译器无法自动判断调用构造函数将设置这两个 required 属性。
2. 在 PacktLibraryModern 项目中，在 Book.cs 中导入命名空间以执行代码分析，然后使用属性装饰构造函数，告诉编译器它设置了所有必需的属性和字段，如下面的代码所示：

using System.Diagnostics.CodeAnalysis; // To use [SetsRequiredMembers].
namespace Packt.Shared;
public class Book
{
  public Book() { } // For use with initialization syntax.
  [SetsRequiredMembers]
  public Book(string isbn, string title)

1. 在 Program.cs 中，注意现在调用构造函数的语句编译没有错误。
2. 可选地，运行 PeopleApp 项目以确认其行为符合预期，如下所示输出：

978-1803237800: C# 12 and .NET 8 - Modern Cross-Platform Development Fundamentals written by Mark J. Price has 821 pages.

更多信息：您可以在以下链接中了解有关 required 字段以及如何使用构造函数设置它们的更多信息：https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/required。

构造函数是一种特殊的方法类别。让我们更详细地看看方法。

与方法和元组一起工作

方法是一个类型的成员，它执行一组语句。它们是属于一个类型的函数。

从方法中返回值

方法可以返回单个值或无返回值：

• 一种执行某些操作但不返回值的函数，在函数名称前使用 void 类型来表示。
• 一种执行某些操作并返回值的函数，在函数名之前用返回值的类型来表示这一点。

例如，在下一个任务中，您将创建两个方法：

• WriteToConsole ：这将执行一个操作（将一些文本写入控制台），但方法将不会返回任何内容，由 void 关键字表示。
• GetOrigin ：这将返回一个文本值，由 string 关键字指示。

让我们编写代码：

1. 在 Person.cs 中，添加语句以定义我之前描述的两个方法，如下所示：

#region Methods: Actions the type can perform.
public void WriteToConsole()
{
  WriteLine(#34;{Name} was born on a {Born:dddd}.");
}
public string GetOrigin()
{
  return #34;{Name} was born on {HomePlanet}.";
}
#endregion

在 Program.cs 中，添加调用两个方法的语句，如下所示代码：

bob.WriteToConsole();
WriteLine(bob.GetOrigin());

运行 PeopleApp 项目并查看结果，如下所示输出

Bob Smith was born on a Wednesday.
Bob Smith was born on Earth.

定义和传递方法参数

方法可以通过传递参数来改变其行为。参数的定义有点像变量声明，但位于方法声明的括号内，就像您在本章前面看到的构造函数那样。让我们看看更多示例：

1. 在 Person.cs 中，添加定义两个方法的语句，第一个不带参数，第二个带一个参数，如下所示：

public string SayHello()
{
  return #34;{Name} says 'Hello!'";
}
public string SayHelloTo(string name)
{
  return #34;{Name} says 'Hello, {name}!'";
}

在 Program.cs 中，添加调用两个方法的语句，并将返回值写入控制台，如下所示：

WriteLine(bob.SayHello());
WriteLine(bob.SayHelloTo("Emily"));

运行 PeopleApp 项目并查看结果：

Bob Smith says 'Hello!'
Bob Smith says 'Hello, Emily!'

当输入调用方法的语句时，IntelliSense 会显示一个包含方法名称、任何参数的类型和方法返回类型的工具提示。

过载方法

而不是有两个不同的方法名，我们可以给这两个方法相同的名字。这是允许的，因为每个方法都有不同的签名。

方法签名是在调用方法时可以传递的参数类型列表。重载方法必须在参数类型列表上有所不同。两个重载方法不能有相同的参数类型列表，并且仅在返回类型上有所不同。让我们编写一个示例：

1. 在 Person.cs 中，将 SayHelloTo 方法的名字更改为 SayHello 。
2. 在 Program.cs 中，将方法调用更改为使用 SayHello 方法，并注意该方法的快速信息显示它有额外的重载，1/2 以及 2/2，在 Visual Studio 中，尽管其他代码编辑器可能不同，如图 5.3 所示：

好的做法：使用重载方法简化您的类，使其看起来拥有更少的方法。

传递可选参数

另一种简化方法是将参数设置为可选。您可以通过在方法参数列表中为参数分配默认值来使参数可选。可选参数必须始终位于参数列表的末尾。

我们现在将创建一个包含三个可选参数的方法：

1. 在 Person.cs 中，添加定义方法的语句，如下所示代码：

public string OptionalParameters(string command = "Run!",
  double number = 0.0, bool active = true)
{
  return string.Format(
    format: "command is {0}, number is {1}, active is {2}",
    arg0: command,
    arg1: number,
    arg2: active);
}

在 Program.cs 中，添加一条语句来调用该方法并将返回值写入控制台，如下所示：

WriteLine(bob.OptionalParameters());

1. 观察 IntelliSense 在您键入代码时出现。您将看到一个工具提示，显示三个可选参数及其默认值。
2. 运行 PeopleApp 项目并查看结果，如下所示输出：

command is Run!, number is 0, active is True

在 Program.cs 中，添加一条语句以传递 string 值给 command 参数和 double 值给 number 参数，如下所示代码：

WriteLine(bob.OptionalParameters("Jump!", 98.5));

运行 PeopleApp 项目并查看结果，如下所示输出：

command is Jump!, number is 98.5, active is True

默认的 command 和 number 参数值已被替换，但 active 的默认值仍然是 true 。

在调用方法时命名参数值

可选参数通常在调用方法时与命名参数结合使用，因为命名参数允许以不同于声明时的顺序传递值：

1. 在 Program.cs 中，添加一个语句以传递 string 值给 command 参数和 double 值给 number 参数，但使用命名参数，这样它们传递的顺序可以互换，如下面的代码所示：

WriteLine(bob.OptionalParameters(number: 52.7, command: "Hide!"));

运行 PeopleApp 项目并查看结果，如下所示输出：

command is Hide!, number is 52.7, active is True

您甚至可以使用命名参数来跳过可选参数。

1. 在 Program.cs 中，添加一条语句以使用位置顺序传递 string 值给 command 参数，跳过 number 参数，并使用命名 active 参数，如下所示：

WriteLine(bob.OptionalParameters("Poke!", active: false));

运行 PeopleApp 项目并查看结果，如下所示输出：

command is Poke!, number is 0, active is False

良好的实践：虽然您可以混合使用命名参数和位置参数值，但大多数开发者更喜欢阅读在同一个方法调用中使用一种或另一种参数值的代码。

混合可选和必选参数

目前， OptionalParameters 方法中的所有参数都是可选的。如果其中一个参数是必需的怎么办？

1. 在 Person.cs 中，向 OptionalParameters 方法添加一个不带默认值的第四个参数，如以下代码所示：

public string OptionalParameters(string command = "Run!",
  double number = 0.0, bool active = true, int count)

1. 构建项目并注意编译错误：

Error CS1737 Optional parameters must appear after all required parameters.

在 OptionalParameters 方法中，将 count 参数移动到可选参数之前，如下所示：

public string OptionalParameters(int count,
  string command = "Run!",
  double number = 0.0, bool active = true)

在 Program.cs 中，修改所有对 OptionalParameters 方法的调用，将 int 值作为第一个参数传递，例如，如下代码所示：

WriteLine(bob.OptionalParameters(3));
WriteLine(bob.OptionalParameters(3, "Jump!", 98.5));
WriteLine(bob.OptionalParameters(3, number: 52.7, command: "Hide!"));
WriteLine(bob.OptionalParameters(3, "Poke!", active: false));

记住，如果你命名了参数，那么你可以改变它们的顺序，例如： bob.OptionalParameters(number: 52.7, command: "Hide!", count: 3) 。

1. 当您调用 OptionalParameters 方法时，注意 Visual Studio 中显示的提示信息，其中包含一个必需参数、三个可选参数及其默认值，如图 5.4 所示：

控制参数传递的方式

当参数传递给一个方法时，它可以以几种方式之一传递：

• 通过值（这是默认值）：将这些视为单向的。尽管值可以更改，但这只会影响方法中的参数。
• 作为一个 out 参数：将这些视为单向输出。 out 参数在其声明中不能分配默认值，也不能留作未初始化。必须在方法内部设置它们；否则，编译器将给出错误。
• 通过引用作为 ref 参数：将这些视为进出。像 out 参数一样， ref 参数也不能有默认值，但由于它们可以在方法外部设置，因此不需要在方法内部设置。
• 作为一个 in 参数：将这些视为只读的引用参数。 in 参数的值不能被更改，如果尝试修改，编译器将显示错误。

让我们看看一些在方法中传递参数的例子：

1. 在 Person.cs 中，添加语句定义一个具有三个参数的方法，一个 in 参数，一个 ref 参数和一个 out 参数，如下所示的方法：

public void PassingParameters(int w, in int x, ref int y, out int z)
{
  // out parameters cannot have a default and they
  // must be initialized inside the method.
  z = 100;
  // Increment each parameter except the read-only x.
  w++;
  // x++; // Gives a compiler error!
  y++;
  z++;
  WriteLine(#34;In the method: w={w}, x={x}, y={y}, z={z}");
}

在 Program.cs 中，添加语句声明一些 int 变量并将它们传递到方法中，如下所示：

int a = 10;
int b = 20;
int c = 30;
int d = 40;
WriteLine(#34;Before: a={a}, b={b}, c={c}, d={d}");
bob.PassingParameters(a, b, ref c, out d);
WriteLine(#34;After: a={a}, b={b}, c={c}, d={d}");

运行 PeopleApp 项目并查看结果，如下所示输出：

Before: a=10, b=20, c=30, d=40
In the method: w=11, x=20, y=31, z=101
After: a=10, b=20, c=31, d=101

请注意以下关于前一个输出的内容：

• 当默认通过参数传递变量时，传递的是其当前值，而不是变量本身。因此， w 有 a 变量的值的副本。 a 变量在 w 增加到 11 后仍保留其原始值 10 。
• 当将变量作为 in 参数传递时，变量的引用会被传递到方法中。因此， x 是 b 的引用。如果在方法执行过程中， b 变量被其他进程增加，那么 x 参数会显示出来。
• 当将变量作为 ref 参数传递时，变量的引用被传递到方法中。因此， y 是 c 的引用。当 y 参数增加时， c 变量会递增。
• 当将变量作为 out 参数传递时，变量的引用被传递到方法中。因此， z 是 d 的引用。 d 变量的值将被方法内部执行的代码所替换。

我们可以通过不将值 40 分配给 d 变量来简化 Main 方法中的代码，因为这个值无论如何都会被替换。在 C# 7 及以后的版本中，我们可以简化使用 out 参数的代码。

1. 在 Program.cs 中，添加语句以声明更多变量，包括一个名为 h 的 out 参数，该参数在行内声明，如下所示：

int e = 50;
int f = 60;
int g = 70;
WriteLine(#34;Before: e={e}, f={f}, g={g}, h doesn't exist yet!");
// Simplified C# 7 or later syntax for the out parameter.
bob.PassingParameters(e, f, ref g, out int h);
WriteLine(#34;After: e={e}, f={f}, g={g}, h={h}");

运行 PeopleApp 项目并查看结果，如下所示输出：

Before: e=50, f=60, g=70, h doesn't exist yet!
In the method: w=51, x=60, y=71, z=101
After: e=50, f=60, g=71, h=101

传递可变数量的参数

C#中的 params 关键字用于指定一个可以接受可变数量参数的方法参数。它允许你将参数数组传递给方法，或者传递一个编译器会自动转换为数组的参数列表。

从 C# 13 及以后版本开始，除了传递数组外，还可以传递任何可以通过集合表达式构造的类型，例如 List<T> 或 IEnumerable<T> 。集合表达式在第八章“使用常见.NET 类型”中有详细说明，但基本上，您可以通过在方括号中包围以逗号分隔的项目列表来定义一个项目集合 [ ] 。

使用 params 的好处包括灵活性。它允许方法接受任意数量的参数，并且易于使用，因为它通过避免在调用方法之前显式创建数组来简化方法签名。

在使用 params 关键字时有一些考虑因素：

• params 关键字只能用于方法中的一个参数，并且如果方法有多个参数，它必须是最后一个参数。
• 您可以将单个参数传递，编译器会自动将它们打包成一个数组。或者，您也可以传递一个数组或集合表达式。
• 当使用 params 时，您可以调用该方法而不传递任何参数给该参数，并将传递一个空数组。

让我们看看一些代码示例：

1. 在 Person.cs 中，添加语句定义一个带有两个参数的方法，一个普通参数和一个 params 参数，如下所示的方法：

public void ParamsParameters(
  string text, params int[] numbers)
{
  int total = 0;
  foreach(int number in numbers)
  {
    total += number;
  }
  WriteLine(#34;{text}: {total}");
}

1. 在 C# 12 及之前版本中， params int[] 必须是一个数组，尽管项目可以是任何数据类型，而不仅仅是 int 。在 C# 13 及以后版本中， params int[] 可以是集合表达式支持的任何数据类型，如 params List<int> 或 IEnumerable<int> ，尽管项目可以是任何数据类型，而不仅仅是 int 。

1. 在 Program.cs 中，添加语句以多种方式将字符串和一些数字传递到方法中，如下所示代码：

bob.ParamsParameters("Sum using commas",
  3, 6, 1, 2);
bob.ParamsParameters("Sum using collection expression",
  [3, 6, 1, 2]);
bob.ParamsParameters("Sum using explicit array",
  new int[] { 3, 6, 1, 2 });
bob.ParamsParameters("Sum (empty)");

运行 PeopleApp 项目并查看结果，如下所示输出：

Sum using commas: 12
Sum using collection expression: 12
Sum using explicit array: 12
Sum (empty): 0

params 关键字是 C# 中一个强大的功能，它通过允许方法接受可变数量的参数，增强了代码的灵活性和可读性。