C# 위임 코드 예제에 대한 자세한 설명

이 글에서는 참고할만한 좋은 C# 델리게이트를 사례 분석을 통해 자세히 소개하겠습니다.

위임도 일종의 유형입니다. C#의 대리자는 개체 지향적이고 형식이 안전합니다. 대리자 인스턴스가 생성되면 생성된 인스턴스에는 여러 메서드를 포함할 수 있는 호출 목록이 포함됩니다. 각 메서드를 호출 엔터티라고 합니다. 호출 엔터티는 정적 메서드이거나 인스턴스 메서드일 수 있습니다. 인스턴스 메서드의 경우 호출 엔터티에는 인스턴스 메서드가 호출된 인스턴스가 포함됩니다. 대리자는 호출하는 메서드의 클래스에는 관심이 없으며 호출된 메서드가 대리자의 형식과 호환되는지 여부에만 관심이 있습니다. 다음은 코드 예입니다.

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();
 }
 }
}

이 코드는 가장 간단한 형태의 위임을 보여줍니다. 대리자 유형은 클래스 외부 또는 클래스 내부에서 정의할 수 있습니다. 이 코드는 클래스 외부에서 정의됩니다. 코드의 세 번째 줄은 대리자 형식을 정의합니다. 대리자 형식의 키워드는 대리자 형식의 액세스 권한 수정자 앞에 옵니다. 키워드 뒤에는 대리자 형식과 호환되는 메서드의 반환 형식이 동일해야 함을 지정하는 대리자 형식의 반환 형식이 옵니다. 반환 유형 뒤에는 대리자 유형의 이름이 있습니다. 다음은 대리자 유형과 호환되는 매개 변수 유형과 메서드 수가 동일해야 함을 지정하는 형식 매개 변수 목록입니다. 코드의 5행에서는 인스턴스 필드이고 액세스 권한이 공개되는 대리자 유형 변수를 정의합니다. 대리인 유형 필드의 액세스 권한은 대리인 유형의 액세스 권한보다 낮거나 대리인 유형의 액세스 권한과 동일해야 합니다. 9, 12, 15행에서는 세 가지 메서드를 정의합니다. 코드의 9행은 정적 메서드입니다. 이 코드는 대리자를 사용하는 가장 간단한 방법을 보여주기 때문에 정적 메서드만 사용됩니다. 6행의 생성자에서 대리자 유형의 변수가 인스턴스화됩니다. 대리자 변수의 호출 목록에 메서드를 추가하려면 해당 생성자에 메서드 이름만 전달하면 됩니다. 이는 대리자에 호출 메서드를 추가하는 가장 기본적인 방법입니다. 21행에서는 Test 클래스의 인스턴스를 정의하고 22행에서는 클래스의 대리자 멤버를 호출합니다. 위임 멤버를 호출할 때 실제 매개변수를 공식 매개변수 목록에 전달해야 합니다. 이것이 위임을 사용하는 가장 기본적인 방법입니다. 이 코드의 실행 결과는 다음과 같습니다.

方法 Show1 被调用，两个实参相加的值是：55

다음은 Delegate 유형의 사용 방법을 소개합니다. 예제 코드는 다음과 같습니다.

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();
 }
 }
}

이 코드는 클래스의 위임 유형 필드를 취소하지만 위임 유형을 클래스로 처리합니다. 진입점 메소드를 포함하는 클래스에서 Test 클래스의 변수는 17행에서 먼저 정의되고 인스턴스화됩니다. 클래스의 인스턴스 메서드가 대리자에게 전달되기 때문에 클래스의 인스턴스 메서드를 참조하려면 먼저 클래스의 인스턴스가 있어야 합니다. 18행에서는 대리자 유형의 변수를 정의하고 인스턴스화합니다. 대리자는 클래스의 멤버가 아니기 때문에 정적 메서드를 생성자에 전달할 때 클래스 이름으로 참조되어야 한다는 점에 유의해야 합니다. . 19행에서는 인스턴스 메서드를 전달할 때 클래스의 인스턴스에서 참조해야 하는 대리자 유형 변수도 정의합니다. 20행은 19행과 동일합니다. 메서드를 대리자에게 전달할 때 메서드의 정식 매개 변수 목록 대신 메서드 이름을 전달해야 합니다. 21~23행은 메서드의 실제 매개 변수가 전달되는 대리자에 대한 호출입니다. 이 코드의 실행 결과는 다음과 같습니다.

方法 Show1 被调用，两个实参相加的值是：55 
方法 Show2 被调用，两个实参相加的值是：77 
方法 Show3 被调用，两个实参相加的值是：121

대리자의 접근 한정자

대리자가 클래스 외부에 있는 경우 사용할 수 있는 액세스 한정자에는 public 및 내부가 포함됩니다. 아무것도 쓰지 않으면 기본값은 내부입니다. 대리자가 클래스 내부에 있는 경우 사용할 수 있는 액세스 한정자는 public, protected, inside, protected

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: 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）！