c# 托付代码实例详解【C#.Net教程】,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();
 }
 }
}

这段代码演示的是最简朴的一种托付情势。托付范例能够定义在类的外部，也能够定义在类的内部。本段代码是定义在类的外部。第 3 行代码定义的就是一个托付范例，托付范例的症结字是 delegate，症结字前是托付范例的接见权限修饰符。症结字后是托付范例的返回范例，这个返回范例划定与托付范例兼容的要领的返回范例必需与之雷同。返回范例以后是托付范例的称号。接下来是形参列表，它指定与托付类型兼容的要领的参数范例和个数必需与之雷同。第 5 行代码定义了一个托付范例的变量，它是一个实例字段，接见权限是 public 的。注重托付范例字段的接见权限肯定要比托付范例的接见权限低或与托付范例的接见权限雷同才够。第 9 行、第 12 行和第 15 行代码定义了三个要领。个中第 9 行代码是一个静态要领。由于这段代码演示的是最简朴的托付运用要领，所以只运用了个中的静态要领。在第 6 行的组织要领中，实例化了托付范例的变量，注重为托付变量的挪用列表增添要领，只须要向其组织要领中通报要领称号即可。这是为托付增添挪用要领的最基本的一种要领。第 21 行定义了 Test 类的一个实例，然后第 22 行挪用了类的托付成员。在挪用托付成员的时刻，须要向其形参列表通报实参。这就是最基本的托付的运用要领。这段代码的实行效果以下：

要领 Show1 被挪用，两个实参相加的值是：55

下面再引见一种托付范例的运用要领，实例代码以下：

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

这段代码取消了类中的托付范例字段，而是将托付范例作为一个类来对待。在包含进口点要领的类中，起首第 17 行定义了 Test 类的一个变量并做了实例化。由于要向托付通报类的实例要领，所以必需有类的实例存在，才援用类的实例要领。第 18 行定义了一个托付范例的变量，并实例化，这里须要注重，由于托付并非类中的一个成员了，所以向其组织要领通报静态要领的时刻，须要以类名援用。第 19 行也定义了一个托付范例的变量，在向其通报实例要领的时刻，须要以类的实例来援用。第 20 行代码的状况同第 19 行代码一样。在向托付通报要领的时刻，须要通报要领名，而不须要要领的形参列表。第 21 行到第 23 行是对托付的挪用，这时候要为其通报要领的实参。这段代码的实行效果以下：

要领 Show1 被挪用，两个实参相加的值是：55 
要领 Show2 被挪用，两个实参相加的值是：77 
要领 Show3 被挪用，两个实参相加的值是：121

托付的接见修饰符

当托付位于类的外部时，能够运用的接见修饰符包含 public 和 internal。假如什么也不写，默许是internal 的。当托付位于类的内部时，能够运用的接见修饰符包含 public、protected、internal、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# 托付代码实例详解的内容，更多相关内容请关注ki4网（www.ki4.cn）！

正文

c# 托付代码实例详解【C#.Net教程】,c#,委托

相关阅读

关于验证码生成要领的汇总引见【C#.Net教程】,

c言语“或”标记【C#.Net教程】,c语言,或符号

.net和c#有什么区别【C#.Net教程】,.net,c#

伪代码是什么？如何写一个伪代码？【C#.Net教程】,伪代码,c语言,算法