让我们一起写出更有效的CSharp代码吧，少年们！

名称

内容和示例

提供API时尽量提供泛型接口

Public interface IComparable<T>{ int CompareTo(T other) }

泛型约束尽可能的严格并有效

Public delegate T FactoryFunc<T>();

Public static T Factory<T>( FactoryFunc<T> newT) where T:new()

{ T t = newt();}

通过运行时类型检查具体化泛型算法

比如根据不同的集合类型优化相应算法

使用泛型强制执行编译时类型推测

Public static T ReadFromStream(XmlReader inputStream)

{ return (T)factory.Deserialize(inputStream) }

保证自定义泛型类支持可析构的类型参数

Public sealed class EngineDriver<T>:IDisposable where T:Engine, new()

{

public void Dispose(){ var resource = driver as IDisposable; if(resource != null) resource.Dispose(); }

}

通过委托在类型参数上定义方法约束

Public static T Add<T>(T left, T right, Func<T,T,T> addFunc){ return addFunc(right, left); }

不要在基类和接口上创建具体化的泛型类型

尽可能使的基类和接口的适用范围更加的广阔

推荐使用泛型方法，除非类型参数是实例字段

Public static T Max<T>(T left, T right)

{ return Comparer<T>.Default.Compare(left, right) < 0 ? right : left }

推荐使用泛型的Tuple作为输出和引用参数

当设置方法的返回值，或者在需要使用ref参数的情形时，使用Tuple<>元组可以使代码更清晰，当然如果参数比较复杂，还是选择建立对应的DTO类型为宜

在泛型接口上增加对应的传统接口

这个在大家基础架构时非常重要，每个方法均提供泛型版本和object版本，使得代码有很强的兼容性。

Public static bool CheckEquality(object left, object right)

{ return left.Equals(right); }

Public static bool CheckEquality<T>(T left, T right) where T:IEquatable<T>

{ return left.Equals(right); }

名称

内容和示例

使用线程池代替创建线程

经过微软的官方测试，由自己调度线程和使用线程池，在每10万个计算消耗的平均时长比较中，前者所消耗时长为后者三倍，因而选用线程池作为默认多线程处理机制是合理的选择

Private static double ThreadPoolThreads(int numThreads)

{

var start = new Stopwatch();

Using(var e = new AutoResetEvent(false)){

int workerThreads = numThreads;

start.Start();//watch.ElapsedMilliseconds, watch.Restart(), watch.Stop();

for(var I = 0; I < numThreads; thread++)

ThreadPool.QueueUserWorkItem( (x)=>{

// to do

If(Interlocked.Decrement(ref workThreads) == 0)

{ e.Set(); }

});

}}

使用后台工作者组件对象用于处理多线程通信

现在已经不再使用后台Worker，而推荐使用Task任务模型替代它，其逻辑为

将lock作为优先级最高的同步原语

使用lock相当于使用了Monitor.Enter和Exit，不过要方便很多，使用的是临界区的概念。Public int TotalNum

{

get{ lock(syncObj) return total; }

set{ lock(syncObj) total++;}

}

Lock中方法体尽可能精简

在使用lock时，一定不要使用lock(this)和lock(typeof(MyType))的形式，这会造成很多的问题，必须保证锁的对象不是公开无法被外部使用的，常见的对方法加锁的形式有：

1．使用特性，[MethodImpl(MethodImplOptions.Synchronized)]

2.使用私有变量作为锁变量 private object syncHandler = new object(); 此外还有一种复杂点的形式如下。

Private object syncHandle;

Private object GetSyncHandle(){

InterLocked.CompareExchange(ref syncHandle, new object(), null);

}

避免在临界区中调用未知代码

比如不要在临界区中使用事件，因为事件的处理方法由调用方注册，是未知的，会造成相关的问题，一定要保证临界区中方法的确定性

理解在WinForm和WPF中的跨线程调用

做过WinForm编程的亲，一定遇到过一个InvalidOperationException，内容为跨线程操作非法，访问Control的线程不是创建线程，这其实是Winform、WPF等框架对UI的保护，避免多个不同线程修改UI值的情况。这种情况主要有一下三种方式来处理，最推荐的解决方案为第二种。

1. 在Form的构造方法中加入 Control.CheckForIllegalCrossThreadCalls =false; (不推荐)
2. Private void UpdateControl(string msg)

   {

   Action<string> act = (x)=>{this.controlA.Text = x; }

   if(controlA.InvokeRequired)

   { this.controlA.Invoke(act, msg); }

   else{ act(); }

   }

3. 使用BackgroundWorker组件(elide)

名称

内容和示例

为序列创建可组合的API， yield return xxx

Public static IEnumerable<int> Square(IEnumerable<int> nums)

{ foreach(var num in nums) yield return num * num; }

通过Action，Predicate，Functions解耦迭代器

Public static IEnumerable<T> Filter<T>(IEnumerable<T> sequence, Predicate<T> filterFunc)

{ if(filterFunc(int)) yield return item; }

根据请求生成序列

[IEnumerable<int>].TakeWhile(num => num < 5);

通过Function参数解耦

Public static T Sum<T>(IEnumerable<T> sequence, T total, Func<T,T,T> accumulator)

{ foreach(T item in sequence){ total = accumulator(total, item); return total; } }

创建清晰，最小化，完整的方法组

即在提供方法时，尽可能的保证完备性（支持主要的类型）

推荐定义方法重载操作符

还记得在学习C++时，很推荐重载操作符，不过在面向对象语言的今天，使用可读性更强的方法更合理

理解事件是如何增加对象运行时的耦合性

public event EventHandler<WorkerEventArgs> OnProgress;

public void DoLotsOfStuff()

{

for (var i = 0; i < 100; i++)

{

SomeWork();

var args = new WorkerEventArgs();

args.Percent = i;

//关于这个=，我总是不算特别明白，不过记得是线程安全的代码

//可以理解为，使用这个，其他调用这个事件的对象就不会被锁定

var progHandler = OnProgress;

if (progHandler != null)

{

//注意这里的this

progHandler(this, args);

}

if (args.Cancel)

return;

}

}

这里想补充的是，event属于编译时解耦，你可以看到，该事件的订阅者都没有入侵事件所属的发布者（发布者-订阅者默认），但实际上，在运行时，所有的订阅者其实是和事件紧密关联在一起的，订阅者们修改共享数据的操作存在很大的不确定性。简而言之，事件是编译时解耦，运行时耦合的。

只声明非虚事件对象

在.NET中，事件提供了类似属性的简易语法，通过add,remove方法添加相关事件处理程序，其实event就是delegate的包装器，这个特殊的委托便于应用事件处理模型，同时提供线程安全性。由于事件的运行时耦合性，如果使用虚事件容易造成未知的错误，

private EventHandler<WorkerEventArgs> progressEvent;

public event EventHandler<WorkerEventArgs> OnProgress

{

[MethodImpl(MethodImplOptions.Synchronized)]

add { progressEvent += value; }

[MethodImpl(MethodImplOptions.Synchronized)]

remove { progressEvent -= value; }

}

通过异常报告方法契约错误

当出现业务异常流程时，推荐抛出异常而不是使用TryXXX组合的方式，因为这样代码更加简单易懂。当然在与业务无关的，如简单数据转换的场景下，使用TryXXX是很好的选择

确定属性的行为和数据一样

让属性尽可能的简单，不要将复杂逻辑放在属性，如果需要可以通过提供相应方法的方式，使得代码更加通俗易懂，且使得调用人坚信属性的调用不会造成任何的性能影响

区分继承和组合

在适当的场景下，用组合代替继承是常见的代码设计模式，这样可以减少类的污染，在选用策略模式的场景下，组合使用的非常的多，常见的形式如下：

public interface IContract{ void SampleImplMethod(); }

public class MyInnerClass:IContract{ public void SampleImplMethod (){ //elided }}

public class MyOuterClass:IContract{

private IContract impl = new MyInnerClass();

public void SampleImplMethod (){

impl.SampleImplMethod();

}}

名称

内容和示例

通过扩展方法扩展接口

Public static bool LessThan<T>(this T left, T right) where T : IComparable<T>

{ return left.CompareTo(right) < 0; }

通过扩展方法增强已经构建的类型

这部分很容易理解，比如你使用系统提供的相关类，无法修改源码（虽然已开源），这时为了代码的便捷性和可读性，使用扩展方法增强该类变得非常有效

推荐隐式类型的本地变量

简单方便

通过匿名类限制类的可见范围

使得代码的封装性更好，更加健壮

为外部的组件创建可组合的API

要求提供的API具有更好的健壮性，功能相对完整并独立，复用性更强，例如尽量不要使用可空类型作为接口参数等

避免修改绑定的变量

这部分内容涉及闭包，通过以下的例子可以很容易的理解

public void Test()

{

int index = 0;

Func<IEnumerable<int>> sequence = () => Generate(30, () => index ++);

index = 20;

foreach (var item in sequence())

{ Console.WriteLine(item); }

}

private IEnumerable<int> Generate(int num, Func<int> act)

{

for (; num > 0; num--) { yield return act(); }

}

在匿名类型上定义本地函数

public void Test01()

{

var randomNumbers = new Random();

var sequence = (from x in Generate(100, () => randomNumbers.NextDouble() * 100)

let y = randomNumbers.NextDouble() * 100

select new { x, y }).TakeWhile(point => point.x < 75);

foreach (var item in sequence)

{ Console.WriteLine(item); }}

不要重载扩展方法

由于个人创建扩展方法的普遍性和完备性不强，重载此类方法容易降低程序的健壮性

名称

内容和示例

理解查询表达式如何映射到方法调用

简单来说，我们所写的LINQ语句都会先转化为对应的扩展方法，然后再解析相关的表达式树最后生成对应语句。

var people = from e in employees where e.Age > 30 orderby e.LastName, e.FirstName, e.Age select e;

var people = employees.Where(e=>e.Age > 30).OrderBy(e=>e.LastName).ThenBy(e=>e.FirstName).ThenBy(e=>e.Age);

推荐Lazy延迟加载查询

延迟加载表示数据到真正使用时再去获取，这个概念不太容易理解，简单来说，我们的获得集合函数调用实际上只是生成相应的查询语句，但并未实际执行，获得任何对象，只有在我们对其经行迭代等操作时，才真正的加载数据。这些概念其实都和委托紧密相关，从逻辑上讲就是加了一个新的层次，函数本身（可以说是其指针、地址）是一个层次，函数的实际调用又是一个层次，在javascript也有相似的概念，就比如FunctionA和FunctionA()的区别。

Private static IEnumerable<TResult> Generate<TResult>(int number, Func<TResult> generator)

{ for(var i = 0; i < number; i++) yield return generator(); }

注意到Func<TResult>这个格式没有，和Task<TResult>何其相似，一个是异步返回值，一个是延迟的返回值，仅仅是一个方便理解的小思路哈。

推荐使用lambda表达式代替方法

这儿的实际意思是指在使用LINQ时，由于每个查询的局限性，不推荐在查询中调用外部方法，而因尽可能通过LINQ自身来完成相应工作，减少各个查询间的干扰

避免在Func和Action中抛出异常

这个也很好理解，由于Action等委托常用于集合操作中，而任何一个一场都会中断整个集合的操作，给集合操作带来了很大的不确定性，并且在并行运算时更加难以控制，因而在Action中把异常捕获并处理掉更加的合理。相信大家在job中常常会遇到循环调用的场景，这是通过返回值将相关的异常信息带回是更合理的处理方式，之后无论是记log还是给相关人发邮件都显得非常的合理

区分预先执行和延迟执行

在实际应用时，将正常加载和延迟加载组合使用非常的常见

var method1 = MethodA();

var answer = DoSomething(()=>method1, ()=>MethodB(), ()=>MethodC());

此外，想说的是，在项目中，比如大部分数据是正常加载，少部分数据使用延迟加载，而一些特殊的场景通过（比如缓存服务器）则使用预热（预先加载）的方式，弄清这里面的逻辑会让这部分的应用更加得心应手

避免捕获昂贵的资源

之前介绍了C#编译器如何生成委托和变量是如何在一个闭包的内部被捕获的，下面是一个简单的构建闭包的例子

int counter = 0;

IEnumerable<int> numbers = Generate(30, ()=>counter++);

其实际生成的代码如下：

private class Closure

{ public int generatedCounter;

public int generatorFunc(){ return generatedCounter ++; }

}

var c = new Closure();

c.generatedCounter = 0;

IEnumerable<int> sequence = Generate(30, new Func<int>(c.generatorFunc));

通过闭包的形式，我们可以发现其扩展了捕获对象的生命周期，如果这个捕获对象是一个昂贵的资源，比如说是个很大的文件流，那么就可能发生内存泄露的情况。因而在委托中使用本地的资源，一定要非常的当心，比较合理的方式是，将你所需要的内容缓存后释放原始对象。

区别IEnumerable和IQueryable的数据源

由于IQueryable数据源其实是对IEnumerable数据源的封装和增强，简答来说，IQueryable对象的相关数据处理操作的性能要远高于IEnumerable对象，因而如果实际的返回值为IQueryable对象，那么不要经行相关的转化，当然也可以通过typeA as IQueryable来尝试转化，如果本来就是IQueryable对象则直接返回，反之对其进行封装后返回

通过Single()和First()方法强行控制查询的语义

这个就是让我们的查询语句通过语义来指导查询，尽早的抛出异常

var stus = (from p in Students where p.Score > 60 orderby p.ID select p).Skip(2).First();

推荐存储Expression<.>替代Func<>

这部分很有意思，当然理解难度也不小，毕竟Expression完全可以实现一个简单的编译器了，真心强大。我们所使用的LINQ完全是建立在其上的，这儿只做个很粗略的学习，作为未来加强学习的引子，可以看到，Expression表达式树是Func的抽象

Expression<Func<int, bool>> IsOdd = val % 2 == 1;

Expression<Func<int, bool>> IsLargeNumber = val => val > 99;

InvocationExpression callLeft = Expression.Invoke(IsOdd, Expression.Constant(5));

InvocationExpression callRight = Expression.Invoke(IsLargeNumber, Expression.Constant(5));

BinaryExpression Combined = Expression.MakeBinary(ExpressionType.Add, callLeft, callRight);

Expression<Func<bool>> typeCombined = Expression.Lamda<Func<bool>>( Combined);

Func<bool> compiled = typeCombined.Compile();

Bool result = compiled();

名称

内容和示例

最小化可空类型的可见性

简单来说，就是减少在公共方法API的输入参数和输出返回值中使用可空类型，因而这样会加大方法的调用难度。当然在内部方法和实体类(包括代码生成的实体类)中使用还是非常方便有效的

给部分类和部分方法建立构造器，设值器和事件处理器

这个主题常出现在有代码生成器出现的场景，比如说使用代码生成工具生成DAO层，其中只包含最基础的CRUD操作，当扩展时，我们如果直接修改类文件，那么当下一次数据库修改，再次生成代码时就可能出现代码覆盖等错误，因而在这种情况下我们会考虑使用分布类（说实话分布方法，我自己也没怎么用过，记得在以前做C++时用过类似external关键字引用外部方法的情形，形式上有点像）。这是需要注意的是，工具生成类和扩展类（一般来说类名相同，但文件名加上Ext并放入对应层次文件夹中）的设计，需要仔细考虑默认构造方法、属性值设置器、事件处理器等类成员的构建。

将数组参数限制为参数数组

由于数组的不确定性，因而不推荐将数组作为参数(指的是不同类型的数据放入一个object[]中，使得方法的使用非常容易出错，当然泛型的数据集合等除外)，而推荐params的形式来传递相应数据，这样API参数在不存在或者提供null值时也不会报错。

Private static void Write(params object[] params)

{ foreach(object o in params) Console.WriteLine(o); }

避免在构造器中调用虚方法

这其实是个很有用的建议，尤其是在构建集成关系复杂的基类及其派生类时，由于子类、父类构造方法调用顺序原因，很容造成初始化和赋值的错误，用一个简单的例子来说明这个问题，借用书中的一句原话，"一个对象在其所有构造器执行完成前并没有完整的被构建"

class A {

protected A() { MethodA(); }

protected virtual void MethodA(){ Console.WriteLine("MethodA in A"); }

}

class B : A{

private readonly string msg = "set by initializer";

public B(string msg){ this.msg = msg; }

protected override void MethodA(){ Console.WriteLine(msg); }

}

class Program{ static void Main(string[] args){ B b = new B("Constructed in main"); } }

这儿的结果是"set by initializer"，首先调用B的构造方法，由于msg是readonly赋值木有成功，然后调用父类无参构造方法，实际调用子类MethodA有以上结果。这部分在实际中我也曾犯过相似的错误，需要非常小心。

对大对象考虑使用弱引用

弱引用的概念接触的相对较少，实际就是将直接引用转化为间接引用

Var weakR = new WeakReference(largeObj);

largeObj = null;

咋一看，感觉确实不太好明白，这儿的意图是首先将大对象的引用(指针)放入一个包装类型，成为弱引用，之后将直接引用对象释放，这样就形成弱引用，利于垃圾回收，其使用场景主要针对没有提供IDispose接口的大对象。说实话，在实际中，我也没有这样使用过，之后尝试后再给大家分享。

推荐对易变量和不可序列化的数据使用隐式属性

简单来说，就是在非Serializable对象中推荐使用priavte set，可以保护数据安全并便于提供验证等方法。当然在支持序列化时，public的set方法和默认无参的构造函数都是必须的