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

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);

我倾向于发现大多数C#开发人员不知道“可空”类型。基本上，基元可以具有空值。

double? num1 = null; 
double num2 = num1 ?? -100;

将一个可为null的双精度值num1设置为null，然后将一个常规双精度值num 2设置为num1或-100（如果num1为null）。

http://msdn.microsoft.com/en-us/library/1t3y8s4s（VS.80）.aspx

关于Nullable类型还有一点：

DateTime? tmp = new DateTime();
tmp = null;
return tmp.ToString();

它是返回String.Empty。有关详细信息，请查看此链接

类似JavaScript的匿名内联函数

返回字符串：

var s = new Func<String>(() =>
{
    return "Hello World!";
})();

返回更复杂的对象：

var d = new Func<Dictionary<Int32, String>>(() =>
{
    return new Dictionary<Int32, String>
    {
        { 0, "Foo" },
        { 1, "Bar" },
        { 2, "..." }
    };
})();

真实世界用例：

var tr = new TableRow();

tr.Cells.AddRange
(
    new[]
    {
        new TableCell { Text = "" },
        new TableCell { Text = "" },
        new TableCell { Text = "" },

        new TableCell
        {
            Text = new Func<String>(() =>
            {
                return @"Result of a chunk of logic, without having to define
                         the logic outside of the TableCell constructor";
            })()
        },

        new TableCell { Text = "" },
        new TableCell { Text = "" }
    }
);

注意：不能在内联函数的范围内重用变量名。

替代语法

// The one-liner
Func<Int32, Int32, String> Add = (a, b) => Convert.ToString(a + b);

// Multiple lines
Func<Int32, Int32, String> Add = (a, b) =>
{
    var i = a + b;

    return i.ToString();
};

// Without parameters
Func<String> Foo = () => "";

// Without parameters, multiple lines
Func<String> Foo = () =>
{
    return "";
};

缩短字符串并添加水平省略号。。。

Func<String, String> Shorten = s => s.Length > 100 ? s.Substring(0, 100) + "&hellip;" : s;

直到最近，我才开始真正欣赏“使用”块。它们使事物变得更加整洁：）

工厂方法的类型推断

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

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

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");

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

类型定义

有人发帖说他们错过了typedef，但你可以这样做

using ListOfDictionary = System.Collections.Generic.List<System.Collections.Generic.Dictionary<string, string>>;

并声明为

ListOfDictionary list = new ListOfDictionary();