In diesem Artikel wird der C#-Delegat durch eine Fallanalyse im Detail vorgestellt, die einen guten Referenzwert hat. Schauen wir uns ihn mit dem Editor an.
Delegation ist ein Typ. Delegaten in C# sind objektorientiert und typsicher. Wenn eine Delegateninstanz erstellt wird, enthält die erstellte Instanz eine Aufrufliste, die mehrere Methoden enthalten kann. Jede Methode wird als aufrufende Entität bezeichnet. Die aufrufende Entität kann eine statische Methode oder eine Instanzmethode sein. Im Fall einer Instanzmethode enthält die aufrufende Entität die Instanz, für die die Instanzmethode aufgerufen wurde. Der Delegat kümmert sich nicht um die Klasse der Methode, die er aufruft, sondern nur darum, ob die aufgerufene Methode mit dem Typ des Delegaten kompatibel ist. Das Folgende ist ein Codebeispiel:
using System;
namespace LycheeTest{
public delegate void D(int a, int b);
public class Test {
public D myDelegate;
public Test() {
myDelegate = new D(Show1);
}
private static void Show1(int a, int b) {
Console.WriteLine("方法 Show1 被调用，两个实参相加的值是：{0}", a + b);
}
private void Show2(int a, int b) {
Console.WriteLine("方法 Show2 被调用，两个实参相加的值是：{0}", a + b);
}
private void Show3(int a, int b) {
Console.WriteLine("方法 Show3 被调用，两个实参相加的值是：{0}", a + b);
}
}
public class Program {
static void Main(string[] args) {
Test myT = new Test();
myT.myDelegate(33, 22);
Console.ReadKey();
}
}
}Dieser Code demonstriert die einfachste Form der Delegation. Der Delegattyp kann außerhalb der Klasse oder innerhalb der Klasse definiert werden . Dieser Code wird außerhalb der Klasse definiert. Die dritte Codezeile definiert einen Delegate-Typ. Das Schlüsselwort des Delegat-Typs lautet „delegate“, und vor dem Schlüsselwort steht der Zugriffsberechtigungsmodifikator des Delegate-Typs. Auf das Schlüsselwort folgt der Rückgabetyp des Delegate-Typs, der angibt, dass der Rückgabetyp der mit dem Delegate-Typ kompatiblen Methoden identisch sein muss. Auf den Rückgabetyp folgt der Name des Delegatentyps. Als nächstes folgt die formale Parameterliste, die angibt, dass der Parametertyp und die Anzahl der mit dem Delegatentyp kompatiblen Methoden gleich sein müssen. Zeile 5 des Codes definiert eine Variable vom Typ Delegat, bei der es sich um ein Instanzfeld handelt und deren Zugriffsberechtigung öffentlich ist. Beachten Sie, dass die Zugriffsrechte des Delegate-Typ-Felds niedriger sein müssen als die Zugriffsrechte des Delegate-Typs oder mit den Zugriffsrechten des Delegate-Typs identisch sein müssen. Die Zeilen 9, 12 und 15 definieren drei Methoden. Zeile 9 des Codes ist eine statische Methode. Da dieser Code die einfachste Methode zur Verwendung von Delegaten demonstriert, werden nur die statischen Methoden verwendet. Im Konstruktor in Zeile 6 wird eine Variable des Delegatentyps instanziiert. Beachten Sie, dass Sie zum Hinzufügen einer Methode zur Aufrufliste der Delegate-Variablen nur den Methodennamen an ihren Konstruktor übergeben müssen. Dies ist die einfachste Möglichkeit, einem Delegaten eine aufrufende Methode hinzuzufügen. Zeile 21 definiert eine Instanz der Test-Klasse und dann ruft Zeile 22 das Delegate-Mitglied der Klasse auf. Wenn Sie ein Delegate-Mitglied aufrufen, müssen Sie tatsächliche Parameter an seine formale Parameterliste übergeben. Dies ist die einfachste Art der Delegation. Das Ausführungsergebnis dieses Codes lautet wie folgt:
方法 Show1 被调用，两个实参相加的值是：55
Das Folgende ist eine Einführung in die Verwendung des Delegatentyps. Der Beispielcode lautet wie folgt:
using System;
namespace LycheeTest {
public delegate void D(int a, int b);
public class Test {
public static void Show1(int a, int b) {
Console.WriteLine("方法 Show1 被调用，两个实参相加的值是：{0}", a + b);
}
public void Show2(int a, int b) {
Console.WriteLine("方法 Show2 被调用，两个实参相加的值是：{0}", a + b);
}
public void Show3(int a, int b) {
Console.WriteLine("方法 Show3 被调用，两个实参相加的值是：{0}", a + b);
}
}
public class Program {
static void Main(string[] args) {
Test myT = new Test();
D myDelegate = new D(Test.Show1);
D myDelegate1 = new D(myT.Show2);
D myDelegate2 = new D(myT.Show3);
myDelegate(22, 33);
myDelegate1(33, 44);
myDelegate2(55, 66);
Console.ReadKey();
}
}
}Dieser Code löscht das Delegate-Typ-Feld in der Klasse, behandelt den Delegate-Typ jedoch als Klasse. In der Klasse, die die Einstiegspunktmethode enthält, wird in Zeile 17 zunächst eine Variable der Testklasse definiert und instanziiert. Da die Instanzmethode der Klasse an den Delegaten übergeben wird, muss eine Instanz der Klasse vorhanden sein, bevor auf die Instanzmethode der Klasse verwiesen werden kann. Zeile 18 definiert eine Variable vom Typ Delegat und instanziiert sie. Da der Delegat kein Mitglied der Klasse ist, muss er beim Übergeben der statischen Methode an seinen Konstruktor durch den Klassennamen referenziert werden . Zeile 19 definiert auch eine Variable vom Typ Delegat, auf die von einer Instanz der Klasse verwiesen werden muss, wenn Instanzmethoden an sie übergeben werden. Zeile 20 ist identisch mit Zeile 19. Wenn Sie eine Methode an einen Delegaten übergeben, müssen Sie den Methodennamen anstelle der formalen Parameterliste der Methode übergeben. Die Zeilen 21 bis 23 sind Aufrufe an den Delegaten, an den die tatsächlichen Parameter der Methode übergeben werden müssen. Das Ausführungsergebnis dieses Codes lautet wie folgt:
方法 Show1 被调用，两个实参相加的值是：55 方法 Show2 被调用，两个实参相加的值是：77 方法 Show3 被调用，两个实参相加的值是：121
Der Zugriffsmodifikator des Delegaten
Wann Der Delegat befindet sich in der Klasse. Wenn er extern ist, können öffentliche und interne Zugriffsmodifikatoren verwendet werden. Wenn nichts geschrieben wird, ist die Standardeinstellung intern. Wenn sich der Delegat in einer Klasse befindet, können folgende Zugriffsmodifikatoren verwendet werden: public, protected, internal, protectedusing System;
namespace LycheeTest{
public class Test {
protected delegate void D(int a, int b);
private delegate void D1(int a, int b);
protected internal delegate void D2(int a, int b);
internal delegate void D3(int a, int b);
private D myD;
private D1 myD1;
private D2 myD2;
private D3 myD3;
public Test() {
myD = new D(Show1);
myD1 = new D1(Show1);
myD2 = new D2(Show1);
myD3 = new D3(Show1);
}
public static void Show1(int a, int b) {
Console.WriteLine("方法 Show1 被调用，两个实参相加的值是：{0}", a + b);
}
public void Show2(int a, int b) {
Console.WriteLine("方法 Show2 被调用，两个实参相加的值是：{0}", a + b);
}
public void Show3(int a, int b) {
Console.WriteLine("方法 Show3 被调用，两个实参相加的值是：{0}", a + b);
}
public void Use() {
myD(11, 12);
myD1(22, 45);
myD2(55, 78);
myD3(345, 100);
}
}
class Test1: Test {
private D Test1D;
private D2 Test1D2;
private D3 Test1D3;
public Test1() {
Test1D = new D(Test.Show1);
Test1D2 = new D2(Test.Show1);
Test1D3 = new D3(Test.Show1);
}
public void Use1() {
Test1D(22, 45);
Test1D2(44, 45);
Test1D3(77, 78);
}
}
public class Program {
static void Main(string[] args) {
Test1 myT1 = new Test1();
myT1.Use();
myT1.Use1();
Console.ReadKey();
}
}
}代码的第 4 行在类的内部定义了委托类型，它作为类的成员定义，访问权限是 protected，它可以被本类内部访问，也可以被派生类访问。代码的第 5 行定义的委托类型，访问权限是 private 的，它只可以被本类内部访问。代码的第 6 行定义的 protected internal 访问权限的委托类型，可以被本程序集访问， 还可以被派生类访问，而不管派生类位于哪个程序集。第 7 行定义的委托类型是 internal 的，它只可以被本程序集访问。因为所有这几种委托类型都可以被本类内部访问，所以第 10 行到第 13 行定义了它们的变量。第 12 行的实例构造方法中，对这四个委托类型的变量进行了实例化，并为它们的调用列表加入了方法 Show1。Show1 是一个静态方法，但是在类内部传入委托类型的构造方法时，不需要使用类名引用。第 27 行定义了实例方法，在方法内部调用了这四个委托，并为其传入实参。第 34 行代码又定义了一个类，它继承自基类 Test。因为基类中的委托类型只有 D、D2 和 D3 可以被派生类访问，所以第 35 行到第 37 行定义了它们的变量。注意，虽然它们和基类中的委托变量是同一种类型， 但是它们是不同的委托。在第 38 行的实例构造方法中，为这三个委托类型的变量创建实例，并为其调用列表加入方法，因为静态方法 Show1 也被派生类所继承，所以这里传入的方法名，可以使用类名引用，也可以不使用类名引用。 第 43 行定义了一个实例方法，方法内部调用了这三个委托，并为其传入实参。第 51 行定义了派生类的实例，然后调用实例方法Use和Use1。这段代码的执行结果如下：
方法 Show1 被调用，两个实参相加的值是：23 方法 Show1 被调用，两个实参相加的值是：67 方法 Show1 被调用，两个实参相加的值是：133 方法 Show1 被调用，两个实参相加的值是：445 方法 Show1 被调用，两个实参相加的值是：67 方法 Show1 被调用，两个实参相加的值是：89 方法 Show1 被调用，两个实参相加的值是：155
因为 D 和 D2 的访问权限被定义成了 protected 和 protected internal。所以下面来验证在其它程序集中是否可以访问它们。首先要将本段代码中的包含 Main 方法的类去掉，然后在它的项目属性中将它改变为类库。接下来新建一个控制台项目，并物理上引用这个类库。控制台项目的代码如下：
using System;
using LycheeTest;
namespace LycheeTest1{
class Program: Test {
private D pD;
private D2 pD2;
public Program() {
pD = new D(Show1);
pD2 = new D2(Show1);
}
public void Use3() {
pD(34, 33);
pD2(12, 11);
}
static void Main(string[] args) {
Program p = new Program();
p.Use3();
Console.ReadKey();
}
}
}因为第 3 行代码的命名空间和类库的命名空间是两个独立的命名空间，它们的成员不位于同一个命名空间内。所以在一个命名空间内引用另一个命名空间的成员时，需要加上另一个命名空间的名称进行引用。 为了代码编写的方便，第 2 行代码首先引用了类库的命名空间。第 4 行代码定义了一个类，它继承自基类 Test。因为是派生类，所以对于委托类型 D 和 D2 都可以访 问。第 5 行代码和第 6 行代码分别定义了 D 和 D2 的两个变量。第 7 行的实例构造方法对这两个变量进行了实例化，并为其传入方法 Show1。因为 Show1 方法被继承了下来，所以这里不需要类名引用。第 11 行代码定义了一个实例方法，它的作用是调用这两个委托，并为其传入实参。第 16 行代码定义了本类的一个实例，并调用了实例方法 Use3。这段代码的执行结果如下：
方法 Show1 被调用，两个实参相加的值是：67 方法 Show1 被调用，两个实参相加的值是：23
类Test中的委托类型D2和D3都具有internal权限，现在来验证一下，对于一个同一程序集中的非派生类是否可以访问它们。首先将类库更改回控制台项目，然后增加一个类，这个类对于Test类来说是独立的。它们之间只是位于一个程序集内，彼此没有继承关系。代码如下：
using System;
namespace LycheeTest {
public class Test {
protected delegate void D(int a, int b);
private delegate void D1(int a, int b);
protected internal delegate void D2(int a, int b);
internal delegate void D3(int a, int b);
private D myD;
private D1 myD1;
private D2 myD2;
private D3 myD3;
public Test() {
myD = new D(Show1);
myD1 = new D1(Show1);
myD2 = new D2(Show1);
myD3 = new D3(Show1);
}
public static void Show1(int a, int b) {
Console.WriteLine("方法 Show1 被调用，两个实参相加的值是：{0}", a + b);
}
public void Show2(int a, int b) {
Console.WriteLine("方法 Show2 被调用，两个实参相加的值是：{0}", a + b);
}
public void Show3(int a, int b) {
Console.WriteLine("方法 Show3 被调用，两个实参相加的值是：{0}", a + b);
}
public void Use() {
myD(11, 12);
myD1(22, 45);
myD2(55, 78);
myD3(345, 100);
}
}
class Test1 {
private Test.D2 tD2;
private Test.D3 tD3;
public Test1() {
tD2 = new Test.D2(Test.Show1);
tD3 = new Test.D3(Test.Show1);
}
public void Use3() {
tD2(34, 33);
tD3(22, 21);
}
}
public class Program {
static void Main(string[] args) {
Test1 myT1 = new Test1();
myT1.Use3();
Console.ReadKey();
}
}
}这段代码中，原来的类Test没有进行修改。在第35行上，定义了一个类，它是一个相对于Test类来说独立的类。它们的关系仅限于同在一个程序集内。第 36 行代码和第 37 行代码定义了委托类型D2和D3的两个变量。这里需要注意，因为这两个类不是继承关系，所以要引用Test类中的这两个委托类型需要使用Test类的类名进行引用。第 38 行代码是实例构造方法，在构造方法中将委托实例化。实例化委托类型的时候，仍然需要使用类名引用委托类型名，传递的方法名也是如此。第 行42 定义了一个实例方法，它调用了委托，并为其传入了实参。第 49 行代码定义了类Test1的一个实例，然后第 61 行调用类的实例方法。这段代码的执行结果如下：
方法 Show1 被调用，两个实参相加的值是：67 方法 Show1 被调用，两个实参相加的值是：43
以上就是c# 委托代码实例详解的内容，更多相关内容请关注PHP中文网（www.php.cn）！
