syxdevcode博客

发表于 更新于 分类于
本文字数： 6.1k 阅读时长 ≈ 6 分钟

DotNet内存泄漏(Memory Leak)-事件(Event)

通过事件(Event)，绝大多数内存泄漏（Memory Leak）的元凶[上篇]这篇文章的实例，学习内存泄漏。

代码下载
提取码：xazz

微信截图_20181213135838.png

  我们这个应用程序叫做TodoListManager，因为通过它可以实时查看属于用户的“待办事宜（Todolist）”。这是一个GUI的应用，有两个Windows Form组成：左侧的窗体是一个程序的主界面（为了简单起见，我甚至没有将其做成MDI窗体），点击Todo List菜单项，右面的Form被显示出来：所有的代码事宜将会全部列出，为了保证记录的实时显示，每隔5秒钟数据自动刷新一次。

  首先定义表示每一项TotoList Item定义了一个相应的类型：MyEvent（不是我们谈到的导致内存泄漏的事件）。Event仅仅包含简单的属性：主题（Subject），截至日期（DueDate）和相应的描述性文字（Description），Event定义如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
namespace WindowsFormsApp1
{
    public class MyEvent
    {
        public string Subject { get; set; }
        public DateTime DueDate { get; set; }
        public string Description { get; set; }
        public MyEvent(string subject, DateTime dueDate, string desc)
        {
            if (string.IsNullOrEmpty(subject))
            {
                throw new ArgumentNullException("subject");
            }
            this.Subject = subject;
            this.DueDate = dueDate;
            this.Description = desc ?? string.Empty;
        }
    }
}

  然后将所有逻辑（实际上仅仅是定期获取TodoList列表而已）定义在下面一个叫做TodoListManager的类型中。将其定义成Singleton的形式，并采用System.Threading.Timer实现定时地获取Todo List的操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
namespace WindowsFormsApp1
{
    public class TodoListManager
    {
        private static readonly TodoListManager instance = new TodoListManager();
        public event EventHandler<TodoListEventArgs> TodoListChanged;
        private Timer todoListRefreshSchedler;
        private TodoListManager()
        {
            todoListRefreshSchedler = new Timer
            (
                state =>
                {
                    if (null == TodoListChanged)
                    {
                        return;
                    }

                    TodoListChanged(null, new TodoListEventArgs(GetTodolist()));
                }
           , null, 0, 5000);
        }
        public static TodoListManager Instance
        {
            get
            {
                return instance;
            }
        }
        private List<MyEvent> GetTodolist()
        {
            var list = new List<MyEvent>();
            list.Add(new MyEvent("Meeting with Testing Team", DateTime.Today.AddDays(2), "NIL"));
            list.Add(new MyEvent("Deliver progress report to manager ", DateTime.Today.AddDays(7), "NIL"));
            return list;
        }
    }
}

  对于Timer的每一个轮询，都会处触发一个类型为EventHandler<TodoListEventArgs>的事件，通过注册这个事件，可以通过类型为TodoListEventArgs的事件参数得到最新的TodoList的列表，TodoListEventArgs定义如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class TodoListEventArgs : EventArgs
{
    public IEnumerable<MyEvent> TodoList
    { get; private set; }
    public TodoListEventArgs(IEnumerable<MyEvent> todoList)
    {
        if (null == todoList)
        {
            throw new ArgumentNullException("todoList");
        }

        this.TodoList = todoList;
    }
}

  在窗体Load的时候注册TodoListManager的TodoListChanged事件，并将获取到的TodoList列表绑定到DataGridView上面。由于TodoListManager异步工作的原因，借助了SynchronizationContext这么一个对象实现对数据的绑定。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
using System;
using System.Threading;
using System.Windows.Forms;

namespace WindowsFormsApp1
{
    public partial class ToDoListForm : Form
    {
        public static SynchronizationContext SynchronizationContext { get; private set; }

        public ToDoListForm()
        {
            InitializeComponent();
        }

        private void ToDoListForm_Load(object sender, EventArgs e)
        {
            SynchronizationContext = SynchronizationContext.Current;
            TodoListManager.Instance.TodoListChanged += TodoListManager_TodoListChanged;
        }

        private void TodoListManager_TodoListChanged(object sender, TodoListEventArgs e)
        {
            SynchronizationContext.Post(
                state =>
                {
                    BindingSource bindingSource = new BindingSource();
                    bindingSource.DataSource = e.TodoList;
                    this.dataGridViewTodoList.DataSource = bindingSource;
                }, null);
        }
    }
}

在整个应用级别定义了一个静态的System.Threading.Timer，让它每隔半秒调用一次GC.Collect()。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Windows.Forms;

namespace WindowsFormsApp1
{
    internal static class Program
    {
        private static System.Threading.Timer gcScheduler = new System.Threading.Timer
            (state => GC.Collect(), null, 0, 500);

        /// <summary>
        /// 应用程序的主入口点。
        /// </summary>
        [STAThread]
        private static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new MainForm());
        }
    }
}

查看内存泄漏，需要借助响应的Memory Profiling工具:

JetBrains的dotTrace（免费），
RedGate的ANTS Memory Profiler(收费)

  ANTS Memory Profiler通过这样的原理来确定你的应用程序是否有泄漏问题：如果你怀疑某个操作会导致应该被GC回收的对象没有被回收，那么你在之前对内存分配情况拍一张快照（Snapshot），然后执行该操作，在操作完成并确定GC完成相应的回收操作后，在拍一张快照。通过对比，找出多余的对象，并根据具体的情况分析该对象是否应该被GC回收，如果是的，怎意味着你的程序存在着内存泄漏问题。

通过ANTS Memory Profiler启动我们的应用程序后，在一开始的时候我们拍摄一张反映程序初始状态的内存快照，然后选择File\Todo List打开TodoListForm，等待一定的时间，再将TodoListForm关闭。为了让GC有充分的时间进行垃圾回收，不妨再作相应的等待，然后拍下第二张快照。在Class List视图中，你会发现原本应该被垃圾回收的TodoListForm窗体对象还存在于内存之中。

微信截图_20181213144749.png

  通过上图可以看得，该对象被TodoListManager的一个类型为EventHandler<TodoListEventArgs>的事件引用，这个对象实际上是一个Delegate对象，而TodoListForm作为这个Delegate对象的Target。通过上面给出的代码，我们不难想出是由于在TodoListForm实现了对TodoListManager的TotoListChanged事件注册导致了TodoListManager不能被垃圾回收。

  对于GUI应用可视化树形结构来说，一个窗体被关闭，照例说它应该成为垃圾对象，GC在执行垃圾回收的时候就可以将其清楚的。但是，由于该对象注册了一个事件到一个生命周期很长的对象（在本例中，TodoManager是一个Singletone对象，具有和整个应用程序一样的生命周期），它就是被这么一个对象长期引用，进而阻止 GC对其的回收工作。

  短暂生命周期注册事件到长期生命周期对象上，在该对象被Dispose的时候，应该解除事件的注册。你可以通过实现System.IDisposable接口，将解除事件注册的操作放在Dispose方法中。对于本里来说，你可以将相应的操作注册到Form的Closing、Closed或者Disposed事件中。比如在下面代码中，我为TodoListForm添加了如下一个Closing事件处理程序：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
using System;
using System.Threading;
using System.Windows.Forms;

namespace WindowsFormsApp1
{
    public partial class ToDoListForm : Form
    {
        public static SynchronizationContext SynchronizationContext { get; private set; }

        public ToDoListForm()
        {
            InitializeComponent();
        }

        private void ToDoListForm_Load(object sender, EventArgs e)
        {
            SynchronizationContext = SynchronizationContext.Current;
            TodoListManager.Instance.TodoListChanged += TodoListManager_TodoListChanged;
        }

        private void TodoListManager_TodoListChanged(object sender, TodoListEventArgs e)
        {
            SynchronizationContext.Post(
                state =>
                {
                    BindingSource bindingSource = new BindingSource();
                    bindingSource.DataSource = e.TodoList;
                    this.dataGridViewTodoList.DataSource = bindingSource;
                }, null);
        }

        private void ToDoListForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            TodoListManager.Instance.TodoListChanged -= TodoListManager_TodoListChanged;
        }
    }
}

修改之后，按照上面的流程利用ANTS Memory Profiler在第二个快照中，你将再也看不到TodoListForm的身影（如下图）。

微信截图_20181213145711.png

参考：

事件(Event)，绝大多数内存泄漏（Memory Leak）的元凶[上篇]

发表于 更新于 分类于
本文字数： 690 阅读时长 ≈ 1 分钟

1.委托是什么

什么是委托？简单来说，委托类似于 C 或 C++ 中的函数指针，允许将方法作为参数进行传递。

2.为什么需要委托

在很多场景下直接调用方法是比较简单方便的，但是在某些场景下，使用委托来调用方法能达到减少代码量

3.委托能用来做什么

1,启动线程和任务

Thread t = new Thread(new ThreadStart(Go));//public static GO(){}

2,设计模式中的简单工厂模式。

向一个方法中传递一个子类的方法。

3,事件。

4.如何自定义委托

1
public delegate void Feedback(int num);

.Net 的委托本质上就是指向函数的指针，只不过这种指针是经过封装后类型安全的。委托和线程是两个不同的概念，线程是动态的，委托就是一个或一组内存地址，是静态的。线程执行时如果遇到了指向函数的指针就执行这个函数。

5..NET默认的委托类型有哪几种

  • 1，Action:无返回值

  • 2，Func:有返回值

6.多播委托是什么

包含多个方法的委托叫做 多播委托。

多播委托的签名就必须返回 void；否则，就只能得到委托调用的最后一个方法的结果。

1
2
3
4
5
6
7
8
9
10
//----多播委托-------
Feedback fbChain = null;
//将feedback1添加到fbChain委托中
fbChain += feedback1;
//将feedback2添加到fbChain委托中
fbChain += feedback2;
//输出:
//2
//4
fbChain(2);

7.什么是泛型委托

Action,Func等

8.什么事匿名方法

匿名方法是用作委托的参数的一段代码。

参考：

不惧面试：委托

发表于 更新于 分类于
本文字数： 25k 阅读时长 ≈ 22 分钟

CSharp中的委托与事件(续)

本章内容涉及事件访问器、异常处理、超时处理和异步方法调用等内容。

为什么要使用事件而不是委托变量？

  • 1，从封装性和易用性上考虑
  • 2，事件应该由事件发布者触发，而不应该由客户端（客户程序）来触发。

NOTE：注意这里术语的变化，当我们单独谈论事件，我们说发布者(publisher)、订阅者(subscriber)、客户端(client)。当我们讨论Observer模式，我们说主题(subject)和观察者(observer)。客户端通常是包含Main()方法的Program类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
class Program {
    static void Main(string[] args) {
        Publishser pub = new Publishser();
        Subscriber sub = new Subscriber();

        pub.NumberChanged += new NumberChangedEventHandler(sub.OnNumberChanged);
        pub.DoSomething();          // 应该通过DoSomething()来触发事件
        pub.NumberChanged(100);     // 但可以被这样直接调用，对委托变量的不恰当使用
    }
}

// 定义委托
public delegate void NumberChangedEventHandler(int count);

// 定义事件发布者
public class Publishser {
    private int count;
    public NumberChangedEventHandler NumberChanged;         // 声明委托变量
    //public event NumberChangedEventHandler NumberChanged; // 声明一个事件

    public void DoSomething() {
        // 在这里完成一些工作 ...

        if (NumberChanged != null) {    // 触发事件
            count++;
            NumberChanged(count);
        }
    }
}

// 定义事件订阅者
public class Subscriber {
    public void OnNumberChanged(int count) {
        Console.WriteLine("Subscriber notified: count = {0}", count);
    }
}

  上面代码定义了一个NumberChangedEventHandler委托，然后我们创建了事件的发布者Publisher和订阅者Subscriber。当使用委托变量时，客户端可以直接通过委托变量触发事件，也就是直接调用pub.NumberChanged(100)，这将会影响到所有注册了该委托的订阅者。而事件的本意应该为在事件发布者在其本身的某个行为中触发，比如说在方法DoSomething()中满足某个条件后触发。通过添加event关键字来发布事件，事件发布者的封装性会更好，事件仅仅是供其他类型订阅，而客户端不能直接触发事件（语句pub.NumberChanged(100)无法通过编译），事件只能在事件发布者Publisher类的内部触发（比如在方法pub.DoSomething()中），换言之，就是NumberChanged(100)语句只能在Publisher内部被调用。

  大家可以尝试一下，将委托变量的声明那行代码注释掉，然后取消下面事件声明的注释。此时程序是无法编译的，当你使用了event关键字之后，直接在客户端触发事件这种行为，也就是直接调用pub.NumberChanged(100)，是被禁止的。事件只能通过调用DoSomething()来触发。这样才是事件的本意，事件发布者的封装才会更好。

  就好像如果我们要定义一个数字类型，我们会使用int而不是使用object一样，给予对象过多的能力并不见得是一件好事，应该是越合适越好。尽管直接使用委托变量通常不会有什么问题，但它给了客户端不应具有的能力，而使用事件，可以限制这一能力，更精确地对类型进行封装。

NOTE：这里还有一个约定俗称的规定，就是订阅事件的方法的命名，通常为“On事件名”，比如这里的OnNumberChanged。

为什么委托定义的返回值通常都为void？

尽管并非必需，但是我们发现很多的委托定义返回值都为void，为什么呢？这是因为委托变量可以供多个订阅者注册，如果定义了返回值，那么多个订阅者的方法都会向发布者返回数值，结果就是后面一个返回的方法值将前面的返回值覆盖掉了，因此，实际上只能获得最后一个方法调用的返回值。可以运行下面的代码测试一下。除此以外，发布者和订阅者是松耦合的，发布者根本不关心谁订阅了它的事件、为什么要订阅，更别说订阅者的返回值了，所以返回订阅者的方法返回值大多数情况下根本没有必要。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
class Program {
    static void Main(string[] args) {
        Publishser pub = new Publishser();
        Subscriber1 sub1 = new Subscriber1();
        Subscriber2 sub2 = new Subscriber2();
        Subscriber3 sub3 = new Subscriber3();

        pub.NumberChanged += new GeneralEventHandler(sub1.OnNumberChanged);
        pub.NumberChanged += new GeneralEventHandler(sub2.OnNumberChanged);
        pub.NumberChanged += new GeneralEventHandler(sub3.OnNumberChanged);
        pub.DoSomething();          // 触发事件
    }
}

// 定义委托
public delegate string GeneralEventHandler();

// 定义事件发布者
public class Publishser {
    public event GeneralEventHandler NumberChanged; // 声明一个事件
    public void DoSomething() {
        if (NumberChanged != null) {    // 触发事件
            string rtn = NumberChanged();
            Console.WriteLine(rtn);     // 打印返回的字符串，输出为Subscriber3
        }
    }
}

// 定义事件订阅者
public class Subscriber1 {  
    public string OnNumberChanged() {
        return "Subscriber1";
    }
}
public class Subscriber2 {
    public string OnNumberChanged() {
        return "Subscriber2";
    }
}
public class Subscriber3 {
    public string OnNumberChanged() {
        return "Subscriber3";
    }
}

如何让事件只允许一个客户订阅？

  少数情况下，比如像上面，为了避免发生“值覆盖”的情况（更多是在异步调用方法时，后面会讨论），我们可能想限制只允许一个客户端注册。此时怎么做呢？我们可以向下面这样，将事件声明为private的，然后提供两个方法来进行注册和取消注册：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 定义事件发布者
public class Publishser {
    private event GeneralEventHandler NumberChanged;    // 声明一个私有事件
    // 注册事件
    public void Register(GeneralEventHandler method) {
        NumberChanged = method;
    }
    // 取消注册
    public void UnRegister(GeneralEventHandler method) {
        NumberChanged -= method;
    }

    public void DoSomething() {
        // 做某些其余的事情
        if (NumberChanged != null) {    // 触发事件
            string rtn = NumberChanged();
            Console.WriteLine("Return: {0}", rtn);      // 打印返回的字符串，输出为Subscriber3
        }
    }
}

NOTE：注意上面，在UnRegister()中，没有进行任何判断就使用了NumberChanged-=method语句。这是因为即使method方法没有进行过注册，此行语句也不会有任何问题，不会抛出异常，仅仅是不会产生任何效果而已。

注意在Register()方法中，我们使用了赋值操作符“=”，而非“+=”，通过这种方式就避免了多个方法注册。上面的代码尽管可以完成我们的需要，但是此时大家还应该注意下面两点：

  • 1、将NumberChanged声明为委托变量还是事件都无所谓了，因为它是私有的，即便将它声明为一个委托变量，客户端也看不到它，也就无法通过它来触发事件、调用订阅者的方法。而只能通过Register()和UnRegister()方法来注册和取消注册，通过调用DoSomething()方法触发事件（而不是NumberChanged本身，这在前面已经讨论过了）。

  • 2、我们还应该发现，这里采用的、对NumberChanged委托变量的访问模式和C#中的属性是多么类似啊？大家知道，在C#中通常一个属性对应一个类型成员，而在类型的外部对成员的操作全部通过属性来完成。尽管这里对委托变量的处理是类似的效果，但却使用了两个方法来进行模拟，有没有办法像使用属性一样来完成上面的例子呢？答案是有的，C#中提供了一种叫事件访问器（Event Accessor）的东西，它用来封装委托变量。如下面例子所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
class Program {
    static void Main(string[] args) {
        Publishser pub = new Publishser();
        Subscriber1 sub1 = new Subscriber1();
        Subscriber2 sub2 = new Subscriber2();

        pub.NumberChanged -= sub1.OnNumberChanged;  // 不会有任何反应
        pub.NumberChanged += sub2.OnNumberChanged;  // 注册了sub2
        pub.NumberChanged += sub1.OnNumberChanged;  // sub1将sub2的覆盖掉了

        pub.DoSomething();          // 触发事件
    }
}

// 定义委托
public delegate string GeneralEventHandler();

// 定义事件发布者
public class Publishser {
    // 声明一个委托变量
    private GeneralEventHandler numberChanged;
    // 事件访问器的定义
    public event GeneralEventHandler NumberChanged {
        add {
            numberChanged = value;
        }
        remove {
            numberChanged -= value;
        }
    }

    public void DoSomething() {
        // 做某些其他的事情
        if (numberChanged != null) {    // 通过委托变量触发事件
            string rtn = numberChanged();
            Console.WriteLine("Return: {0}", rtn);      // 打印返回的字符串
        }
    }
}

// 定义事件订阅者
public class Subscriber1 {
    public string OnNumberChanged() {
        Console.WriteLine("Subscriber1 Invoked!");
        return "Subscriber1";
    }
}
public class Subscriber2 {/* 与上类同，略 */}
public class Subscriber3 {/* 与上类同，略 */}

  上面代码中类似属性的public event GeneralEventHandler NumberChanged {add{…}remove{…}}语句便是事件访问器。使用了事件访问器以后，在DoSomething方法中便只能通过numberChanged委托变量来触发事件，而不能NumberChanged事件访问器（注意它们的大小写不同）触发，它只用于注册和取消注册。下面是代码输出：

1
2
Subscriber1 Invoked!
Return: Subscriber1

获得多个返回值与异常处理

  现在假设我们想要获得多个订阅者的返回值，以List<string>的形式返回，该如何做呢？我们应该记得委托定义在编译时会生成一个继承自MulticastDelegate的类，而这个MulticastDelegate又继承自Delegate，在Delegate内部，维护了一个委托链表，链表上的每一个元素，为一个只包含一个目标方法的委托对象。而通过Delegate基类的GetInvocationList()静态方法，可以获得这个委托链表。随后我们遍历这个链表，通过链表中的每个委托对象来调用方法，这样就可以分别获得每个方法的返回值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
class Program4 {
    static void Main(string[] args) {
        Publishser pub = new Publishser();
        Subscriber1 sub1 = new Subscriber1();
        Subscriber2 sub2 = new Subscriber2();
        Subscriber3 sub3 = new Subscriber3();

        pub.NumberChanged += new DemoEventHandler(sub1.OnNumberChanged);
        pub.NumberChanged += new DemoEventHandler(sub2.OnNumberChanged);
        pub.NumberChanged += new DemoEventHandler(sub3.OnNumberChanged);

        List<string> list = pub.DoSomething();  //调用方法，在方法内触发事件

        foreach (string str in list) {
            Console.WriteLine(str);
        }
    }
}

public delegate string DemoEventHandler(int num);

// 定义事件发布者
public class Publishser {
    public event DemoEventHandler NumberChanged;    // 声明一个事件

    public List<string> DoSomething() {
        // 做某些其他的事

        List<string> strList = new List<string>();
        if (NumberChanged == null) return strList;

        // 获得委托数组
        Delegate[] delArray = NumberChanged.GetInvocationList();

        foreach (Delegate del in delArray) {
            // 进行一个向下转换
            DemoEventHandler method = (DemoEventHandler)del;
            strList.Add(method(100));       // 调用方法并获取返回值
        }

        return strList;
    }
}

// 定义事件订阅者
public class Subscriber1 {
    public string OnNumberChanged(int num) {
        Console.WriteLine("Subscriber1 invoked, number:{0}", num);
        return "[Subscriber1 returned]";
    }
}
public class Subscriber3 {与上面类同，略}
public class Subscriber3 {与上面类同，略}

如果运行上面的代码，可以得到这样的输出：

1
2
3
4
5
6
Subscriber1 invoked, number:100
Subscriber2 invoked, number:100
Subscriber3 invoked, number:100
[Subscriber1 returned]
[Subscriber2 returned]
[Subscriber3 returned]

  可见我们获得了三个方法的返回值。而我们前面说过，很多情况下委托的定义都不包含返回值，所以上面介绍的方法似乎没有什么实际意义。其实通过这种方式来触发事件最常见的情况应该是在异常处理中，因为很有可能在触发事件时，订阅者的方法会抛出异常，而这一异常会直接影响到发布者，使得发布者程序中止，而后面订阅者的方法将不会被执行。因此我们需要加上异常处理，考虑下面一段程序：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
class Program5 {
    static void Main(string[] args) {
        Publisher pub = new Publisher();
        Subscriber1 sub1 = new Subscriber1();
        Subscriber2 sub2 = new Subscriber2();
        Subscriber3 sub3 = new Subscriber3();

        pub.MyEvent += new EventHandler(sub1.OnEvent);
        pub.MyEvent += new EventHandler(sub2.OnEvent);
        pub.MyEvent += new EventHandler(sub3.OnEvent);

        pub.DoSomething();

        Console.ReadKey();
    }
}

public class Publisher {
    public event EventHandler MyEvent;
    public void DoSomething() {
        // 做某些其他的事情
        if (NumberChanged != null) {
            try {
                NumberChanged(this, EventArgs.Empty);
            } catch (Exception e) {
                Console.WriteLine("Exception: {0}", e.Message);
            }
        }
    }
}

public class Subscriber1 {
    public void OnEvent(object sender, EventArgs e) {
        Console.WriteLine("Subscriber1 Invoked!");
    }
}

public class Subscriber2 {
    public void OnEvent(object sender, EventArgs e) {
        throw new Exception("Subscriber2 Failed");
    }
}
public class Subscriber3 {/* 与Subsciber1类同，略*/}

注意到我们在Subscriber2中抛出了异常，同时我们在Publisher中使用了try/catch语句来处理异常。运行上面的代码，我们得到的结果是：

1
2
Subscriber1 Invoked!
Exception: Subscriber2 Failed

  可以看到，尽管我们捕获了异常，使得程序没有异常结束，但是却影响到了后面的订阅者，因为Subscriber3也订阅了事件，但是却没有收到事件通知（它的方法没有被调用）。此时，我们可以采用上面的办法，先获得委托链表，然后在遍历链表的循环中处理异常，我们只需要修改一下DoSomething方法就可以了：

1
2
3
4
5
6
7
8
9
10
11
12
13
public void DoSomething() {
    if (MyEvent != null) {
        Delegate[] delArray = MyEvent.GetInvocationList();
        foreach (Delegate del in delArray) {
            EventHandler method = (EventHandler)del;    // 强制转换为具体的委托类型
            try {
                method(this, EventArgs.Empty);
            } catch (Exception e) {
                Console.WriteLine("Exception: {0}", e.Message);
            }
        }
    }
}

  注意到Delegate是EventHandler的基类，所以为了触发事件，先要进行一个向下的强制转换，之后才能在其上触发事件，调用所有注册对象的方法。除了使用这种方式以外，还有一种更灵活方式可以调用方法，它是定义在Delegate基类中的DynamicInvoke()方法：

1
public object DynamicInvoke(params object[] args);

  这可能是调用委托最通用的方法了，适用于所有类型的委托。它接受的参数为object[]，也就是说它可以将任意数量的任意类型作为参数，并返回单个object对象。上面的DoSomething()方法也可以改写成下面这种通用形式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public void DoSomething() {
    // 做某些其他的事情
    if (MyEvent != null) {
        Delegate[] delArray = MyEvent.GetInvocationList();
        foreach (Delegate del in delArray) {
            try {
                // 使用DynamicInvoke方法触发事件
                del.DynamicInvoke(this, EventArgs.Empty);
            } catch (Exception e) {
                Console.WriteLine("Exception: {0}", e.Message);
            }
        }
    }
}

  注意现在在DoSomething()方法中，我们取消了向具体委托类型的向下转换，现在没有了任何的基于特定委托类型的代码，而DynamicInvoke又可以接受任何类型的参数，且返回一个object对象。所以我们完全可以将DoSomething()方法抽象出来，使它成为一个公共方法，然后供其他类来调用，我们将这个方法声明为静态的，然后定义在Program类中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 触发某个事件，以列表形式返回所有方法的返回值
public static object[] FireEvent(Delegate del, params object[] args){

    List<object> objList = new List<object>();

    if (del != null) {
        Delegate[] delArray = del.GetInvocationList();
        foreach (Delegate method in delArray) {
            try {
                // 使用DynamicInvoke方法触发事件
                object obj = method.DynamicInvoke(args);
                if (obj != null)
                    objList.Add(obj);
            } catch { }
        }
    }
    return objList.ToArray();
}

随后，我们在DoSomething()中只要简单的调用一下这个方法就可以了：

1
2
3
4
public void DoSomething() {
    // 做某些其他的事情
    Program5.FireEvent(MyEvent, this, EventArgs.Empty);
}

或者使用泛型版本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public static List<T> FireEvent<T>(Delegate del, params object[] args)
{
    List<T> objList = new List<T>();

    if (del != null)
    {
        Delegate[] delArray = del.GetInvocationList();
        foreach (Delegate method in delArray)
        {
            try
            {
                // 使用DynamicInvoke方法触发事件
                object   obj = method.DynamicInvoke(args);
                if (obj != null)
                    objList.Add((T)obj);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Exception:{0}", ex.Message);
            }
        }
    }
    return objList;
}
然后調用時這樣子：
Program.FireEvent<string>(deg, 100)

委托中订阅者方法超时的处理

  订阅者除了可以通过异常的方式来影响发布者以外，还可以通过另一种方式：超时。一般说超时，指的是方法的执行超过某个指定的时间，而这里我将含义扩展了一下，凡是方法执行的时间比较长，我就认为它超时了，这个“比较长”是一个比较模糊的概念，2秒、3秒、5秒都可以视为超时。超时和异常的区别就是超时并不会影响事件的正确触发和程序的正常运行，却会导致事件触发后需要很长才能够结束。在依次执行订阅者的方法这段期间内，客户端程序会被中断，什么也不能做。因为当执行订阅者方法时（通过委托，相当于依次调用所有注册了的方法），当前线程会转去执行方法中的代码，调用方法的客户端会被中断，只有当方法执行完毕并返回时，控制权才会回到客户端，从而继续执行下面的代码。我们来看一下下面一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
class Program6 {
    static void Main(string[] args) {

        Publisher pub = new Publisher();
        Subscriber1 sub1 = new Subscriber1();
        Subscriber2 sub2 = new Subscriber2();
        Subscriber3 sub3 = new Subscriber3();

        pub.MyEvent += new EventHandler(sub1.OnEvent);
        pub.MyEvent += new EventHandler(sub2.OnEvent);
        pub.MyEvent += new EventHandler(sub3.OnEvent);

        pub.DoSomething();      // 触发事件

        Console.WriteLine("\nControl back to client!"); // 返回控制权
    }

    // 触发某个事件，以列表形式返回所有方法的返回值
    public static object[] FireEvent(Delegate del, params object[] args) {
        // 代码与上同，略
    }
}

public class Publisher {
    public event EventHandler MyEvent;
    public void DoSomething() {
        // 做某些其他的事情
        Console.WriteLine("DoSomething invoked!");
        Program6.FireEvent(MyEvent, this, EventArgs.Empty); //触发事件
    }
}

public class Subscriber1 {
    public void OnEvent(object sender, EventArgs e) {
        Thread.Sleep(TimeSpan.FromSeconds(3));
        Console.WriteLine("Waited for 3 seconds, subscriber1 invoked!");
    }
}
public class Subscriber2 {
    public void OnEvent(object sender, EventArgs e) {
        Console.WriteLine("Subscriber2 immediately Invoked!");
    }
}
public class Subscriber3 {
    public void OnEvent(object sender, EventArgs e) {
        Thread.Sleep(TimeSpan.FromSeconds(2));
        Console.WriteLine("Waited for 2 seconds, subscriber2 invoked!");
    }
}

  在这段代码中，我们使用Thread.Sleep()静态方法模拟了方法超时的情况。其中Subscriber1.OnEvent()需要三秒钟完成，Subscriber2.OnEvent()立即执行，Subscriber3.OnEvent需要两秒完成。这段代码完全可以正常输出，也没有异常抛出（如果有，也仅仅是该订阅者被忽略掉），下面是输出的情况：

1
2
3
4
5
6
DoSomething invoked!
Waited for 3 seconds, subscriber1 invoked!
Subscriber2 immediately Invoked!
Waited for 2 seconds, subscriber2 invoked!

Control back to client!

  但是这段程序在调用方法DoSomething()、打印了“DoSomething invoked”之后，触发了事件，随后必须等订阅者的三个方法全部执行完毕了之后，也就是大概5秒钟的时间，才能继续执行下面的语句，也就是打印“Control back to client”。而我们前面说过，很多情况下，尤其是远程调用的时候（比如说在Remoting中），发布者和订阅者应该是完全的松耦合，发布者不关心谁订阅了它、不关心订阅者的方法有什么返回值、不关心订阅者会不会抛出异常，当然也不关心订阅者需要多长时间才能完成订阅的方法，它只要在事件发生的那一瞬间告知订阅者事件已经发生并将相关参数传给订阅者就可以了。然后它就应该继续执行它后面的动作，在本例中就是打印“Control back to client！”。而订阅者不管失败或是超时都不应该影响到发布者，但在上面的例子中，发布者却不得不等待订阅者的方法执行完毕才能继续运行。

  现在我们来看下如何解决这个问题，先回顾一下之前我在C#中的委托和事件一文中提到的内容，我说过，委托的定义会生成继承自MulticastDelegate的完整的类，其中包含Invoke()、BeginInvoke()和EndInvoke()方法。当我们直接调用委托时，实际上是调用了Invoke()方法，它会中断调用它的客户端，然后在客户端线程上执行所有订阅者的方法（客户端无法继续执行后面代码），最后将控制权返回客户端。注意到BeginInvoke()、EndInvoke()方法，在.Net中，异步执行的方法通常都会配对出现，并且以Begin和End作为方法的开头（最常见的可能就是Stream类的BeginRead()和EndRead()方法了）。它们用于方法的异步执行，即是在调用BeginInvoke()之后，客户端从线程池中抓取一个闲置线程，然后交由这个线程去执行订阅者的方法，而客户端线程则可以继续执行下面的代码。

  BeginInvoke()接受“动态”的参数个数和类型，为什么说“动态”的呢？因为它的参数是在编译时根据委托的定义动态生成的，其中前面参数的个数和类型与委托定义中接受的参数个数和类型相同，最后两个参数分别是AsyncCallback和Object类型，对于它们更具体的内容，可以参见下一节委托和方法的异步调用部分。现在，我们仅需要对这两个参数传入null就可以了。另外还需要注意几点：

  • 在委托类型上调用BeginInvoke()时，此委托对象只能包含一个目标方法，所以对于多个订阅者注册的情况，必须使用GetInvocationList()获得所有委托对象，然后遍历它们，分别在其上调用BeginInvoke()方法。如果直接在委托上调用BeginInvoke()，会抛出异常，提示“委托只能包含一个目标方法”。
  • 如果订阅者的方法抛出异常，.NET会捕捉到它，但是只有在调用EndInvoke()的时候，才会将异常重新抛出。而在本例中，我们不使用EndInvoke()（因为我们不关心订阅者的执行情况），所以我们无需处理异常，因为即使抛出异常，也是在另一个线程上，不会影响到客户端线程（客户端甚至不知道订阅者发生了异常，这有时是好事有时是坏事）。
  • BeginInvoke()方法属于委托定义所生成的类，它既不属于MulticastDelegate也不属于Delegate基类，所以无法继续使用可重用的FireEvent()方法，我们需要进行一个向下转换，来获取到实际的委托类型。

现在我们修改一下上面的程序，使用异步调用来解决订阅者方法执行超时的情况：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
class Program6 {
    static void Main(string[] args) {

        Publisher pub = new Publisher();
        Subscriber1 sub1 = new Subscriber1();
        Subscriber2 sub2 = new Subscriber2();
        Subscriber3 sub3 = new Subscriber3();

        pub.MyEvent += new EventHandler(sub1.OnEvent);
        pub.MyEvent += new EventHandler(sub2.OnEvent);
        pub.MyEvent += new EventHandler(sub3.OnEvent);

        pub.DoSomething();      // 触发事件

        Console.WriteLine("Control back to client!\n"); // 返回控制权
        Console.WriteLine("Press any thing to exit...");
        Console.ReadKey();      // 暂停客户程序，提供时间供订阅者完成方法
    }
}

public class Publisher {
    public event EventHandler MyEvent;
    public void DoSomething() {
        // 做某些其他的事情
        Console.WriteLine("DoSomething invoked!");

        if (MyEvent != null) {
            Delegate[] delArray = MyEvent.GetInvocationList();

            foreach (Delegate del in delArray) {
                EventHandler method = (EventHandler)del;
                method.BeginInvoke(null, EventArgs.Empty, null, null);
            }
        }
    }
}

public class Subscriber1 {
    public void OnEvent(object sender, EventArgs e) {
        Thread.Sleep(TimeSpan.FromSeconds(3));      // 模拟耗时三秒才能完成方法
        Console.WriteLine("Waited for 3 seconds, subscriber1 invoked!");
    }
}

public class Subscriber2 {
    public void OnEvent(object sender, EventArgs e) {
        throw new Exception("Subsciber2 Failed");   // 即使抛出异常也不会影响到客户端
        //Console.WriteLine("Subscriber2 immediately Invoked!");
    }
}

public class Subscriber3 {
    public void OnEvent(object sender, EventArgs e) {
        Thread.Sleep(TimeSpan.FromSeconds(2));  // 模拟耗时两秒才能完成方法
        Console.WriteLine("Waited for 2 seconds, subscriber3 invoked!");
    }
}

运行上面的代码，会得到下面的输出：

1
2
3
4
5
6
7
DoSomething invoked!
Control back to client!

Press any thing to exit...

Waited for 2 seconds, subscriber3 invoked!
Waited for 3 seconds, subscriber1 invoked!

需要注意代码输出中的几个变化：

  • 1.我们需要在客户端程序中调用Console.ReadKey()方法来暂停客户端，以提供足够的时间来让异步方法去执行完代码，不然的话客户端的程序到此处便会运行结束，程序会退出，不会看到任何订阅者方法的输出，因为它们根本没来得及执行完毕。原因是这样的：客户端所在的线程我们通常称为主线程，而执行订阅者方法的线程来自线程池，属于后台线程(Background Thread），当主线程结束时，不论后台线程有没有结束，都会退出程序。（当然还有一种前台线程(Foreground Thread)，主线程结束后必须等前台线程也结束后程序才会退出，关于线程的讨论可以开辟另一个庞大的主题，这里就不讨论了）。
  • 2.在打印完“Press any thing to exit…”之后，两个订阅者的方法会以2秒、1秒的间隔显示出来，且尽管我们先注册了subscirber1，但是却先执行了subscriber3，这是因为执行它需要的时间更短。除此以外，注意到这两个方法是并行执行的，所以执行它们的总时间是最长的方法所需要的时间，也就是3秒，而不是他们的累加5秒。
  • 3.如同前面所提到的，尽管subscriber2抛出了异常，我们也没有针对异常进行处理，但是客户程序并没有察觉到，程序也没有因此而中断。

委托和方法的异步调用

  通常情况下，如果需要异步执行一个耗时的操作，我们会新起一个线程，然后让这个线程去执行代码。但是对于每一个异步调用都通过创建线程来进行操作显然会对性能产生一定的影响，同时操作也相对繁琐一些。.Net中可以通过委托进行方法的异步调用，就是说客户端在异步调用方法时，本身并不会因为方法的调用而中断，而是从线程池中抓取一个线程去执行该方法，自身线程（主线程）在完成抓取线程这一过程之后，继续执行下面的代码，这样就实现了代码的并行执行。使用线程池的好处就是避免了频繁进行异步调用时创建、销毁线程的开销。

  如同上面所示，当我们在委托对象上调用BeginInvoke()时，便进行了一个异步的方法调用。上面的例子中是在事件的发布和订阅这一过程中使用了异步调用，而在事件发布者和订阅者之间往往是松耦合的，发布者通常不需要获得订阅者方法执行的情况；而当使用异步调用时，更多情况下是为了提升系统的性能，而并非专用于事件的发布和订阅这一编程模型。而在这种情况下使用异步编程时，就需要进行更多的控制，比如当异步执行方法的方法结束时通知客户端、返回异步执行方法的返回值等。本节就对BeginInvoke()方法、EndInvoke()方法和其相关的IAysncResult做一个简单的介绍。

我们看这样一段代码，它演示了不使用异步调用的通常情况：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
class Program7 {
    static void Main(string[] args) {

        Console.WriteLine("Client application started!\n");
        Thread.CurrentThread.Name = "Main Thread";

        Calculator cal = new Calculator();
        int result = cal.Add(2, 5);
        Console.WriteLine("Result: {0}\n", result);

        // 做某些其它的事情，模拟需要执行3秒钟
        for (int i = 1; i <= 3; i++) {
            Thread.Sleep(TimeSpan.FromSeconds(i));
            Console.WriteLine("{0}: Client executed {1} second(s).",
                Thread.CurrentThread.Name, i);  
        }

        Console.WriteLine("\nPress any key to exit...");
        Console.ReadKey();
    }
}

public class Calculator {
    public int Add(int x, int y) {
        if (Thread.CurrentThread.IsThreadPoolThread) {
            Thread.CurrentThread.Name = "Pool Thread";
        }
        Console.WriteLine("Method invoked!");

        // 执行某些事情，模拟需要执行2秒钟
        for (int i = 1; i <= 2; i++) {
            Thread.Sleep(TimeSpan.FromSeconds(i));
            Console.WriteLine("{0}: Add executed {1} second(s).",
                Thread.CurrentThread.Name, i);  
        }
        Console.WriteLine("Method complete!");
        return x + y;
    }
}

上面代码有几个关于对于线程的操作，如果不了解可以看一下下面的说明，如果你已经了解可以直接跳过：

  • Thread.Sleep()，它会让执行当前代码的线程暂停一段时间（如果你对线程的概念比较陌生，可以理解为使程序的执行暂停一段时间），以毫秒为单位，比如Thread.Sleep(1000)，将会使线程暂停1秒钟。在上面我使用了它的重载方法，个人觉得使用TimeSpan.FromSeconds(1)，可读性更好一些。
  • Thread.CurrentThread.Name，通过这个属性可以设置、获取执行当前代码的线程的名称，值得注意的是这个属性只可以设置一次，如果设置两次，会抛出异常。
  • Thread.IsThreadPoolThread，可以判断执行当前代码的线程是否为线程池中的线程。

运行这段程序，会产生下面的输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

Client application started!

Method invoked!
Main Thread: Add executed 1 second(s).
Main Thread: Add executed 2 second(s).
Method complete!
Result: 7

Main Thread: Client executed 1 second(s).
Main Thread: Client executed 2 second(s).
Main Thread: Client executed 3 second(s).

Press any key to exit...

  如果你确实执行了这段代码，会看到这些输出并不是一瞬间输出的，而是执行了大概5秒钟的时间，因为线程是串行执行的，所以在执行完Add()方法之后才会继续客户端剩下的代码。

  接下来我们定义一个AddDelegate委托，并使用BeginInvoke()方法来异步地调用它。在上面已经介绍过，BeginInvoke()除了最后两个参数为AsyncCallback类型和Object类型以外，前面的参数类型和个数与委托定义相同。另外BeginInvoke()方法返回了一个实现了IAsyncResult接口的对象（实际上就是一个AsyncResult类型实例，注意这里IAsyncResult和AysncResult是不同的，它们均包含在.Net Framework中）。

  AsyncResult的用途有这么几个：传递参数，它包含了对调用了BeginInvoke()的委托的引用；它还包含了BeginInvoke()的最后一个Object类型的参数；它可以鉴别出是哪个方法的哪一次调用，因为通过同一个委托变量可以对同一个方法调用多次。

  EndInvoke()方法接受IAsyncResult类型的对象（以及ref和out类型参数，这里不讨论了，对它们的处理和返回值类似），所以在调用BeginInvoke()之后，我们需要保留IAsyncResult，以便在调用EndInvoke()时进行传递。这里最重要的就是EndInvoke()方法的返回值，它就是方法的返回值。除此以外，当客户端调用EndInvoke()时，如果异步调用的方法没有执行完毕，则会中断当前线程而去等待该方法，只有当异步方法执行完毕后才会继续执行后面的代码。所以在调用完BeginInvoke()后立即执行EndInvoke()是没有任何意义的。我们通常在尽可能早的时候调用BeginInvoke()，然后在需要方法的返回值的时候再去调用EndInvoke()，或者是根据情况在晚些时候调用。说了这么多，我们现在看一下使用异步调用改写后上面的代码吧：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public delegate int AddDelegate(int x, int y);

class Program8 {

    static void Main(string[] args) {

        Console.WriteLine("Client application started!\n");
        Thread.CurrentThread.Name = "Main Thread";

        Calculator cal = new Calculator();
        AddDelegate del = new AddDelegate(cal.Add);
        IAsyncResult asyncResult = del.BeginInvoke(2,5,null,null);  // 异步调用方法

        // 做某些其它的事情，模拟需要执行3秒钟
        for (int i = 1; i <= 3; i++) {
            Thread.Sleep(TimeSpan.FromSeconds(i));
            Console.WriteLine("{0}: Client executed {1} second(s).",
                Thread.CurrentThread.Name, i);
        }

        int rtn = del.EndInvoke(asyncResult);
        Console.WriteLine("Result: {0}\n", rtn);

        Console.WriteLine("\nPress any key to exit...");
        Console.ReadKey();
    }
}

public class Calculator { /* 与上面同，略 */}

此时的输出为：

1
2
3
4
5
6
7
8
9
10
11
12
Client application started!

Method invoked!
Main Thread: Client executed 1 second(s).
Pool Thread: Add executed 1 second(s).
Main Thread: Client executed 2 second(s).
Pool Thread: Add executed 2 second(s).
Method complete!
Main Thread: Client executed 3 second(s).
Result: 7

Press any key to exit...

现在执行完这段代码只需要3秒钟时间，两个for循环所产生的输出交替进行，这也说明了这两段代码并行执行的情况。可以看到Add()方法是由线程池中的线程在执行，因为Thread.CurrentThread.IsThreadPoolThread返回了True，同时我们对该线程命名为了Pool Thread。另外我们可以看到通过EndInvoke()方法得到了返回值。

有时候，我们可能会将获得返回值的操作放到另一段代码或者客户端去执行，而不是向上面那样直接写在BeginInvoke()的后面。比如说我们在Program中新建一个方法GetReturn()，此时可以通过AsyncResult的AsyncDelegate获得del委托对象，然后再在其上调用EndInvoke()方法，这也说明了AsyncResult可以唯一的获取到与它相关的调用了的方法（或者也可以理解成委托对象）。所以上面获取返回值的代码也可以改写成这样：

1
2
3
4
5
6
static int GetReturn(IAsyncResult asyncResult) {
    AsyncResult result = (AsyncResult)asyncResult;
    AddDelegate del = (AddDelegate)result.AsyncDelegate;
    int rtn = del.EndInvoke(asyncResult);
    return rtn;
}

然后再将int rtn = del.EndInvoke(asyncResult);语句改为int rtn = GetReturn(asyncResult);。注意上面IAsyncResult要转换为实际的类型AsyncResult才能访问AsyncDelegate属性，因为它没有包含在IAsyncResult接口的定义中。

BeginInvoke的另外两个参数分别是AsyncCallback和Object类型，其中AsyncCallback是一个委托类型，它用于方法的回调，即是说当异步方法执行完毕时自动进行调用的方法。它的定义为：

1
public delegate void AsyncCallback(IAsyncResult ar);

Object类型用于传递任何你想要的数值，它可以通过IAsyncResult的AsyncState属性获得。下面我们将获取方法返回值、打印返回值的操作放到了OnAddComplete()回调方法中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public delegate int AddDelegate(int x, int y);

class Program9 {

    static void Main(string[] args) {

        Console.WriteLine("Client application started!\n");
        Thread.CurrentThread.Name = "Main Thread";

        Calculator cal = new Calculator();
        AddDelegate del = new AddDelegate(cal.Add);
        string data = "Any data you want to pass.";
        AsyncCallback callBack = new AsyncCallback(OnAddComplete);
        del.BeginInvoke(2, 5, callBack, data);      // 异步调用方法

        // 做某些其它的事情，模拟需要执行3秒钟
        for (int i = 1; i <= 3; i++) {
            Thread.Sleep(TimeSpan.FromSeconds(i));
            Console.WriteLine("{0}: Client executed {1} second(s).",
                Thread.CurrentThread.Name, i);
        }

        Console.WriteLine("\nPress any key to exit...");
        Console.ReadKey();
    }

    static void OnAddComplete(IAsyncResult asyncResult) {
        AsyncResult result = (AsyncResult)asyncResult;
        AddDelegate del = (AddDelegate)result.AsyncDelegate;
        string data = (string)asyncResult.AsyncState;

        int rtn = del.EndInvoke(asyncResult);
        Console.WriteLine("{0}: Result, {1}; Data: {2}\n", 
            Thread.CurrentThread.Name, rtn, data);
    }
}
public class Calculator { /* 与上面同，略 */}

它产生的输出为：

1
2
3
4
5
6
7
8
9
10
11
12
13
Client application started!

Method invoked!
Main Thread: Client executed 1 second(s).
Pool Thread: Add executed 1 second(s).
Main Thread: Client executed 2 second(s).
Pool Thread: Add executed 2 second(s).
Method complete!
Pool Thread: Result, 7; Data: Any data you want to pass.

Main Thread: Client executed 3 second(s).

Press any key to exit...

这里有几个值得注意的地方：1、我们在调用BeginInvoke()后不再需要保存IAysncResult了，因为AysncCallback委托将该对象定义在了回调方法的参数列表中；2、我们在OnAddComplete()方法中获得了调用BeginInvoke()时最后一个参数传递的值，字符串“Any data you want to pass”；3、执行回调方法的线程并非客户端线程Main Thread，而是来自线程池中的线程Pool Thread。另外如前面所说，在调用EndInvoke()时有可能会抛出异常，所以在应该将它放到try/catch块中。

参考：

C#中的委托和事件(续)

发表于 更新于 分类于
本文字数： 322 阅读时长 ≈ 1 分钟

解决办法:

  • 1,进入到博客项目中 .deploy_git文件夹，修改 .git 下的 config 文件，将 ignorecase=true 改为 ignorecase=false

可以使用以下命令行：

1
2
cd .deploy_git
vim .git/config
  • 2,删除博客项目中 .deploy_git 文件夹下的所有文件，并 push 到 Github 上, 这一步是清空你的 github.io 项目中所有文件。
1
2
3
git rm -rf *
git commit -m 'clean all file'
git push
  • 3,使用 Hexo 再次生成及部署
1
2
3
cd ..
hexo clean
hexo deploy -generate

参考：

Hexo 部署到 Github Pages 文件夹大小写问题

发表于 更新于 分类于
本文字数： 4.9k 阅读时长 ≈ 4 分钟

CSharp中的委托，事件与设计模式

Observer设计模式

假设我们有个高档的热水器，我们给它通上电，当水温超过95度的时候：1、扬声器会开始发出语音，告诉你水的温度；2、液晶屏也会改变水温的显示，来提示水已经快烧开了。

现在我们需要写个程序来模拟这个烧水的过程，我们将定义一个类来代表热水器，我们管它叫：Heater，它有代表水温的字段，叫做temperature；当然，还有必不可少的给水加热方法BoilWater()，一个发出语音警报的方法MakeAlert()，一个显示水温的方法，ShowMsg()。

我们先了解一下Observer设计模式，Observer设计模式中主要包括如下两类对象：

  • 1,Subject：监视对象，它往往包含着其他对象所感兴趣的内容。在本范例中，热水器就是一个监视对象，它包含的其他对象所感兴趣的内容，就是temprature字段，当这个字段的值快到100时，会不断把数据发给监视它的对象。
  • 2,Observer：监视者，它监视Subject，当Subject中的某件事发生的时候，会告知Observer，而Observer则会采取相应的行动。在本范例中，Observer有警报器和显示器，它们采取的行动分别是发出警报和显示水温。

在本例中，事情发生的顺序应该是这样的：

  • 1,警报器和显示器告诉热水器，它对它的温度比较感兴趣(注册)。
  • 2,热水器知道后保留对警报器和显示器的引用。
  • 3,热水器进行烧水这一动作，当水温超过95度时，通过对警报器和显示器的引用，自动调用警报器的MakeAlert()方法、显示器的ShowMsg()方法。

Observer设计模式：Observer设计模式是为了定义对象间的一种一对多的依赖关系，以便于当一个对象的状态改变时，其他依赖于它的对象会被自动告知并更新。Observer模式是一种松耦合的设计模式。

实现范例的Observer设计模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
using System;
using System.Collections.Generic;
using System.Text;

namespace Delegate {
    // 热水器
    public class Heater {
       private int temperature;
       public delegate void BoilHandler(int param);   //声明委托
       public event BoilHandler BoilEvent;        //声明事件

       // 烧水
       public void BoilWater() {
           for (int i = 0; i <= 100; i++) {
              temperature = i;

              if (temperature > 95) {
                  if (BoilEvent != null) { //如果有对象注册
                      BoilEvent(temperature);  //调用所有注册对象的方法
                  }
              }
           }
       }
    }

    // 警报器
    public class Alarm {
       public void MakeAlert(int param) {
           Console.WriteLine("Alarm：嘀嘀嘀，水已经 {0} 度了：", param);
       }
    }

    // 显示器
    public class Display {
       public static void ShowMsg(int param) { //静态方法
           Console.WriteLine("Display：水快烧开了，当前温度：{0}度。", param);
       }
    }

    class Program {
       static void Main() {
           Heater heater = new Heater();
           Alarm alarm = new Alarm();

           heater.BoilEvent += alarm.MakeAlert;    //注册方法
           heater.BoilEvent += (new Alarm()).MakeAlert;   //给匿名对象注册方法
           heater.BoilEvent += Display.ShowMsg;       //注册静态方法

           heater.BoilWater();   //烧水，会自动调用注册过对象的方法
       }
    }
}
输出为：
Alarm：嘀嘀嘀，水已经 96 度了：
Alarm：嘀嘀嘀，水已经 96 度了：
Display：水快烧开了，当前温度：96度。
// 省略...

.Net Framework中的委托与事件

尽管上面的范例很好地完成了我们想要完成的工作，但是我们不仅疑惑：为什么.Net Framework 中的事件模型和上面的不同？为什么有很多的EventArgs参数？

在回答上面的问题之前，我们先搞懂 .Net Framework的编码规范：

  • 委托类型的名称都应该以EventHandler结束。
  • 委托的原型定义：有一个void返回值，并接受两个输入参数：一个Object 类型，一个 EventArgs类型(或继承自EventArgs)。
  • 事件的命名为 委托去掉 EventHandler之后剩余的部分。
  • 继承自EventArgs的类型应该以EventArgs结尾。

再做一下说明：

  • 1,委托声明原型中的Object类型的参数代表了Subject，也就是监视对象，在本例中是 Heater(热水器)。回调函数(比如Alarm的MakeAlert)可以通过它访问触发事件的对象(Heater)。
  • 2,EventArgs 对象包含了Observer所感兴趣的数据，在本例中是temperature。

** 上面这些其实不仅仅是为了编码规范而已，这样也使得程序有更大的灵活性**。比如说，如果我们不光想获得热水器的温度，还想在Observer端(警报器或者显示器)方法中获得它的生产日期、型号、价格，那么委托和方法的声明都会变得很麻烦，而如果我们将热水器的引用传给警报器的方法，就可以在方法中直接访问热水器了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
using System;
using System.Collections.Generic;
using System.Text;

namespace Delegate {
    // 热水器
    public class Heater {
       private int temperature;
       public string type = "RealFire 001";       // 添加型号作为演示
       public string area = "China Xian";         // 添加产地作为演示
       //声明委托
       public delegate void BoiledEventHandler(Object sender, BoiledEventArgs e);
       public event BoiledEventHandler Boiled; //声明事件

       // 定义BoiledEventArgs类，传递给Observer所感兴趣的信息
       public class BoiledEventArgs : EventArgs {
           public readonly int temperature;
           public BoiledEventArgs(int temperature) {
              this.temperature = temperature;
           }
       }

       // 可以供继承自 Heater 的类重写，以便继承类拒绝其他对象对它的监视
       protected virtual void OnBoiled(BoiledEventArgs e) {
           if (Boiled != null) { // 如果有对象注册
              Boiled(this, e);  // 调用所有注册对象的方法
           }
       }

       // 烧水。
       public void BoilWater() {
           for (int i = 0; i <= 100; i++) {
              temperature = i;
              if (temperature > 95) {
                  //建立BoiledEventArgs 对象。
                  BoiledEventArgs e = new BoiledEventArgs(temperature);
                  OnBoiled(e);  // 调用 OnBolied方法
              }
           }
       }
    }

    // 警报器
    public class Alarm {
       public void MakeAlert(Object sender, Heater.BoiledEventArgs e) {
           Heater heater = (Heater)sender;     //这里是不是很熟悉呢？
           //访问 sender 中的公共字段
           Console.WriteLine("Alarm：{0} - {1}: ", heater.area, heater.type);
           Console.WriteLine("Alarm: 嘀嘀嘀，水已经 {0} 度了：", e.temperature);
           Console.WriteLine();
       }
    }

    // 显示器
    public class Display {
       public static void ShowMsg(Object sender, Heater.BoiledEventArgs e) {   //静态方法
           Heater heater = (Heater)sender;
           Console.WriteLine("Display：{0} - {1}: ", heater.area, heater.type);
           Console.WriteLine("Display：水快烧开了，当前温度：{0}度。", e.temperature);
           Console.WriteLine();
       }
    }

    class Program {
       static void Main() {
           Heater heater = new Heater();
           Alarm alarm = new Alarm();

           heater.Boiled += alarm.MakeAlert;   //注册方法
           heater.Boiled += (new Alarm()).MakeAlert;      //给匿名对象注册方法
           heater.Boiled += new Heater.BoiledEventHandler(alarm.MakeAlert);    //也可以这么注册
           heater.Boiled += Display.ShowMsg;       //注册静态方法

           heater.BoilWater();   //烧水，会自动调用注册过对象的方法
       }
    }
}

输出为：
Alarm：China Xian - RealFire 001:
Alarm: 嘀嘀嘀，水已经 96 度了：
Alarm：China Xian - RealFire 001:
Alarm: 嘀嘀嘀，水已经 96 度了：
Alarm：China Xian - RealFire 001:
Alarm: 嘀嘀嘀，水已经 96 度了：
Display：China Xian - RealFire 001:
Display：水快烧开了，当前温度：96度。
// 省略 ...

参考：

C#中的委托和事件

发表于 更新于 分类于
本文字数： 9k 阅读时长 ≈ 8 分钟

MSIL：Microsoft 中间语言

参考：OpCodes Class

名称 说明
Add 将两个值相加并将结果推送到计算堆栈上。
Add.Ovf 将两个整数相加，执行溢出检查，并且将结果推送到计算堆栈上。
Add.Ovf.Un 将两个无符号整数值相加，执行溢出检查，并且将结果推送到计算堆栈上。
And 计算两个值的按位“与”并将结果推送到计算堆栈上。
Arglist 返回指向当前方法的参数列表的非托管指针。
Beq 如果两个值相等，则将控制转移到目标指令。
Beq.S 如果两个值相等，则将控制转移到目标指令（短格式）。
Bge 如果第一个值大于或等于第二个值，则将控制转移到目标指令。
Bge.S 如果第一个值大于或等于第二个值，则将控制转移到目标指令（短格式）。
Bge.Un 当比较无符号整数值或不可排序的浮点型值时，如果第一个值大于第二个值，则将控制转移到目标指令。
Bge.Un.S 当比较无符号整数值或不可排序的浮点型值时，如果第一个值大于第二个值，则将控制转移到目标指令（短格式）。
Bgt 如果第一个值大于第二个值，则将控制转移到目标指令。
Bgt.S 如果第一个值大于第二个值，则将控制转移到目标指令（短格式）。
Bgt.Un 当比较无符号整数值或不可排序的浮点型值时，如果第一个值大于第二个值，则将控制转移到目标指令。
Bgt.Un.S 当比较无符号整数值或不可排序的浮点型值时，如果第一个值大于第二个值，则将控制转移到目标指令（短格式）。
Ble 如果第一个值小于或等于第二个值，则将控制转移到目标指令。
Ble.S 如果第一个值小于或等于第二个值，则将控制转移到目标指令（短格式）。
Ble.Un 当比较无符号整数值或不可排序的浮点型值时，如果第一个值小于或等于第二个值，则将控制转移到目标指令。
Ble.Un.S 当比较无符号整数值或不可排序的浮点值时，如果第一个值小于或等于第二个值，则将控制权转移到目标指令（短格式）。
Blt 如果第一个值小于第二个值，则将控制转移到目标指令。
Blt.S 如果第一个值小于第二个值，则将控制转移到目标指令（短格式）。
Blt.Un 当比较无符号整数值或不可排序的浮点型值时，如果第一个值小于第二个值，则将控制转移到目标指令。
Blt.Un.S 当比较无符号整数值或不可排序的浮点型值时，如果第一个值小于第二个值，则将控制转移到目标指令（短格式）。
Bne.Un 当两个无符号整数值或不可排序的浮点型值不相等时，将控制转移到目标指令。
Bne.Un.S 当两个无符号整数值或不可排序的浮点型值不相等时，将控制转移到目标指令（短格式）。
Box 将值类转换为对象引用（O 类型）。
Br 无条件地将控制转移到目标指令。
Br.S 无条件地将控制转移到目标指令（短格式）。
Break 向公共语言结构 (CLI) 发出信号以通知调试器已撞上了一个断点。
Brfalse 如果 value 为 false、空引用（Visual Basic 中的 Nothing）或零，则将控制转移到目标指令。
Brfalse.S 如果 value 为 false、空引用或零，则将控制转移到目标指令。
Brtrue 如果 value 为 true、非空或非零，则将控制转移到目标指令。
Brtrue.S 如果 value 为 true、非空或非零，则将控制转移到目标指令（短格式）。
Call 调用由传递的方法说明符指示的方法。
Calli 通过调用约定描述的参数调用在计算堆栈上指示的方法（作为指向入口点的指针）。
Callvirt 对对象调用后期绑定方法，并且将返回值推送到计算堆栈上。
Castclass 尝试将引用传递的对象转换为指定的类。
Ceq 比较两个值。如果这两个值相等，则将整数值 1 (int32) 推送到计算堆栈上；否则，将 0 (int32) 推送到计算堆栈上。
Cgt 比较两个值。如果第一个值大于第二个值，则将整数值 1 (int32) 推送到计算堆栈上；反之，将 0 (int32) 推送到计算堆栈上。
Cgt.Un 比较两个无符号的或不可排序的值。如果第一个值大于第二个值，则将整数值 1 (int32) 推送到计算堆栈上；反之，将 0 (int32) 推送到计算堆栈上。
Ckfinite 如果值不是有限数，则引发 ArithmeticException。
Clt 比较两个值。如果第一个值小于第二个值，则将整数值 1 (int32) 推送到计算堆栈上；反之，将 0 (int32) 推送到计算堆栈上。
Clt.Un 比较无符号的或不可排序的值 value1 和 value2。如果 value1 小于 value2，则将整数值 1 (int32 ) 推送到计算堆栈上；反之，将 0 ( int32 ) 推送到计算堆栈上。
Constrained 约束要对其进行虚方法调用的类型。
Conv.I 将位于计算堆栈顶部的值转换为 native int。
Conv.I1 将位于计算堆栈顶部的值转换为 int8，然后将其扩展（填充）为 int32。
Conv.I2 将位于计算堆栈顶部的值转换为 int16，然后将其扩展（填充）为 int32。
Conv.I4 将位于计算堆栈顶部的值转换为 int32。
Conv.I8 将位于计算堆栈顶部的值转换为 int64。
Conv.Ovf.I 将位于计算堆栈顶部的有符号值转换为有符号 native int，并在溢出时引发 OverflowException。
Conv.Ovf.I.Un 将位于计算堆栈顶部的无符号值转换为有符号 native int，并在溢出时引发 OverflowException。
Conv.Ovf.I1 将位于计算堆栈顶部的有符号值转换为有符号 int8 并将其扩展为 int32，并在溢出时引发 OverflowException。
Conv.Ovf.I1.Un 将位于计算堆栈顶部的无符号值转换为有符号 int8 并将其扩展为 int32，并在溢出时引发 OverflowException。
Conv.Ovf.I2 将位于计算堆栈顶部的有符号值转换为有符号 int16 并将其扩展为 int32，并在溢出时引发 OverflowException。
Conv.Ovf.I2.Un 将位于计算堆栈顶部的无符号值转换为有符号 int16 并将其扩展为 int32，并在溢出时引发 OverflowException。
Conv.Ovf.I4 将位于计算堆栈顶部的有符号值转换为有符号 int32，并在溢出时引发 OverflowException。
Conv.Ovf.I4.Un 将位于计算堆栈顶部的无符号值转换为有符号 int32，并在溢出时引发 OverflowException。
Conv.Ovf.I8 将位于计算堆栈顶部的有符号值转换为有符号 int64，并在溢出时引发 OverflowException。
Conv.Ovf.I8.Un 将位于计算堆栈顶部的无符号值转换为有符号 int64，并在溢出时引发 OverflowException。
Conv.Ovf.U 将位于计算堆栈顶部的有符号值转换为 unsigned native int，并在溢出时引发 OverflowException。
Conv.Ovf.U.Un 将位于计算堆栈顶部的无符号值转换为 unsigned native int，并在溢出时引发 OverflowException。
Conv.Ovf.U1 将位于计算堆栈顶部的有符号值转换为 unsigned int8 并将其扩展为 int32，并在溢出时引发 OverflowException。
Conv.Ovf.U1.Un 将位于计算堆栈顶部的无符号值转换为 unsigned int8 并将其扩展为 int32，并在溢出时引发 OverflowException。
Conv.Ovf.U2 将位于计算堆栈顶部的有符号值转换为 unsigned int16 并将其扩展为 int32，并在溢出时引发 OverflowException。
Conv.Ovf.U2.Un 将位于计算堆栈顶部的无符号值转换为 unsigned int16 并将其扩展为 int32，并在溢出时引发 OverflowException。
Conv.Ovf.U4 将位于计算堆栈顶部的有符号值转换为 unsigned int32，并在溢出时引发 OverflowException。
Conv.Ovf.U4.Un 将位于计算堆栈顶部的无符号值转换为 unsigned int32，并在溢出时引发 OverflowException。
Conv.Ovf.U8 将位于计算堆栈顶部的有符号值转换为 unsigned int64，并在溢出时引发 OverflowException。
Conv.Ovf.U8.Un 将位于计算堆栈顶部的无符号值转换为 unsigned int64，并在溢出时引发 OverflowException。
Conv.R.Un 将位于计算堆栈顶部的无符号整数值转换为 float32。
Conv.R4 将位于计算堆栈顶部的值转换为 float32。
Conv.R8 将位于计算堆栈顶部的值转换为 float64。
Conv.U 将位于计算堆栈顶部的值转换为 unsigned native int，然后将其扩展为 native int。
Conv.U1 将位于计算堆栈顶部的值转换为 unsigned int8，然后将其扩展为 int32。
Conv.U2 将位于计算堆栈顶部的值转换为 unsigned int16，然后将其扩展为 int32。
Conv.U4 将位于计算堆栈顶部的值转换为 unsigned int32，然后将其扩展为 int32。
Conv.U8 将位于计算堆栈顶部的值转换为 unsigned int64，然后将其扩展为 int64。
Cpblk 将指定数目的字节从源地址复制到目标地址。
Cpobj 将位于对象（&、* 或 native int 类型）地址的值类型复制到目标对象（&、* 或 native int 类型）的地址。
Div 将两个值相除并将结果作为浮点（F 类型）或商（int32 类型）推送到计算堆栈上。
Div.Un 两个无符号整数值相除并将结果 ( int32 ) 推送到计算堆栈上。
Dup 复制计算堆栈上当前最顶端的值，然后将副本推送到计算堆栈上。
Endfilter 将控制从异常的 filter 子句转移回公共语言结构 (CLI) 异常处理程序。
Endfinally 将控制从异常块的 fault 或 finally 子句转移回公共语言结构 (CLI) 异常处理程序。
Initblk 将位于特定地址的内存的指定块初始化为给定大小和初始值。
Initobj 将位于指定地址的值类型的每个字段初始化为空引用或适当的基元类型的 0。
Isinst 测试对象引用（O 类型）是否为特定类的实例。
Jmp 退出当前方法并跳至指定方法。
Ldarg 将参数（由指定索引值引用）加载到堆栈上。
Ldarg.0 将索引为 0 的参数加载到计算堆栈上。
Ldarg.1 将索引为 1 的参数加载到计算堆栈上。
Ldarg.2 将索引为 2 的参数加载到计算堆栈上。
Ldarg.3 将索引为 3 的参数加载到计算堆栈上。
Ldarg.S 将参数（由指定的短格式索引引用）加载到计算堆栈上。
Ldarga 将参数地址加载到计算堆栈上。
Ldarga.S 以短格式将参数地址加载到计算堆栈上。
Ldc.I4 将所提供的 int32 类型的值作为 int32 推送到计算堆栈上。
Ldc.I4.0 将整数值 0 作为 int32 推送到计算堆栈上。
Ldc.I4.1 将整数值 1 作为 int32 推送到计算堆栈上。
Ldc.I4.2 将整数值 2 作为 int32 推送到计算堆栈上。
Ldc.I4.3 将整数值 3 作为 int32 推送到计算堆栈上。
Ldc.I4.4 将整数值 4 作为 int32 推送到计算堆栈上。
Ldc.I4.5 将整数值 5 作为 int32 推送到计算堆栈上。
Ldc.I4.6 将整数值 6 作为 int32 推送到计算堆栈上。
Ldc.I4.7 将整数值 7 作为 int32 推送到计算堆栈上。
Ldc.I4.8 将整数值 8 作为 int32 推送到计算堆栈上。
Ldc.I4.M1 将整数值 -1 作为 int32 推送到计算堆栈上。
Ldc.I4.S 将提供的 int8 值作为 int32 推送到计算堆栈上（短格式）。
Ldc.I8 将所提供的 int64 类型的值作为 int64 推送到计算堆栈上。
Ldc.R4 将所提供的 float32 类型的值作为 F (float) 类型推送到计算堆栈上。
Ldc.R8 将所提供的 float64 类型的值作为 F (float) 类型推送到计算堆栈上。
Ldelem 按照指令中指定的类型，将指定数组索引中的元素加载到计算堆栈的顶部。
Ldelem.I 将位于指定数组索引处的 native int 类型的元素作为 native int 加载到计算堆栈的顶部。
Ldelem.I1 将位于指定数组索引处的 int8 类型的元素作为 int32 加载到计算堆栈的顶部。
Ldelem.I2 将位于指定数组索引处的 int16 类型的元素作为 int32 加载到计算堆栈的顶部。
Ldelem.I4 将位于指定数组索引处的 int32 类型的元素作为 int32 加载到计算堆栈的顶部。
Ldelem.I8 将位于指定数组索引处的 int64 类型的元素作为 int64 加载到计算堆栈的顶部。
Ldelem.R4 将位于指定数组索引处的 float32 类型的元素作为 F 类型（浮点型）加载到计算堆栈的顶部。
Ldelem.R8 将位于指定数组索引处的 float64 类型的元素作为 F 类型（浮点型）加载到计算堆栈的顶部。
Ldelem.Ref 将位于指定数组索引处的包含对象引用的元素作为 O 类型（对象引用）加载到计算堆栈的顶部。
Ldelem.U1 将位于指定数组索引处的 unsigned int8 类型的元素作为 int32 加载到计算堆栈的顶部。
Ldelem.U2 将位于指定数组索引处的 unsigned int16 类型的元素作为 int32 加载到计算堆栈的顶部。
Ldelem.U4 将位于指定数组索引处的 unsigned int32 类型的元素作为 int32 加载到计算堆栈的顶部。
Ldelema 将位于指定数组索引的数组元素的地址作为 & 类型（托管指针）加载到计算堆栈的顶部。
Ldfld 查找对象中其引用当前位于计算堆栈的字段的值。
Ldflda 查找对象中其引用当前位于计算堆栈的字段的地址。
Ldftn 将指向实现特定方法的本机代码的非托管指针（native int 类型）推送到计算堆栈上。
Ldind.I 将 native int 类型的值作为 native int 间接加载到计算堆栈上。
Ldind.I1 将 int8 类型的值作为 int32 间接加载到计算堆栈上。
Ldind.I2 将 int16 类型的值作为 int32 间接加载到计算堆栈上。
Ldind.I4 将 int32 类型的值作为 int32 间接加载到计算堆栈上。
Ldind.I8 将 int64 类型的值作为 int64 间接加载到计算堆栈上。
Ldind.R4 将 float32 类型的值作为 F (float) 类型间接加载到计算堆栈上。
Ldind.R8 将 float64 类型的值作为 F (float) 类型间接加载到计算堆栈上。
Ldind.Ref 将对象引用作为 O（对象引用）类型间接加载到计算堆栈上。
Ldind.U1 将 unsigned int8 类型的值作为 int32 间接加载到计算堆栈上。
Ldind.U2 将 unsigned int16 类型的值作为 int32 间接加载到计算堆栈上。
Ldind.U4 将 unsigned int32 类型的值作为 int32 间接加载到计算堆栈上。
Ldlen 将从零开始的、一维数组的元素的数目推送到计算堆栈上。
Ldloc 将指定索引处的局部变量加载到计算堆栈上。
Ldloc.0 将索引 0 处的局部变量加载到计算堆栈上。
Ldloc.1 将索引 1 处的局部变量加载到计算堆栈上。
Ldloc.2 将索引 2 处的局部变量加载到计算堆栈上。
Ldloc.3 将索引 3 处的局部变量加载到计算堆栈上。
Ldloc.S 将特定索引处的局部变量加载到计算堆栈上（短格式）。
Ldloca 将位于特定索引处的局部变量的地址加载到计算堆栈上。
Ldloca.S 将位于特定索引处的局部变量的地址加载到计算堆栈上（短格式）。
Ldnull 将空引用（O 类型）推送到计算堆栈上。
Ldobj 将地址指向的值类型对象复制到计算堆栈的顶部。
Ldsfld 将静态字段的值推送到计算堆栈上。
Ldsflda 将静态字段的地址推送到计算堆栈上。
Ldstr 推送对元数据中存储的字符串的新对象引用。
Ldtoken 将元数据标记转换为其运行时表示形式，并将其推送到计算堆栈上。
Ldvirtftn 将指向实现与指定对象关联的特定虚方法的本机代码的非托管指针（native int 类型）推送到计算堆栈上。
Leave 退出受保护的代码区域，无条件将控制转移到特定目标指令。
Leave.S 退出受保护的代码区域，无条件将控制转移到目标指令（缩写形式）。
Localloc 从本地动态内存池分配特定数目的字节并将第一个分配的字节的地址（瞬态指针，* 类型）推送到计算堆栈上。
Mkrefany 将对特定类型实例的类型化引用推送到计算堆栈上。
Mul 将两个值相乘并将结果推送到计算堆栈上。
Mul.Ovf 将两个整数值相乘，执行溢出检查，并将结果推送到计算堆栈上。
Mul.Ovf.Un 将两个无符号整数值相乘，执行溢出检查，并将结果推送到计算堆栈上。
Neg 对一个值执行求反并将结果推送到计算堆栈上。
Newarr 将对新的从零开始的一维数组（其元素属于特定类型）的对象引用推送到计算堆栈上。
Newobj 创建一个值类型的新对象或新实例，并将对象引用（O 类型）推送到计算堆栈上。
Nop 如果修补操作码，则填充空间。尽管可能消耗处理周期，但未执行任何有意义的操作。
Not 计算堆栈顶部整数值的按位求补并将结果作为相同的类型推送到计算堆栈上。
Or 计算位于堆栈顶部的两个整数值的按位求补并将结果推送到计算堆栈上。
Pop 移除当前位于计算堆栈顶部的值。
Prefix1 基础结构。此指令为保留指令。
Prefix2 基础结构。此指令为保留指令。
Prefix3 基础结构。此指令为保留指令。
Prefix4 基础结构。此指令为保留指令。
Prefix5 基础结构。此指令为保留指令。
Prefix6 基础结构。此指令为保留指令。
Prefix7 基础结构。此指令为保留指令。
Prefixref 基础结构。此指令为保留指令。
Readonly 指定后面的数组地址操作在运行时不执行类型检查，并且返回可变性受限的托管指针。
Refanytype 检索嵌入在类型化引用内的类型标记。
Refanyval 检索嵌入在类型化引用内的地址（& 类型）。
Rem 将两个值相除并将余数推送到计算堆栈上。
Rem.Un 将两个无符号值相除并将余数推送到计算堆栈上。
Ret 从当前方法返回，并将返回值（如果存在）从调用方的计算堆栈推送到被调用方的计算堆栈上。
Rethrow 再次引发当前异常。
Shl 将整数值左移（用零填充）指定的位数，并将结果推送到计算堆栈上。
Shr 将整数值右移（保留符号）指定的位数，并将结果推送到计算堆栈上。
Shr.Un 将无符号整数值右移（用零填充）指定的位数，并将结果推送到计算堆栈上。
Sizeof 将提供的值类型的大小（以字节为单位）推送到计算堆栈上。
Starg 将位于计算堆栈顶部的值存储到位于指定索引的参数槽中。
Starg.S 将位于计算堆栈顶部的值存储在参数槽中的指定索引处（短格式）。
Stelem 用计算堆栈中的值替换给定索引处的数组元素，其类型在指令中指定。
Stelem.I 用计算堆栈上的 native int 值替换给定索引处的数组元素。
Stelem.I1 用计算堆栈上的 int8 值替换给定索引处的数组元素。
Stelem.I2 用计算堆栈上的 int16 值替换给定索引处的数组元素。
Stelem.I4 用计算堆栈上的 int32 值替换给定索引处的数组元素。
Stelem.I8 用计算堆栈上的 int64 值替换给定索引处的数组元素。
Stelem.R4 用计算堆栈上的 float32 值替换给定索引处的数组元素。
Stelem.R8 用计算堆栈上的 float64 值替换给定索引处的数组元素。
Stelem.Ref 用计算堆栈上的对象 ref 值（O 类型）替换给定索引处的数组元素。
Stfld 用新值替换在对象引用或指针的字段中存储的值。
Stind.I 在所提供的地址存储 native int 类型的值。
Stind.I1 在所提供的地址存储 int8 类型的值。
Stind.I2 在所提供的地址存储 int16 类型的值。
Stind.I4 在所提供的地址存储 int32 类型的值。
Stind.I8 在所提供的地址存储 int64 类型的值。
Stind.R4 在所提供的地址存储 float32 类型的值。
Stind.R8 在所提供的地址存储 float64 类型的值。
Stind.Ref 存储所提供地址处的对象引用值。
Stloc 从计算堆栈的顶部弹出当前值并将其存储到指定索引处的局部变量列表中。
Stloc.0 从计算堆栈的顶部弹出当前值并将其存储到索引 0 处的局部变量列表中。
Stloc.1 从计算堆栈的顶部弹出当前值并将其存储到索引 1 处的局部变量列表中。
Stloc.2 从计算堆栈的顶部弹出当前值并将其存储到索引 2 处的局部变量列表中。
Stloc.3 从计算堆栈的顶部弹出当前值并将其存储到索引 3 处的局部变量列表中。
Stloc.S 从计算堆栈的顶部弹出当前值并将其存储在局部变量列表中的 index 处（短格式）。
Stobj 将指定类型的值从计算堆栈复制到所提供的内存地址中。
Stsfld 用来自计算堆栈的值替换静态字段的值。
Sub 从其他值中减去一个值并将结果推送到计算堆栈上。
Sub.Ovf 从另一值中减去一个整数值，执行溢出检查，并且将结果推送到计算堆栈上。
Sub.Ovf.Un 从另一值中减去一个无符号整数值，执行溢出检查，并且将结果推送到计算堆栈上。
Switch 实现跳转表。
Tailcall 执行后缀的方法调用指令，以便在执行实际调用指令前移除当前方法的堆栈帧。
Throw 引发当前位于计算堆栈上的异常对象。
Unaligned 指示当前位于计算堆栈上的地址可能没有与紧接的 ldind、stind、ldfld、stfld、ldobj、stobj、initblk 或 cpblk 指令的自然大小对齐。
Unbox 将值类型的已装箱的表示形式转换为其未装箱的形式。
Unbox.Any 将指令中指定类型的已装箱的表示形式转换成未装箱形式。
Volatile 指定当前位于计算堆栈顶部的地址可以是易失的，并且读取该位置的结果不能被缓存，或者对该地址的多个存储区不能被取消。
Xor 计算位于计算堆栈顶部的两个值的按位异或，并且将结果推送到计算堆栈上。

发表于 更新于 分类于
本文字数： 4.7k 阅读时长 ≈ 4 分钟

委托

将方法作为方法的参数

委托在编译的时候确实会编译成类。因为Delegate是一个类，所以在任何可以声明类的地方都可以声明委托。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
using System;
using System.Collections.Generic;
using System.Text;

namespace Delegate {
     //定义委托，它定义了可以代表的方法的类型
     public delegate void GreetingDelegate(string name);
        class Program {

           private static void EnglishGreeting(string name) {
               Console.WriteLine("Morning, " + name);
           }

           private static void ChineseGreeting(string name) {
               Console.WriteLine("早上好, " + name);
           }

           //注意此方法，它接受一个GreetingDelegate类型的方法作为参数
           private static void GreetPeople(string name, GreetingDelegate MakeGreeting) {
               MakeGreeting(name);
            }

           static void Main(string[] args) {
               GreetPeople("Jimmy Zhang", EnglishGreeting);
               GreetPeople("张子阳", ChineseGreeting);
               Console.ReadKey();
           }
        }
    }

输出如下：
Morning, Jimmy Zhang
早上好, 张子阳

我们现在对委托做一个总结：

委托是一个类，它定义了方法的类型，使得可以将方法当作另一个方法的参数来进行传递，这种将方法动态地赋给参数的做法，可以避免在程序中大量使用If-Else(Switch)语句，同时使得程序具有更好的可扩展性。

将方法绑定到委托

可以将多个方法赋给同一个委托，或者叫将多个方法绑定到同一个委托，当调用这个委托的时候，将依次调用其所绑定的方法。 
1
2
3
4
5
6
7
8
9
10
11
12
13
static void Main(string[] args) {
    GreetingDelegate delegate1;
    delegate1 = EnglishGreeting; // 先给委托类型的变量赋值
    delegate1 += ChineseGreeting;   // 给此委托变量再绑定一个方法

     // 将先后调用 EnglishGreeting 与 ChineseGreeting 方法
    GreetPeople("Jimmy Zhang", delegate1);  
    Console.ReadKey();
}

输出为：
Morning, Jimmy Zhang
早上好, Jimmy Zhang

实际上，我们可以也可以绕过GreetPeople方法，通过委托来直接调用EnglishGreeting和ChineseGreeting：

1
2
3
4
5
6
7
8
9
static void Main(string[] args) {
    GreetingDelegate delegate1;
    delegate1 = EnglishGreeting; // 先给委托类型的变量赋值
    delegate1 += ChineseGreeting;   // 给此委托变量再绑定一个方法

    // 将先后调用 EnglishGreeting 与 ChineseGreeting 方法
    delegate1 ("Jimmy Zhang");
    Console.ReadKey();
}
注意这里，第一次用的“=”，是赋值的语法；第二次，用的是“+=”，是绑定的语法。如果第一次就使用“+=”，将出现“使用了未赋值的局部变量”的编译错误。

我们也可以使用下面的代码来这样简化这一过程：

1
2
GreetingDelegate delegate1 = new GreetingDelegate(EnglishGreeting);
delegate1 += ChineseGreeting;   // 给此委托变量再绑定一个方法

如下，这样会出现编译错误： “GreetingDelegate”方法没有采用“0”个参数的重载。尽管这样的结果让我们觉得有点沮丧，但是编译的提示：“没有0个参数的重载”再次让我们联想到了类的构造函数。

1
2
3
GreetingDelegate delegate1 = new GreetingDelegate();
delegate1 += EnglishGreeting;   // 这次用的是 “+=”，绑定语法。
delegate1 += ChineseGreeting;   // 给此委托变量再绑定一个方法

既然给委托可以绑定一个方法，那么也应该有办法取消对方法的绑定，很容易想到，这个语法是“-=”：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
static void Main(string[] args) {
    GreetingDelegate delegate1 = new GreetingDelegate(EnglishGreeting);
    delegate1 += ChineseGreeting;   // 给此委托变量再绑定一个方法

    // 将先后调用 EnglishGreeting 与 ChineseGreeting 方法
    GreetPeople("Jimmy Zhang", delegate1);  
    Console.WriteLine();

    delegate1 -= EnglishGreeting; //取消对EnglishGreeting方法的绑定
    // 将仅调用 ChineseGreeting 
    GreetPeople("张子阳", delegate1);
    Console.ReadKey();
}
输出为：
Morning, Jimmy Zhang
早上好, Jimmy Zhang
早上好, 张子阳

让我们再次对委托作个总结：

使用委托可以将多个方法绑定到同一个委托变量，当调用此变量时(这里用“调用”这个词，是因为此变量代表一个方法)，可以依次调用所有绑定的方法。

事件

Event：在类的内部，不管你声明它是public还是protected，它总是private的。在类的外部，注册“+=”和注销“-=”的访问限定符与你在声明事件时使用的访问符相同。

1
2
3
4
5
6
7
8
public class GreetingManager{
    //这一次我们在这里声明一个事件
    public event GreetingDelegate MakeGreet;

    public void GreetPeople(string name) {
        MakeGreet(name);
    }
}

很容易注意到：MakeGreet 事件的声明与之前委托变量delegate1的声明唯一的区别是多了一个event关键字。看到这里，在结合上面的讲解，你应该明白到：事件其实没什么不好理解的，声明一个事件不过类似于声明一个进行了封装的委托类型的变量而已。

为了证明上面的推论，如果我们像下面这样改写Main方法：

1
2
3
4
5
6
7
static void Main(string[] args) {
    GreetingManager gm = new  GreetingManager();
    gm.MakeGreet = EnglishGreeting;         // 编译错误1
    gm.MakeGreet += ChineseGreeting;

    gm.GreetPeople("Jimmy Zhang");
}

事件和委托的编译代码

这时候，我们注释掉编译错误的行，然后重新进行编译，再借助Reflactor来对 event的声明语句做一探究，看看为什么会发生这样的错误：

1
public event GreetingDelegate MakeGreet;

01.gif

可以看到，实际上尽管我们在GreetingManager里将 MakeGreet 声明为public，但是，实际上MakeGreet会被编译成 私有字段，难怪会发生上面的编译错误了，因为它根本就不允许在GreetingManager类的外面以赋值的方式访问，从而验证了我们上面所做的推论。

我们再进一步看下MakeGreet所产生的代码：

1
2
3
4
5
6
7
8
9
10
11
private GreetingDelegate MakeGreet; //对事件的声明 实际是 声明一个私有的委托变量

[MethodImpl(MethodImplOptions.Synchronized)]
public void add_MakeGreet(GreetingDelegate value){
    this.MakeGreet = (GreetingDelegate) Delegate.Combine(this.MakeGreet, value);
}

[MethodImpl(MethodImplOptions.Synchronized)]
public void remove_MakeGreet(GreetingDelegate value){
    this.MakeGreet = (GreetingDelegate) Delegate.Remove(this.MakeGreet, value);
}

现在已经很明确了：MakeGreet事件确实是一个GreetingDelegate类型的委托，只不过不管是不是声明为public，它总是被声明为private。另外，它还有两个方法，分别是add_MakeGreet和remove_MakeGreet，这两个方法分别用于注册委托类型的方法和取消注册。实际上也就是： “+= ”对应 add_MakeGreet，“-=”对应remove_MakeGreet。而这两个方法的访问限制取决于声明事件时的访问限制符。

在add_MakeGreet()方法内部，实际上调用了System.Delegate的Combine()静态方法，这个方法用于将当前的变量添加到委托链表中。我们前面提到过两次，说委托实际上是一个类，在我们定义委托的时候：

1
public delegate void GreetingDelegate(string name);

当编译器遇到这段代码的时候，会生成下面这样一个完整的类：

1
2
3
4
5
6
public sealed class GreetingDelegate:System.MulticastDelegate{
    public GreetingDelegate(object @object, IntPtr method);
    public virtual IAsyncResult BeginInvoke(string name, AsyncCallback callback, object @object);
    public virtual void EndInvoke(IAsyncResult result);
    public virtual void Invoke(string name);
}

02.gif

参考：

C#中的委托和事件

发表于 更新于 分类于
本文字数： 4.5k 阅读时长 ≈ 4 分钟

字段与属性

常量

常量的几个特点：

  • 常量的值必须在编译时确定，简单说就是在定义是设置值，以后都不会被改变了，她是编译常量。
  • 常量只能用于简单的类型，因为常量值是要被编译然后保存到程序集的元数据中，只支持基元类型，如 int、char、string、bool、double 等。
  • 常量在使用时，是把常量的值内联到 IL 代码中的，常量类似一个占位符，在编译时被替换掉了。正是这个特点导致常量的一个风险，就是 不支持跨程序集版本更新；

关于常量不支持跨程序集版本更新，举个简单的例子来说明：

1
2
3
4
5
6
7
8
9
public class A
{
    public const int PORT = 10086;

    public virtual void Print()
    {
        Console.WriteLine(A.PORT);
    }
}

上面一段非常简单代码，其生产的 IL 代码如下，在使用常量变量的地方，把她的值拷过来了（把常量的值内联到使用的地方），与常量变量 A.PORT 没有关系了。假如 A 引用了 B 程序集（ B.dll 文件）中的一个常量，如果后面单独修改B程序集中的常量值，只是重新编译了 B，而没有编译程序集 A，就会出问题了，就是上面所说的不支持跨程序集版本更新。常量值更新后，所有使用该常量的代码都必须重新编译，这是我们在使用常量时必须要注意的一个问题。

  • 不要随意使用常量，特别是有可能变化的数据；
  • 不要随便修改已定义好的常量值；

151257-20160308203229116-399744142.png

枚举

枚举 enum 也有类似的问题，其根源和const一样.

下面的是一个简单的枚举定义，她的 IL 代码定义和 const 定义是一样一样的！枚举的成员定义和常量定义一样，因此枚举其实本质上就相当是一个常量集合。

1
2
3
4
5
6
public enum EnumType : int
{
    None=0,
    Int=1,
    String=2,
}

151257-20160308203230647-581894993.png

字段

字段的内联初始化问题

1
2
3
4
5
6
public class SomeType
{
    private int Age = 0;
    private DateTime StartTime = DateTime.Now;
    private string Name = "三体";
}

定义字段并初始化值，是一种很常见的代码编写习惯。但注意了，看看 IL 代码结构，一行代码（定义字段+赋值）被拆成了两块，最终的赋值都在构造函数里执行的。

151257-20160308203231741-1268662687.png

如果有多个构造函数，就像下面这样，有多个构造函数，会造成在两个构造函数 .ctor 中重复产生对字段赋值的 IL 代码，这就造成了不必要的代码膨胀。这个其实也很好解决，在非默认构造函数后加一个 “:this()” 就OK了，或者显示的在构造函数里初始化字段。

1
2
3
4
5
6
7
8
9
10
public class SomeType
{
    private DateTime _startTime = DateTime.Now;

    public SomeType() { }

    public SomeType(string name)
    {
    }
}

改进之后：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class SomeType
{
    //改进
    private DateTime _startTime;

    public SomeType()
    {
        _startTime = DateTime.Now;
    }

    public SomeType(string name):base()
    {
    }
}

属性

属性是面向对象编程的基本概念，提供了对私有字段的访问封装，在 C# 中以 get 和 set 访问器方法实现对可读可写属性的操作，提供了安全和灵活的数据访问封装。我们看看属性的本质，主要手段还是 IL 代码：

1
2
3
4
5
6
public class SomeType
{
    public int Index { get; set; }

    public SomeType() { }
}

151257-20160308203232913-500597794.png

上面定义的属性Index被分成了三个部分：

  • 自动生成的私有字段 “<Index>k__BackingField”
  • 方法：get_Index()，获取字段值；
  • 方法：set_Index(int32 ‘value’)，设置字段值；

因此可以说属性的本质还是方法，使用面向对象的思想把字段封装了一下。在定义属性时，我们可以自定义一个私有字段，也可以使用 自动属性 “{ get; set; }”的简化语法形式。

使用自动属性时需要注意一点的是，私有字段是由编译器自动命名的，是不受开发人员控制的。

委托与事件

委托

将方法作为参数进行传递。

  • C# 中的委托都继承自 System.Delegate 类型；
  • 委托类型的声明与方法签名类似，有返回值和参数；
  • 委托是一种可以封装命名（或匿名）方法的引用类型，把方法当做指针传递，但委托是面向对象、类型安全的；

委托的本质——是一个类。

1
public delegate void ShowMessageHandler(string mes);

151257-20160308203234335-1390533361.png

  • 编译器自动帮我们创建了一个类 ShowMessageHandler，继承自 System.MulticastDelegate（她又继承自 System.Delegate ），这是一个多播委托；
  • 委托类 ShowMessageHandler 中包含几个方法，其中最重要的就是 Invoke 方法，签名和定义的方法签名一致；
  • 其他两个版本 BeginInvoke 和 EndInvoke 是异步执行版本；

当我们调用委托的时候，其实就是调用委托对象的 Invoke 方法，可以验证一下，下面的调用代码会被编译为对委托对象的 Invoke 方法调用：

1
2
3
4
private ShowMessageHandler ShowMessage;

//调用
this.ShowMessage("123");

事件

Event 封装了委托类型的变量，使得：在类的内部，不管你声明它是 public 还是 protected ，它总是 private 的。在类的外部，注册 “+=” 和 注销“-=” 的访问限定符与你在声明事件时使用的访问符相同。

声明一个事件不过类似于声明一个进行了封装的委托类型的变量而已。

.NET的闭包

闭包提供了一种类似脚本语言函数式编程的便捷、可以共享数据，但也存在一些隐患。

1
2
3
4
5
6
List<Action> acs = new List<Action>(5);
for (int i = 0; i < 5; i++)
{
    acs.Add(() => { Console.WriteLine(i); });
}
acs.ForEach(ac => ac()); // 输出了 5 5 5 5 5，全是5

上面的代码中的 Action 就是 .NET 为我们定义好的一个无参数无返回值的委托，从上一节我们知道委托实质是一个类，理解这一点是解决本题的关键。在这个地方委托方法共享使用了一个局部变量i，那生成的类会是什么样的呢？看看IL代码：

151257-20160308203236460-853216066.png

共享的局部变量被提升为委托类的一个字段了：

  • 变量 i 的生命周期延长了；
  • for 循环结束后字段 i 的值是 5 了；
  • 后面再次调用委托方法，肯定就是输出 5 了；

修改以后：

1
2
3
4
5
6
7
List<Action> acss = new List<Action>(5);
for (int i = 0; i < 5; i++)
{
    int m = i;
    acss.Add(() => { Console.WriteLine(m); });
}
acss.ForEach(ac => ac()); // 输出了 0 1 2 3 4

题目答案解析

1. const和readonly有什么区别？

const 关键字用来声明编译时常量，readonly 用来声明运行时常量。都可以标识一个常量，主要有以下区别：
1、初始化位置不同。const 必须在声明的同时赋值；readonly 即可以在声明处赋值，也可以在构造方法里赋值。
2、修饰对象不同。const 即可以修饰类的字段，也可以修饰局部变量；readonly 只能修饰类的字段 。
3、const是编译时常量，在编译时确定该值，且值在编译时被内联到代码中；readonly 是运行时常量，在运行时确定该值。
4、const 默认是静态的；而 readonly 如果设置成静态需要显示声明 。
5、支持的类型时不同，const 只能修饰基元类型或值为 null 的其他引用类型；readonly 可以是任何类型。

2. 哪些类型可以定义为常量？常量const有什么风险？

基元类型或值为 null 的其他引用类型，常量的风险就是不支持跨程序集版本更新，常量值更新后，所有使用该常量的代码都必须重新编译。

3. 字段与属性有什么异同？

  • 属性提供了更为强大的，灵活的功能来操作字段
  • 出于面向对象的封装性，字段一般不设计为 Public
  • 属性允许在 set 和 get 中编写代码
  • 属性允许控制 set 和 get 的可访问性，从而提供只读或者可读写的功能 （逻辑上只写是没有意义的）
  • 属性可以使用 override 和 new

4. 静态成员和非静态成员的区别？

  • 静态变量使用 static 修饰符进行声明，静态成员在加类的时候就被加载（静态字段是随类型对象存放在 Load Heap 上），通过类进行访问。
  • 不带有 static 修饰符声明的变量称做非静态变量，在对象被实例化时创建，通过对象进行访问 。
  • 一个类的所有实例的同一静态变量都是同一个值，同一个类的不同实例的同一非静态变量可以是不同的值 。
  • 静态函数的实现里不能使用非静态成员，如非静态变量、非静态函数等。

5. 自动属性有什么风险？

因为自动属性的私有字段是由编译器命名的，后期不宜随意修改，比如在序列化中会导致字段值丢失。

6. 特性是什么？如何使用？

特性与属性是完全不相同的两个概念，只是在名称上比较相近。Attribute 特性就是关联了一个目标对象的一段配置信息，本质上是一个类，其为目标元素提供关联附加信息，这段附加信息存储在 dll 内的元数据，它本身没什么意义。运行期以反射的方式来获取附加信息。

7. 下面的代码输出什么结果？为什么？

1
2
3
4
5
6
List<Action> acs = new List<Action>(5);
for (int i = 0; i < 5; i++)
{
    acs.Add(() => { Console.WriteLine(i); });
}
acs.ForEach(ac => ac());

输出了 5 5 5 5 5，全是5！因为闭包中的共享变量i会被提升为委托对象的公共字段，生命周期延长了。

8. C#中的委托是什么？事件是不是一种委托？

什么是委托？简单来说，委托类似于 C 或 C++ 中的函数指针，允许将方法作为参数进行传递。

  • C# 中的委托都继承自 System.Delegate 类型；
  • 委托类型的声明与方法签名类似，有返回值和参数；
  • 委托是一种可以封装命名（或匿名）方法的引用类型，把方法当做指针传递，但委托是面向对象、类型安全的；

事件可以理解为一种特殊的委托，事件内部是基于委托来实现的。

参考：

.NET面试题解析(05)-常量、字段、属性、特性与委托

C# 中的委托和事件

发表于 更新于 分类于
本文字数： 6.4k 阅读时长 ≈ 6 分钟

类型基础

类型Type简述

.NET 中主要的类型就是值类型和引用类型，所有类型的基类就是 System.Object ，也就是说我们使用 FCL 提供的各种类型的、自定义的所有类型都最终派生自 System.Object ，因此他们也都继承了 System.Object 提供的基本方法。

typesystem.gif

在 .NET 代码中，我们可以很方便的创建各种类型，一个简单的数据模型、复杂的聚合对象类型、或是对客观世界实体的抽象。类 (class) 是最基础的 C# 类型，支持继承与多态。
一个 c# 类 Class 主要包含两种基本成员：

  • 状态（字段、常量、属性等）
  • 操作（方法、事件、索引器、构造函数等）

利用创建的类型（或者系统提供的），可以很容易的创建对象的实例。使用 new 运算符创建，该运算符为新的实例分配内存，调用构造函数初始化该实例，并返回对该实例的引用，如下面的语法形式：

1
<类名>  <实例名> = new <类名>([构造函数的参数])

创建后的实例对象，是一个存储在内存上（在线程栈或托管堆上）的一个对象，那可以创造实例的类型在内存中又是一个什么样的存在呢？她就是 类型对象（Type Object）。

类型对象（Type Object）

1
2
3
4
5
6
int a = 123;                                                           // 创建int类型实例a
int b = 20;                                                            // 创建int类型实例b
var atype = a.GetType();                                               // 获取对象实例a的类型Type
var btype = b.GetType();                                               // 获取对象实例b的类型Type
Console.WriteLine(System.Object.Equals(atype,btype));                  //输出：True
Console.WriteLine(System.Object.ReferenceEquals(atype, btype));        //输出：True

任何对象都有一个 GetType() 方法（基类 System.Object 提供的），该方法返回一个对象的类型，类型上面包含了对象内部的详细信息，如字段、属性、方法、基类、事件等等（通过反射可以获取）。在上面的代码中两个不同的 int 变量的类型（ int.GetType() ）是同一个 Type ，说明 int 在内存中有唯一一个（类似静态的） Systen.Int32 类型。

上面获取到的 Type 对象（ Systen.Int32 ）就是一个类型对象，她同其他引用类型一样，也是一个引用对象，这个对象中存储了 int32 类型的所有信息（类型的所有元数据信息）。

关于类型对象（Object Type）：

  • 每一个类型（如 System.Int32 ）在内存中都会有一个唯一的类型对象，通过（int）a.GetType() 可以获取该对象；
  • 类型对象（ Object Type ）存储在内存中一个独立的区域，叫 加载堆（Load Heap），加载堆是在进程创建的时候创建的，不受 GC 垃圾回收管制，因此类型对象一经创建就不会被释放的，他的生命周期从 AppDomain 创建到结束；
  • 每个引用对象都包含两个附加成员：TypeHandle 和 同步块索引，其中 TypeHandle 就指向该对象对应的类型对象；
  • 类型对象的加载由 class loader 负责，在第一次使用前加载；
  • 类型中的静态字段就是存储在这里的（加载堆上的类型对象），所以说静态字段是全局的，而且不会释放；

可以参考下面的图，第一幅图描述了对象在内存中的一个关系， 第二幅图更复杂，更准确、全面的描述了内存的结构分布。

Anytao_15_3.jpg

image_thumb_1.png

方法表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public void DoTest()
{
    B1 b1 = new B1(); B2 b2 = new B2();
    b1.Print(); b2.Print();      //按预期应该输出 B1、B2

    A ab1 = new B1(); A ab2 = new B2();
    ab1.Print(); ab2.Print();   //这里应该B1,A
}

public class A
{
    public virtual void Print() { Console.WriteLine("A"); }
}
public class B1 : A
{
    public override void Print() { Console.WriteLine("B1"); }
}
public class B2 : A
{
    public new void Print() { Console.WriteLine("B2"); }
}

方法表的加载：

  • 方法表的加载时 父类在前，子类在后，首先加载的是固定的4个来自 System.Object 的虚方法：ToString, Equals, GetHashCode, Finalize；
  • 然后加载父类 A 的虚方法；
  • 加载自己的方法；
  • 最后是构造方法：静态构造函数 .cctor() ，对象构造函数 .ctor() ；

方法的调用：
当执行代码 b1.Print() 时（此处只关注方法调用，忽略方法的继承等因素），通过 b1 的 TypeHandel 找到对应类型对象，然后找到 方法表槽，然后是对应的 IL 代码，第一次执行的时候，JIT 编译器需要把 IL 代码编译为本地机器码，第一次执行完成后机器码会保留，下一次执行就不需要 JIT 编译了。这也是为什么说 .NET 程序启动需要预热的原因。

.NET中的继承本质

方法表的创建过程是从父类到子类自上而下的，这是 .NET 中继承的很好体现，当发现有覆写父类虚方法会覆盖同名的父方法，所有类型的加载都会递归到 System.Object 类。

  • 继承是可传递的，子类是对父类的扩展，必须继承父类方法，同时可以添加新方法。
  • 子类可以调用父类方法和字段，而父类不能调用子类方法和字段。
  • 子类不光继承父类的公有成员，也继承了私有成员，只是不可直接访问。
  • new 关键字在虚方法继承中的阻断作用，中断某一虚方法的继承传递。

用基类（A）和用本身B1声明到底有什么区别呢？

1
2
B1 b1 = new B1();
A ab1 = new B1();

无论用什么做引用声明，哪怕是 object，等号右边的[ = new 类型()]都是没有区别的，也就说说对象的创建不受影响的，b1 和 ab1 对象在内存结构上是一致的；
他们的的差别就在引用指针的类型不同，这种不同在编码中智能提示就直观的反应出来了，在实际方法调用上也与引用指针类型有直接关系；
综合来说，不同引用指针类型对于对象的创建（new操作）不影响；但对于对象的使用（如方法调用）有影响，这一点在上面代码的执行结果中体现出来了！

上面调用的IL代码：

151257-20160306225941018-923782671.png

对于虚方法的调用，在 IL 中都是使用指令 callvirt，该指令主要意思就是具体的方法在运行时动态确定的：

callvirt 使用虚拟调度，也就是根据引用类型的动态类型来调度方法，
callvirt 指令根据引用变量指向的对象类型来调用方法，在运行时动态绑定，主要用于调用虚方法。

不同的类型指针在虚拟方法表中有不同的附加信息作为标志，来区别其访问的地址区域，称为 offset。不同类型的指针只能在其特定地址区域内执行。

编译器在方法调用时还有一个原则：

执行就近原则：对于同名字段或者方法，编译器是按照其顺序查找来引用的，也就是首先访问离它创建最近的字段或者方法。

151257-20160306225942315-1520940493.png

在 C# 中，new 关键字可用作运算符、修饰符或约束。

  • 1，new 运算符：用于创建对象和调用构造函数。
  • 2，new 修饰符：在用作修饰符时，new 关键字可以显式隐藏从基类继承的成员。
  • 3，new 约束：用于在泛型声明中约束可能用作类型参数的参数的类型。

.NET中的继承

抽象类

抽象类提供多个派生类共享基类的公共定义，它既可以提供抽象方法，也可以提供非抽象方法。抽象类不能实例化，必须通过继承由派生类实现其抽象方法，因此对抽象类不能使用 new 关键字，也不能被密封。

基本特点：

  • 抽象类使用 Abstract 声明，抽象方法也是用 Abstract 标示；
  • 抽象类不能被实例化；
  • 抽象方法必须定义在抽象类中；
  • 抽象类可以继承一个抽象类；
  • 抽象类不能被密封（不能使用 sealed）；
  • 同类 Class 一样，只支持单继承；
1
2
3
4
5
public abstract class AbstractUser
{
    public int Age { get; set; }
    public abstract void SetName(string name);
}

151257-20160306225944377-748332278.png

接口

接口简单理解就是一种规范、契约，使得实现接口的类或结构在形式上保持一致。实现接口的类或结构必须实现接口定义中所有接口成员，以及该接口从其他接口中继承的所有接口成员。

基本特点：

  • 接口使用 interface 声明；
  • 接口类似于抽象基类，不能直接实例化接口；
  • 接口中的方法都是抽象方法，不能有实现代码，实现接口的任何非抽象类型都必须实现接口的所有成员：
  • 接口成员是自动公开的，且不能包含任何访问修饰符。
  • 接口自身可从多个接口继承，类和结构可继承多个接口，但接口不能继承类。
1
2
3
4
5
public interface IUser
{
    int Age { get; set; }
    void SetName(string name);
}

下面是 IUser 接口定义的 IL 代码，看上去是不是和上面的抽象类 AbstractUser 的 IL 代码差不多！接口也是使用.Class ~ abstract 标记，方法定义同抽象类中的方法一样使用 abstract virtual 标记。因此可以把接口看做是一种特殊的抽象类，该类只提供定义，没有实现。

151257-20160306225945627-434523504.png

另外一个小细节，上面说到接口是一个特殊的类型，不继承 System.Object，通过 IL 代码其实可以证实这一点。无论是自定义的任何类型还是抽象类，都会隐式继承 System.Object，AbstractUser 的 IL 代码中就有 “extends [mscorlib]System.Object”，而接口的 IL 代码并没有这一段代码。

继承

在.NET中继承的主要两种方式就是类继承和接口继承，两者的主要思想是不一样的：

  • 类继承强调父子关系，是一个“IS A”的关系，因此只能单继承（就像一个人只能有一个Father）；
  • 接口继承强调的是一种规范、约束，是一个“CAN DO”的关系，支持多继承，是实现多态一种重要方式。

题目答案解析

1. 所有类型都继承System.Object吗？

基本上是的，所有值类型和引用类型都继承自 System.Object，接口是一个特殊的类型，不继承自 System.Object。

2. 解释virtual、sealed、override和abstract的区别

  • virtual 申明虚方法的关键字，说明该方法可以被重写
  • sealed 说明该类不可被继承
  • override 重写基类的方法
  • abstract 申明抽象类和抽象方法的关键字，抽象方法不提供实现，由子类实现，抽象类不可实例化。

3. 接口和类有什么异同？

不同点：

1、接口不能直接实例化。

2、接口只包含方法或属性的声明，不包含方法的实现。

3、接口可以多继承，类只能单继承。

4、表达的含义不同，接口主要定义一种规范，统一调用方法，也就是规范类，约束类，类是方法功能的实现和集合

相同点：

1、接口、类和结构都可以从多个接口继承。

2、接口类似于抽象基类：继承接口的任何非抽象类型都必须实现接口的所有成员。

3、接口和类都可以包含事件、索引器、方法和属性。

4. 抽象类和接口有什么区别？

1、继承：接口支持多继承；抽象类不能实现多继承。

2、表达的概念：接口用于规范，更强调契约，抽象类用于共性，强调父子。抽象类是一类事物的高度聚合，那么对于继承抽象类的子类来说，对于抽象类来说，属于”Is A”的关系；而接口是定义行为规范，强调“Can Do”的关系，因此对于实现接口的子类来说，相对于接口来说，是”行为需要按照接口来完成”。

3、方法实现：对抽象类中的方法，即可以给出实现部分，也可以不给出；而接口的方法（抽象规则）都不能给出实现部分，接口中方法不能加修饰符。

4、子类重写：继承类对于两者所涉及方法的实现是不同的。继承类对于抽象类所定义的抽象方法，可以不用重写，也就是说，可以延用抽象类的方法；而对于接口类所定义的方法或者属性来说，在继承类中必须重写，给出相应的方法和属性实现。

5、新增方法的影响：在抽象类中，新增一个方法的话，继承类中可以不用作任何处理；而对于接口来说，则需要修改继承类，提供新定义的方法。

6、接口可以作用于值类型（枚举可以实现接口）和引用类型；抽象类只能作用于引用类型。

7、接口不能包含字段和已实现的方法，接口只包含方法、属性、索引器、事件的签名；抽象类可以定义字段、属性、包含有实现的方法。

5. 重载与覆盖的区别？

重载：当类包含两个名称相同但签名不同(方法名相同,参数列表不相同)的方法时发生方法重载。用方法重载来提供在语义上完成相同而功能不同的方法。

覆写：在类的继承中使用，通过覆写子类方法可以改变父类虚方法的实现。

主要区别：

1、方法的覆盖是子类和父类之间的关系，是垂直关系；方法的重载是同一个类中方法之间的关系，是水平关系。
2、覆盖只能由一个方法，或只能由一对方法产生关系；方法的重载是多个方法之间的关系。
3、覆盖要求参数列表相同；重载要求参数列表不同。
4、覆盖关系中，调用那个方法体，是根据对象的类型来决定；重载关系，是根据调用时的实参表与形参表来选择方法体的。

6. 在继承中new和override相同点和区别？看下面的代码，有一个基类A，B1和B2都继承自A，并且使用不同的方式改变了父类方法Print（）的行为。测试代码输出什么？为什么？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public void DoTest()
{
    B1 b1 = new B1(); B2 b2 = new B2();
    b1.Print(); b2.Print();      //按预期应该输出 B1、B2

    A ab1 = new B1(); A ab2 = new B2();
    ab1.Print(); ab2.Print();   //这里应该输出什么呢？输出B1、A
}
public class A
{
    public virtual void Print() { Console.WriteLine("A"); }
}
public class B1 : A
{
    public override void Print() { Console.WriteLine("B1"); }
}
public class B2 : A
{
    // 显式隐藏从基类继承的成员,也就是说此方法被隐藏，被调用ab2.Print()时，输出基类中的方法
    public new void Print() { Console.WriteLine("B2"); }
}

7. 下面代码中，变量a、b都是int类型，代码输出结果是什么？

1
2
3
4
5
6
int a = 123;
int b = 20;
var atype = a.GetType();
var btype = b.GetType();
Console.WriteLine(System.Object.Equals(atype,btype));          //输出True
Console.WriteLine(System.Object.ReferenceEquals(atype,btype)); //输出True

8.class中定义的静态字段是存储在内存中的哪个地方？为什么会说她不会被GC回收？

随类型对象存储在内存的加载堆上，因为加载堆不受GC管理，其生命周期随 AppDomain，不会被 GC 回收。

参考：

.NET面试题解析(04)-类型、方法与继承

2md

发表于 更新于 分类于
本文字数： 7.6k 阅读时长 ≈ 7 分钟

字符串操作

认识string

string 是一个特殊的引用类型,其对象值存储在托管堆中。string 的内部是一个 char 集合，他的长度 Length 就是字符char 数组的字符个数，一个字符两个字节。string 不允许使用 new string() 的方式创建实例，而是另一种更简单的语法，直接赋值（string aa= “000” 这一点也类似值类型）。

1
2
3
4
5
6
7
8
9
10
11
public void DoStringTest()
{
    var aa = "000";
    SetStringValue(aa);
    Console.WriteLine(aa);
}

private void SetStringValue(string aa)
{
    aa += "111";
}

上面的输出结果为“000”。

通过前面的值类型与引用类型的文章，我们知道 string 是一个引用类型，既然是一个引用类型，参数传递的是引用地址，那为什么不是输出“000111”呢？是不是很有值类型的特点呢！这一切的原因源于 string 类型的两个重要的特性：恒定性 与 驻留性。

String的恒定性（不变性）

字符串是不可变的，字符串一经创建，就不会改变，任何改变都会产生新的字符串。

151257-20160303222417112-1147871973.png

上文中的 任何改变都会产生新的字符串 ，包括字符串的一些操作函数，如 str1.ToLower，Trim()，Remove(int startIndex, int count)，ToUpper() 等，都会产生新的字符串，因此在很多编程实践中，对于字符串忽略大小的比较：

1
2
if（str1.ToLower()==str2.ToLower()） //这种方式会产生新的字符串，不推荐
if（string.Compare(str1,str2,true)） //这种方式性能更好

String的驻留性

由于字符串的不变性，在大量使用字符串操作时，会导致创建大量的字符串对象，带来极大的性能损失。因此 CLR 又给 string 提供另外一个法宝，就是字符串驻留，先看看下面的代码，字符串 s1、s2 竟然是同一个对象！

1
2
3
4
var s1 = "123";
var s2 = "123";
Console.WriteLine(System.Object.Equals(s1, s2));  //输出 True
Console.WriteLine(System.Object.ReferenceEquals(s1, s2));  //输出 True

相同的字符串在内存（堆）中只分配一次，第二次申请字符串时，发现已经有该字符串是，直接返回已有字符串的地址，这就是驻留的基本过程。

字符串驻留的基本原理：

  • CLR 初始化时会在内存中创建一个驻留池，内部其实是一个哈希表，存储被驻留的字符串和其内存地址。
  • 驻留池是进程级别的，多个 AppDomain 共享。同时她不受 GC 控制，生命周期随进程，意思就是不会被 GC 回收
  • 当分配字符串时，首先会到驻留池中查找，如找到，则返回已有相同字符串的地址，不会创建新字符串对象。如果没有找到，则创建新的字符串，并把字符串添加到驻留池中。

如果大量的字符串都驻留到内存里，而得不到释放，不是很容易造成内存爆炸吗，当然不会了? 因为不是任何字符串都会驻留，只有通过 IL 指令 ldstr 创建的字符串才会留用。

1
2
3
4
5
var s1 = "123";
var s2 = s1 + "abc";
var s3 = string.Concat(s1, s2);
var s4 = 123.ToString();
var s5 = s2.ToUpper();

IL代码如下：
151257-20160303221217190-205612505.png

在上面的代码中，出现两个字符串常量，“123” 和 “abc”，这个两个常量字符串在 IL 代码中都是通过 IL 指令 ldstr 创建的，只有该指令创建的字符串才会被驻留，其他方式产生新的字符串都不会被驻留，也就不会共享字符串了，会被 GC 正常回收。

那该如何来验证字符串是否驻留呢，string 类提供两个静态方法：

  • string.Intern(string str) 可以主动驻留一个字符串；
  • string.IsInterned(string str) 检测指定字符串是否驻留，如果驻留则返回字符串，否则返回NULL
1
2
3
4
5
6
7
var s1 = "123";
var s2 = s1 + "abc";
Console.WriteLine(s2);   //输出：123abc
Console.WriteLine(string.IsInterned(s2) ?? "NULL");   //输出：NULL。因为“123abc”没有驻留

string.Intern(s2);   //主动驻留字符串
Console.WriteLine(string.IsInterned(s2) ?? "NULL");   //输出：123abc

认识StringBuilder

大量的编程实践和意见中，都说大量字符串连接操作，应该使用 StringBuilder。相对于 string 的不可变，StringBuilder 代表可变字符串，不会像字符串，在托管堆上频繁分配新对象。

首先 StringBuilder 内部同 string 一样，有一个 char[] 字符数组，负责维护字符串内容。因此，与 char 数组相关，就有两个很重要的属性：

  • public int Capacity：StringBuilder 的容量，其实就是字符数组的长度。
  • public int Length：StringBuilder 中实际字符的长度，>=0，<= 容量 Capacity。

StringBuilder 之所以比 string 效率高，主要原因就是不会创建大量的新对象，StringBuilder 在以下两种情况下会分配新对象：

  • 追加字符串时，当字符总长度超过了当前设置的容量 Capacity，这个时候，会重新创建一个更大的字符数组，此时会涉及到分配新对象。
  • 调用 StringBuilder.ToString()，创建新的字符串。

追加字符串的过程：

  • StringBuilder 的默认初始容量为16；
  • 使用 stringBuilder.Append() 追加一个字符串时，当字符数大于16，StringBuilder 会自动申请一个更大的字符数组，一般是倍增；
  • 在新的字符数组分配完成后，将原字符数组中的字符复制到新字符数组中，原字符数组就被GC回收；
  • 最后把需要追加的字符串追加到新字符数组中；

简单来说，当 StringBuilder 的容量 Capacity 发生变化时，就会引起托管对象申请、内存复制等操作，带来不好的性能影响，因此设置合适的初始容量是非常必要的，尽量减少内存申请和对象创建。

验证代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
StringBuilder sb1 = new StringBuilder();
Console.WriteLine("Capacity={0}; Length={1};", sb1.Capacity, sb1.Length); //输出：Capacity=16; Length=0;   //初始容量为16 
sb1.Append('a', 12);    //追加12个字符
Console.WriteLine("Capacity={0}; Length={1};", sb1.Capacity, sb1.Length); //输出：Capacity=16; Length=12;  
sb1.Append('a', 20);    //继续追加20个字符，容量倍增了
Console.WriteLine("Capacity={0}; Length={1};", sb1.Capacity, sb1.Length); //输出：Capacity=32; Length=32;  
sb1.Append('a', 41);    //追加41个字符，新容量=32+41=73
Console.WriteLine("Capacity={0}; Length={1};", sb1.Capacity, sb1.Length); //输出：Capacity=73; Length=73;  

StringBuilder sb2 = new StringBuilder(80); //设置一个合适的初始容量
Console.WriteLine("Capacity={0}; Length={1};", sb2.Capacity, sb2.Length); //输出：Capacity=80; Length=0;
sb2.Append('a', 12);
Console.WriteLine("Capacity={0}; Length={1};", sb2.Capacity, sb2.Length); //输出：Capacity=80; Length=12;
sb2.Append('a', 20);
Console.WriteLine("Capacity={0}; Length={1};", sb2.Capacity, sb2.Length); //输出：Capacity=80; Length=32;
sb2.Append('a', 41);
Console.WriteLine("Capacity={0}; Length={1};", sb2.Capacity, sb2.Length); //输出：Capacity=80; Length=73;

为什么少量字符串不推荐使用 StringBuilder 呢？因为 StringBuilder 本身是有一定的开销的，少量字符串就不推荐使用了，使用 String.Concat 和 String.Join 更合适。

高效的使用字符串

  • 在使用线程锁的时候，不要锁定一个字符串对象，因为字符串的驻留性，可能会引发不可以预料的问题；
  • 理解字符串的不变性，尽量避免产生额外字符串，如：
1
2
if（str1.ToLower()==str2.ToLower()） //这种方式会产生新的字符串，不推荐
if（string. Compare(str1,str2,true)） //这种方式性能更好
  • 在处理大量字符串连接的时候，尽量使用 StringBuilder，在使用 StringBuilder 时，尽量设置一个合适的长度初始值；
1
2
3
StringBuilder myStringBuilder = new StringBuilder("Hello World!", 25);
或
myStringBuilder.Capacity = 25;
  • 少量字符串连接建议使用 String.Concat 和 String.Join 代替。

题目答案解析

1.字符串是引用类型类型还是值类型？

引用类型。

2.在字符串连加处理中，最好采用什么方式，理由是什么？

少量字符串连接，使用 String.Concat，大量字符串使用 StringBuilder，因为 StringBuilder 的性能更好，如果 string 的话会创建大量字符串对象。

3.使用 StringBuilder时，需要注意些什么问题？

  • 少量字符串时，尽量不要用，StringBuilder 本身是有一定性能开销的；
  • 大量字符串连接使用 StringBuilder 时，应该设置一个合适的容量。

4.以下代码执行后内存中会存在多少个字符串？分别是什么？输出结果是什么？为什么呢？

1
2
3
4
string st1 = "123" + "abc";
string st2 = "123abc";
Console.WriteLine(st1 == st2);
Console.WriteLine(System.Object.ReferenceEquals(st1, st2));

输出结果：

1
2
True
True

内存中的字符串只有一个“123abc”,第一行代码（string st1 = “123” + “abc”; ）常量字符串相加会被编译器优化。由于字符串驻留机制，两个变量st1、st2都指向同一个对象。IL代码如下：

151257-20160303221219330-60155453.png

5.以下代码执行后内存中会存在多少个字符串？分别是什么？输出结果是什么？为什么呢？

1
2
3
4
5
string s1 = "123";
string s2 = s1 + "abc";
string s3 = "123abc";
Console.WriteLine(s2 == s3);
Console.WriteLine(System.Object.ReferenceEquals(s2, s3));

结果：

1
2
True
False

4个字符串。
分别是123，abc，123abc，123abc。

理由：
s1+abc时产生的不是可驻留的的字符串，而下句则是个驻留字符串。
字符串是不可变的，字符串一经创建，就不会改变，任何改变都会产生新的字符串。

6.使用C#实现字符串反转算法，例如：输入”12345”, 输出”54321”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static string Reverse(string str)
{
    if (string.IsNullOrEmpty(str))
    {
        throw new ArgumentException("参数不合法");
    }

    StringBuilder sb = new StringBuilder(str.Length);  //注意：设置合适的初始长度，可以显著提高效率（避免了多次内存申请）
    for (int index = str.Length - 1; index >= 0; index--)
    {
        sb.Append(str[index]);
    }
    return sb.ToString();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static string Reverse(string str)
{
    if (string.IsNullOrEmpty(str))
    {
        throw new ArgumentException("参数不合法");
    }
    char[] chars = str.ToCharArray();
    int begin = 0;
    int end = chars.Length - 1;
    char tempChar;
    while (begin < end)
    {
        tempChar = chars[begin];
        chars[begin] = chars[end];
        chars[end] = tempChar;
        begin++;
        end--;
    }
    string strResult = new string(chars);
    return strResult;
}
1
2
3
4
5
6
public static string Reverse(string str)
{
    char[] arr = str.ToCharArray();
    Array.Reverse(arr);
    return new string(arr);
}

7.下面的代码输出结果？为什么？

1
2
3
4
5
6
7
object a = "123";
object b = "123";
Console.WriteLine(System.Object.Equals(a,b));
Console.WriteLine(System.Object.ReferenceEquals(a,b));
string sa = "123";
Console.WriteLine(System.Object.Equals(a, sa));
Console.WriteLine(System.Object.ReferenceEquals(a, sa));

输出结果全是 True，因为他们都指向同一个字符串实例，使用 object 声明和 string 声明在这里并没有区别（string是引用类型）。

8.C#中string.Empty、""和null 之间的区别

实际上 Empty 是 string 类中的一个静态的只读字段，他的定义是这样的：

public static readonly String Empty = "";

也就是说 string.Empty 的内部实现是等于""的。

引用类型是将对象是实际数据保存在堆上, 将对象在堆上的地址保存在栈上。因此 string.Empty 与 "" 都会在栈上保存一个地址这个地址占4字节，指向内存堆中的某个长度为0的空间，这个空间保存的是 string.Empty 的实际值

"" 是通过 CLR 进行优化的,CLR 会维护一个字符串池,以防在堆中创建重复的字符串。
而 string.Empty 是一种 c# 语法级别的优化，是在 C# 编译器将代码编译为 IL (即 MSIL )时进行了优化，即所有对 string 类的静态字段 Empty 的访问都会被指向同一引用，以节省内存空间。也就是说，"" 与 string.Empty 在用法与性能上基本没区别。string.Empty 是在语法级别对 "" 的优化。

那就是 string.Empty 会在堆上占用一个长度为0的空间，而null不会。具体内容如下：

1
2
string str1="";
string str2=null;

如刚才所说 str1 会在栈上保存一个地址,这个地址占4字节，指向内存堆中的某个长度为0的空间，这个空间保存的是 str1 的实际值。

str2 同样会在栈上保存一个地址,这个地址也占4字节，但是这个地址是没有明确指向的，它哪也不指，其内容为 0x00000000。

参考：

.NET面试题解析(03)-string与字符串操作

C#基础知识梳理系列九：StringBuilder

深入理解string和如何高效地使用string

C#中string.Empty、””和null 之间的区别

发表于 更新于 分类于
本文字数： 2k 阅读时长 ≈ 2 分钟

装箱与拆箱

所有值类型都是继承自 System.ValueType ，而 System.ValueType 继承自 System.Object 。因此 Object 是 .NET 中的万物之源，几乎所有类型都来自她，这是装箱与拆箱的基础。

基本概念

拆箱与装箱就是值类型与引用类型的转换，她是值类型和引用类型之间的桥梁，他们可以相互转换的一个基本前提就是上面所说的：Object 是 .NET 中的万物之源

1
2
3
int x = 1023;
object o = x; //装箱
int y = (int) o; //拆箱

装箱：值类型转换为引用对象，一般是转换为 System.Object 类型或值类型实现的接口引用类型；
拆箱：引用类型转换为值类型，注意，这里的引用类型只能是被装箱的引用类型对象；

装箱是非常“昂贵”的操作，它需要 内存分配 和 内存复制，并且由于需要回收临时创建的装箱对象，因此会对垃圾回收器产生压力。

装箱的过程

1
2
int x = 1023;
object o = x; //装箱
当编译器检测到需要将值类型实例当作引用类型时，就会生成IL指令box。然后，JIT编译器解释该指令，调用某个方法分派堆内存，将值类型实例的内容复制到堆上，并用对象头（对象头字节和方法表指针（类型对象指针））包装起来。每当需要对象引用的时候，就使用这种“箱子”。

拆箱的过程

1
2
3
int x = 1023;
object o = x; //装箱
int y = (int) o; //拆箱

具体过程：

  • 1.检查实例对象（ object o ）是否有效，如是否为 null，其装箱的类型与拆箱的类型（int）是否一致，如检测不合法，抛出异常；
  • 2.指针返回，就是获取装箱对象（object o）中值类型字段值的地址；
  • 3.字段拷贝，把装箱对象（object o）中值类型字段值拷贝到栈上，意思就是创建一个新的值类型变量来存储拆箱后的值；

总结

只有值类型才有装箱、拆箱两个状态，而引用类型一直都在箱子里。

一般来说，装箱的性能开销更大，因为引用对象的分配更加复杂，成本也更高，值类型分配在栈上，分配和释放的效率都很高。装箱过程是需要创建一个新的引用类型对象实例，拆箱过程需要创建一个值类型字段，开销更低。

为了尽量避免这种性能损失，尽量使用泛型，在代码编写中也尽量避免隐式装箱。

在值类型中重写 Equals ,重载 Equals ,实现 IEquatable ,以及重载操作符==和!=（通过 constrained IL 前缀）。

注：constrained：强迫;强使;限制;约束

题目答案解析

1.什么是拆箱和装箱？

装箱就是值类型转换为引用类型，拆箱就是引用类型（被装箱的对象）转换为值类型。

2.什么是箱子？

值类型转换为引用类型的对象。

3.箱子放在哪里？

托管堆上。

4.装箱和拆箱有什么性能影响？

装箱和拆箱都涉及到内存的分配和对象的创建，有较大的性能影响。

5.如何避免隐身装箱？

编码中，多使用泛型、显示装箱。

6.箱子的基本结构？

上面说了，箱子就是一个引用类型对象，因此它的结构，主要包含两部分：

  • 值类型字段值；
  • 引用类型的标准配置，引用对象的额外空间：对象头字节（包括同步块索引）和 TypeHandle（或方法表指针，类型对象指针）

7.装箱的过程？

  • 1.在堆中申请内存，内存大小为值类型的大小，再加上额外固定空间（引用类型的标配：对象头字节（包括同步块索引）和 TypeHandle（或方法表指针，类型对象指针））；
  • 2.将值类型的字段值（x=1023）拷贝新分配的内存中；
  • 3.返回新引用对象的地址（给引用变量object o）

8.拆箱的过程？

  • 1.检查实例对象（object o）是否有效，如是否为null，其装箱的类型与拆箱的类型（int）是否一致，如检测不合法，抛出异常；
  • 2.指针返回，就是获取装箱对象（object o）中值类型字段值的地址；
  • 3.字段拷贝，把装箱对象（object o）中值类型字段值拷贝到栈上，意思就是创建一个新的值类型变量来存储拆箱后的值；

9.下面这段代码输出什么？共发生多少次装箱？多少次拆箱？

1
2
3
4
5
6
7
8
int i = 5;
object obj = i;
IFormattable ftt = i;
Console.WriteLine(System.Object.ReferenceEquals(i, obj));
Console.WriteLine(System.Object.ReferenceEquals(i, ftt));
Console.WriteLine(System.Object.ReferenceEquals(ftt, obj));
Console.WriteLine(System.Object.ReferenceEquals(i, (int)obj));
Console.WriteLine(System.Object.ReferenceEquals(i, (int)ftt));

上面代码输出如下：

1
2
3
4
5
False
False
False
False
False

参考：

.NET面试题解析(02)-拆箱与装箱

2md

发表于 更新于 分类于
本文字数： 6k 阅读时长 ≈ 5 分钟

基本概念

CLR 支持两种类型：引用类型和值类型。这是 .NET 语言的基础和关键，他们从类型定义、实例创建、参数传递，到内存分配都有所不同。

typesystem.gif

下图清晰了展示了 .NET 中类型分类，值类型主要是一些简单的、基础的数据类型，引用类型主要用于更丰富的、复杂的、复合的数据类型。

2009020510331710.jpg

使用值类型最佳实践

  • 对象很小，并且打算创建很多这样的对象
  • 需要高密度的内存集合
  • 在值类型中重写 Equals ,重载 Equals ,实现 IEquatable<T> ,以及重载操作符==和!=。
  • 在值类型中重写 GetHashCode。
  • 考虑将值类型实现为不可变的。

为什么要为值类型重定义相等性

原因主要有以下几点：

  • 值类型默认无法使用 == 操作符，除非对它进行重写 ( System.ValueType 里面对 object.Equals() 方法的重写)
  • 性能原因，因为值类型默认的相等性比较会使用装箱和反射，所以性能很差
  • 根据业务需求，其实际相等性的意义和默认的比较结果可能会不同，但是这种情况可能不较少

986268-20190413072415659-1667812156.png

值类型和 string 类型除外，因为所有值类型继承于 System.ValueType() ( System.ValueType() 同样继承于Object，但是 System.ValueType() 本身却是引用类型)，而 System.ValueType() 对 Equals() 和==操作符进行了重写，是逐字节比较的。而 string 类型是比较特殊的引用类型，所以 string 在很多地方都是特殊处理的。

在值类型使用 Equals() 时，因为 Equals() 使用了反射，在比较时会影响效率。

注意：

如果要把引用类型做为 Dictionary 或 HashTable 的 key 使用时，必须重写这两个方法。

原因：当我们把引用类型( string 除外)做为 Dictionary 或 HashTable 的key时，有可能永远无法根据 Key 获得 value 的值，或者说两个类型的 HashCode 永远不会相等。

拿 Dictionary 来说，虽然我们存储的时候是键值对，但是 CLR 会先把 key 转成 HashCode 并且验证 Equals 后再做存储，根据 key 取值的时候也是把 key 转换成 HashCode 并且验证 Equals 后再取值。

注意验证时 HashCode 和 Equals 的关系是并且( && )的关系。也就是说，只要 GetHashCode 和 Equlas 中有一个方法没有重写，在验证时没有重写的那个方法会调用基类的默认实现，而这两个方法的默认实现都是根据内存地址判断的，也就是说，只重写一个方法的返回值永远会是 false 。

参考：

聊一聊C#的Equals()和GetHashCode()方法

实现步骤

  • 重写 object.Equals() 方法
  • 实现 IEquatable<T>.Equals() 接口方法
  • 重写 == 和 != 操作符
  • 重写 object.GetHashCode()

参考：

C# 为值类型重定义相等性

如何重写GetHashCode方法

Object 中 GetHasCode 的算法保证了同一对象返回同一 HashCode，而不同的对象返回不同的 HashCode，但对于值类型等，视内容相等的对象为相等对象的类型时，默认的 GetHashCode 算法并不正确。重写后的 GetHashCode 必须要保证同一对象无论何时都返回同一 HashCode 值，而相等的对象也必须返回相同的值。并且在此基础上，保证 HashCode 尽量随机地散列分布。

引用类型

标准配置，引用对象的额外空间：对象头字节（包括同步块索引）和 TypeHandle（或方法表指针，类型对象指针）

方法表指针指向一个 CLR 内部数据结构–方法表（ MT ）。方法表指向另一个内部数据结构—EEClass (EE代表Execution Engine,执行引擎)。方法表和 EEClass 包含一些信息，可用来分发虚方法和接口方法调用，访问静态变量，确定对象的运行时类型，高效访问基类型方法等。

内存结构

值类型 和 引用类型 最根源的区别就是其内存分配的差异，在这之前首先要理解 CLR 的内存中两个重要的概念：

Stack 栈：线程栈，由操作系统管理，存放值类型、引用类型变量（就是引用对象在托管堆上的地址）。栈是基于线程的，也就是说一个线程会包含一个线程栈，线程栈中的值类型在对象作用域结束后会被清理，效率很高。

GC Heap托管堆：进程初始化后在进程地址空间上划分的内存空间，存储 .NET 运行过程中的对象，所有的引用类型都分配在托管堆上，托管堆上分配的对象是由 GC 来管理和释放的。托管堆是基于进程的，当然托管堆内部还有其他更为复杂的结构。

结合下图理解，变量a及其值3都是存储在栈上面。变量b在栈上存储，其值指向字符串“123”的托管堆对象地址(字符串是引用类型，字符串对象是存储在托管堆上面。字符串是一个特殊的引用类型)

151257-20160301092426314-1061559039.png

值类型一直都存储在栈上面吗？所有的引用类型都存储在托管堆上面吗？

  • 1.单独的值类型变量，如局部值类型变量都是存储在栈上面的；
  • 2.当值类型是自定义 class 的一个字段、属性时，它随引用类型存储在托管堆上，此时她是引用类型的一部分；
  • 4.所有的引用类型肯定都是存放在托管堆上的。
  • 5.结构体（值类型）中定义引用类型字段，结构体是存储在栈上，其引用变量字段只存储内存地址，指向堆中的引用实例。

对象的传递

将值类型的变量赋值给另一个变量（或者作为参数传递），会执行一次值复制。
将引用类型的变量赋值给另一个引用类型的变量，它复制的值是引用对象的内存地址，因此赋值后就会多个变量指向同一个引用对象实例。

理解这一点非常重要，下面代码测试验证一下：

1
2
3
4
5
6
7
8
9
10
11
12
int v1 = 0;
int v2 = v1;
v2 = 100;
Console.WriteLine("v1=" + v1); //输出：v1=0
Console.WriteLine("v2=" + v2); //输出：v2=100

User u1=new User();
u1.Age = 0;
User u2 = u1;
u2.Age = 100;
Console.WriteLine("u1.Age=" + u1.Age); //输出：u1.Age=100
Console.WriteLine("u2.Age=" + u2.Age); //输出：u2.Age=100，因为u1/u2指向同一个对象

当把对象作为参数传递的时候，效果同上面一样，他们都称为按值传递，但因为值类型和引用类型的区别，导致其产生的效果也不同。

参数-按值传递：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
private void DoTest(int a)
{
    a *= 2;
}

private void DoUserTest(User user)
{
    user.Age *= 2;
}

[NUnit.Framework.Test]
public void DoParaTest()
{
    int a = 10;
    DoTest(a);
    Console.WriteLine("a=" + a); //输出：a=10
    User user = new User();
    user.Age = 10;
    DoUserTest(user);
    Console.WriteLine("user.Age=" + user.Age); //输出：user.Age=20
}

上面的代码示例，两个方法的参数，都是按值传递

  • 对于值类型( int a) ：传递的是变量a的值拷贝副本，因此原本的a值并没有改变。
  • 对于引用类型( User user) ：传递的是变量 user 的引用地址（ User 对象实例的内存地址）拷贝副本，因此他们操作都是同一个 User 对象实例。

参数-按引用传递：

按引用传递的两个主要关键字：out 和 ref不管值类型还是引用类型，按引用传递的效果是一样的，都不传递值副本，而是引用的引用（类似c++的指针的指针）。out 和 ref告诉编译器方法传递额是参数地址，而不是参数本身，理解这一点很重要。 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
private void DoTest(ref int a)
{
    a *= 2;
}

private void DoUserTest(ref User user)
{
    user.Age *= 2;
}

public void DoParaTest()
{
    int a = 10;
    DoTest(ref a);
    Console.WriteLine("a=" + a); //输出：a=20 ,a的值改变了
    User user = new User();
    user.Age = 10;
    DoUserTest(ref user);
    Console.WriteLine("user.Age=" + user.Age); //输出：user.Age=20
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
int m = 0;
Console.WriteLine(RefValue(1, ref m)); //输出 1
Console.WriteLine(m);  //输出 222

int n;
Console.WriteLine(OutValue(1, out n));  //输出 223
Console.WriteLine(n);  //输出 222

static int RefValue(int i, ref int j)
{
    int k = j;
    j = 222;
    return i + k;
}

static int OutValue(int i, out int j)
{
    j = 222;
    return i + j;
}

out 和 ref的主要异同:

  • out 和 ref 都指示编译器传递参数地址，在行为上是相同的；
  • 他们的使用机制稍有不同，ref 必须要求参数在使用之前要显式初始化，out 必须要在方法内部初始化；
  • 使用 ref 和 out 时，在方法的参数和执行方法时，都要加Ref或Out关键字，以满足匹配；
  • out 适合用在需要 retrun 多个返回值的地方，而 ref 则用在需要被调用的方法修改调用者的引用的时候。
  • out 和 ref 不可以重载，就是不能定义 Method(ref int a) 和 Method(out int a) 这样的重载，从编译角度看，二者的实质是相同的，只是使用时有区别；
  • ref 是有进有出，而 out 是只出不进。
注：在C#中，方法的参数传递有四种类型：传值（by value），传址（by reference），输出参数（by output），数组参数（by array）。传值参数无需额外的修饰符，传址参数需要修饰符ref，输出参数需要修饰符out，数组参数需要修饰符params。

常见问题

值类型和引用类型区别.jpg

题目答案解析

1. 值类型和引用类型的区别？

值类型包括简单类型、结构体类型和枚举类型，引用类型包括自定义类、数组、接口、委托等。

  • 1、赋值方式：将一个值类型变量赋给另一个值类型变量时，将复制包含的值。这与引用类型变量的赋值不同，引用类型变量的赋值只复制对象的引用（即内存地址，类似 C++ 中的指针），而不复制对象本身。
  • 2、继承：值类型不可能派生出新的类型，所有的值类型均隐式派生自 System.ValueType。但与引用类型相同的是，结构也可以实现接口。
  • 3、null：与引用类型不同，值类型不可能包含 null 值。然而，可空类型允许将 null 赋给值类型（他其实只是一种语法形式，在 clr 底层做了特殊处理）。
  • 4、每种值类型均有一个隐式的默认构造函数来初始化该类型的默认值，值类型初始会默认为0，引用类型默认为null。
  • 5、值类型存储在栈中，引用类型存储在托管堆中。

2. 结构和类的区别？

结构体是值类型，类是引用类型，主要区别如题1。其他的区别：

  • 结构不支持无惨构造函数，不支持析构函数，并且不能有 protected 修饰；
  • 结构常用于数据存储，类 class 多用于行为；
  • class 需要用 new 关键字实例化对象，struct 可以不适用 new 关键字；
  • class 可以为抽象类，struct 不支持抽象；

3. delegate是引用类型还是值类型？enum、int[]和string呢？

enum 枚举是值类型，其他都是引用类型。

4. 堆和栈的区别？

线程堆栈：简称栈 Stack
托管堆： 简称堆 Heap

  • 值类型大多分配在栈上，引用类型都分配在堆上；
  • 栈由操作系统管理，栈上的变量在其作用域完成后就被释放，效率较高，但空间有限。堆受 CLR 的 GC 控制；
  • 栈是基于线程的，每个线程都有自己的线程栈，初始大小为1M。堆是基于进程的，一个进程分配一个堆，堆的大小由 GC 根据运行情况动态控制；

5.“结构”对象可能分配在堆上吗？什么情况下会发生，有什么需要注意的吗？

结构是值类型，有两种情况会分配在对上面：

  • 结构作为class的一个字段或属性，会随class一起分配在堆上面；
  • 装箱后会在堆中存储，尽量避免值类型的装箱，值类型的拆箱和装箱都有性能损失；

6. 理解参数按值传递？以及按引用传递？

  • 按值传递：对于值类型传递的它的值拷贝副本，而引用类型传递的是引用变量的内存地址，他们还是指向的同一个对象。
  • 按引用传递：通过关键字 out 和 ref 传递参数的内存地址，值类型和引用类型的效果是相同的。

7. out 和 ref的区别与相同点？

  • out 和 ref 都指示编译器传递参数地址，在行为上是相同的；
  • 他们的使用机制稍有不同，ref 要求参数在使用之前要显式初始化，out 要在方法内部初始化；
  • out 和 ref 不可以重载，就是不能定义 Method(ref int a) 和 Method(out int a) 这样的重载，从编译角度看，二者的实质是相同的，只是使用时有区别；

8. C#支持哪几个预定义的值类型？C#支持哪些预定义的引用类型？

值类型：整数、浮点数、字符、bool 和 decimal

引用类型：Object，String

9. 有几种方法可以判定值类型和引用类型？

简单来说，继承自 System.ValueType 的是值类型，反之是引用类型。

10. 说说值类型和引用类型的生命周期？

值类型在作用域结束后释放。

引用类型由 GC 垃圾回收期回收。

11. 如果结构体中定义引用类型，对象在内存中是如何存储的？例如下面结构体中的class类 User对象是存储在栈上，还是堆上？

1
2
3
4
5
public struct MyStruct
{
    public int Index;
    public User User;
}

MyStruct 存储在栈中，其字段 User 的实例存储在堆中，MyStruct.User 字段存储指向 User 对象的内存地址。

参考：

.NET面试题解析(01)-值类型与引用类型

2md

C#基础：ref和out的区别

发表于 更新于 分类于
本文字数： 1.7k 阅读时长 ≈ 2 分钟

CSharp中迭代器yield-return用法

迭代器方法

迭代器方法有一个重要限制：在同一方法中不能同时使用 return 语句和 yield return 语句。

此限制通常不是问题。 可以选择在整个方法中使用 yield return，或选择将原始方法分成多个方法，一些使用 return，另一些使用 yield return。

使用 yield return 上下文关键字定义迭代器方法。

yield关键字用于遍历循环中，yield return用于返回IEnumerable<T>；
yield break用于终止循环遍历。

简单理解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static bool onOff = false;
public static IEnumerable ForExample()
{
    yield return "1";  // 第一次调用时执行  
    yield return "2";  // 第二次调用时执行  
    if (onOff)         // 第三次调用时执行  
    {
        // 执行 yield break 之后不再执行下面语句  
        yield break;
    }
    // 否则,onOff为 false  
    yield return "3";  // 第四次调用时执行  
    yield return "4";  // 第五次调用时执行  
}

实例

以下int类型的集合，需要打印出所有值大于2的元素。

1
2
3
4
static List<int> GetInitialData()
{
  return new List<int>(){1,2,3,4};
}

不使用yield return的实现

1
2
3
4
5
6
7
8
9
10
11
12
static IEnumerable<int> FilterWithoutYield()
{
    List<int> result = new List<int>();
    foreach (int i in GetInitialData())
    {
        if (i > 2)
        {
            result.Add(i);
        }
    }
    return result;
}

客户端调用：

1
2
3
4
5
foreach (var item in FilterWithoutYield())
{
    Console.WriteLine(item);
}
Console.ReadKey();

结果：3，4

使用yeild return实现

1
2
3
4
5
6
7
8
9
10
11
12
static IEnumerable<int> FilterWithYield()
{
    foreach (int i in GetInitialData())
    {
        if (i > 2)
        {
            yield return i;
        }
    }
    yield break; // 执行 yield break 之后不再执行下面语句
    Console.WriteLine("这里的代码不执行");
}
1
2
3
4
5
foreach (var item in FilterWithYield())
{
    Console.WriteLine(item);
}
Console.ReadKey();

结果：3，4

总结

第一种方法（不使用yield），是把结果集全部加载到内存中再遍历；

第二种方法（使用yield），客户端每调用一次，yield return就返回一个值给客户端，是”按需供给”。

使用yield return为什么能保证每次循环遍历的时候从前一次停止的地方开始执行呢？

–因为，编译器会生成一个状态机来维护迭代器的状态。

简单地说，当希望获取一个IEnumerable<T>类型的集合，而不想把数据一次性加载到内存，就可以考虑使用yield return实现”按需供给”。

参考：

https://docs.microsoft.com/zh-cn/dotnet/csharp/iterators

C#中yield return用法分析

C#中 yield return 与 yield break

发表于 更新于 分类于
本文字数： 1.5k 阅读时长 ≈ 1 分钟

MongoDB权限介绍

  • 1.MongoDB安装时不添加任何参数,默认是没有权限验证的,登录的用户可以对数据库任意操作而且可以远程访问数据库，需以 --auth 参数启动。

  • 2.在刚安装完毕的时候 MongoDB 都默认有一个 admin 数据库,此时admin数据库是空的,没有记录权限相关的信息。当 admin.system.users 一个用户都没有时，即使 mongod 启动时添加了 --auth 参数,如果没有在 admin 数据库中添加用户,此时不进行任何认证还是可以做任何操作(不管是否是以 --auth 参数启动),直到在 admin.system.users 中添加了一个用户。

  • 3.MongoDB的访问分为连接和权限验证，即使以 --auth 参数启动还是可以不使用用户名连接数据库，但是不会有任何的权限进行任何操作

  • 4.admin 数据库中的用户名可以管理所有数据库，其他数据库中的用户只能管理其所在的数据库。

MongoDB中用户的角色说明

  • read角色：数据库的只读权限
  • readWrite角色：数据库的读写权限
  • dbAdmin角色：数据库的管理权限，不具备读写权限
  • userAdmin角色：数据库的用户管理权限
  • clusterAdmin角色：集群管理权限(副本集、分片、主从等相关管理)
  • readAnyDatabase角色：任何数据库的只读权限(和read相似)
  • readWriteAnyDatabase角色：任何数据库的读写权限(和readWrite相似)
  • userAdminAnyDatabase角色：任何数据库用户的管理权限(和userAdmin相似)
  • dbAdminAnyDatabase角色：任何数据库的管理权限(dbAdmin相似)

启用访问控制和强制认证

在admin数据库中，创建一个admin 用户

1
2
3
4
5
6
7
8
9
10
use admin
db.createUser({
    user:"admin",
    pwd:"admin",
    roles:[{
        role:"root",
        db:"admin"
    }]
})
db.auth("admin", "admin")

对具体的库进行授权

1
2
3
4
5
6
7
8
9
10
11
12
13
use mydb
db.createUser({
    user:"mydbuser1",
    pwd:"123456",
    roles:[{
        role:"dbAdmin",
        db:"mydb"
    },{
        role:"readWrite",
        db:"mydb"
    }]
})
db.auth("mydbuser1", "123456")

常用命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 添加用户
use admin
db.addUser("test","test")

// 显示所有数据库
show dbs

// 使用某个数据库
use mydb

// 连接数据库
mongo test -uroot -p123456

// 添加用户认证
db.auth("username","password")

// 查看用户
db.system.users.find()

参考：

MongoDB安全配置

MongoDB 3.4.2 添加用户、设置权限

https://docs.mongodb.com/manual/tutorial/enable-authentication/

发表于 更新于 分类于
本文字数： 5.7k 阅读时长 ≈ 5 分钟

docker安装mongodb4.1群集

官网：https://www.mongodb.com

镜像：https://hub.docker.com/_/mongo/

github: Dockerfile

相关概念

sharded-cluster-production-architecture.bakedsvg.svg

路由，分片、副本集、配置服务器

四个组件：mongos、config server、shard、replica set。

  • mongos，数据库集群请求的入口，所有的请求都通过 mongos 进行协调，不需要在应用程序添加一个路由选择器，mongos 自己就是一个请求分发中心，它负责把对应的数据请求请求转发到对应的 shard 服务器上。在生产环境通常有多 mongos 作为请求的入口，防止其中一个挂掉所有的 mongodb 请求都没有办法操作。

  • config server，顾名思义为配置服务器，存储所有数据库元信息（路由、分片）的配置。mongos 本身没有物理存储分片服务器和数据路由信息，只是缓存在内存里，配置服务器则实际存储这些数据。mongos 第一次启动或者关掉重启就会从 config server 加载配置信息，以后如果配置服务器信息变化会通知到所有的 mongos 更新自己的状态，这样 mongos 就能继续准确路由。在生产环境通常有多个 config server 配置服务器，因为它存储了分片路由的元数据，防止数据丢失！

  • shard，分片（sharding）是指将数据库拆分，将其分散在不同的机器上的过程。将数据分散到不同的机器上，不需要功能强大的服务器就可以存储更多的数据和处理更大的负载。基本思想就是将集合切成小块，这些块分散到若干片里，每个片只负责总数据的一部分，最后通过一个均衡器来对各个分片进行均衡（数据迁移）。

  • replica set，中文翻译 副本集，其实就是 shard 的备份，防止 shard 挂掉之后数据丢失。复制提供了数据的冗余备份，并在多个服务器上存储数据副本，提高了数据的可用性， 并可以保证数据的安全性。

仲裁者（Arbiter），是复制集中的一个 MongoDB 实例，它并不保存数据。仲裁节点使用最小的资源并且不要求硬件设备，不能将 Arbiter 部署在同一个数据集节点中，可以部署在其他应用服务器或者监视服务器中，也可部署在单独的虚拟机中。为了确保复制集中有奇数的投票成员（包括 primary ），需要添加仲裁节点做为投票，否则 primary 不能运行时不会自动切换 primary。

注：mongodb3.4 以后要求配置服务器也创建副本集，不然集群搭建不成功。

部署

目录结构：

1
2
3
mongodb
 |--docker-compose.yml
 |- mongodbtest

创建2个路由服务（mongos） 命令：configdb

创建3个配置服务（configsvr ）

创建2个分片服务（shardsvr），每个 shardsvr 包含3个副本，其中1个主节点，1个从节点，1个仲裁节点。

创建目录

在 mongodb 目录运行以下命令生成目录：

1
2
3
4
5
mkdir -p /home/toor/Documents/mongodb/mongodbtest/mongos1 # mongos1
mkdir -p /home/toor/Documents/mongodb/mongodbtest/mongos2 # mongos2
mkdir -p /home/toor/Documents/mongodb/mongodbtest/cs/rs1 /home/toor/Documents/mongodb/mongodbtest/cs/rs2 /home/toor/Documents/mongodb/mongodbtest/cs/rs3 # config server replset
mkdir -p /home/toor/Documents/mongodb/mongodbtest/sh1/rs1 /home/toor/Documents/mongodb/mongodbtest/sh1/rs2 /home/toor/Documents/mongodb/mongodbtest/sh1/rs3 # sharding
mkdir -p /home/toor/Documents/mongodb/mongodbtest/sh2/rs1 /home/toor/Documents/mongodb/mongodbtest/sh2/rs2 /home/toor/Documents/mongodb/mongodbtest/sh2/rs3 # sharding

创建docker-compose

1
2
touch docker-compose.yml
vim docker-compose.yml

docker-compose.yml内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
version: '3'
services:
  csrs1:
    image: mongo:latest
    volumes:
      - $PWD/mongodbtest/cs/rs1:/data/db
    command: mongod --noauth --configsvr --replSet csrs --dbpath /data/db
  csrs2:
    image: mongo:latest
    volumes:
      - $PWD/mongodbtest/cs/rs2:/data/db
    command: mongod --noauth --configsvr --replSet csrs --dbpath /data/db
  csrs3:
    image: mongo:latest
    volumes:
      - $PWD/mongodbtest/cs/rs3:/data/db
    command: mongod --noauth --configsvr --replSet csrs --dbpath /data/db
  mongos1:
    image: mongo:latest
    volumes:
      - $PWD/mongodbtest/mongos1:/data/db
    command: mongos --noauth --configdb csrs/csrs1:27019,csrs2:27019,csrs3:27019
  mongos2:
    image: mongo:latest
    volumes:
      - $PWD/mongodbtest/mongos2:/data/db
    command: mongos --noauth --configdb csrs/csrs1:27019,csrs2:27019,csrs3:27019
  sh1rs1:
    image: mongo:latest
    volumes:
      - $PWD/mongodbtest/sh1/rs1:/data/db
    command: mongod --noauth --dbpath /data/db --shardsvr --replSet shrs1
  sh1rs2:
    image: mongo:latest
    volumes:
      - $PWD/mongodbtest/sh1/rs2:/data/db
    command: mongod --noauth --dbpath /data/db --shardsvr --replSet shrs1
  sh1rs3:
    image: mongo:latest
    volumes:
      - $PWD/mongodbtest/sh1/rs3:/data/db
    command: mongod --noauth --dbpath /data/db --shardsvr --replSet shrs1
  sh2rs1:
    image: mongo:latest
    volumes:
      - $PWD/mongodbtest/sh2/rs1:/data/db
    command: mongod --noauth --dbpath /data/db --shardsvr --replSet shrs2
  sh2rs2:
    image: mongo:latest
    volumes:
      - $PWD/mongodbtest/sh2/rs2:/data/db
    command: mongod --noauth --dbpath /data/db --shardsvr --replSet shrs2
  sh2rs3:
    image: mongo:latest
    volumes:
      - $PWD/mongodbtest/sh2/rs3:/data/db
    command: mongod --noauth --dbpath /data/db --shardsvr --replSet shrs2

注：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
--noauth 不进行身份认证
--auth 进行身份认证

# 不加会有一个28017的端口监听，可以通过网页管理mongodb，不需要请去掉
--nohttpinterface

# 这两个参数的作用就是改变启动端口
--shardsvr
--configsvr

# 副本集设置
--replSet

# 这一项是用来指定chunk的大小的，单位是MB，默认大小为200MB
--chunkSize

# 可以限制访问的ip
--bind_ip

# 可以重新制定端口，默认为27017
--port

初始化[配置服务]副本集(Config Server)

1
2
3
4
5
6
docker-compose exec csrs1 mongo --port 27019
rs.initiate()
rs.add('csrs2:27019')
rs.add('csrs3:27019')
rs.status() //查看状态
quit() // 退出 或 exit

注：config server 默认端口为 27019

初始化分片

注：shard server 默认端口号为 27018

shrs1副本集

1
2
3
4
5
6
7
8
docker-compose exec sh1rs1 mongo --port 27018
rs.initiate()
var cfg = rs.conf()
cfg.members[0].host = 'sh1rs1:27018'
rs.reconfig(cfg)
rs.add('sh1rs2:27018')
rs.add({host:"sh1rs3:27018", arbiterOnly:true}) // 仲裁
quit()

shrs2副本集

1
2
3
4
5
6
7
8
docker-compose exec sh2rs1 mongo --port 27018
rs.initiate()
var cfg = rs.conf()
cfg.members[0].host = 'sh2rs1:27018'
rs.reconfig(cfg)
rs.add('sh2rs2:27018')
rs.add({host:"sh2rs3:27018", arbiterOnly:true})
quit()

通过mongos添加分片关系到configsvr

mongos1:

1
2
3
4
docker-compose exec mongos1 mongo
sh.addShard('shrs1/sh1rs1:27018,sh1rs2:27018,sh1rs3:27018')
sh.addShard('shrs2/sh2rs1:27018,sh2rs2:27018,sh2rs3:27018')
sh.status() //查看状态

mongos2:

1
2
3
4
docker-compose exec mongos2 mongo
sh.addShard('shrs1/sh1rs1:27018,sh1rs2:27018,sh1rs3:27018')
sh.addShard('shrs2/sh2rs1:27018,sh2rs2:27018,sh2rs3:27018')
sh.status() //查看状态

QQ截图20180824094655.png

启用分片

设置分片chunk大小

1
2
use config
db.settings.save({"_id":"chunksize","value":1}) // //设置块大小为1M是方便实验，不然就需要插入海量数据

启用数据库分片

1
2
3
4
5
6
7
8
9
#  数据库分片就有针对性，可以自定义需要分片的库或者表，毕竟也不是所有数据都是需要分片操作的
sh.enableSharding("python")

#  为表创建的索引,以”id“为索引
db.user.createIndex({"id":1})

# 启用表分片
sh.shardCollection("python.user",{"id":1})
sh.status()

模拟写入数据

1
2
3
4
5
6
use python
for(i=1;i<=50000;i++){db.user.insert({"id":i,"name":"jack"+i})}
sh.status()
db.user.stats()
db.user.count()
show dbs

后期运维

mongodb 的启动顺序是，先启动配置服务器，在启动分片，最后启动 mongos.

关闭时，直接 killall 杀掉所有进程

例：

1
2
killall mongod
killall mongos

参考：

mongodb 3.4 集群搭建：分片+副本集

MongoDB(4.0)分片——大数据的处理之道

mongodb 3.4 集群搭建升级版 五台集群

docker 搭建 mongo 集群

[原创]在Docker上部署mongodb分片副本集群