通用约束：

 //Constructor constraint, T has a default empty constructor
class Node<K,T> where T : new() 
{
}

//Reference\Value Type constraints
//T is a struct
public class MyClass<T> where T : struct 

{...}

//T is a reference type
public class MyClass<T> where T : class 

{...}

public class MyClass<T> where T : SomeBaseClass, ISomeInterface 

{...}

Dictionary.TryGetValue（K键，out V值）

用作支票和支票。而不是

if(dictionary.ContainsKey(key)) 
{
    value = dictionary[key];
    ...
}

你可以这样做；

if(dictionary.TryGetValue(key, out value)) 
{ ... }

并且该值已被设置。

您可以在C#名称中使用任何Unicode字符，例如：

public class MyClass
{
    public string Hårføner()
    {
        return "Yes, it works!";
    }
}

您甚至可以使用Unicode转义。这一点相当于上述内容：

public class MyClass
{
    public string H\u00e5rføner()
    {
        return "Yes, it (still) works!";
    }
}

我喜欢

#if DEBUG
           //Code run in debugging mode

#else
           //Code run in release mode

#endif

工厂方法的类型推断

我不知道这是否已经发布（我扫描了第一篇帖子，找不到）。

这最好用一个例子来说明，假设你有这个类（模拟一个元组），在中，为了演示使这成为可能的所有语言特性，我将一步一步地学习。

public class Tuple<V1, V2> : Tuple
{
    public readonly V1 v1;
    public readonly V2 v2;

    public Tuple(V1 v1, V2 v2)
    {
      this.v1 = v1;
      this.v2 = v2;
    }
}

每个人都知道如何创建它的实例，例如：

Tuple<int, string> tup = new Tuple<int, string>(1, "Hello, World!");

不完全是火箭科学，现在我们当然可以将变量的类型声明更改为var，如下所示：

var tup = new Tuple<int, string>(1, "Hello, World!");

众所周知，这里有一个带类型参数的静态方法，每个人都应该熟悉：

public static void Create<T1, T2>()
{
    // stuff
}

这也是众所周知的，是这样做的：

Create<float, double>();

大多数人不知道的是，如果泛型方法的参数包含它所需的所有类型，则可以推断它们，例如：

public static void Create<T1, T2>(T1 a, T2 b)
{
    // stuff
}

这两个调用是相同的：

Create<float, string>(1.0f, "test");
Create(1.0f, "test");

因为T1和T2是从传递的参数推断出来的。将这些知识与var关键字相结合，我们可以通过添加第二个静态类和静态方法，例如：

public abstract class Tuple
{
    public static Tuple<V1, V2> Create<V1, V2>(V1 v1, V2 v2)
    {
        return new Tuple<V1, V2>(v1, v2);
    }
}

实现此效果：

var tup = Tuple.Create(1, "Hello, World!");

这意味着：变量“tup”的类型、类型参数“Create”和返回值“Create”都是从作为参数传递给Create的类型中推断出来的

完整代码如下所示：

public abstract class Tuple
{
    public static Tuple<V1, V2> Create<V1, V2>(V1 v1, V2 v2)
    {
        return new Tuple<V1, V2>(v1, v2);
    }
}

public class Tuple<V1, V2> : Tuple
{
    public readonly V1 v1;
    public readonly V2 v2;

    public Tuple(V1 v1, V2 v2)
    {
        this.v1 = v1;
        this.v2 = v2;
    }
}

// Example usage:
var tup = Tuple.Create(1, "test");

这为您提供了随处可见的完全类型推断工厂方法！

混合物。基本上，如果您想向多个类添加一个特性，但不能对所有类使用一个基类，请让每个类实现一个接口（没有成员）。然后，为接口编写一个扩展方法，即。

public static DeepCopy(this IPrototype p) { ... }

当然，牺牲了一些清晰度。但它奏效了！