Detaillierte Erläuterung der Konstruktionsmethode und Beispielcode der C#-Klasse

In diesem Artikel wird hauptsächlich die Konstruktormethode der Klasse c# vorgestellt. Es hat einen bestimmten Referenzwert, schauen wir es uns mit dem Editor unten an

1. Konstruktionsmethode

Die Konstruktionsmethode einer Klasse ist das Mitglied Methode der Klasse, ihre Funktion besteht darin, Mitglieder in der Klasse zu initialisieren. Die Konstruktionsmethoden der Klasse sind unterteilt in:

1. statische Konstruktionsmethode

2. Instanzkonstruktionsmethode

1. Statische Konstruktionsmethode

Die statische Konstruktionsmethode einer Klasse ist eine Art Mitgliedsmethode der Klasse, und ihre Funktion besteht darin, statische Mitglieder in der Klasse zu initialisieren. Bitte sehen Sie sich das Codebeispiel unten an:

using System;
namespace LycheeTest {
 class Test {
 //定义一个静态成员变量
 private static int a;
 //定义静态构造函数
 static Test() {
  //初始化静态成员变量
  a = 11;
 }
 public void Show() {
  Console.WriteLine("静态字段 a 的值是：{0}", a);
 }
 }
 class Program {
 static void Main(string[] args) {
  Test t = new Test();
  t.Show();
  Console.ReadKey();
 }
 }
}

Zunächst definiert der obige Code zwei Klassen. Zeile 3 definiert die Klasse Test. Beim Definieren einer Klasse gibt es zwei Zugriffsmodifikatoren für die Klasse: einer ist öffentlich und der andere ist intern. Wenn kein Zugriffsmodifikator geschrieben wird, ist die Zugriffsberechtigung der Klasse standardmäßig intern. Die Bedeutung dieser Zugriffsberechtigung besteht darin, dass auf diese Klasse nur von dieser Assembly zugegriffen werden kann und nicht von Klassen außerhalb dieser Assembly. Wenn diese Klasse zu einer

Klassenbibliothek gehört, muss sie öffentlich sein, andernfalls kann die Assembly, die sie aufruft, nicht darauf zugreifen. Zeile 5 des Codes definiert ein statisches Feldmitglied und Zeile 7 des Codes ist der statische Konstruktor. Wie Sie sehen können, besteht das Merkmal der statischen Konstruktionsmethode darin, dass das Schlüsselwort static angibt, dass die Methode statisch ist und der Methodenname genau mit dem Klassennamen übereinstimmen muss. Achten Sie hier auf die Groß-/Kleinschreibung. Statische Konstruktionsmethoden dürfen keine Parameter enthalten und statische Konstruktionsmethoden können keine Rückgabewerte haben. Sie können statische Elemente im Hauptteil der statischen Konstruktormethode initialisieren. Zeile 11 des Codes definiert eine Instanzmethode, die den Wert eines statischen Felds ausgibt. Diese Klasse wird in der Methode Main (Anmerkung: main in Java) in der Klasse Program in Zeile 16 aufgerufen, eine Instanz dieser Klasse wird in Zeile 18 erstellt und die Instanzmethode der Klasse wird in Zeile 19 aufgerufen.

Wie Sie dem obigen Code entnehmen können, wird der statische Konstruktor der Klasse nicht explizit aufgerufen.

Bitte sehen Sie sich das Ausführungsergebnis des obigen Codes unten an:

静态字段 a 的值是：11

Wie Sie sehen können, wird die statische Konstruktionsmethode tatsächlich ausgeführt. Dann ist das obige Beispiel eine der Ausführungsbedingungen der statischen Konstruktionsmethode. Wenn eine Instanz der Klasse erstellt wird, wird die statische Konstruktionsmethode der Klasse automatisch aufgerufen.

Die Aufrufreihenfolge des statischen Konstruktors folgt nach dem Initialisierer des statischen Felds.

Das heißt, der erste Schritt besteht darin, den Standardwert des statischen Felds festzulegen, der zweite Schritt darin, den Anfangswertsetzer des statischen Felds auszuführen und der dritte Schritt darin, die statische Konstruktormethode von aufzurufen die Klasse.

Ändern wir das vorherige Codebeispiel. Der Code lautet wie folgt:

using System;
namespace LycheeTest{
 class Test {
 private static int a;
 static Test() {
  a++;
 }
 public void Show() {
  Console.WriteLine("静态字段 a 的值是：{0}", a);
  14
 }
 }
 class Program {
 static void Main(string[] args) {
  Test t = new Test();
  t.Show();
  Test t1 = new Test();
  t.Show();
  Console.ReadKey();
 }
 }
}

Dieser Code ändert die statische Konstruktionsmethode und erhöht das statische Feld a im Methodenkörper. Dann wird in Zeile 17 des Codes eine weitere Instanz der Klasse erstellt und die Instanzmethode der Klasse erneut aufgerufen.

Sehen Sie sich die Ausführungsergebnisse unten an:

静态字段 a 的值是：1 
静态字段 a 的值是：1

Wie Sie sehen können, hat sich der Wert des statischen Felds nicht erhöht. Dies ist das Merkmal der statischen Konstruktorausführung, sie wird nur einmal ausgeführt. Wenn die Assembly ausgeführt wird, wird eine Anwendungsdomäne erstellt. In einer Anwendungsdomäne wird die statische Konstruktionsmethode der Klasse nur einmal ausgeführt.

Das Codebeispiel wird wie folgt geändert:

using System;
namespace LycheeTest {
 class Test {
 public static int a;
 static Test() {
  Console.WriteLine("类的静态构造方法开始执行");
  a++;
 }
 public void Show() {
  Console.WriteLine("静态字段 a 的值是：{0}", a);
 }
 }
 class Program {
 static void Main(string[] args) {
  Console.WriteLine("静态字段 a 的值是：{0}", Test.a);
  Console.WriteLine("静态字段 a 的值是：{0}", Test.a);
  Console.ReadKey();
 }
 }
}

Dieser Code gibt eine Zeile von Tags in der statischen Konstruktionsmethode der Klasse und die Zugriffsberechtigungen der statischen Felder der aus Die Klasse wird ebenfalls in „öffentlich“ geändert, wodurch sie außerhalb der Klasse aufgerufen werden kann. Der Wert des statischen Felds wird in der Main-Methode zweimal ausgedruckt. Beachten Sie, dass der Aufruf des statischen Felds der Klasse außerhalb der Klasse die Verwendung des Klassennamens als

Referenz erfordert.

Das Folgende ist das Ausführungsergebnis des Codes:

类的静态构造方法开始执行
静态字段 a 的值是：1
静态字段 a 的值是：1

Dieser Code erstellt keine Instanz der Klasse. Bevor auf die statischen Mitglieder der Klasse verwiesen wird, wird der statische Konstruktor der Klasse aufgerufen. Zu den statischen Mitgliedern der aufgerufenen Klasse gehören statische Felder und statische Methoden. Dies ist die zweite Bedingung für den Aufruf der statischen Konstruktormethode der Klasse.

Das Codebeispiel wird wie folgt geändert:

using System;
namespace LycheeTest {
 class Program {
 private static int a;
 static Program() {
  Console.WriteLine("类的静态构造方法被调用");
  a = 11;
 }
 static void Main(string[] args) {
  Console.WriteLine("Main 方法被调用");
  Console.WriteLine("静态字段 a 的值是：{0}", a);
  Console.ReadKey();
 }
 }
}

Dieser Code definiert statische Felder und statische Konstruktoren in der Klasse, die die Main-Methode enthält. Da die Main-Methode auch eine statische Methode ist, wird der statische Konstruktor der Klasse aufgerufen und ist die Einstiegspunktmethode der Klasse. Wer ruft sie also zuerst zwischen ihr und dem statischen Konstruktor der Klasse auf? Schauen wir uns zunächst die Ausführungsergebnisse des Codes an:

类的静态构造方法被调用
Main 方法被调用
静态字段 a 的值是：11

An den Ausführungsergebnissen des Codes können Sie erkennen, dass die Einstiegspunktmethode der Klasse immer noch eine statische Methode ist, bevor es statische Mitglieder gibt aufgerufen, werden zuerst die statischen Konstruktionsmethoden aufgerufen. Daraus kann geschlossen werden, dass der statische Konstruktor der Klasse vor der Main-Methode der Klasse aufgerufen wird.

Kann der statische Konstruktor einer Klasse also explizit aufgerufen werden? Schauen Sie sich das Codebeispiel unten an:

using System;
namespace LycheeTest {
 class Program {
 private static int a;
 static Program() {
  Console.WriteLine("类的静态构造方法被调用");
  a = 11;
 }
 static void Main(string[] args) {
  Program();
  Console.ReadKey();
 }
 }
}

在这段代码中的第 10 行显式调用了类的静态构造方法，这时编译器会报错。

2.实例构造函数

类的实例构造方法是类的成员方法的一种，它的作用是对类的实例成员进行初始化操作。实例构造方法可以实现重载，在创建类的实例时，可以显式的指定不同的参数来调用重载的不同的实例构造方法。下面请看代码实例：

using System;
namespace LycheeTest {
 class Program {
 private static int a;
 private int b = 12;
 private string c = "Hello World";
 static Program() {
  Console.WriteLine("类的静态构造方法被调用");
  a = 11;
 }
 public Program(int a, string s) {
  Console.WriteLine("带二个参数的构造方法被调用");
  this.b = a;
  this.c = s;
 }
 public Program(int a) : this(a, "通过 this 关键字调用构造方法") {
  Console.WriteLine("带一个参数的构造方法被调用");
 }
 public void Show() {
  Console.WriteLine("静态字段 a 的值是：{0}", a);
  Console.WriteLine("实例字段 b 的值是：{0}", b);
  Console.WriteLine("实例字段 c 的值是：{0}", c);
 }
 static void Main(string[] args) {
  Program p1 = new Program(33, "这是创建的实例 P1");
  Program p2 = new Program(34);
  p1.Show();
  p2.Show();
  Console.ReadKey();
 }
 }

这段代码的第 4 行、第 5 行和第 6 行分别定义了三个字段成员，第 4 行是静态字段，第 5 行和第 6 行代码都有初始值设定项。代码的第 8 行就是一个实例构造方法的定义，实例构造方法也是以类名作为方法名，它没有返回值， 在方法名前面是访问权限修饰符，可以使用的访问权限修饰符包括 public、private 和 protected。其中的 protected 意味着构造方法只能在此类内部访问。实例构造方法可以带参数。 第 12 行代码的实例构造方法使用两个传入的参数对实例字段进行了赋值。第 17 行代码定义了带一个参数的实例构造方法，它和前一个实例构造方法形成了重载。实例构造方法可以通过 this 关键字调用其他的实例构造方法，方法就是在参数列表的后面使用冒号然后接 this 关键字， 然后再跟参数列表，这个参数列表要匹配另一个重载的实例构造方法。第 17 行的构造方法只有一个参数， 它将这个参数通过 this 关键字传递给了另一个构造方法，在用 this 调用另一个构造方法的时候，为其同时传入了一个字符串参数。第 24 行的实例方法打印类的字段成员的值。在 Main 方法中，第 26 行代码和第 27 行代码分别定义了两个实例，它们使用 new 关键字调用了不同的实例构造方法。第 28 行和第 29 行分别调用实例方法打印类的静态字段和实例的两个字段成员的值。

下面先来看代码的执行结果：

类的静态构造方法被调用 带二个参数的构造方法被调用 带二个参数的构造方法被调用 带一个参数的构造方法被调用 
静态字段 a 的值是：11 
实例字段 b 的值是：33
实例字段 c 的值是：这是创建的实例 P1 静态字段 a 的值是：11
实例字段 b 的值是：34
实例字段 c 的值是：通过 this 关键字调用构造方法

现在用执行结果来介绍实例构造方法的执行过程，当第 26 行代码创建类的实例时，类的静态字段首先被设置成默认值，因为没有字段的初始值设定项，所以接着就执行类的静态构造方法。这时静态字段 a 被 设置成 11。因为第 26 行代码使用 new 调用了带有两个参数的实例构造方法，所以首先实例字段 b 被设置为 0，实例字段 c 被设置为 null。然后执行字段的初始值设定项，b 被赋值为 12，c 被赋值为“Hello World”。接 下来执行实例构造方法体中的第一个语句，“带二个参数的构造方法被调用”这个字符串被打印。接下来 实例 p1 的字段 b 被设置为传入的参数 33，注意构造方法的形参 a 在这里覆盖了类的静态字段 a。也就是说， 这时起作用的是实例构造方法的局部变量 a。然后实例字段 c 被设置为字符串"这是创建的实例 P1"。第 27 行代码使用 new 关键字调用了带一个参数的实例构造方法，在调用时，首先属于 p2 的实例字段 b 被设置为 0，实例字段 c 被设置为 null。然后执行字段的初始值设定项，b 被赋值为 12，c 被赋值为“Hello World”。接下来执行的是 this 引用的带两个参数的实例构造方法，"带二个参数的构造方法被调用"这个 字符串被打印。然后 b 被设置为 34，c 被设置为"通过 this 关键字调用构造方法"。最后，代码控制又返回 来执行带一个参数的实例构造方法体中的打印语句，"带一个参数的构造方法被调用"这个字符串被打印。 至此，实例构造方法的执行完毕。接下来的代码打印静态字段的值，可以看到两个实例打印出来的静态字段值是一样的，但是它们的实 例字段的值各不相同。

可选参数和命名参数也可以用于实例构造方法，下面看代码实例：

using System;
namespace LycheeTest {
 class Program {
 private int b;
 private string c;
 public Program(int a = 12, string s = "") {
  this.b = a;
  this.c = s;
 }
 public void Show() {
  Console.WriteLine("实例字段 b 的值是：{0}", b);
  Console.WriteLine("实例字段 c 的值是：{0}", c);
 }
 static void Main(string[] args) {
  Program p1 = new Program(); //构造方法的两个参数都采用默认值
  Program p2 = new Program(34); //构造方法的 string 类型参数采用默认值
  Program p3 = new Program(23, "Hello World"); //构造方法的两个参数采用传入参数
  Program p4 = new Program(s: "今天的天气真好"); //采用命名参数，另一个参数 a 采用默认值
  p1.Show();
  p2.Show();
  p3.Show();
  p4.Show();
  Console.ReadKey();
 }
 }
}

代码的第 6 行定义了一个带有可选参数和命名参数的构造方法，然后第 15 创建了一个类的实例，在构造方法中没有传入任何参数，这时，构造方法的两个参数都采用默认值。第 16 行代码为构造方法传入了一个 int 类型的参数，这时，另一个 string 类型的参数采用默认值。 第 17 行代码传入了两个参数，构造方法的两个参数都使用了这两个传入的参数。第 18 行代码使用了命名参数指定传入的参数是 string 类型的参数，并将它传递给形参 s。这时另一 个 int 类型的参数采用默认值。第 19 行到第 23 行代码打印类的实例字段的值。这段代码的执行结果如下：

实例字段 b 的值是：12 
实例字段 c 的值是： 
实例字段 b 的值是：34 
实例字段 c 的值是： 
实例字段 b 的值是：23
实例字段 c 的值是：Hello World 实例字段 b 的值是：12
实例字段 c 的值是：今天的天气真好

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Konstruktionsmethode und Beispielcode der C#-Klasse. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!