基于这个线程的标题应该是“你直到最近才知道的关于C#的事情，尽管你认为你已经知道了一切”，我的个人特色是异步委托。

直到我读了Jeff Richter的C#/CLR书（这本书很棒，每个做.NET的人都应该读），我才知道你可以使用BeginInvoke/EndInvoke调用任何委托。我倾向于做很多ThreadPool.QueueUserWorkItem调用（我想这很像委托BeginInvoke在内部所做的），但添加标准化的加入/会合模式有时可能真的很有用。

我喜欢的两件事是自动财产，这样您可以进一步折叠代码：

private string _name;
public string Name
{
    get
    {
        return _name;
    }
    set
    {
        _name = value;
    }
}

变成

public string Name { get; set;}

还有对象初始化器：

Employee emp = new Employee();
emp.Name = "John Smith";
emp.StartDate = DateTime.Now();

变成

Employee emp = new Employee {Name="John Smith", StartDate=DateTime.Now()}

在泛型代码中使用默认关键字返回类型的默认值。

public class GenericList<T>
{
    private class Node
    {
        //...

        public Node Next;
        public T Data;
    }

    private Node head;

    //...

    public T GetNext()
    {
        T temp = default(T);

        Node current = head;
        if (current != null)
        {
            temp = current.Data;
            current = current.Next;
        }
        return temp;
    }
}

这里的另一个例子

无特定顺序：

Lists<>
Mutex

Framework 3.5中的新属性定义快捷方式。

从方法返回匿名类型并访问成员而不进行反射。

// Useful? probably not.
private void foo()
{
    var user = AnonCast(GetUserTuple(), new { Name = default(string), Badges = default(int) });
    Console.WriteLine("Name: {0} Badges: {1}", user.Name, user.Badges);
}

object GetUserTuple()
{
    return new { Name = "dp", Badges = 5 };
}    

// Using the magic of Type Inference...
static T AnonCast<T>(object obj, T t)
{
   return (T) obj;
}

我很确定每个人都熟悉运算符重载，但可能有些人不熟悉。

class myClass
{
    private string myClassValue = "";

    public myClass(string myString)
    {
        myClassValue = myString;
    }

    public override string ToString()
    {
        return myClassValue;
    }

    public static myClass operator <<(myClass mc, int shiftLen)
    {
        string newString = "";
        for (int i = shiftLen; i < mc.myClassValue.Length; i++)
            newString += mc.myClassValue[i].ToString();
        mc.myClassValue = newString.ToString();
        return mc;
    }

    public static myClass operator >>(myClass mc, int shiftLen)
    {
        char[] newString = new char[shiftLen + mc.myClassValue.Length];

        for (int i = shiftLen; i < mc.myClassValue.Length; i++)
            newString[i] += mc.myClassValue[i - shiftLen];

        mc.myClassValue = new string(newString);
        return mc;
    }

    public static myClass operator +(myClass mc, string args)
    {
        if (args.Trim().Length > 1)
            mc.myClassValue += args;
        return mc;
    }

    public static myClass operator -(myClass mc, string args)
    {
        if (args.Trim().Length > 1)
        {
            Regex rgx = new Regex(args);
            mc.myClassValue = rgx.Replace(mc.myClassValue, "");
        }
        return mc;
    }
}

我认为能够使用<<and>>左右移动字符串或使用-=

myClass tmpClass = new myClass("  HelloWorld123");
tmpClass -= @"World";
tmpClass <<= 2;
Console.WriteLine(tmpClass);