从这个问题中学到以下内容后，我想到了这一点：

where T : struct

我们C＃开发人员都知道C＃的基础知识。我的意思是声明，条件，循环，运算符等。

我们中有些人甚至掌握了泛型，匿名类型，lambdas，LINQ等...

但是，即使C＃爱好者，成瘾者，专家也几乎不知道C＃最隐藏的功能或技巧是什么？

到目前为止，这里是一些揭示的功能：

关键词

• yield通过迈克尔·斯托姆
• var通过迈克尔·斯托姆
• using()科科斯的声明
• readonly由kokos
• as由Mike Stone
• as/ 埃德·斯旺格is（Ed Swangren）
• as/ is（由Rocketpants改进）
• default通过鼠的死亡
• global::通过pzycoman
• using()由块AlexCuse
• volatile由的JakubŠturc
• extern alias由的JakubŠturc

属性

• DefaultValueAttribute通过迈克尔·斯托姆
• ObsoleteAttribute由DannySmurf
• DebuggerDisplayAttribute由Stu
• DebuggerBrowsable并DebuggerStepThrough通过bdukes
• ThreadStaticAttribute通过marxidad
• FlagsAttribute马丁·克拉克（Martin Clarke）
• ConditionalAttribute由AndrewBurns

句法

• ??（coalesce null）运算符by kokos
• Nick Berardi的举报
• where T:new由LarsMæhlum
• Keith的隐式泛型
• Keith的一参数lambda
• Keith的汽车属性
• Keith的命名空间别名
• 逐字字符串文字，带@ by Patrick
• enum通过数值lfoust
• @variablenames由marxidad
• event运算符by marxidad
• 通过波特曼格式化字符串括号
• xanadont的属性访问器可访问性修改器
• JasonS的条件（三元）运算符（?:）
• checked和unchecked运营商Binoj Antony
• implicit and explicit运营商Flory

语言功能

• 布拉德·巴克的可空类型
• Keith的匿名类型
• __makeref __reftype __refvalue通过Judah Himango
• lomaxx的对象初始化程序
• David在Dakota中格式化字符串
• marxidad的扩展方法
• partial乔恩·埃里克森（Jon Erickson）的方法
• John Asbeck的预处理程序指令
• DEBUGRobert Durgin的预处理程序指令
• SefBkn的运算符重载
• 通过chakrit键入推断
• 布尔运算符带到一个新的水平由罗布·高夫
• 将值类型变量作为接口传递，无需Roman Boiko进行装箱
• 以编程方式确定Roman Boiko声明的变量类型
• 克里斯的静态构造函数
• 借助公鸡油酸使用LINQ，更容易在眼睛上/浓缩ORM映射
• __arglist由扎克保龄球

Visual Studio功能

• 通过Himadri在编辑器中选择文本块
• 通过片段DannySmurf

构架

• TransactionScope通过KiwiBastard
• DependantTransaction通过KiwiBastard
• Nullable<T>由IainMH
• Mutex通过Diago
• System.IO.Path通过ageektrapped
• WeakReference通过Juan Manuel

方法和性质

• String.IsNullOrEmpty()KiwiBastard的方法
• List.ForEach()KiwiBastard的方法
• BeginInvoke()，Will Dean的EndInvoke()方法
• Nullable<T>.HasValue和Nullable<T>.Value物业的Rismo
• GetValueOrDefaultJohn Sheehan的方法

提示与技巧

• Andreas HR Nilsson为事件处理程序提供了一种不错的方法
• John的大写比较
• 访问匿名类型而无需dp的反映
• Will延迟实例化集合属性的快速方法
• roosteronacid的类似于JavaScript的匿名内联函数

其他

• netmodules由kokos
• LINQBridge，邓肯·斯马特（Duncan Smart）
• 并行扩展由乔尔Coehoorn

这本身不是C＃，但我还没有看到任何真正真正使用过的人System.IO.Path.Combine()。实际上，整个Path类确实很有用，但是没有人使用它！

我愿意打赌，每个生产应用程序都具有以下代码，即使它不应该具有以下代码：

string path = dir + "\\" + fileName;

lambda和类型推断被低估了。Lambda可以具有多个语句，并且它们可以自动兼用作兼容的委托对象（只需确保签名匹配），如下所示：

Console.CancelKeyPress +=
    (sender, e) => {
        Console.WriteLine("CTRL+C detected!\n");
        e.Cancel = true;
    };

请注意，我没有new CancellationEventHandler或也不必指定sender和的类型e，它们可以从事件中推断出来。这就是为什么这样写起来就不那么麻烦，delegate (blah blah)它也要求您指定参数的类型。

Lambda不需要返回任何内容，并且在这种情况下类型推断非常强大。

顺便说一句，您始终可以返回从函数编程意义上构成Lambda的Lambda。例如，以下是一个lambda，它使lambda可以处理Button.Click事件：

Func<int, int, EventHandler> makeHandler =
    (dx, dy) => (sender, e) => {
        var btn = (Button) sender;
        btn.Top += dy;
        btn.Left += dx;
    };

btnUp.Click += makeHandler(0, -1);
btnDown.Click += makeHandler(0, 1);
btnLeft.Click += makeHandler(-1, 0);
btnRight.Click += makeHandler(1, 0);

注意链接： (dx, dy) => (sender, e) =>

这就是为什么我很高兴参加函数式编程课程的原因:-)

除了C中的指针，我认为这是您还应该学习的另一项基本知识:-)

从里克·斯特拉尔（Rick Strahl）：

您可以链接?? 运算符，以便您可以进行一系列空比较。

string result = value1 ?? value2 ?? value3 ?? String.Empty;

别名泛型：

using ASimpleName = Dictionary<string, Dictionary<string, List<string>>>;

它允许您使用ASimpleName而不是Dictionary<string, Dictionary<string, List<string>>>。

当您将在许多地方使用相同的通用大型长复杂事物时，请使用它。

从CLR通过C＃：

规范化字符串时，强烈建议您使用ToUpperInvariant而不是ToLowerInvariant，因为Microsoft已经优化了用于执行大写比较的代码。

我记得有一次我的同事在比较之前总是将字符串更改为大写。我一直想知道他为什么这样做，因为我觉得先转换为小写字母更“自然”。看完这本书后，我知道为什么了。

我最喜欢的技巧是使用null合并运算符和括号自动为我实例化集合。

private IList<Foo> _foo;

public IList<Foo> ListOfFoo 
    { get { return _foo ?? (_foo = new List<Foo>()); } }

避免检查空事件处理程序

在声明时向事件添加一个空的委托，从而消除了在调用它之前必须始终检查该事件是否为null的需要。例：

public delegate void MyClickHandler(object sender, string myValue);
public event MyClickHandler Click = delegate {}; // add empty delegate!

让你做

public void DoSomething()
{
    Click(this, "foo");
}

代替这个

public void DoSomething()
{
    // Unnecessary!
    MyClickHandler click = Click;
    if (click != null) // Unnecessary! 
    {
        click(this, "foo");
    }
}

另请参阅此相关讨论以及Eric Lippert的有关此主题的博客文章（以及可能的弊端）。

其他一切，再加上

1）隐式泛型（为什么只对方法而不对类？）

void GenericMethod<T>( T input ) { ... }

//Infer type, so
GenericMethod<int>(23); //You don't need the <>.
GenericMethod(23);      //Is enough.

2）具有一个参数的简单lambda：

x => x.ToString() //simplify so many calls

3）匿名类型和初始化程序：

//Duck-typed: works with any .Add method.
var colours = new Dictionary<string, string> {
    { "red", "#ff0000" },
    { "green", "#00ff00" },
    { "blue", "#0000ff" }
};

int[] arrayOfInt = { 1, 2, 3, 4, 5 };

另一个：

4）自动属性可以具有不同的范围：

public int MyId { get; private set; }

感谢@pzycoman提醒我：

5）命名空间别名（并非您可能需要此特殊区别）：

using web = System.Web.UI.WebControls;
using win = System.Windows.Forms;

web::Control aWebControl = new web::Control();
win::Control aFormControl = new win::Control();

我很长一段时间都不知道“ as”关键字了。

MyClass myObject = (MyClass) obj;

与

MyClass myObject = obj as MyClass;

如果obj不是MyClass，则第二个将返回null，而不是引发类强制转换异常。

我喜欢的两件事是自动属性，因此您可以进一步折叠代码：

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()}

通用类型中的“默认”关键字：

T t = default(T);

如果T是引用类型，则结果为“ null”；如果它是int，则结果为0；如果它是布尔值，则结果为false，等等。

一般的属性，但最重要的是DebuggerDisplay。节省您数年。

@告诉编译器忽略字符串中的任何转义字符。

只是想澄清这一点...它并没有告诉它忽略转义字符，它实际上是告诉编译器将字符串解释为文字。

如果你有

string s = @"cat
             dog
             fish"

它实际上将打印为（请注意，它甚至包括用于缩进的空格）：

cat
             dog
             fish

我认为C＃（.NET 3.5）最不被人赏识和鲜为人知的功能之一就是表达式树，尤其是当与泛型和Lambda结合使用时。这是一种创建API的方法，较新的库（如NInject和Moq）正在使用。

例如，假设我要向API注册方法，并且该API需要获取方法名称

给定本课：

public class MyClass
{
     public void SomeMethod() { /* Do Something */ }
}

以前，很常见的是，开发人员使用字符串和类型（或其他主要基于字符串的形式）执行此操作：

RegisterMethod(typeof(MyClass), "SomeMethod");

好吧，这是因为缺乏强类型性而令人讨厌。如果我重命名“ SomeMethod”怎么办？现在，在3.5版中，我可以采用强类型的方式进行此操作：

RegisterMethod<MyClass>(cl => cl.SomeMethod());

其中RegisterMethod类的用法Expression<Action<T>>如下：

void RegisterMethod<T>(Expression<Action<T>> action) where T : class
{
    var expression = (action.Body as MethodCallExpression);

    if (expression != null)
    {
        // TODO: Register method
        Console.WriteLine(expression.Method.Name);
    }
}

这是我现在爱上Lambda和Expression Trees的重要原因之一。

我想到了“ 屈服 ”。一些属性，例如[DefaultValue（）]也是我的最爱。

关键字“ var ”稍微有点知名，但是您似乎也可以在.NET 2.0应用程序中使用它（只要您使用.NET 3.5编译器并将其设置为输出2.0代码即可）好。

编辑：kokos，感谢您指出？运算符，确实非常有用。由于要对其进行搜索有点困难（因为??只是被忽略了），因此以下是该操作员的MSDN文档页面：?? 运算符（C＃参考）

我倾向于发现大多数C＃开发人员都不了解“可空”类型。基本上，可以具有空值的图元。

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

将可为null的双精度数num1设置为null，然后将常规双精度num2设置为num1或-100（如果num1为null）。

http://msdn.microsoft.com/zh-CN/library/1t3y8s4s(VS.80).aspx

关于Nullable类型的另一件事：

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

它是返回String.Empty。检查此链接以获取更多详细信息

以下是一些有趣的隐藏C＃功能，以未记录的C＃关键字的形式出现：

__makeref

__reftype

__refvalue

__arglist

这些是未记录的C＃关键字（甚至Visual Studio都可以识别它们！），为在泛型之前更有效地装箱/取消装箱而添加了这些关键字。它们与System.TypedReference结构协同工作。

还有__arglist，用于可变长度参数列表。

人们不太了解的一件事是System.WeakReference-一个非常有用的类，它可以跟踪对象，但仍允许垃圾收集器对其进行收集。

最有用的“隐藏”功能是yield return关键字。它并不是真正的隐藏，但是很多人对此并不了解。LINQ基于此构建。它通过在后台生成状态机来允许延迟执行的查询。雷蒙德·陈（Raymond Chen）最近发布了有关内部细节的详细信息。

纯净，安全的C＃中的并集（C ++共享内存类型）

在不求助于不安全模式和指针的情况下，您可以让类成员共享类/结构中的内存空间。给定以下类别：

[StructLayout(LayoutKind.Explicit)]
public class A
{
    [FieldOffset(0)]
    public byte One;

    [FieldOffset(1)]
    public byte Two;

    [FieldOffset(2)]
    public byte Three;

    [FieldOffset(3)]
    public byte Four;

    [FieldOffset(0)]
    public int Int32;
}

您可以通过操作Int32字段来修改字节字段的值，反之亦然。例如，该程序：

    static void Main(string[] args)
    {
        A a = new A { Int32 = int.MaxValue };

        Console.WriteLine(a.Int32);
        Console.WriteLine("{0:X} {1:X} {2:X} {3:X}", a.One, a.Two, a.Three, a.Four);

        a.Four = 0;
        a.Three = 0;
        Console.WriteLine(a.Int32);
    }

输出此：

2147483647
FF FF FF 7F
65535

只需使用System.Runtime.InteropServices添加；

将@用作关键字的变量名。

var @object = new object();
var @string = "";
var @if = IpsoFacto(); 

如果要退出程序而不调用任何finally块或终结器，请使用FailFast：

Environment.FailFast()

从方法返回匿名类型并访问成员而无需进行反思。

// 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;
}

这是一个用于正则表达式和文件路径的有用的代码：

"c:\\program files\\oldway"
@"c:\program file\newway"

@告诉编译器忽略字符串中的任何转义字符。

Mixins。基本上，如果要向多个类添加功能，但不能对所有这些类都使用一个基类，请获取每个类以实现一个接口（无成员）。然后，为接口编写扩展方法，即

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

当然，牺牲了一些清晰度。但这有效！

虽然不确定为什么有人会使用Nullable <bool>。:-)

是，否，FileNotFound？

这个名称没有被“隐藏”，而是被错误地命名。

人们对算法“ map”，“ reduce”和“ filter”给予了极大的关注。大多数人没有意识到的是.NET 3.5添加了所有这三种算法，但是基于它们属于LINQ的事实，它给了它们非常类似于SQL的名称。

“ map” =>选择
将数据从一种形式转换为另一种形式

“ reduce” =>汇总
将值汇总为单个结果

“ filter” =>其中
根据条件过滤数据

使用LINQ对用于进行迭代和条件处理的集合进行内联工作的能力非常有价值。值得学习所有LINQ扩展方法如何帮助使您的代码更加紧凑和可维护。

Environment.NewLine

用于系统独立的换行符。

如果您尝试在String.Format表达式中使用大括号...

int foo = 3;
string bar = "blind mice";
String.Format("{{I am in brackets!}} {0} {1}", foo, bar);
//Outputs "{I am in brackets!} 3 blind mice"

1. ?? -合并运算符
2. using（语句 / 指令）-很棒的关键字，它不仅可以用于调用Dispose，还可以用于其他用途
3. 只读 -应该更多使用
4. netmodules-太糟糕了，Visual Studio不支持

@Ed，我对发布此消息比较谨慎，因为它只不过是挑剔。但是，我要指出的是在您的代码示例中：

MyClass c;
  if (obj is MyClass)
    c = obj as MyClass

如果要使用“ is”，为什么还要使用“ as”进行安全转换？如果您确定obj确实是MyClass，则为沼泽标准强制转换：

c = (MyClass)obj

...永远不会失败。

同样，您可以说：

MyClass c = obj as MyClass;
if(c != null)
{
   ...
}

我不太了解.NET的内部知识，但是我的直觉告诉我，这会将最多两种类型的强制转换操作减少到最多一种。几乎不可能以任何一种方式破坏处理银行。就个人而言，我认为后一种形式看起来也更干净。

也许这不是一种先进的技术，但我一直看到的一种使我发疯的方法：

if (x == 1)
{
   x = 2;
}
else
{
   x = 3;
}

可以浓缩为：

x = (x==1) ? 2 : 3;