谈及到C#的基本特性，“委托”是不得不去了解和深入分析的一个特性。对于大多数刚入门的程序员谈到“委托”时，都会想到“将方法作为方法的参数进行传递”，很多时候都只是知道简单的定义，主要是因为“委托”在理解上有较其他特性比较难的地方。在本次说明中，不会将委托的简单声明和调用作为重点。
“委托”不需要直接定义一个要执行的行为，而是将这个行为用某种方法“包含”在一个对象中。这个对象可以像其他任何对象那样使用。在该对象中，可以执行封装的操作。可以选择将委托看作之定义了一个方法的接口，将委托的实例看作实现了那个接口的对象。
在“委托”的相关定义中，我们可以不难看出，“委托与方法“相比较于“接口与类”有着设计理念上的相似部分，产生的背景源于”设计原则“中的”开放-封闭原则“，”开放-封闭“原则：是说软件实体（类，模块，函数等等）应该可以扩展，但是不可修改。换一种说法可能更好的理解”对于扩展是开放的，对于更改是封闭的“，面对新的需求，对于程序的改动是通过增加新的代码进行的，而不是更改现有的代码。
在C#中委托用delegate关键字定义，使用new操作符构造委托实例，采用传统的方法调用语法来回调函数（只是要用引用了委托对象的一个变量代替方法名）。在C#中，委托在编译的时候会被编译成类。对于委托的一个说明：委托是一个类，它定义了方法的类型，使得可以将方法当作另一个方法的参数来进行传递。委托类既可嵌套在一个类型中定义，也可以在全局范围内定义。由于委托是类，凡是可以定义类的地方，都可以定义委托。
接下来我们来看一下”委托“的组成，需要满足的条件：
1.声明委托类型。
2.必须有一个方法包含了要执行的代码。
3.必须创建一个委托实例。
4.必须调用委托实例。
接下来大致的了解一下上面所提出的4项条件：
委托类型实际上只是参数类型的一个列表以及返回类型。规定了类型的实例能表示的操作。在调用一个委托实例的时候，必须保证使用的参数完全匹配，而且能以指定的方式使用返回值。对于委托实例的创建，取决于操作使用实例方法还是静态方法（如果操作是静态方法，指定类型名称就可以，如果是操作实例方法，需要先创建类型的实例）。对于委托的调用，可以直接调用委托的实例的方法就可以完成对应的操作。
以上谈及了”委托“的定义和组成，接下来我们来了解一下如何将方法绑定到”委托“上，以及委托的合并和删除。
可以将多个方法赋给同一个委托，委托实例实际有一个操作列表与之关联。在System.Delegate类型中提供了两个静态方法Combine()和Remove()负责委托实例的新增和删除操作。但是在我们的实际开发中，较多的采用-=和+=操作符。
在FCL中，所有的委托类型都派生自MulticastDelegate，该类型在System.MulticastDelegate类型中。
具体来看一下Combine()方法的底层实现代码：
[System.Runtime.InteropServices.ComVisible(true)]
public static Delegate Combine(params Delegate[] delegates)
{
if (delegates == null || delegates.Length == 0)
return null;
Delegate d = delegates[0];
for (int i = 1; i < delegates.Length; i++)
d = Combine(d,delegates[i]);
return d;
}
public static Delegate Combine(Delegate a, Delegate b)
{
if ((Object)a == null)
return b;
return a.CombineImpl(b);
}
以上两个方法为System.Delegate类型中，CombineImpl方法在MulticastDelegate重写。
[System.Security.SecuritySafeCritical]
protected override sealed Delegate CombineImpl(Delegate follow)
{
if ((Object)follow == null)
return this;
if (!InternalEqualTypes(this, follow))
throw new ArgumentException(Environment.GetResourceString("Arg_DlgtTypeMis"));
MulticastDelegate dFollow = (MulticastDelegate)follow;
Object[] resultList;
int followCount = 1;
Object[] followList = dFollow._invocationList as Object[];
if (followList != null)
followCount = (int)dFollow._invocationCount;
int resultCount;
Object[] invocationList = _invocationList as Object[];
if (invocationList == null)
{
resultCount = 1 + followCount;
resultList = new Object[resultCount];
resultList[0] = this;
if (followList == null)
{
resultList[1] = dFollow;
}
else
{
for (int i = 0; i < followCount; i++)
resultList[1 + i] = followList[i];
}
return NewMulticastDelegate(resultList, resultCount);
}
else
{
int invocationCount = (int)_invocationCount;
resultCount = invocationCount + followCount;
resultList = null;
if (resultCount <= invocationList.Length)
{
resultList = invocationList;
if (followList == null)
{
if (!TrySetSlot(resultList, invocationCount, dFollow))
resultList = null;
}
else
{
for (int i = 0; i < followCount; i++)
{
if (!TrySetSlot(resultList, invocationCount + i, followList[i]))
{
resultList = null;
break;
}
}
}
}
if (resultList == null)
{
int allocCount = invocationList.Length;
while (allocCount < resultCount)
allocCount *= 2;
resultList = new Object[allocCount];
for (int i = 0; i < invocationCount; i++)
resultList[i] = invocationList[i];
if (followList == null)
{
resultList[invocationCount] = dFollow;
}
else
{
for (int i = 0; i < followCount; i++)
resultList[invocationCount + i] = followList[i];
}
}
return NewMulticastDelegate(resultList, resultCount, true);
}
}
再来具体看一下Remove()方法的底层实现代码，RemoveAll和Remove两个方法为System.Delegate类型中，CombineImpl方法在MulticastDelegate重写。：
public static Delegate RemoveAll(Delegate source, Delegate value)
{
Delegate newDelegate = null;
do
{
newDelegate = source;
source = Remove(source, value);
}
while (newDelegate != source);
return newDelegate;
}
[System.Security.SecuritySafeCritical]
protected override sealed Delegate RemoveImpl(Delegate value)
{ MulticastDelegate v = value as MulticastDelegate;
if (v == null)
return this;
if (v._invocationList as Object[] == null)
{
Object[] invocationList = _invocationList as Object[];
if (invocationList == null)
{
if (this.Equals(value))
return null;
}
else
{
int invocationCount = (int)_invocationCount;
for (int i = invocationCount; --i >= 0; )
{
if (value.Equals(invocationList[i]))
{
if (invocationCount == 2)
{
return (Delegate)invocationList[1-i];
}
else
{
Object[] list = DeleteFromInvocationList(invocationList, invocationCount, i, 1);
return NewMulticastDelegate(list, invocationCount-1, true);
}
}
}
}
}
else
{
Object[] invocationList = _invocationList as Object[];
if (invocationList != null) {
int invocationCount = (int)_invocationCount;
int vInvocationCount = (int)v._invocationCount;
for (int i = invocationCount - vInvocationCount; i >= 0; i--)
{
if (EqualInvocationLists(invocationList, v._invocationList as Object[], i, vInvocationCount))
{
if (invocationCount - vInvocationCount == 0)
{
return null;
}
else if (invocationCount - vInvocationCount == 1)
{
return (Delegate)invocationList[i != 0 ? 0 : invocationCount-1];
}
else
{
Object[] list = DeleteFromInvocationList(invocationList, invocationCount, i, vInvocationCount);
return NewMulticastDelegate(list, invocationCount - vInvocationCount, true);
}
}
}
}
}
return this;
}
[System.Security.SecuritySafeCritical]
public static Delegate Remove(Delegate source, Delegate value)
{
if (source == null)
return null;
if (value == null)
return source;
if (!InternalEqualTypes(source, value))
throw new ArgumentException(Environment.GetResourceString("Arg_DlgtTypeMis"));
return source.RemoveImpl(value);
}
在以上的代码中，我们了解到了在.NET底层是如何实现委托实例的绑定和删除绑定。
在调用委托实例时，所有的操作都是顺序执行的。如果调用具有一个非void的返回类型，则调用的返回值是最后一个操作的返回值。如果调用列表中任何操作抛出异常，都会阻止执行后续的操作。
在上面提到了委托列表中出现非void实例调用，如果委托实例中出现多个非void调用，并且需要获取所有的委托实例的返回值结果，那么应该如何操作，在.NET红提供了一个方法GetInvocationList()，用于获取委托链表。
接下来具体了解一下GetInvocationList()的底层代码：
[System.Security.SecuritySafeCritical]
public override sealed Delegate[] GetInvocationList()
{
Delegate[] del;
Object[] invocationList = _invocationList as Object[];
if (invocationList == null)
{
del = new Delegate[1];
del[0] = this;
}
else
{
int invocationCount = (int)_invocationCount;
del = new Delegate[invocationCount];
for (int i = 0; i < invocationCount; i++)
del[i] = (Delegate)invocationList[i];
}
return del;
}
当获取到委托实例列表后，可采用循环迭代的方式，依次获取每个委托实例的返回值。
再来了解一个属性Method，具体看一下此属性的底层实现代码：
public MethodInfo Method
{
get
{
return GetMethodImpl();
}
}
[System.Security.SecuritySafeCritical]
protected virtual MethodInfo GetMethodImpl()
{
if ((_methodBase == null) || !(_methodBase is MethodInfo))
{
IRuntimeMethodInfo method = FindMethodHandle();
RuntimeType declaringType = RuntimeMethodHandle.GetDeclaringType(method);
if (RuntimeTypeHandle.IsGenericTypeDefinition(declaringType) || RuntimeTypeHandle.HasInstantiation(declaringType))
{
bool isStatic = (RuntimeMethodHandle.GetAttributes(method) & MethodAttributes.Static) != (MethodAttributes)0;
if (!isStatic)
{
if (_methodPtrAux == (IntPtr)0)
{
Type currentType = _target.GetType();
Type targetType = declaringType.GetGenericTypeDefinition();
while (currentType != null)
{
if (currentType.IsGenericType &&
currentType.GetGenericTypeDefinition() == targetType)
{
declaringType = currentType as RuntimeType;
break;
}
currentType = currentType.BaseType;
}
BCLDebug.Assert(currentType != null || _target.GetType().IsCOMObject, "The class hierarchy should declare the method");
}
else
{
MethodInfo invoke = this.GetType().GetMethod("Invoke");
declaringType = (RuntimeType)invoke.GetParameters()[0].ParameterType;
}
}
}
_methodBase = (MethodInfo)RuntimeType.GetMethodBase(declaringType, method);
}
return (MethodInfo)_methodBase;
}
以上是System.Delegate类中的定义，接下来看一下MulticastDelegate重写：
[System.Security.SecuritySafeCritical]
protected override MethodInfo GetMethodImpl()
{
if (_invocationCount != (IntPtr)0 && _invocationList != null)
{
Object[] invocationList = _invocationList as Object[];
if (invocationList != null)
{
int index = (int)_invocationCount - 1;
return ((Delegate)invocationList[index]).Method;
}
MulticastDelegate innerDelegate = _invocationList as MulticastDelegate;
if (innerDelegate != null)
{
return innerDelegate.GetMethodImpl();
}
}
else if (IsUnmanagedFunctionPtr())
{
if ((_methodBase == null) || !(_methodBase is MethodInfo))
{
IRuntimeMethodInfo method = FindMethodHandle();
RuntimeType declaringType = RuntimeMethodHandle.GetDeclaringType(method);
if (RuntimeTypeHandle.IsGenericTypeDefinition(declaringType) || RuntimeTypeHandle.HasInstantiation(declaringType))
{
RuntimeType reflectedType = GetType() as RuntimeType;
declaringType = reflectedType;
}
_methodBase = (MethodInfo)RuntimeType.GetMethodBase(declaringType, method);
}
return (MethodInfo)_methodBase;
}
return base.GetMethodImpl();
}
以上是对委托的相关定义，以及有关委托的一些操作方法的说明，没有具体指出如何去创建和使用委托，因为委托的简单创建和一般应用，对于大部分开发者来说是相对较为简单的，因为微软在不断的对C#的语法进行提升和修改，极大的简化了对应的操作。但是正是由于在应用层做了较大的封装，这也会导致特性在底层的复杂度慢慢的增大。
相关推荐
C# 委托实例解析 委托是 C# 中的一种特殊类型，用于封装方法的引用，以便在需要时调用该方法。委托可以看作是一种方法的容器，容纳着方法的引用，可以在需要时调用该方法。 在 C# 中，委托是通过关键字 "delegate...
在.NET框架中，C#语言提供了许多强大的特性，其中泛型、委托和事件是三个核心概念，它们极大地提升了代码的可重用性、性能和安全性。这篇文章将深入解析这三个概念，帮助开发者更好地理解和运用。 首先，让我们来...
这是一个泛型委托的示例，主要是让初学者了解泛型委托的用法，虽然很简单，但是代码有注释，我的这个例子是在vs2010中做的，用vs08的朋友们，最好还是转一下，但是绝对能实现（本程序是控制台应用程序，适合初学者）...
3. **事件和委托**：C#中的事件和委托是实现组件通信的重要机制，案例可能涉及GUI应用中的按钮点击事件，或者网络编程中的数据传输事件。 4. **LINQ（Language Integrated Query）**：C# 3.0引入的查询语言，让数据...
### C#中的委托及其调用 #### 引言 对于初学者来说，理解C#中的委托可能是一项挑战。本文将通过一个简单的示例来解释委托的概念，并探讨如何在实际编程中使用它们。 #### 什么是委托？ 在C#中，**委托**是一种...
### C#中利用委托实现子窗口关闭时通知父窗口执行特定方法 在C#中，事件和委托是非常重要的概念，特别是在处理用户界面交互时。本文将详细介绍如何利用委托（Delegate）来实现在关闭子窗口时通知父窗口执行特定的...
本文将深入解析这两个概念，帮助你克服C#学习过程中的难点。 首先，我们来理解什么是委托（Delegate）。在C#中，委托是一种类型，它代表了一组方法的签名。委托类似于函数指针，但更加安全和类型安全。通过使用委托...
### C#中委托时间的处理机制 在C#编程语言中，委托是一种引用类型的数据结构，它封装了方法调用的引用。通过使用委托，我们可以将方法作为参数传递给其他方法，或者创建能够动态地调用多个方法的事件。本文将深入...
6. **事件和委托**：C#中的事件和委托是实现事件驱动编程的关键，常用于UI编程，例如按钮点击事件的处理。 7. **接口**：接口定义了一组方法签名，类可以实现多个接口，从而实现多种行为。 8. **异常处理**：C#...
在C#中，**委托**是一种引用类型的数据，它可以像方法那样被调用。委托可以用来封装类中的方法，并允许将方法作为参数传递给其他方法。它使得可以将代码片段（方法）作为参数传递给其他方法，从而实现回调机制。 ##...
C#中的事件和委托就是观察者模式的应用。 4. 装饰者模式：动态地给对象添加一些职责，可以独立于其他对象进行扩展功能，而不会破坏封装性。 5. 代理模式：为其他对象提供一种代理以控制对这个对象的访问。在C#中，...
接下来，我们将基于提供的代码片段深入分析C#委托的另一种实现方式，并讨论其实现原理及其应用场景。 ### 委托的基本概念 委托在C#中是一种引用类型的数据结构，它定义了方法的类型，使得可以将方法当作另一个方法...
本文将详细解析C#中的委托以及匿名方法，通过实例帮助读者深入理解其原理与应用。 ### 一、委托（Delegate） #### 1.1 基本概念 委托是一种引用类型的数据结构，它定义了方法的类型，允许将方法作为参数进行传递...
在本文档中，我们探讨了如何使用 C# 中的委托和多线程技术来安全地更新 ListBox 控件。这种技术不仅可以提高程序的响应性和性能，还可以确保 UI 更新的正确性。理解这些概念对于开发复杂的、具有高度交互性的应用...
本教程主要探讨如何使用C#的Socket实现异步通信，并结合事件和委托来处理通信过程中的消息传递，以及如何将通信逻辑与用户界面(UI)分离，以实现更高效、更灵活的程序设计。 首先，让我们理解什么是Socket异步通信。...
本文将深入探讨C#中的两个关键概念：事件和委托，并通过实例进行详细解析，帮助初学者更好地理解和运用。 首先，我们来了解什么是委托。在C#中，委托是一种类型，它代表了方法的引用，类似于函数指针。委托可以被视...
本文将深入探讨C#中的自定义事件和委托，并结合实例进行详细解析。 首先，我们来看看什么是事件。事件是类的一个特殊属性，它允许对象在特定条件满足时通知其他对象。在C#中，事件是通过`event`关键字来声明的，它...
### C#中的委托与事件关系解析 #### 一、引言 在面向对象编程语言C#中，委托（Delegate）和事件（Event）是两个重要的概念。本文将深入探讨这两者之间的关系及其在实际开发中的应用。 #### 二、委托（Delegate） ...
在C#编程语言中，委托、事件和Lambda表达式是三个非常重要的概念，它们构成了C#强大功能的基础。本文将详细解析这些知识点，帮助你深入理解并熟练运用它们。 首先，我们来谈谈委托（Delegate）。委托在C#中类似于...