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

“var”关键字更为人所知，但您也可以在.NET 2.0应用程序中使用它（只要您使用.NET 3.5编译器并将其设置为输出2.0代码），这似乎并不广为人知。

编辑：科科斯，谢谢你指出了？？运算符，这确实很有用。由于搜索它有点困难（因为？？只是被忽略了），下面是该操作员的MSDN文档页面：？？操作员（C#参考）

?? - 合并运算符using（statement/directive）-伟大的关键字，可用于不仅仅调用Dispose只读-应更多使用netmodules-太糟糕了，Visual Studio中不支持

我个人最喜欢的两个，我很少使用：

代码段（尤其是针对财产的代码段，这在Visual Studio 2008中做得更好）过时属性

老实说，根据定义，专家们应该知道这件事。但要回答您的问题：内置类型表（C#参考）

编译器标记数字是众所周知的：

Decimal = M
Float = F
Double = D

// for example
double d = 30D;

然而，这些更为晦涩：

Long = L
Unsigned Long = UL
Unsigned Int = U

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

MyClass myObject = (MyClass) obj;

vs

MyClass myObject = obj as MyClass;

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

System.Transactions中的TransactionScope和DependentTransaction是在.NET中使用事务处理的一种轻量级方法-它也不仅仅适用于数据库事务String.IsNullOrEmpty是一个我很惊讶地了解到很多开发人员不知道的东西List.ForEach-使用委托方法遍历泛型列表

还有更多，但这是我头脑中最明显的三个。。。

属性，但大多数是DebuggerDisplay。为您节省多年。

我倾向于发现大多数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。有关详细信息，请查看此链接

我经常遇到需要将泛型参数对象持久化为基类中的视图状态。

public abstract class BaseListControl<ListType,KeyType,ParameterType>
                 : UserControl 
                 where ListType : BaseListType
                 && ParameterType : BaseParameterType, new
{

    private const string viewStateFilterKey = "FilterKey";

    protected ParameterType Filters
    {
        get
        {
            if (ViewState[viewStateFilterKey] == null)
                ViewState[viewStateFilterKey]= new ParameterType();

            return ViewState[viewStateFilterKey] as ParameterType;
        }
        set
        {
            ViewState[viewStateFilterKey] = value;
        }
    }

}

用法：

private void SomeEventHappened(object sender, EventArgs e)
{
    Filters.SomeValue = SomeControl.SelectedValue;
}

private void TimeToFetchSomeData()
{
    GridView.DataSource = Repository.GetList(Filters);
}

“where ParameterType:BaseParameterType，new”的这个小技巧使它真正起作用。

在我的基类中有了这个属性，我可以自动处理分页，设置过滤器值以过滤网格视图，使排序变得非常容易，等等。

我真的只是想说，在错误的手中，仿制药可能是一种非常强大的野兽。

@艾德，我有点不愿意发表这篇文章，因为这只是吹毛求疵。但是，我要指出，在您的代码示例中：

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的内部结构了解不多，但我的直觉告诉我，这会将最多两个类型转换操作减少到最多一个。无论哪种方式都不太可能打破处理银行；我个人认为，后一种形式看起来也更干净。

其他一切，加上

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

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

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

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

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

下面是正则表达式和文件路径的有用示例：

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

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

@布拉德·巴克

我认为如果必须使用可空类型，最好使用可空<.T>，而不是问号表示法。这让人非常明显地看到魔法正在发生。但不确定为什么有人会想要使用Nullable＜.bool＞。：-）

Krzysztof Cwalina（Framwork Design Guidelines的作者之一）在这里有一篇很好的文章：http://blogs.msdn.com/kcwalina/archive/2008/07/16/Nullable.aspx

Mike Hadlow在“无效巫毒”上发表了一篇很好的帖子

以下是一些有趣的隐藏C#特性，以未记录的C#关键字的形式出现：

__makeref

__reftype

__refvalue

__arglist

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

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

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

最有用的“隐藏”特性是yield return关键字。它并没有真正隐藏，但很多人都不知道它；它允许通过在后台生成状态机来延迟执行查询。Raymond Chen最近发布了关于内部细节的帖子。

但不确定为什么有人会想要使用Nullable＜bool＞。：-）

真、假、文件未找到？

无特定顺序：

Lists<>
Mutex

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

避免检查空事件处理程序

在声明时向事件添加一个空委托，在调用事件之前不必总是检查事件是否为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）关于此主题的相关讨论和博客文章（以及可能的缺点）。

这本身不是C#，但我还没有见过真正使用System.IO.Path.Combine（）的人。事实上，整个Path类非常有用，但没有人使用它！

我敢打赌，每个生产应用程序都有以下代码，尽管它不应该：

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

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

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

如果你有

string s = @"cat
             dog
             fish"

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

cat
             dog
             fish

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

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

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

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

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

T t = default(T);

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

表达式

Func<int, int, int> add = (a, b) => (a + b);

模糊字符串格式

Console.WriteLine("{0:D10}", 2); // 0000000002

Dictionary<string, string> dict = new Dictionary<string, string> { 
    {"David", "C#"}, 
    {"Johann", "Perl"}, 
    {"Morgan", "Python"}
};

Console.WriteLine( "{0,10} {1, 10}", "Programmer", "Language" );

Console.WriteLine( "-".PadRight( 21, '-' ) );

foreach (string key in dict.Keys)
{
    Console.WriteLine( "{0, 10} {1, 10}", key, dict[key] );             
}

我喜欢这样一个事实：我可以在普通的旧.NET 2.0上使用LINQ对象（即不需要到处安装.NET 3.5）。您只需要实现所有查询运算符Extension方法-请参阅LINQBridge

除了duncansmart的回复，还可以在Framework 2.0上使用扩展方法。只需在System.Runtime.CompilerServices命名空间下添加一个ExtensionAttribute类，就可以使用扩展方法（当然，仅适用于C#3.0）。

namespace System.Runtime.CompilerServices
{
    public class ExtensionAttribute : Attribute
    { 
    }
}

能够使枚举类型具有int以外的值（默认值）

public enum MyEnum : long
{
    Val1 = 1,
    Val2 = 2
}

此外，您可以为该枚举分配任何数值：

MyEnum e = (MyEnum)123;

通过C#从CLR：标准化字符串时建议您使用ToUpperInvariant而不是ToLowerInvariant，因为Microsoft具有优化代码以执行大写比较。

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

我最喜欢的是

global::

关键字来逃避我们的一些第三方代码提供商的命名空间地狱。。。

例子：

global::System.Collections.Generic.List<global::System.String> myList =
    new global::System.Collections.Generic.List<global::System.String>();

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

这一条并不是“隐藏”的，而是被误称的。

大量的注意力集中在算法“map”、“reduce”和“filter”上。大多数人没有意识到的是，.NET3.5添加了这三种算法，但基于它们是LINQ的一部分这一事实，它给它们起了非常SQL的名字。

“map”=>选择变换数据从一种形式到另一种形式“reduce”=>骨料值转换为单个结果“filter”=>其中过滤数据基于一个标准

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

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

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

还有ThreadStaticAttribute可以使每个线程的静态字段唯一，因此您可以拥有强类型的线程本地存储。

即使扩展方法不是那么秘密（LINQ是基于它们的），对于实用程序助手方法来说，它们的有用性和可读性可能并不明显：

//for adding multiple elements to a collection that doesn't have AddRange
//e.g., collection.Add(item1, item2, itemN);
static void Add<T>(this ICollection<T> coll, params T[] items)
 { foreach (var item in items) coll.Add(item);
 }

//like string.Format() but with custom string representation of arguments
//e.g., "{0} {1} {2}".Format<Custom>(c=>c.Name,"string",new object(),new Custom())
//      result: "string {System.Object} Custom1Name"
static string Format<T>(this string format, Func<T,object> select, params object[] args)
 { for(int i=0; i < args.Length; ++i)
    { var x = args[i] as T;
      if (x != null) args[i] = select(x);
    }
   return string.Format(format, args);
 }

我想如果你必须使用nullable类型，最好使用Nullable＜.T＞而不是问号符号这让它令人心疼很明显，魔法正在发生。不确定为什么有人会想使用但可为null<.bool>。

在VB.NET Web服务中，参数可能无法传递（因为合作伙伴请求不一致或不可靠），但必须通过针对建议类型的验证（布尔值表示“if is search request”）。把它归结为“管理层的另一个需求”。。。

…是的，我知道有些人认为这不是做这些事情的正确方法，但IsSearchRequest As Nullable（Of Boolean）让我当晚失去了理智！

对关键字变量名使用@。

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

事件实际上是幕后委托，任何委托对象都可以附加多个函数，并分别使用+=和-=运算符从中提取。

事件也可以使用add/remove进行控制，类似于get/set，但在使用+=和-=时调用它们：

public event EventHandler SelectiveEvent(object sender, EventArgs args) 
  { add 
     { if (value.Target == null) throw new Exception("No static handlers!");
       _SelectiveEvent += value;
     }
    remove
     { _SelectiveEvent -= value;
     }
  } EventHandler _SelectiveEvent;

它实际上并不是一个C#隐藏的特性，但我最近发现了WeakReference类，并被它吓了一跳（尽管这可能有点偏颇，因为它帮助我找到了解决我的一个特定问题的方法…）

我必须承认，我不确定这是否比正常的ASP.NET转发器onItemDatabound转换代码更好或更差，但无论如何，这是我的5美分。

MyObject obj = e.Item.DataItem as MyObject;
if(obj != null)
{
  //Do work
}

如果您试图在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"

几乎所有酷的都被提到了。不确定这个是否广为人知

C#属性/字段构造函数初始化：

var foo = new Rectangle() 
{ 
    Fill = new SolidColorBrush(c), 
    Width = 20, 
    Height = 20 
};

这将创建矩形，并设置列出的财产。

我注意到了一些有趣的东西——你可以在财产列表的末尾使用逗号，而不会出现语法错误。因此，这也是有效的：

var foo = new Rectangle() 
{ 
    Fill = new SolidColorBrush(c), 
    Width = 20, 
    Height = 20,
};

没有隐藏，但我认为许多开发人员没有在可空类型上使用HasValue和Value财产。

        int? x = null;
        int y;
        if (x.HasValue)
            y = x.Value;

@lomaxx我前几天还了解到（在我了解您的提示的同时），您现在可以在同一个属性上拥有不同的访问级别：

public string Name { get; private set;}

这样，只有类本身才能设置Name属性。

public MyClass(string name) { Name = name; }

来自Rick Strahl：

你可以把？？运算符，以便您可以进行一系列空比较。

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

分部方法

Charlie Calvert在他的博客上解释了部分方法

Scott Cate在这里有一个很好的分部方法演示

代码生成类（LINQ to SQL，EF）中的扩展点如果未实现，则不会编译到dll中（请使用.NETReflector检查）

也许这不是一种先进的技术，但我一直看到一种让我疯狂的技术：

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

可以浓缩成：

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

如果您希望在调试模式和发布模式之间有不同的行为，那么预处理器指令可以很好。

http://msdn.microsoft.com/en-us/library/ed8yd1ha.aspx

我看到很多人复制了Nullable<T>.GetValueOrDefault（T）的功能。

您键入“prop”，然后按两次[TAB]，它会为您的财产生成有用的代码，并可以加快键入速度。

我知道这在VS2005中有效（我使用它），但在以前的版本中我不知道。

枚举上的FlagsAttribute如何？它允许您执行逐位操作。。。我花了很长时间才发现如何在.NET中很好地执行位操作。

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

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#语言的不同部分是在不同的时间编写的，因此不一致。例如，框架本身违反了许多FxCop规则，因为在编写框架时，这些规则并没有全部到位。

此外，using语句旨在使“范围”分离，而不是专门用于处理资源。它是在lock语句之后编写的。埃里克·冈纳森（Eric Gunnerson）曾提到，如果使用语句首先出现，他们可能不需要编写锁语句（尽管谁知道，也许他们无论如何都会有），因为使用语句可能已经足够了。

@lainMH，

当从可为null的数据库中检索值以及将值放回数据库时，可为null布尔值非常有用。有时您想知道字段尚未设置。

阅读有关.NET框架开发的书籍。一个很好的建议是不要使用bool来打开或关闭内容，而是使用ENum。

使用ENums，您可以在不必重写任何代码的情况下为函数添加新功能的情况下，为自己提供一些可扩展性。

C#？？空合并运算符-

没有真正隐藏，但很少使用。可能是因为很多开发人员看到条件时跑了一英里？操作员，所以他们看到这一个时运行两个。已使用：

string mystring = foo ?? "foo was null"

而不是

string mystring;
if (foo==null)
    mystring = "foo was null";
else
    mystring = foo;

兰姆达斯和类型推断被低估了。Lambdas可以有多个语句，它们会自动作为兼容的委托对象（只需确保签名匹配），如下所示：

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

注意，我没有新的CancellationEventHandler，也不必指定发送者和e的类型，它们可以从事件中推断出来。这就是为什么编写整个委托（blah blah）不那么麻烦的原因，这也需要您指定参数类型。

Lambdas不需要返回任何内容，类型推理在这样的上下文中非常强大。

顺便说一下，您可以始终返回在函数式编程意义上生成Lambdas的Lambdas。例如，这里有一个lambda，它生成一个处理Button的lambda。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中的指针，我认为这是你应该学习的另一个基本内容：-）

脑海中浮现出反射发射和表达树。。。

不要错过Jeffrey Richter通过C#和Jon Skeet的CLR

请参阅此处获取一些资源：

http://www.codeproject.com/KB/trace/releasemodebreakpoint.aspx

http://www.codeproject.com/KB/dotnet/Creating_Dynamic_Types.aspx

http://www.codeproject.com/KB/cs/lambdaexpressions.aspx

#if DEBUG预处理器指令。它对测试和调试（尽管我通常更喜欢单元测试路线）。

string customerName = null;
#if DEBUG
  customerName = "Bob"
#endif

仅当Visual Studio设置为在“调试”模式下编译。否则，代码块将被编译器忽略（在Visual Studio中变灰）。

我参加这个聚会迟到了，所以我的第一选择已经被接受了。但我还没看到有人提到这个宝石：

.NET Framework的并行扩展

它有类似于用Parallel.For或foreach替换Parallel.foreach

平行样品：在您看来，一秒钟可以创建多少个CLR对象？参见休耕示例：

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

namespace ObjectInitSpeedTest
{
   class Program
   {
       //Note: don't forget to build it in Release mode.
       static void Main()
       {
           normalSpeedTest();           
           parallelSpeedTest();

           Console.ForegroundColor = ConsoleColor.White;
           Console.WriteLine("Press a key ...");
           Console.ReadKey();
       }

       private static void parallelSpeedTest()
       {
           Console.ForegroundColor = ConsoleColor.Yellow;
           Console.WriteLine("parallelSpeedTest");

           long totalObjectsCreated = 0;
           long totalElapsedTime = 0;

           var tasks = new List<Task>();
           var processorCount = Environment.ProcessorCount;

           Console.WriteLine("Running on {0} cores", processorCount);

           for (var t = 0; t < processorCount; t++)
           {
               tasks.Add(Task.Factory.StartNew(
               () =>
               {
                   const int reps = 1000000000;
                   var sp = Stopwatch.StartNew();
                   for (var j = 0; j < reps; ++j)
                   {
                       new object();
                   }
                   sp.Stop();

                   Interlocked.Add(ref totalObjectsCreated, reps);
                   Interlocked.Add(ref totalElapsedTime, sp.ElapsedMilliseconds);
               }
               ));
           }

           // let's complete all the tasks
           Task.WaitAll(tasks.ToArray());

           Console.WriteLine("Created {0:N} objects in 1 sec\n", (totalObjectsCreated / (totalElapsedTime / processorCount)) * 1000);
       }

       private static void normalSpeedTest()
       {
           Console.ForegroundColor = ConsoleColor.Green;
           Console.WriteLine("normalSpeedTest");

           const int reps = 1000000000;
           var sp = Stopwatch.StartNew();
           sp.Start();
           for (var j = 0; j < reps; ++j)
           {
               new object();
           }
           sp.Stop();

           Console.WriteLine("Created {0:N} objects in 1 sec\n", (reps / sp.ElapsedMilliseconds) * 1000);
       }
   }
}

真运算符和假运算符真的很奇怪。

这里可以找到更全面的示例。

编辑：有一个相关的SO问题，C#中的假运算符有什么用？

返回IQueryable预测

protected void LdsPostings_Selecting(object sender, LinqDataSourceSelectEventArgs e)
{   
    var dc = new MyDataContext();
    var query = dc.Posting.AsQueryable();

    if (isCondition1)
    {
        query = query.Where(q => q.PostedBy == Username);
        e.Result = QueryProjection(query);
        return;
    }

    ...

    if (isConditionN)
    {
        query = query.Where(q => q.Status.StatusName == "submitted");
        query = query.Where(q => q.ReviewedBy == Username);
        e.Result = QueryProjection(query);
        return;
    }
}

而不是多次编码投影，创建一种方法：

private IQueryable QueryProjection(IQueryable<Posting> query)
{
    return query.Select(p => new
    {
        p.PostingID,
        p.Category.CategoryName,
        p.Type.TypeName,
        p.Status.StatusName,
        p.Description,
        p.Updated,
        p.PostedBy,
        p.ReviewedBy,
    });
}

我喜欢在SQL查询中使用@字符。它使sql保持良好的格式，并且不必用字符串分隔符围绕每一行。

string sql = @"SELECT firstname, lastname, email
               FROM users
               WHERE username = @username AND password = @password";

考虑了@dp AnonCast，决定尝试一下。以下是我提出的可能对某些人有用的建议：

// using the concepts of dp's AnonCast
static Func<T> TypeCurry<T>(Func<object> f, T type)
{
    return () => (T)f();
}

下面是它的使用方法：

static void Main(string[] args)
{

    var getRandomObjectX = TypeCurry(GetRandomObject,
        new { Name = default(string), Badges = default(int) });

    do {

        var obj = getRandomObjectX();

        Console.WriteLine("Name : {0} Badges : {1}",
            obj.Name,
            obj.Badges);

    } while (Console.ReadKey().Key != ConsoleKey.Escape);

}

static Random r = new Random();
static object GetRandomObject()
{
    return new {
        Name = Guid.NewGuid().ToString().Substring(0, 4),
        Badges = r.Next(0, 100)
    };
}

我喜欢在列表中查找以下内容：-

bool basketContainsFruit(string fruit) {
  return new[] { "apple", "orange", "banana", "pear" }.Contains(fruit);
}

而不是：-

bool basketContainsFruit(string fruit) {
  return fruit == "apple" || fruit == "orange" || fruit == "banana" ||
    fruit == "pear";
}

在实践中并没有太多，但根据搜索主题匹配项目的想法确实非常有用和简洁。

来自System.Diagnostics命名空间的其他几个属性非常有用。

DebuggerBrowsable允许您在调试器窗口中隐藏变量（我们将其用于公开财产的所有私有支持变量）。除此之外，DebuggerStepThrough使调试器单步执行该代码，这对于哑财产非常有用（如果您可以依赖C#3.0编译器，则可能应该将其转换为自动属性）。举个例子

[DebuggerBrowsable(DebuggerBrowsableState.Never)]
private string nickName;
public string NickName    {
    [DebuggerStepThrough]
    get { return nickName; }
    [DebuggerStepThrough]
    set { this.nickName = value; }
}

条件属性

允许您告诉编译器在特定条件下（#define）省略对标记有属性的方法的调用。

方法调用被省略的事实也意味着它的参数不会被求值。这是非常方便的，它允许您在Debug.Assert（）中调用昂贵的验证函数，而不用担心它们会减慢您的发布版本。

Environment.NewLine

对于独立于系统的换行符。

使用语句嵌套

通常我们这样做：

StringBuilder sb = new StringBuilder();
using (StringWriter sw = new StringWriter()) {
    using (IndentedTextWriter itw = new IndentedTextWriter(sw)) {
        ... 
    }
}

但我们可以这样做：

StringBuilder sb = new StringBuilder();
using (StringWriter sw = new StringWriter())
using (IndentedTextWriter itw = new IndentedTextWriter(sw)) {
    ... 
}

外部别名关键字引用具有相同完全限定类型名称的两个版本的程序集。

PreviousPage属性：

“System.Web.UI.Page表示将控件传输到当前页面的页面。”

它非常有用。

验证用户输入时，每个基元类型的TryParse方法都很好。

double doubleValue
if (!Double.TryParse(myDataRow("myColumn"), out doubleValue))
{
    // set validation error
}

Foreach使用鸭子打字

翻译，或无耻地从Krzysztof Cwalinas的博客上窃取。比什么都有趣的琐事。

对于支持foreach的对象，不必实现IEnumerable。也就是说，这不是一个约束，编译器不会检查它。检查的是

对象提供了一个公共方法GetEnumerator不接受参数返回具有两个成员的类型返回布尔值的无参数方法MoveNext带有返回Object的getter的属性Current

例如

class Foo
{
    public Bar GetEnumerator() { return new Bar(); }

    public struct Bar
    {
        public bool MoveNext()
        {
            return false;
        }

        public object Current
        {
            get { return null; }
        }
    }
}

// the following complies just fine:
Foo f = new Foo();
foreach (object o in f)
{
    Console.WriteLine("Krzysztof Cwalina's da man!");
}

C#中有一些真正隐藏的关键字和特性与TypedReference未记录类相关。以下关键字未记录：

__制造商参考__重新键入__参考值__参数列表

使用示例：

// Create a typed reference
int i = 1;
TypedReference tr1 = __makeref(i);
// Get the type of a typed reference
Type t = __reftype(tr1);
// Get the value of a typed referece
int j = __refvalue(tr1, int); 
// Create a method that accepts and arbitrary number of typed references
void SomeMethod(__arglist) { ...
// Call the method
int x = 1;
string y = "Foo";
Object o = new Object();
SomeMethod(__arglist(x,y,o));
// And finally iterate over method parameters
void SomeMethod(__arglist) {
    ArgIterator ai = new ArgIterator(__arglist);
while(ai.GetRemainingCount() >0)
{
      TypedReference tr = ai.GetNextArg();
      Console.WriteLine(TypedReference.ToObject(tr));
}}

@罗比摇滚裤

但我的直觉告诉我最多可以切割两种类型的铸件最多可执行一次操作。"

如果按照示例1中的建议进行强制转换（使用is&as），将导致对“is”运算符的两次调用。因为当您执行“c=obj as MyClass”时，首先它在后台调用“is”，然后如果失败，它只返回null。

如果你按照你在示例2中建议的方式进行演员扮演，

c = (MyClass)obj

然后，它实际上再次执行“is”操作，如果检查失败，则抛出异常（InvalidCastException）。

因此，如果你想做一个轻量级的动态投射，最好做你提供的第三个例子：

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

if (c != null)
{
}

vs

MyClass c = obj as MyClass;

if (c != null)
{
}

你可以看到哪个更快、更稳定、更清晰。

@达科他州的大卫：

Console.WriteLine( "-".PadRight( 21, '-' ) );

我曾经这样做，直到我发现String类有一个构造函数，它允许你以更干净的方式做同样的事情：

new String('-',22);

InternalsVisibleTo属性是一个不太为人所知的属性，但在某些情况下，它会变得越来越有用。它基本上允许另一个程序集访问定义程序集的“内部”元素。

我今天才知道这一点——我已经和C#合作5年了！

这是命名空间别名限定符：

extern alias YourAliasHere;

您可以使用它加载同一类型的多个版本。这在维护或升级场景中非常有用，因为您的类型有一个更新版本，在某些旧代码中无法使用，但您需要将其升级到新版本。敲击命名空间别名限定符，编译器将允许您在代码中同时使用这两种类型。

我喜欢关键字continue。

如果您在循环中遇到一个条件，并且不想做任何事情，只想推进循环，只需坚持“continue；”即可。

例如。：

foreach(object o in ACollection)
{
  if(NotInterested)
     continue;
}

不是C#的具体内容，但我是一个三元操作迷。

而不是

if (boolean Condition)
{
    //Do Function
}
else
{
    //Do something else
}

你可以用一个简洁的

booleanCondtion ? true operation : false operation;

e.g.

而不是

int value = param;
if (doubleValue)
{
    value *= 2;
}
else
{
    value *= 3;
}

您可以键入

int value = param * (tripleValue ? 3 : 2);

它确实有助于编写简洁的代码，但嵌套这些该死的东西可能会令人讨厌，它们可能会被用于邪恶，但我还是喜欢那些小笨蛋

看到上面提到List.ForEach；2.0引入了一系列基于谓词的集合操作-Find、FindAll、Exists等。加上匿名委托，您几乎可以实现3.5的lambda表达式的简单性。

我喜欢几件事：

-如果创建类似于

 public interface SomeObject<T> where T : SomeObject<T>, new()

将从该接口继承的任何内容强制包含无参数构造函数。它对于我遇到过几件事。

-使用匿名类型动态创建有用的对象：

var myAwesomeObject = new {Name="Foo", Size=10};

-最后，许多Java开发人员熟悉语法，如：

public synchronized void MySynchronizedMethod(){}

然而，在C#中，这不是有效的语法。解决方法是方法属性：

 [MethodImpl(MethodImplOptions.Synchronized)]
 public void MySynchronizedMethod(){}

我认为C#（.NET3.5）的一个最不受重视和鲜为人知的特性是表达式树，尤其是与Generics和Lambdas结合时。这是NInject和Moq等较新的库正在使用的API创建方法。

例如，假设我想向API注册一个方法，而API需要获取方法名

给定此类：

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

以前，开发人员使用字符串和类型（或其他基本上基于字符串的东西）执行此操作是非常常见的：

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

嗯，这太糟糕了，因为缺少强大的打字能力。如果我重命名“SomeMethod”怎么办？现在，在3.5版本中，我可以以强类型的方式实现这一点：

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

其中RegisterMethod类使用表达式＜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);
    }
}

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

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

private IList<Foo> _foo;

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

volatile关键字，用于告诉编译器一个字段可以由多个线程同时修改。

我看不到上面的这一点——直到最近我才意识到你可以做的是从另一个构造函数调用一个构造函数：

class Example
{
    public Example(int value1)
        : this(value1, "Default Value")
    {
    }

    public Example(int value1, string value2)
    {
        m_Value1 = value1;
        m_value2 = value2;
    }

    int m_Value1;
    string m_value2;
}

我还不能发表评论，但请注意，默认情况下，VisualStudio2008会自动跳过财产，因此在这种情况下不再需要DebuggerStepThrough属性。此外，我还没有注意到有人展示如何声明无参数lambda（对于实现Action＜＞很有用）（）=>DoSomething（x）；

你还应该仔细阅读闭包——我不够聪明，无法正确解释它们。但基本上，这意味着编译器做了一些聪明的事情，这样即使在创建lambda之后“超出范围”，这行代码中的x仍然可以工作。

我最近还发现，可以假装忽略lambda参数：（e，_）=>DoSomething（e）

它并不是真的忽略它，只是_是一个有效的标识符。所以你不能像那样忽略这两个参数，但我认为这是一种很好的方式来表明我们不关心这个参数（通常是EventArgs，它是.Empty）。

System.Runtime.Remoting.Proxies.RealProxy

它支持C#中的面向方面编程，你也可以用它做很多其他的事情。

别名泛型：

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

它允许您使用ASimpleName，而不是Dictionary＜string，Dictionary＞string，List＜string＞＞。

当你在很多地方使用同一个通用的大而长的复杂的东西时，可以使用它。

新修饰符

C#中“new”修饰符的用法并不是完全隐藏的，但并不常见。当您需要“隐藏”基类成员而不总是覆盖它们时，新的修饰符很有用。这意味着当您将派生类转换为基类时，“隐藏”方法将变得可见，并被调用，而不是派生类中的相同方法。

在代码中更容易看到：

public class BaseFoo
{
    virtual public void DoSomething()
    {
        Console.WriteLine("Foo");
    }
}

public class DerivedFoo : BaseFoo
{
    public new void DoSomething()
    {
        Console.WriteLine("Bar");
    }
}

public class DerivedBar : BaseFoo
{
    public override void DoSomething()
    {
        Console.WriteLine("FooBar");
    }
}

class Program
{
    static void Main(string[] args)
    {
        BaseFoo derivedBarAsBaseFoo = new DerivedBar();
        BaseFoo derivedFooAsBaseFoo = new DerivedFoo();

        DerivedFoo derivedFoo = new DerivedFoo();

        derivedFooAsBaseFoo.DoSomething(); //Prints "Foo" when you might expect "Bar"
        derivedBarAsBaseFoo.DoSomething(); //Prints "FooBar"

        derivedFoo.DoSomething(); //Prints "Bar"
    }
}

[艾德：双关语能给我加分吗？对不起，没办法。]

别忘了后藤。

通过在case中没有代码（参见case 0），或者使用特殊的goto-case（参见case 1）或goto-default（参见case 2）形式，可以实现切换case的下降：

switch (/*...*/) {
    case 0: // shares the exact same code as case 1
    case 1:
        // do something
        goto case 2;
    case 2:
        // do something else
        goto default;
    default:
        // do something entirely different
        break;
}

#region｛string｝和#endregion对对代码进行分组（概述）非常简单。

#region Using statements
using System;
using System.IO;
using ....;
using ....;
#endregion

代码块可以压缩为一行描述文本。也适用于函数内部。

静态构造函数。

实例：

public class Example
{
    static Example()
    {
        // Code to execute during type initialization
    }

    public Example()
    {
        // Code to execute during object initialization
    }
}

静态类：

public static class Example
{
    static Example()
    {
        // Code to execute during type initialization
    }
}

MSDN表示：

静态构造函数用于初始化任何静态数据，或执行只需要执行一次的特定操作。在创建第一个实例或引用任何静态成员之前自动调用它。

例如：

public class MyWebService
{
    public static DateTime StartTime;

    static MyWebService()
    {
        MyWebService.StartTime = DateTime.Now;
    }

    public TimeSpan Uptime
    {
        get { return DateTime.Now - MyWebService.StartTime; }
    }
}

但是，你也可以很容易地做到：

public class MyWebService
{
    public static DateTime StartTime = DateTime.Now;

    public TimeSpan Uptime
    {
        get { return DateTime.Now - MyWebService.StartTime; }
    }
}

因此，当您实际需要使用静态构造函数时，您将很难找到任何实例。

MSDN提供了关于静态构造函数的有用注释：

静态构造函数不接受访问修饰符或参数。自动调用静态构造函数来初始化类在创建第一个实例之前或引用任何静态成员。不能直接调用静态构造函数。用户无法控制何时在程序静态构造函数的典型用法是使用日志文件和构造函数用于编写此文件的条目。静态构造函数在为非托管代码，当构造函数可以调用LoadLibrary方法。如果静态构造函数抛出异常，则运行时不会再次调用它，然后键入将保持未初始化状态中应用程序域的生存期您的程序正在运行。

最重要的一点是，如果静态构造函数中发生错误，将引发TypeIntializationException，并且无法深入到有问题的代码行。相反，您必须检查TypeInitializationException的InnerException成员，这是特定的原因。

BCL中的一些并发实用程序可能符合隐藏功能的要求。

lock关键字在内部使用System.Threading.Monitor等属性；显然，在C#中，lock关键字是首选的，但有时了解在较低级别上如何完成工作是值得的；我必须锁定C++/CLI，所以我用调用Monitor.Enter（）和Monitor.Exit（）封装了一块代码。

文字可以用作该类型的变量。如。

Console.WriteLine(5.ToString());
Console.WriteLine(5M.GetType());   // Returns "System.Decimal"
Console.WriteLine("This is a string!!!".Replace("!!", "!"));

只是一些琐事。。。

有很多事情人们没有提到，但它们大多与不安全的构造有关。这里有一个可以被“常规”代码使用：

选中/未选中的关键字：

public static int UncheckedAddition(int a, int b)
{
    unchecked { return a + b; }
}

public static int CheckedAddition(int a, int b)
{
    checked { return a + b; } // or "return checked(a + b)";
}

public static void Main() 
{
    Console.WriteLine("Unchecked: " + UncheckedAddition(Int32.MaxValue, + 1));  // "Wraps around"
    Console.WriteLine("Checked: " + CheckedAddition(Int32.MaxValue, + 1));  // Throws an Overflow exception
    Console.ReadLine();
}

在lambda发挥作用之前，它是匿名委托。这可以用于与Ruby的blockgiven类似的总括代码。但我还没有测试lambda的工作原理，因为到目前为止我想坚持使用.NET2.0。

例如，当您希望确保记住关闭HTML标记时：

MyHtmlWriter writer=new MyHtmlWriter();
writer.writeTag("html", 
  delegate ()
  { 
    writer.writeTag("head", 
       delegate() 
       { 
           writer.writeTag("title"...);
       }
    )
  })

我确信，如果lambda是一个选项，那么会产生更干净的代码：）

如果允许第三方扩展，那么C5和Microsoft CCR（请参阅本博客文章了解快速介绍）是必须了解的。

C5补充了.Net有点缺乏的集合库（不是Set？？？），CCR使并发编程更容易（我听说它将与并行扩展合并）。

Dictionary.TryGetValue（K键，out V值）

用作支票和支票。而不是

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

你可以这样做；

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

并且该值已被设置。

我想很多人都知道C中的指针，但不确定它在C#中是否有效。您可以在不安全的上下文中使用C#中的指针：

static void Main()
{
    int i;
    unsafe
    {               
        // pointer pi has the address of variable i
        int* pi = &i; 
        // pointer ppi has the address of variable pi
        int** ppi = π
        // ppi(addess of pi) -> pi(addess of i) -> i(0)
        i = 0;
        // dereference the pi, i.e. *pi is i
        Console.WriteLine("i = {0}", *pi); // output: i = 0
        // since *pi is i, equivalent to i++
        (*pi)++;
        Console.WriteLine("i = {0}", *pi); // output: i = 1
        // since *ppi is pi, one more dereference  *pi is i 
        // equivalent to i += 2
        **ppi += 2;
        Console.WriteLine("i = {0}", *pi);// output: i = 3
    }
    Console.ReadLine();
}

一些奇怪：）

Delegate target =
  (target0 = target as CallTargetWithContext0) ??
  (target1 = target as CallTargetWithContext1) ??
  (target2 = target as CallTargetWithContext2) ??
  (target3 = target as CallTargetWithContext3) ??
  (target4 = target as CallTargetWithContext4) ??
  (target5 = target as CallTargetWithContext5) ??
  ((Delegate)(targetN = target as CallTargetWithContextN));

值得注意的是，出于某种原因需要最后一个演员阵容。缺陷还是设计？

System.Diagnostics.Debug.Assert (false);

将触发一个弹出窗口，并允许您在执行期间将调试器附加到正在运行的.NET进程。对于某些原因无法直接调试ASP.NET应用程序的情况非常有用。

存在用于在声明的类和一个或多个任意类之间执行隐式和显式用户定义类型转换的运算符。隐式运算符有效地允许模拟重载赋值运算符，这在C++等语言中是可能的，但在C#中是不可能的。

这似乎不是一个经常遇到的特性，但实际上它在LINQ to XML（System.XML.LINQ）库中使用，在那里您可以将字符串隐式转换为XName对象。例子：

XName tagName = "x:Name";

我在这篇关于如何在C#中模拟多重继承的文章中发现了这个特性。

纯安全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；

我遇到的一些隐藏功能：

stackalloc，允许您在堆栈上分配数组没有显式参数列表的匿名方法，可以隐式转换为具有非out/ref参数的任何委托类型（对于事件非常方便，如前面的注释所述）很多人不知道事件到底是什么（一对添加/删除方法，如财产的get/set）；C#中类似字段的事件实际上同时声明了变量和事件==和！=运算符可以重载为返回bool以外的类型。奇怪但真实。C#3中的查询表达式转换在某些方面非常“简单”——这意味着可以让它做一些非常奇怪的事情。可为null的类型具有特殊的装箱行为：null值被装箱为null引用，您也可以将null装箱为可为null类型。

我在Stack Overflow上只学到的一个特性是在返回参数上设置属性的能力。

[AttributeUsage( AttributeTargets.ReturnValue )]
public class CuriosityAttribute:Attribute
{
}

public class Bar
{
    [return: Curiosity]
    public Bar ReturnANewBar()
    {
        return new Bar();
    }
}

这对我来说确实是一个隐藏的功能：-）

字符串实习。这是我在这次讨论中还没有看到的。它有点晦涩难懂，但在某些条件下它可能有用。

CLR保存了一个对文本字符串（以及以编程方式嵌入的字符串）的引用表。如果在代码中的多个位置使用相同的字符串，那么它将在表中存储一次。这可以减少分配字符串所需的内存量。

您可以通过使用string.IsInterned（字符串）测试字符串是否被内部化，也可以使用string.intern（字符串）内部化字符串。

注意：CLR可以在应用程序或甚至AppDomain结束后保存对内部字符串的引用。有关详细信息，请参阅MSDN文档。

params关键字，即。

public void DoSomething(params string[] theStrings)
{
  foreach(string s in theStrings)
  {
    // Something with the Strings…
  }
}

像这样调用

DoSomething(“The”, “cat”, “sat”, “on”, “the” ,”mat”);

正在标记我的末端区域。。。

#region stuff1
 #region stuff1a
 //...
 #endregion stuff1a
#endregion stuff1

我在使用ReSharper时选择了这个：

隐式方法组转换

//If given this:
var myStrings = new List<string>(){"abc","def","xyz"};
//Then this:
myStrings.ForEach(s => Console.WriteLine(s));
//Is equivalent to this:
myStrings.ForEach(Console.WriteLine);

有关详细信息，请参阅“C#中的隐式方法组转换”。

与使用int.TryParse（）或Convert.ToInt32（）不同，我喜欢有一个静态整数解析函数，当它无法解析时返回null。那么我可以使用？？和三元运算符一起使用，以更清楚地确保我的声明和初始化都在一行中以易于理解的方式完成。

public static class Parser {
    public static int? ParseInt(string s) {
        int result;
        bool parsed = int.TryParse(s, out result);
        if (parsed) return result;
        else return null;
    }
    // ...
}

这对于避免重复赋值的左侧也是很好的，但对于避免在赋值的右侧重复长调用（例如下面的示例中的数据库调用）则更好。而不是丑陋的“如果那么”树（我经常遇到）：

int x = 0;
YourDatabaseResultSet data = new YourDatabaseResultSet();
if (cond1)
    if (int.TryParse(x_input, x)){
        data = YourDatabaseAccessMethod("my_proc_name", 2, x);
    }
    else{
        x = -1;
        // do something to report "Can't Parse"    
    }
}
else {
    x = y;
    data = YourDatabaseAccessMethod("my_proc_name", 
       new SqlParameter("@param1", 2),
       new SqlParameter("@param2", x));
}

您可以执行以下操作：

int x = cond1 ? (Parser.ParseInt(x_input) ?? -1) : y;
if (x >= 0)  data = YourDatabaseAccessMethod("my_proc_name", 
    new SqlParameter("@param1", 2),
    new SqlParameter("@param2", x));

更干净，更容易理解

Environment.UserInteractive属性。

UserInteractive属性报告对于Windows进程或类似IIS的服务，在没有用户界面。如果此属性为false，不显示模式对话框或消息框，因为没有用户的图形用户界面与之互动。

ContextBound对象

与其说是C#，不如说是.NET。这是实现DI的另一种方式，尽管它可以是艰苦的工作。你必须从中继承，这可能会让人反感。

http://msdn.microsoft.com/en-us/library/system.contextboundobject.aspx

当我用自定义日志记录属性修饰类/方法时，我用它来添加日志记录。

完全访问调用堆栈：

public static void Main()
{
  StackTrace stackTrace = new StackTrace();           // get call stack
  StackFrame[] stackFrames = stackTrace.GetFrames();  // get method calls (frames)

  // write call stack method names
  foreach (StackFrame stackFrame in stackFrames)
  {
    Console.WriteLine(stackFrame.GetMethod().Name);   // write method name
  }
}

所以，如果你选择第一个-你知道你在哪个函数中。如果你正在创建一个助手跟踪函数-在最后一个之前选择一个-你就会知道你的调用者。

在使用linqxml时，我发现这种技术很有趣：

public bool GetFooSetting(XElement ndef){
   return (bool?)ndef.Element("MyBoolSettingValue") ?? true;
}

而不是：

public bool GetFooSetting(XElement ndef){
   return ndef.Element("MyBoolSettingValue") != null ? bool.Parse(ndef.Element("MyBoolSettingValue") ) : true;
}

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

Environment.FailFast()

double dSqrd = Math.Pow(d,2.0); 

比

double dSqrd = d * d; // Here we can lose precision

你可以打开字符串！

switch(name)
{
  case "Dave":
    return true;
  case "Bob":
    return false;
  default:
    throw new ApplicationException();
}

非常方便！比一堆if else语句更干净

刚刚了解到，匿名类型可以从变量名推断属性名：

string hello = "world";
var o = new { hello };
Console.WriteLine(o.hello);

更多的是运行时特性，但我最近了解到有两个垃圾收集器。工作站gc和服务器gc。工作站是windows客户端版本的默认设置，但服务器在多核机器上速度更快。

<configuration>
   <runtime>
      <gcServer enabled="true"/>
   </runtime>
</configuration>

小心。服务器gc需要更多内存。

对于数据库应用程序开发人员来说，这可能很基本，但我花了一段时间才意识到null与DBNull.value不同。

当您想查看数据库记录中的值是否为空时，必须使用DBNull.value。

Object.ReferenceEquals方法

确定指定的Object实例是否为同一实例。

参数：

objA:System.Object-要比较的第一个对象。objB:System.Object-要比较的第二个对象。

例子：

 object o = null;
 object p = null;
 object q = new Object();

 Console.WriteLine(Object.ReferenceEquals(o, p));
 p = q;
 Console.WriteLine(Object.ReferenceEquals(p, q));
 Console.WriteLine(Object.ReferenceEquals(o, p));

与“==”和“.Equals”的差值：

基本上，对象A的Equal（）测试与对象B具有相同的内容。

System.Object.ReferenceEquals（）方法始终比较引用。尽管类可以为相等运算符提供自己的行为（下面），如果调用了该运算符，则不会调用该重新定义的运算符通过对System.Object的引用。

对于字符串，实际上没有什么区别，因为==和Equals都已被重写以比较字符串的内容。

另请参见另一个问题的答案（“如何在没有无限递归的情况下检查'=='运算符重载中的空值？”）。

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

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

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

ThreadStaticAttribute是我的最爱。此外，NonSerializableAttribute也很有用。（你能告诉我我用远程处理做了很多服务器工作吗？）

通用事件处理程序：

public event EventHandler<MyEventArgs> MyEvent;

这样你就不必一直申报自己的代表，

刚刚学会了[UnmanagedFunctionPointerAttribute（CallingConvention.CDecl）]的乐趣，因为它尝试与非托管C++函数库接口，该函数库定义了不带__stdcall的回调。

我几乎一年都没有发现强类型DataRows包含Is[ColumnName]Null（）方法。

例如：

Units.UnitsDataTable dataTable = new Units.UnitsDataTable();

foreach (Units.UnitsRow row in dataTable.Rows)
{
    if (row.IsPrimaryKeyNull())
        //....

    if (row.IsForeignKeyNull())
        //....
}

检查边界的数学最大值和最小值：我在很多代码中都看到了这一点：

if (x < lowerBoundary) 
{
   x = lowerBoundary;
}

我发现这个更小、更干净、更可读：

x = Math.Max(x, lowerBoundary);

也可以使用三元运算符：

x = ( x < lowerBoundary) ? lowerBoundary : x;

我错过了很久：可以将字符串与

"string".equals("String", StringComparison.InvariantCultureIgnoreCase)

而不是：

"string".ToLower() == "String".ToLower();

混合是一个很好的功能。基本上，mixin允许您为接口而不是类编写具体代码。然后，只需在一堆类中实现接口，就可以自动获得mixin功能。例如，要将深度复制混合到几个类中，请定义一个接口

internal interface IPrototype<T> { }

为此接口添加功能

internal static class Prototype
{
  public static T DeepCopy<T>(this IPrototype<T> target)
  {
    T copy;
    using (var stream = new MemoryStream())
    {
      var formatter = new BinaryFormatter();
      formatter.Serialize(stream, (T)target);
      stream.Seek(0, SeekOrigin.Begin);
      copy = (T) formatter.Deserialize(stream);
      stream.Close();
    }
    return copy;
  }
}

然后以任何类型实现接口以获得混合。

ViewState getter可以是一行代码。

使用默认值：

public string Caption
{
    get { return (string) (ViewState["Caption"] ?? "Foo"); }
    set { ViewState["Caption"] = value; }
}

public int Index
{
    get { return (int) (ViewState["Index"] ?? 0); }
    set { ViewState["Index"] = value; }
}

使用null作为默认值：

public string Caption
{
    get { return (string) ViewState["Caption"]; }
    set { ViewState["Caption"] = value; }
}

public int? Index
{
    get { return (int?) ViewState["Index"]; }
    set { ViewState["Index"] = value; }
}

这适用于任何有字典支持的情况。

关于foreach：它不使用“duck typing”，因为duck tying IMO指的是运行时检查。它在编译时使用结构类型检查（而不是标称）来检查类型中所需的方法。

下面是如何使用#Region指令记录代码的提示。

（我刚刚使用了这个）将字段设置为空，并返回它而不使用中间变量：

try
{
    return _field;
}
finally
{
    _field = null;
}

显式接口成员实现，其中实现了接口成员，但除非将实例强制转换为接口类型，否则隐藏该接口成员。

一行中的按需字段初始化：

public StringBuilder Builder
{
    get { return _builder ?? (_builder = new StringBuilder()); }
}

我不知道我对C#支持赋值表达式的感觉如何，但嘿，它就在那里：-）

有几个人提到过使用积木，但我认为它们比人们想象的有用得多。将它们视为穷人的AOP工具。我有很多简单的对象，它们在构造函数中捕获状态，然后在Dispose（）方法中恢复状态。这允许我将一段功能包装在一个using块中，并确保在最后恢复状态。例如：

using(new CursorState(this, BusyCursor));
{
    // Do stuff
}

CursorState捕获窗体使用的当前光标，然后将窗体设置为使用提供的光标。最后，它将恢复原始光标。我做了很多类似的事情，例如在刷新之前捕获网格上的选择和当前行等等。

您可以在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
            Console.Write("Debugging");
#else
            Console.Write("Final");
#endif

当您使用定义的DEBUG编译解决方案时，它将输出“调试”。

如果您的编译设置为Release，它将写为“Final”。

框架功能

我不知道，但我对VisualStyleRenderer和整个System.Windows.Forms.VisualStyles-Namespace感到非常惊讶。非常酷！

IEnumerable的SelectMany，它将列表展平为单个列表。假设我有一个订单列表，每个订单上都有一个行项目列表。

我想知道售出的LineItems的总数。。。

int totalItems = Orders.Select(o => o.LineItems).SelectMany(i => i).Sum();

这不是特定于C#的类型，但我刚刚找到了ISurrogateSelector和ISerializationSurrogate接口--

http://msdn.microsoft.com/en-us/library/system.runtime.serialization.isurrogateselector.aspx

http://msdn.microsoft.com/en-us/library/system.runtime.serialization.isurrogateselector.aspx

将这些与BinaryFormatter结合使用允许通过代理类的实现序列化不可序列化对象。代理模式在计算机科学中很好理解，尤其是在处理序列化问题时。我认为这个实现只是作为BinaryFormatter构造函数的一个参数隐藏起来，这太糟糕了。

仍然-非常隐藏。：）

委托语法在连续的C#版本中不断发展，但我仍然觉得很难记住。幸运的是，Action＜＞和Func＜＞代理很容易记住。

例如：

Action＜int＞是一个委托方法，它接受一个int参数并返回void。Func＜int＞是一个不接受参数并返回int的委托方法。Func＜int，bool＞是一个接受单个int参数并返回bool的委托方法。

这些功能是在.NET框架3.5版中引入的。

我喜欢的一个很棒的类是System.Xml.XmlConvert，它可以用于从Xml标记中读取值。特别是，如果我从xml属性或元素中读取布尔值，我使用

bool myFlag  = System.Xml.XmlConvert.ToBoolean(myAttribute.Value);

注意：由于xml中的布尔类型接受1和0以及“true”和“false”作为有效值，因此在这种情况下使用字符串比较容易出错。

检查和取消检查其他未充分利用的运营商：

short x = 32767;   // 32767 is the max value for short
short y = 32767;
int z1 =  checked((short)(x + y));   //will throw an OverflowException
int z2 =  unchecked((short)(x + y)); // will return -2
int z3 =  (short)(x + y);            // will return -2

要调用基类构造函数，只需将base（）与构造函数内联。要调用基类方法，只需将base.MethodName（）放在派生类方法中

class ClassA 
{
  public ClassA(int a)
  {
    //Do something
  }

  public void Method1()
  {
     //Do Something
  }
}

class ClassB : ClassA
{
  public ClassB(int a) : base(a) // calling the base class constructor
  {
    //Do something
  }

  public void Method2()
  {
    base.Method1();               // calling the base class method
  }
}

当然，只需说出base.MethodName（）就可以调用基类的方法

C#4.0中的dynamic关键字

如果您希望只在运行时解析方法调用，则可以使用dynamic关键字。

dynamic invoker=new DynamicInvoker();
dynamic result1=invoker.MyMethod1();
dynamic result2=invoker.MyMethod2();

这里我实现了一个动态调用程序。

public class DynamicInvoker : IDynamicObject
    {
        public MetaObject GetMetaObject
              (System.Linq.Expressions.Expression parameter)
        {
            return new DynamicReaderDispatch (parameter);
        }
    }

    public class DynamicDispatcher : MetaObject
    {
        public DynamicDispatcher (Expression parameter) 
                   : base(parameter, Restrictions.Empty){ }

        public override MetaObject Call(CallAction action, MetaObject[] args)
        {
            //You'll get MyMethod1 and MyMethod2 here (and what ever you call)
            Console.WriteLine("Logic to invoke Method '{0}'", action.Name);
            return this; //Return a meta object
        }
    }

能够使用LINQ表达式执行强类型反射：

static void Main(string[] args)
{
  var domain = "matrix";
  Check(() => domain);
  Console.ReadLine();
}

static void Check<T>(Expression<Func<T>> expr)
{
  var body = ((MemberExpression)expr.Body);
  Console.WriteLine("Name is: {0}", body.Member.Name);
  Console.WriteLine("Value is: {0}", ((FieldInfo)body.Member)
   .GetValue(((ConstantExpression)body.Expression).Value));
}

// output:
// Name is: 'domain'
// Value is: 'matrix'

有关更多详细信息，请参阅How to Find Variable or Parameter Name in C#？

这不是一个C#特有的特性，但它是一个我觉得非常有用的插件。它被称为资源重构工具。它允许您右键单击文本字符串并将其提取到资源文件中。它将搜索代码并找到匹配的任何其他文本字符串，并用Resx文件中的相同资源替换它。

http://www.codeplex.com/ResourceRefactoring

TrueForAll列表方法＜T＞：

List<int> s = new List<int> { 6, 1, 2 };

bool a = s.TrueForAll(p => p > 0);

关闭

自从匿名委托被添加到2.0之后，我们就能够开发闭包。它们很少被程序员使用，但提供了巨大的好处，如立即代码重用。考虑这段代码：

bool changed = false;

if (model.Prop1 != prop1)
{
    changed = true;
    model.Prop1 = prop1;
}
if (model.Prop2 != prop2)
{
    changed = true;
    model.Prop2 = prop2;
}
// ... etc. 

请注意，上面的if-statements执行类似的代码，只有一行代码除外，即设置不同的财产。这可以通过以下方式缩短，其中变化的代码行作为Action对象的参数输入，适当命名为setAndTagChanged：

bool changed = false;
Action<Action> setAndTagChanged = (action) => 
{ 
    changed = true; 
    action(); 
};

if (model.Prop1 != prop1) setAndTagChanged(() => model.Prop1 = prop1);
if (model.Prop2 != prop2) setAndTagChanged(() => model.Prop2 = prop2);

在第二种情况下，闭包允许您确定lambda中的变化变量的范围，这是解决这个问题的一种简洁方法。

另一种方法是使用另一个未使用的特性，即“或相等”二进制赋值运算符。以下代码显示了如何操作：

private bool conditionalSet(bool condition, Action action)
{
    if (condition) action();
    return condition;
}

// ...

bool changed = false;
changed |= conditionalSet(model.Prop1 == prop1, () => model.Prop1 = prop1);
changed |= conditionalSet(model.Prop2 == prop2, () => model.Prop2 = prop2);

我称此为AutoDebug，因为您可以根据bool值（也可以存储为项目用户设置）在需要的位置和时间进行调试。

例子：

//Place at top of your code
public UseAutoDebug = true;


//Place anywhere in your code including catch areas in try/catch blocks
Debug.Assert(!this.UseAutoDebug);

只需将上述内容放在try/catch块或代码的其他区域，并将UseAutoDebug设置为true或false，然后随时进行调试即可。

您可以将此代码保留在原位，并在测试时打开和关闭此功能。您还可以将其保存为项目设置，并在部署后手动更改，以便在需要时/如果需要时从用户处获取其他错误信息。

在这里，您可以看到一个在Visual Studio C#项目模板中使用此技术的功能和工作示例，其中大量使用此技术：

http://code.msdn.microsoft.com/SEHE

C#3.0的LINQ查询综合是一个完整的一元综合，就像Haskell（事实上，它们是由Haskell的一位设计师设计的）。它们将适用于遵循“LINQ模式”的任何泛型类型，并允许您以纯一元函数样式编写，这意味着所有变量都是不可变的（就像在using和foreach语句中使用的唯一变量是IDisposable和IEnumerable一样）。这有助于保持变量声明接近其使用位置，并确保显式声明所有副作用（如果有的话）。

 interface IFoo<T>
  { T Bar {get;}
  }

 class MyFoo<T> : IFoo<T> 
  { public MyFoo(T t) {Bar = t;}
    public T Bar {get; private set;} 
  }

 static class Foo 
  { public static IFoo<T> ToFoo<T>(this T t) {return new MyFoo<T>(t);}

    public static void Do<T>(this T t, Action<T> a) { a(t);}

    public static IFoo<U> Select<T,U>(this IFoo<T> foo, Func<T,U> f) 
     { return f(foo.Bar).ToFoo();
     }
  }

 /* ... */

 using (var file = File.OpenRead("objc.h"))
 { var x = from f in file.ToFoo()
           let s = new Scanner(f)
           let p = new Parser {scanner = s}
           select p.Parse();

   x.Do(p => 
    { /* drop into imperative code to handle file 
         in Foo monad if necessary */      
    });

 }

我想说，将某些系统类用于扩展方法非常方便，例如system.Enum，您可以执行以下操作。。。

[Flags]
public enum ErrorTypes : int {
    None = 0,
    MissingPassword = 1,
    MissingUsername = 2,
    PasswordIncorrect = 4
}

public static class EnumExtensions {

    public static T Append<T> (this System.Enum type, T value) where T : struct
    {
        return (T)(ValueType)(((int)(ValueType) type | (int)(ValueType) value));
    }

    public static T Remove<T> (this System.Enum type, T value) where T : struct
    {
        return (T)(ValueType)(((int)(ValueType)type & ~(int)(ValueType)value));
    }

    public static bool Has<T> (this System.Enum type, T value) where T : struct
    {
        return (((int)(ValueType)type & (int)(ValueType)value) == (int)(ValueType)value);
    }

}

...

//used like the following...

ErrorTypes error = ErrorTypes.None;
error = error.Append(ErrorTypes.MissingUsername);
error = error.Append(ErrorTypes.MissingPassword);
error = error.Remove(ErrorTypes.MissingUsername);

//then you can check using other methods
if (error.Has(ErrorTypes.MissingUsername)) {
    ...
}

当然，这只是一个例子——这些方法可能需要更多的工作。。。

可以在非泛型类中使用泛型方法。

使用lambdas时模拟函数“通配符”参数（如Haskell中的“_”）的妙招：

(_, b, __) => b.DoStuff();  // only interested in b here

仅适用于使用扩展方法的引用枚举二进制操作。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;

namespace BinaryOpGenericTest
{
    [Flags]
    enum MyFlags
    {
        A = 1,
        B = 2,
        C = 4

    }

    static class EnumExtensions
    {
        private static Dictionary<Type, Delegate> m_operations = new Dictionary<Type, Delegate>();

        public static bool IsFlagSet<T>(this T firstOperand, T secondOperand) 
                                                  where T : struct
        {

            Type enumType = typeof(T);


            if (!enumType.IsEnum)
            {
                throw new InvalidOperationException("Enum type parameter required");
            }


            Delegate funcImplementorBase = null;
            m_operations.TryGetValue(enumType, out funcImplementorBase);

            Func<T, T, bool> funcImplementor = funcImplementorBase as Func<T, T, bool>;

            if (funcImplementor == null)
            {
                funcImplementor = buildFuncImplementor(secondOperand);
            }



            return funcImplementor(firstOperand, secondOperand);
        }


        private static Func<T, T, bool> buildFuncImplementor<T>(T val)
                                                            where T : struct
        {
            var first = Expression.Parameter(val.GetType(), "first");
            var second = Expression.Parameter(val.GetType(), "second");

            Expression convertSecondExpresion = Expression.Convert(second, typeof(int));
            var andOperator = Expression.Lambda<Func<T, T, bool>>(Expression.Equal(
                                                                                                       Expression.And(
                                                                                                            Expression.Convert(first, typeof(int)),
                                                                                                             convertSecondExpresion),
                                                                                                       convertSecondExpresion),
                                                                                             new[] { first, second });
            Func<T, T, bool> andOperatorFunc = andOperator.Compile();
            m_operations[typeof(T)] = andOperatorFunc;
            return andOperatorFunc;
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            MyFlags flag = MyFlags.A | MyFlags.B;

            Console.WriteLine(flag.IsFlagSet(MyFlags.A));            
            Console.WriteLine(EnumExtensions.IsFlagSet(flag, MyFlags.C));
            Console.ReadLine();
        }
    }
}

方法组并不广为人知。

鉴于：

Func<Func<int,int>,int,int> myFunc1 = (i, j) => i(j);
Func<int, int> myFunc2 = i => i + 2;

您可以这样做：

var x = myFunc1(myFunc2, 1);

而不是：

var x = myFunc1(z => myFunc2(z), 1);

如果方法参数实现了两个接口，则可以使用泛型来检查（编译时）：

interface IPropA 
{
    string PropA { get; set; } 
}

interface IPropB 
{
    string PropB { get; set; }
}

class TestClass 
{
    void DoSomething<T>(T t) where T : IPropA, IPropB 
    {
        MessageBox.Show(t.PropA);
        MessageBox.Show(t.PropB);
    }
}

与从基类和接口继承的参数相同。

构造函数链是否已被引用？

namespace constructorChain {
    using System;

    public class Class1 {
        public string x;
        public string y;

        public Class1() {
            x = "class1";
            y = "";
        }

        public Class1(string y)
            : this() {
            this.y = y;
        }
    }

    public class Class2 : Class1 {
        public Class2(int y)
            : base(y.ToString()) {

        }
    }
}

...

        constructorChain.Class1 c1 = new constructorChain.Class1();
        constructorChain.Class1 c12 = new constructorChain.Class1("Hello, Constructor!");
        constructorChain.Class2 c2 = new constructorChain.Class2(10);
        Console.WriteLine("{0}:{1}", c1.x, c1.y);
        Console.WriteLine("{0}:{1}", c12.x, c12.y);
        Console.WriteLine("{0}:{1}", c2.x, c2.y);

        Console.ReadLine();

没有隐藏，但很整洁。我发现这是一个简单的if-then-else的更简洁的替代方法，它只基于一个条件分配一个值。

string result = 
              i < 2 ?               //question
              "less than 2" :       //answer
              i < 5 ?               //question
             "less than 5":         //answer   
              i < 10 ?              //question
              "less than 10":       //answer
              "something else";     //default answer 

下面是我最近发现的一个有用的：

Microsoft.VisualBasic.Logging.FileLogTraceListener

MSDN链接

这是一个TraceListener实现，它有很多功能，例如自动日志文件回滚，我以前会使用自定义日志框架。好的是，它是.NET的核心部分，并与Trace框架集成，因此易于立即获取和使用。

这是“隐藏的”，因为它在Microsoft.VisualBasic程序集中。。。但您也可以从C#中使用它。

使用枚举。

将字符串转换为枚举：

enum MyEnum
{
    FirstValue,
    SecondValue,
    ThirdValue
}

string enumValueString = "FirstValue";
MyEnum val = (MyEnum)Enum.Parse(typeof(MyEnum), enumValueString, true)

我使用它从数据库中的设置表中加载ASP.NET应用程序中CacheItemPriority的值，这样我就可以动态控制缓存（以及其他设置），而不必关闭应用程序。

比较enum类型的变量时，不必强制转换为int：

MyEnum val = MyEnum.SecondValue;
if (val < MyEnum.ThirdValue)
{
    // Do something
}

我非常喜欢函数上的隐式泛型参数。例如，如果您有：

public void DoStuff<T>(T value);

与其这样称呼它：

DoStuff<int>(5);

你可以：

DoStuff(5);

它将根据参数的类型计算出泛型类型。

如果您通过反射调用方法，则这不起作用。我记得Mono出现了一些奇怪的问题。

许多人没有意识到，他们可以使用：OrdinalIgnoreCase来比较字符串，而不必执行someString.ToUpper（）。这消除了额外的字符串分配开销。

if( myString.ToUpper() == theirString.ToUpper() ){ ... }

变成

if( myString.Equals( theirString, StringComparison.OrdinalIgnoreCase ) ){ ... }

我最喜欢的属性：InternalsVisibleTo

在程序集级别，您可以声明另一个程序集可以看到您的内部构件。出于测试目的，这绝对是美妙的。

将其粘贴到AssemblyInfo.cs或等效程序中，测试程序集就可以完全访问所有需要测试的内部内容。

[assembly: InternalsVisibleTo("MyLibrary.Test, PublicKey=0024...5c042cb")]

如您所见，测试程序集必须具有强名称才能获得被测试程序集的信任。

在.Net Framework 2.0+、Compact Framework 2.0+和XNA Framework 1.0+中提供。

固定/C#中指针的力量-这个主题太大了，但我只概述一些简单的事情。

在C中，我们有装载结构的设施，如。。。

struct cType{
   char type[4];
   int  size;
   char name[50];
   char email[100];
}

cType myType;
fread(file, &mType, sizeof(mType));

我们可以在“unsafe”方法中使用fixed关键字来读取字节数组对齐的结构。

[Layout(LayoutKind.Sequential, Pack=1)]
public unsafe class CType{
    public fixed byte type[4];
    public int size;
    public fixed byte name[50];
    public fixed byte email[100];
}

方法1（从字节缓冲区中的常规流读取，并将字节数组映射到结构的各个字节）

CType mType = new CType();
byte[] buffer = new byte[Marshal.SizeOf(CType)];
stream.Read(buffer,0,buffer.Length);
// you can map your buffer back to your struct...
fixed(CType* sp = &mType)
{
    byte* bsp = (byte*) sp;
    fixed(byte* bp = &buffer)
    {
         for(int i=0;i<buffer.Length;i++)
         {
             (*bsp) = (*bp);
             bsp++;bp++;
         }
    }
}

方法2，您可以将Win32 User32.dll的ReadFile映射为直接读取字节。。。

CType mType = new CType();
fixed(CType* p = &mType)
{
    User32.ReadFile(fileHandle, (byte*) p, Marshal.SizeOf(mType),0);
}

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

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

这里的另一个例子

InternalsVisibleToAttribute指定通常仅在当前程序集中可见的类型对另一个程序集可见。关于msdn的文章

而不是这样做：

Console.WriteLine("{0} item(s) found.", count);

我使用以下内联技巧：

Console.WriteLine("{0} item{1} found.", count, count==1 ? "" : "s");

当有一个项目时，将显示“项目”，当有多于（或少于）1个项目时将显示“项”。没有太多的努力来获得一点专业性。

很多人不知道的一件事是C#引入的一些预处理器指令。您可以使用#error这是一个错误。生成编译器错误和#warning这是一个警告。

当我使用自上而下的方法进行开发时，我通常使用这些作为“待办事项”列表。我将#error实现此函数，或#warning最终实现此角案例作为提醒。

在处理C++和C#之间的互操作时，许多人没有意识到C++/CLI是一个很好的选择。

假设您有一个C++DLL和一个依赖于C++DLL的C#DLL。通常，最简单的技术是使用/clr开关编译C++DLL的一些（或所有）模块。要调用C#，C++DLL就是在C++DLL中编写托管C++包装类。C++/CLI类可以比C#更无缝地调用本机C++代码，因为C++编译器将自动为您生成P/calls，它有一个专门用于interop的库，以及用于interop（如pin_ptr）的语言功能。它允许托管代码和本机代码在同一个二进制文件中共存。

在C#端，您只需像调用任何其他.NET二进制文件一样调用DLL。

我回答这个问题太晚了，但我想补充一些我认为尚未涵盖的内容。这些不是特定于C#的，但我认为对于任何C#开发人员来说都值得一提。

环境值属性这类似于DefaultValueAttribute，但它不是提供属性默认的值，而是提供属性用来决定是否从其他地方请求其值的值。例如，对于WinForms中的许多控件，它们的ForeColor和BackColor财产的AmbientValue为Color.Empty，以便它们知道从其父控件获取颜色。

隔离存储设置这是一个Silverlight。该框架方便地包含了这个密封类，用于在每个应用程序和每个站点级别提供设置持久性。

标记与扩展方法的交互

使用扩展方法，标志枚举的使用可以更加易读。

    public static bool Contains(
          this MyEnumType enumValue,
          MyEnumType flagValue)
    {
        return ((enumValue & flagValue) == flagValue);
    }

    public static bool ContainsAny(
          this MyEnumType enumValue,
          MyEnumType flagValue)
    {
        return ((enumValue & flagValue) > 0);
    }

这使得对标志值的检查很容易读写。当然，如果我们可以使用泛型并将T强制为枚举，那会更好，但这是不允许的。也许动态将使这更容易。

当您想要调用/BegginInvoke内联代码时，内置（2.0）MethodInvoker委托非常有用。这避免了需要创建实际的委托和单独的方法。

    void FileMessageEvent(object sender, MessageEventArgs e)
    {

        if (this.InvokeRequired == true)
        {
            this.BeginInvoke((MethodInvoker)delegate { 
                     lblMessage.Text=e.Message; 
                     Application.DoEvents(); 
                 }
            ); 

        }
    }

解决错误：“无法将匿名方法转换为类型”System.Delegate“，因为它不是委托类型”。

我发现编译器在对外部变量的使用进行编码时遇到了什么样的麻烦，真是难以置信：

string output = "helo world!";
Action action = () => Console.WriteLine(output);
output = "hello!";
action();

这实际上是打印hello！。为什么？因为编译器为委托创建了一个嵌套类，所有外部变量都有公共字段，并在每次调用委托之前插入设置代码：）下面是代码“reflected”：

Action action;
<>c__DisplayClass1 CS$<>8__locals2;
CS$<>8__locals2 = new <>c__DisplayClass1();
CS$<>8__locals2.output = "helo world!";
action = new Action(CS$<>8__locals2.<Main>b__0);
CS$<>8__locals2.output = "hello!";
action();

我觉得很酷。

直到我将Convert类中的一些函数与Array.ConvertAll组合在一起，我才弄清楚它们的用途（例如Convert.ToDouble（int）、Convert.ToInt（double））：

int[] someArrayYouHaveAsInt;
double[] copyOfArrayAsDouble = Array.ConvertAll<int, double>(
                                someArrayYouHaveAsInt,
                                new Converter<int,double>(Convert.ToDouble));

这避免了由于定义内联委托/闭包而产生的资源分配问题（并且稍微更易读）：

int[] someArrayYouHaveAsInt;
double[] copyOfArrayAsDouble = Array.ConvertAll<int, double>(
                                someArrayYouHaveAsInt,
                                new Converter<int,double>(
                                  delegate(int i) { return (double)i; }
                                ));

不指定数组元素类型的数组初始化：

var pets = new[] { "Cat", "Dog", "Bird" };

好不要使用它，但很多人不知道C#支持邪恶的后藤：）

static void Example()
{
    int i = 0;
top:
    Console.WriteLine(i.ToString());
    if (i == 0)
    {
        i++;
        goto top;
    }
}

在刚刚了解了不变性、协方差和反方差的含义之后，我发现了.NET4.0中包含的内外通用修饰符。它们看起来很晦涩，大多数程序员都不知道。

Visual Studio Magazine上有一篇文章讨论了这些关键字以及如何使用它们。

恶劣的目标

每个人都看过。基本上，当您看到以下内容时：

[assembly: ComVisible(false)]

该属性的“assembly:”部分是目标。在这种情况下，该属性将应用于程序集，但还有其他属性：

[return: SomeAttr]
int Method3() { return 0; } 

在此示例中，属性应用于返回值。

如果要阻止垃圾收集器运行对象的终结器，只需使用GC.SuppressFinalize（object）；。同理，GC.KeepAlive（对象）；将阻止垃圾收集器通过引用对象来收集该对象。至少在我的经验中，这不是很常用，但很高兴知道以防万一。

在设计视图中查看组件时要显示的财产财产：

private double _Zoom = 1;

[Category("View")]
[Description("The Current Zoom Level")]
public double Zoom
{
get { return _Zoom;}
set { _Zoom = value;}
}

使您的组件库的其他用户更加轻松。

当小心使用时，释放是如此强大。我在电子邮件模板系统中使用了它。模板管理器将被传递一个对象，html模板将具有引用财产的嵌入字段，可以使用反射从传递的对象中检索这些字段。做得很好。

在.NET 3.5中与lambdas语句一起使用时，Func＜＞类型是绝对的。这些功能允许自定义功能，并且可以很好地帮助用户提供可自定义的对象，而无需对其进行子类化或求助于某些有限的系统，例如跟踪列出用户想要监视的按钮或键的变量。此外，它们可以像常规方法一样被调用，也可以像变量一样被赋值。我能想到的唯一缺点是，你只能有5个论点！尽管到那时你可能想考虑一个不同的解决方案。。。编辑：提供一些示例。

...
public Func<InputHelper, float> _horizontalCameraMovement = (InputHelper input) => 
{
    return (input.LeftStickPosition.X * _moveRate) * _zoom;
}
public Func<InputHelper, float> _verticalCameraMovement = (InputHelper input) => 
{
    return (-input.LeftStickPosition.Y * _moveRate) * _zoom;
}
...
public void Update(InputHelper input)
{
    ...
    position += new Vector2(_horizontalCameraMovement(input), _verticalCameraMovement(input));
    ...
}

在本例中，您可以编写一个函数，该函数执行任意计算并返回一个浮点值，该值将确定相机移动的量。这不是最好的代码，但它可以跨越这一点。

private int foo;
public int FooProperty {
    get
    {
        if (_onFooGotten() == true)
            return _foo;
    }
    set
    {
        if (onFooSet() == true)
            _foo = value;
    }
}
...
public Func<bool> _onFooGotten = () => 
{
    //do whatever...
    return true;
}
public Func<bool> _onFooSet = () =>
{
    //do whatever...
    return true;
}

这并不是最好的例子（因为我还没有真正探讨过这个用法），但它展示了一个使用lambda函数进行快速事件引发的例子，而没有代理的麻烦。编辑：想到了另一个。空值！C#最接近可选参数。

FlagsAttribute，使用enum生成位掩码时的一个小但不错的功能：

[Flags]
public enum ConfigOptions
{
    None    = 0,
    A       = 1 << 0,
    B       = 1 << 1,
    Both    = A | B
}

Console.WriteLine( ConfigOptions.A.ToString() );
Console.WriteLine( ConfigOptions.Both.ToString() );
// Will print:
// A
// A, B

如果您在Visual Studio工具栏中有搜索文本框，则可以键入“>of Program.cs”以打开文件Program.cs

可以为枚举定义数据类型：

enum EnumName : [byte, char, int16, int32, int64, uint16, uint32, uint64]
{
    A = 1,
    B = 2
}

我给你几个——你想怎么做就怎么做。

属性：

[assembly::InternalsVisibleTo("SomeAssembly")]

允许您将程序集的内部方法/财产或数据公开给另一个名为“SomeAssembly”的程序集。所有受保护的/私人物品都保持隐藏状态。

静态构造函数（否则称为“类型构造函数”）

public MyClass
{
  public static MyClass()
  {
     // type init goes here
  }
  ......
}  

关键字internal。在很多方面都很有用。

高级调试

陈列

已经提到的DebuggerDisplay和DebuggerBrowseble属性控制元素的可见性和显示的文本值。简单地重写ToString（）将导致调试器使用该方法的输出。

如果您想要更复杂的输出，可以使用/创建调试器可视化工具这里有。

罢工之子

微软提供了一个名为SOS的调试器扩展。这是一个非常强大（虽然经常令人困惑）的扩展，是诊断“泄漏”的极好方法，更准确地说，对不再需要的对象的不需要的引用。

框架源的符号服务器

遵循这些说明将允许您逐步了解框架某些部分的源代码。

2010年的变化

Visual Studio 2010中有几个增强功能和新功能：

调试并行任务并行堆栈允许同时查看多个线程调用堆栈。历史调试允许您及时查看事件和非本地变量（只要您提前启用集合）。可能会对调试方式产生重大影响。

使用“throw；”而不是“throw ex；”来保留堆栈跟踪

如果在不添加附加信息的情况下重新抛出异常，请使用“throw”而不是“throw ex”。catch块中的空“throw”语句将发出特定的IL，该IL在保留原始堆栈跟踪的同时重新抛出异常。“throw ex”将丢失对异常原始源的堆栈跟踪。

能够基于如下泛型参数创建类型的实例

新T（）；

当Yield关键字具有强大的功能时，它经常被忽略。不久前，我在博客中讨论了它的好处（不同的处理），并在收益的掩护下进行了讨论，以帮助更好地理解。

使用C中的产量#

您可以从扩展方法创建委托，就像它们是常规方法一样，使用此参数。例如

static class FunnyExtension {
    public static string Double(this string str) { return str + str; }
    public static int Double(this int num) { return num + num; }
}


Func<string> aaMaker = "a".Double;
Func<string, string> doubler = FunnyExtension.Double;

Console.WriteLine(aaMaker());       //Prints "aa"
Console.WriteLine(doubler("b"));    //Prints "bb"

注意，这在扩展值类型；看到这个问题。

还不确定是否提到了这一点，但ThreadStatic属性是一个非常有用的属性。这使得静态字段仅对当前线程是静态的。

[ThreadStatic]
private static int _ThreadStaticInteger;

您不应该包含初始值设定项，因为它只在整个应用程序中执行一次，所以最好将字段设置为空，并在使用它之前检查该值是否为空。

此外，ASP.NET应用程序线程还有一点是重用的，因此如果您修改该值，它可能最终被用于另一个页面请求。

尽管如此，我还是多次发现这一点很有用。例如，在创建自定义事务类时：

using (DbTransaction tran = new DbTransaction())
{
    DoQuery("...");
    DoQuery("...");    
}

DbTransaction构造函数将ThreadStatic字段设置为其自身，并在dispose方法中将其重置为null。DoQuery检查静态字段，如果！=null使用当前事务，如果不是，则默认为其他事务。我们避免了必须将事务传递给每个方法，而且它可以很容易地包装原本不打算用于事务内部事务的其他方法。。。

只需一次使用：）

HttpContext.Current.Server.Execute 

非常适合将HTML呈现为AJAX回调的字符串。您可以将其与组件一起使用，而不是将HTML字符串片段拼接在一起。我能够在几乎没有混乱的情况下将页面膨胀减少几百KB。我是这样使用的：

Page pageHolder = new Page();
UserControl viewControl = (UserControl)pageHolder.LoadControl(@"MyComponent.ascx");
pageHolder.Controls.Add(viewControl);
StringWriter output = new StringWriter();
HttpContext.Current.Server.Execute(pageHolder, output, false);
return output.ToString();

不可序列化的营销事件：

[field:NonSerializable]
public event SomeDelegate SomeEvent;

您可以通过较少的键入来添加和删除代理。

常规方式：

handler += new EventHandler(func);

更少的键入方式：

handler += func;

通用约束：

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

{...}

Or赋值运算符非常好。你可以这样写：

x |= y

而不是：

x = x | y

如果您必须将一个变量或属性（示例中的x）开头为false，但仅当其他值为true时，才希望将其更改为其他布尔变量/属性的值，这通常是实用的。

可以对null调用扩展方法；这不会导致引发NullReferenceException。

示例应用程序：您可以为ToString（）定义一个名为ToStringOrEmpty（）的替代方法，当调用null时，该方法将返回空字符串。

我已经读完了所有七页，我错过了这些：

String.Join

我见过很多用于将项目列表转换为带分隔符的字符串的for循环。确保不以分隔符开头，也不以分隔字符结尾，这总是一件痛苦的事。内置方法使此操作更简单：

String.Join(",", new String[] { "a", "b", "c"});

注释中的TODO

不是真正的C#特性，更多的是Visual Studio特性。当您使用TODO开始注释时，它将添加到Visual Studio任务列表中（查看->任务列表.Comments）

// TODO: Implement this!
throw new NotImplementedException();

扩展方法符合Generics

您可以将扩展方法与泛型相结合，当您想到本主题前面的提示时，可以向特定接口添加扩展

public static void Process<T>(this T item) where T:ITest,ITest2 {}

可枚举范围

只需要一个整数列表？

Enumerable.Range(0, 15)

我会想更多的。。。

C#中的指针。

它们可用于就地字符串操作。这是一个不安全的功能，因此不安全关键字用于标记不安全代码的区域。还要注意fixed关键字是如何用来指示指向的内存是固定的，GC无法移动。这是至关重要的，指针指向内存地址，GC可以将内存移动到不同的地址，否则会导致无效指针。

    string str = "some string";
    Console.WriteLine(str);
    unsafe
    {
        fixed(char *s = str)
        {
            char *c = s;
            while(*c != '\0')
            {
                *c = Char.ToUpper(*c++);                    
            }
        }
    }
    Console.WriteLine(str);

我从来不会这样做，只是为了这个问题来演示这个特性。

我喜欢使用using指令重命名一些类，以便于阅读，如下所示：

// defines a descriptive name for a complexed data type
using MyDomainClassList = System.Collections.Generic.List<
  MyProjectNameSpace.MyDomainClass>;

....


MyDomainClassList myList = new MyDomainClassList();
/* instead of 
List<MyDomainClass> myList = new List<MyDomainClass>();
*/

这对于代码维护也非常方便。如果需要更改类名，只需要更改一个位置。另一个例子：

using FloatValue  = float; // you only need to change it once to decimal, double...

....
FloatValue val1;
...

异常筛选器。因此，如果没有编译后补丁，你甚至无法使用它们（至少从C#）；）

表达式树怎么样？它们是LINQ的核心，允许延迟执行：

摘自大卫·海登的博客：

在C#3.0中，可以使用lambda表达式如下定义委托：

Func<int,int> f = x => x + 1;

此委托被编译为应用程序中的可执行代码，可以这样调用：

var three = f(2); // 2 + 1

代码按照您的预期工作。这里没什么好看的。

表达式树

使用System.Query.Expression将委托定义为表达式树时：

Expression<Func<int,int>> expression = x => x + 1;

委托不再编译为可执行代码，而是编译为可以转换并编译为原始委托的数据。

要在应用程序中实际使用表示为表达式树的委托，必须在应用程序中将其编译和调用：

var originalDelegate = expression.Compile();

var three = originalDelegate.Invoke(2);

[field: NonSerialized]
public event EventHandler Event;

这样，事件侦听器就不会序列化。

仅[NonSerialized]不起作用，因为NonSerializedAttribute只能应用于字段。

我特别喜欢可为空的DateTime。所以，如果你在某些情况下给出了日期，而在其他情况下没有给出日期，我认为这是最好的方法，而且IMHO更容易理解为使用DateTime.MinValue或其他任何方法。。。

DateTime? myDate = null;

if (myDate.HasValue)
{
    //doSomething
}
else
{
    //soSomethingElse
}

如果您试图从项目列表中创建逗号分隔的字符串：

string[] itemList = { "Example 1", "Example 2", "Example 3" };
CommaDelimitedStringCollection commaStr = new CommaDelimitedStringCollection();
commaStr.AddRange(itemList);
//outputs Example 1,Example 2,Example 3

看看这里的另一个例子。

零参数Lambdas

()=>Console.ReadLine()

我没有看到这个：

for (;;);

与…一样

while (true) ;

我正成为扩展方法的忠实粉丝，因为它们可以为现有代码或无法编辑的代码添加非常有用的功能。我现在所做的一切中添加的最喜欢的一项是字符串。IsNullOrEmpty（）

public static class Strings
{
    public static bool IsNullOrEmpty(this string value)
    {
        return string.IsNullOrEmpty(value);
    }
}

这使您可以像这样缩短代码

var input = Console.ReadLine();
if (input.IsNullOrEmpty())
{
    Console.WriteLine("try again");
}

条件字符串。格式：

根据数字是正、负还是零，对数字应用不同的格式。

string s = string.Format("{0:positive;negative;zero}", i);

e.g.

string format = "000;-#;(0)";

string pos = 1.ToString(format);     // 001
string neg = (-1).ToString(format);  // -1
string zer = 0.ToString(format);     // (0)

标准中已经解释了很多这一点。无论是初学者还是专家，这都是一本好书，阅读量很大，但这是官方标准，而且充满了有趣的细节。

一旦您完全理解了C#，就应该进一步了解公共语言基础设施的基本原理了。C#的体系结构和基础。

我遇到过很多程序员，他们不知道对象和ValueType之间的区别，除了其固有的局限性。

熟悉这两个文件，你永远不会成为那个人。

当您需要（a）在对象之间就事件的发生进行同步通信时，有一个特殊的接口叫做ISynchronizeInvoke。

引用MSDN文章（链接）：

实现此接口的对象可以接收事件发生的通知，并且可以响应有关事件的查询。通过这种方式，客户端可以确保在提交后续请求（取决于第一个请求的完成）之前，已经处理了一个请求。

这里是一个通用包装器：

protected void OnEvent<T>(EventHandler<T> eventHandler, T args) where T : EventArgs
{
    if (eventHandler == null) return;

    foreach (EventHandler<T> singleEvent in eventHandler.GetInvocationList())
    {
        if (singleEvent.Target != null && singleEvent.Target is ISynchronizeInvoke)
        {
            var target = (ISynchronizeInvoke)singleEvent.Target;

            if (target.InvokeRequired) {
                target.BeginInvoke(singleEvent, new object[] { this, args });
                continue;
            }
        }
        singleEvent(this, args);
    }
}

下面是一个示例用法：

public event EventHandler<ProgressEventArgs> ProgressChanged;

private void OnProgressChanged(int processed, int total)
{
    OnEvent(ProgressChanged, new ProgressEventArgs(processed, total));
}

在C#3.5中初始化字典的表达式：

new Dictionary＜string，Int64＞（）｛｛“Testing”，123｝，｛“Test”，125｝｝；

我想没有人提到那个附录？在值类型名称之后，将使其可为null。

您可以执行以下操作：

DateTime? date = null;

DateTime是一个结构。

从C/C++迁移的程序员可能会错过这一点：

在C#中，%（模运算符）作用于浮点数！

泛型和奇怪的递归模板模式确实有助于一些静态方法/属性声明。

假设您正在构建类层次结构：

class Base
{
}

class Foo: Base
{
}

class Bar: Base
{
}

现在，您需要在类型上声明静态方法，这些方法应该采用相同类型的参数（或返回值）或相同类型的静态财产。例如，您需要：

class Base
{
    public static Base Get()
    {
        // Return a suitable Base.
    }
}

class Foo: Base
{
    public static Foo Get()
    {
        // Return a suitable Foo.
    }
}

class Bar: Base
{
    public static Bar Get()
    {
        // Return a suitable Bar.
    }
}

如果这些静态方法基本上都做相同的事情，那么您手中就有大量重复的代码。一种解决方案是在返回值上删除类型安全，并始终返回Base类型。但是，如果您希望类型安全，那么解决方案是将Base声明为：

class Base<T> where T: Base<T>
{
    public static T Get<T>()
    {
        // Return a suitable T.
    }
}

你Foo和Bar是：

class Foo: Base<Foo>
{
}

class Bar: Base<Bar>
{
}

这样，他们将自动获得静态方法的副本。

将Singleton模式封装在基类中也很神奇（我知道下面的代码不是线程安全的，这只是为了证明一点）：

public class Singleton<T> where T: Singleton<T>, new()
{
  public static T Instance { get; private set; }

  static Singleton<T>()
  {
    Instance = new T();
  }
}

我意识到这迫使您在单例子类上使用一个公共的无参数构造函数，但是如果没有where T:protected new（）构造，在编译时就无法避免这种情况；然而，可以使用反射在运行时调用子类的受保护/私有无参数构造函数来实现这一点。

Eric Lippert的四个开关怪癖

阻止DataGridView显示属性：

[System.ComponentModel.Browsable(false)]
public String LastActionID{get; private set;}

用于设置组件（如DataGrid或DataGridView）的友好显示：

[System.ComponentModel.DisplayName("Last Action")]
public String LastAction{get; private set;}

对于支持变量，如果您不希望任何东西直接访问它们，这会使其变得更困难：

[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
    private DataController p_dataSources;

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

我最近刚刚学到的一点是，您仍然可以对可为null的值调用方法。。。。

当你有一个可为null的值时：

decimal? MyValue = null;

你可能认为你必须写下：

MyValue == null ? null : MyValue .ToString()

您可以改为写：

MyValue.ToString()

我已经意识到我可以调用MyValue.HasValue和MyValue.Value……但我不能完全调用ToString（）。

这不会编译：

namespace ns
{
    class Class1
    {
        Nullable<int> a;
    }
}

找不到类型或命名空间名称“Nullable”（是否缺少using指令或程序集引用？）<--缺少“using System；”

But

namespace ns
{
    class Class1
    {
        int? a;
    }
}

将编译！（.NET 2.0）。

嵌套类可以访问外部类的私有成员。

public class Outer
{
    private int Value { get; set; }

    public class Inner
    {
        protected void ModifyOuterMember(Outer outer, int value)
        {
            outer.Value = value;
        }
    }
}

现在，结合上述功能，您还可以继承嵌套类，就像它们是顶级类一样，如下所示。

public class Cheater : Outer.Inner
{
    protected void MakeValue5(Outer outer)
    {
        ModifyOuterMember(outer, 5);
    }
}

这些特性允许一些有趣的可能性，比如通过一些隐藏的类访问特定成员。

类似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;

首先-DebuggerTypeProxy。

[DebuggerTypeProxy(typeof(HashtableDebugView))]
class MyHashtable : Hashtable
{
    private const string TestString = 
        "This should not appear in the debug window.";

    internal class HashtableDebugView
    {
        private Hashtable hashtable;
        public const string TestStringProxy = 
            "This should appear in the debug window.";

        // The constructor for the type proxy class must have a 
        // constructor that takes the target type as a parameter.
        public HashtableDebugView(Hashtable hashtable)
        {
            this.hashtable = hashtable;
        }
    }
}

第二步：

ICustomTypeDescriptor

如果有人提到这个，我很抱歉，但我经常使用这个。

AlexPapadimoulis为Visual Studio开发了一个插件。它用于将常规文本粘贴为字符串、字符串生成器、注释或区域。

http://weblogs.asp.net/alex_papadimoulis/archive/2004/05/25/Smart-Paster-1.1-Add-In---StringBuilder-and-Better-C_2300_-Handling.aspx

在这个插件中（我也不知道是否提到了这一点），我注意到字符串粘贴了字符串文字前缀：

@

我知道这些，但我不知道在文字中使用双引号来逃避引用。

例如

string s = "A line of text" + Environment.NewLine + "Another with a \"quote\"!!";

可以表示为

string s = @"A line of text 
Another with a ""quote""!!";

定义自定义属性时，可以将其与[MyAttrAttribute]或[MyAttr]一起使用。当两种书写都存在类时，就会发生编译错误。

@特殊字符可用于区分它们：

[AttributeUsage(AttributeTargets.All)]
public class X: Attribute
{}

[AttributeUsage(AttributeTargets.All)]
public class XAttribute: Attribute
{}

[X]      // Error: ambiguity
class Class1 {}

[XAttribute]   // Refers to XAttribute
class Class2 {}

[@X]      // Refers to X
class Class3 {}

[@XAttribute]   // Refers to XAttribute
class Class4 {}

您可以在一个using语句中“使用”多个对象。

using (Font f1= new Font("Arial", 10.0f), f2 = new Font("Arial", 10.0f))
{
    // Use f1 and f2.
}

请注意，已经有一个答案表明您可以这样做：

using (Font f1= new Font("Arial", 10.0f))
using (Font f2 = new Font("Arial", 10.0f))
{    }

这和我的不同。

不确定微软会喜欢这个问题，尤其是有这么多人回答。我相信我曾经听过一位微软负责人说：

隐藏功能是浪费的功能

…或类似的东西。

您可以使用｛｝括号来限制变量的生命周期和范围。

{
    string test2 = "3";
    Console.Write(test2);
}

Console.Write(test2); //compile error

test2只存在于括号内。

很抱歉这么晚才发布，我是Stack Overflow的新手，因此错过了之前的机会。

我发现EventHandler＜T＞是该框架的一个很好的功能，但未得到充分利用。

我遇到的大多数C#开发人员在定义自定义事件时仍然会定义自定义事件处理程序委托，这不再是必要的。

而不是：

public delegate void MyCustomEventHandler(object sender, MyCustomEventArgs e);

public class MyCustomEventClass 
{
    public event MyCustomEventHandler MyCustomEvent;
}

你可以去：

public class MyCustomEventClass 
{
    public event EventHandler<MyCustomEventArgs> MyCustomEvent;
}

这要简洁得多，而且您不会陷入这样的两难境地：是将委托放在包含事件的类的.cs文件中，还是EventArgs派生类中。

开放泛型是另一个方便的特性，尤其是在使用控制反转时：

container.RegisterType(typeof(IRepository<>), typeof(NHibernateRepository<>));

在包含转义字符的字符串之前使用@。基本上，当使用物理路径在字符串变量中赋值时，每个人都会在字符串中出现转义符时使用“\”。

例如string strPath=“D:\websites\web1\images\”；

但在字符串值之前使用@可以忽略转义字符。

例如string strPath=@“D:\websites\web1\images\”；

我喜欢滥用静态模板类不共享其静态成员的事实。

这是一个线程安全（在创建时）和廉价的替代品，可以替代任何Dictionary＜Type，…＞当Type实例在编译时已知时。

public static class MyCachedData<T>{
    static readonly CachedData Value;
    static MyCachedData(){
       Value=// Heavy computation, such as baking IL code or doing lots of reflection on a type
    }
}

干杯弗洛里安语

下面的一个不是隐藏的，但它相当含蓄。我不知道像下面这样的示例是否已在这里发布，我看不出有什么好处（可能没有），但我将尝试显示一个“奇怪”的代码。以下示例通过C#（委托/匿名委托[lambdas]）和闭包中的函子模拟for语句。其他流语句如if、if/else、while和do/whle也被模拟，但我不确定是否切换（也许，我太懒了：）。我将示例源代码压缩了一点，以使其更清晰。

private static readonly Action EmptyAction = () => { };
private static readonly Func<bool> EmptyCondition = () => { return true; };

private sealed class BreakStatementException : Exception { }
private sealed class ContinueStatementException : Exception { }
private static void Break() { throw new BreakStatementException(); }
private static void Continue() { throw new ContinueStatementException(); }

private static void For(Action init, Func<bool> condition, Action postBlock, Action statement) {
    init = init ?? EmptyAction;
    condition = condition ?? EmptyCondition;
    postBlock = postBlock ?? EmptyAction;
    statement = statement ?? EmptyAction;
    for ( init(); condition(); postBlock() ) {
        try {
            statement();
        } catch ( BreakStatementException ) {
            break;
        } catch ( ContinueStatementException ) {
            continue;
        }
    }
}

private static void Main() {
    int i = 0; // avoiding error "Use of unassigned local variable 'i'" if not using `for` init block
    For(() => i = 0, () => i < 10, () => i++,
        () => {
            if ( i == 5 )
                Continue();
            Console.WriteLine(i);
        }
    );
}

如果我没有错的话，这种方法与函数式编程实践非常相关。我说得对吗？

C#允许您将属性setter方法添加到实现只读接口财产的具体类型中，即使接口声明本身没有属性setter。例如：

public interface IReadOnlyFoo
{
   object SomeReadOnlyProperty { get; }
}

具体类如下所示：

internal class Foo : IReadOnlyFoo
{
   public object SomeReadOnlyProperty { get; internal set; }
}

有趣的是，如果将Foo类强制转换为IReadOnlyFoo接口，则它是不可变的：

// Create a Foo instance
Foo foo = new Foo();

// This statement is legal
foo.SomeReadOnlyProperty = 12345;

// Make Foo read only
IReadOnlyFoo readOnlyFoo = foo;

// This statement won't compile
readOnlyFoo.SomeReadOnlyProperty = 54321;

我只是想复制没有注释的代码。因此，诀窍是只需按下Alt按钮，然后突出显示您喜欢的矩形。（例如下文）。

protected void GridView1_RowCommand(object sender, GridViewCommandEventArgs e)
    {
        //if (e.CommandName == "sel")
        //{
        //    lblCat.Text = e.CommandArgument.ToString();
        //}
    }

在上面的代码中，如果我想选择：

e.CommandName == "sel"

lblCat.Text = e.Comman

然后，我按下ALt键并选择矩形，无需取消注释线条。

看看这个。

C#+CLR：

Thread.MemoryBarrier：大多数人不会使用它，MSDN上有一些不准确的信息。但如果您了解复杂性，那么您可以进行漂亮的无锁同步。volatile、Thread.volatile阅读、Thread.Wolatile写作：很少有人能够使用这些工具，更没有人能够理解他们避免和引入的所有风险：）。ThreadStatic变量：在过去几年中，我发现只有一种情况是ThreadStatic绝对是天赐的，是不可或缺的。例如，当您想为整个呼叫链做一些事情时，它们非常有用。fixed关键字：当您想以几乎与C++一样快的速度访问大型数组的元素时，这是一个隐藏的武器（默认情况下，C#强制执行绑定检查，以降低速度）。default（typeName）关键字也可以在泛型类之外使用。创建结构的空副本很有用。我使用的一个方便的特性是DataRow[columnName].ToString（）总是返回非空值。若数据库中的值为NULL，则得到空字符串。当您希望开发人员注意时，即使尚未启用异常自动中断，也可以使用调试器对象自动中断：

#if DEBUG  
    if (Debugger.IsAttached)  
        Debugger.Break();  
#endif

您可以对复杂的难看的泛型类型进行别名，这样就不必反复复制粘贴它们。您还可以在一个位置对该类型进行更改。例如

    using ComplicatedDictionary = Dictionary<int, Dictionary<string, object>>;
    ComplicatedDictionary myDictionary = new ComplicatedDictionary();

需要返回空IEnumerable？

public IEnumerable<T> GetEnumerator(){
  yield break;
}

工厂方法的类型推断

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

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

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

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

我喜欢EditorBrowsebleAttribute。它允许您控制是否在Intellisense中显示方法/属性。可以将值设置为“始终”、“高级”或“从不”。

从MSDN。。。

评论

EditorBrowsebleAttribute是对设计器的提示，指示是否要显示属性或方法。您可以在可视化设计器或文本编辑器中使用此类型来确定用户可见的内容。例如，Visual Studio中的IntelliSense引擎使用此属性来确定是否显示属性或方法。

在Visual C#中，可以使用“工具”|“选项”|“文本编辑器”| C#下的“隐藏高级成员”设置来控制高级财产何时显示在IntelliSense和“财产窗口”中。相应的EditorBrowsebleState为Advanced。

轻松确定声明变量的类型（根据我的回答）：

using System;
using System.Collections.Generic;

static class Program
{
    public static Type GetDeclaredType<T>(T x)
    {
        return typeof(T);
    }

    // Demonstrate how GetDeclaredType works
    static void Main(string[] args)
    {
        IList<string> iList = new List<string>();
        List<string> list = null;

        Console.WriteLine(GetDeclaredType(iList).Name);
        Console.WriteLine(GetDeclaredType(list).Name);
    }
}

结果：

IList`1
List`1

及其名称（借用自“Get variable name”）：

static void Main(string[] args)
{
    Console.WriteLine("Name is '{0}'", GetName(new {args}));
    Console.ReadLine();
}

static string GetName<T>(T item) where T : class
{
    var properties = typeof(T).GetProperties();
    return properties[0].Name;
}

结果：名称为“args”

将枚举值转换为字符串值

给定枚举

enum Country
{
    UnitedKingdom, 
    UnitedStates,
    UnitedArabEmirates,
}

使用它：

public static void PrintEnumAsString( Country country )
{
    Console.Writeline( country.ToString() );
}

将枚举值的名称打印为字符串，例如“UnitedKingdom”

我发现只有少数开发人员知道这个特性。

如果您需要一个通过某个接口（由该值类型实现）与值类型变量一起工作的方法，那么在方法调用期间很容易避免装箱。

示例代码：

using System;
using System.Collections;

interface IFoo {
    void Foo();
}
struct MyStructure : IFoo {
    public void Foo() {
    }
}
public static class Program {
    static void MethodDoesNotBoxArguments<T>(T t) where T : IFoo {
        t.Foo();
    }
    static void Main(string[] args) {
        MyStructure s = new MyStructure();
        MethodThatDoesNotBoxArguments(s);
    }
}

IL代码不包含任何方框说明：

.method private hidebysig static void  MethodDoesNotBoxArguments<(IFoo) T>(!!T t) cil managed
{
  // Code size       14 (0xe)
  .maxstack  8
  IL_0000:  ldarga.s   t
  IL_0002:  constrained. !!T
  IL_0008:  callvirt   instance void IFoo::Foo()
  IL_000d:  ret
} // end of method Program::MethodDoesNotBoxArguments

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       15 (0xf)
  .maxstack  1
  .locals init ([0] valuetype MyStructure s)
  IL_0000:  ldloca.s   s
  IL_0002:  initobj    MyStructure
  IL_0008:  ldloc.0
  IL_0009:  call       void Program::MethodDoesNotBoxArguments<valuetype MyStructure>(!!0)
  IL_000e:  ret
} // end of method Program::Main

参见Richter，J.CLR via C#，第2版，第14章：接口，关于泛型和接口约束的章节。

另见我对另一个问题的回答。

我能想到的一对：

[field: NonSerialized()]
public EventHandler event SomeEvent;

这将防止事件被串行化。“field:”表示属性应应用于事件的支持字段。

另一个鲜为人知的功能是重写添加/删除事件处理程序：

public event EventHandler SomeEvent
{
    add
    {
        // ...
    }

    remove
    {
        // ...
    }
}

__arglist也是

[DllImport("msvcrt40.dll")]
public static extern int printf(string format, __arglist);

static void Main(string[] args)
{
   printf("Hello %s!\n", __arglist("Bart"));
}

字典初始化器对于需要硬编码某些数据的快速黑客和单元测试总是有用的。

var dict = new Dictionary<int, string> { { 10, "Hello" }, { 20, "World" } };

Action和Func委托助手与lambda方法结合使用。我将这些用于需要委托以提高可读性的简单模式。例如，一个简单的缓存模式是检查请求的对象是否存在于缓存中。如果它确实存在：返回缓存的对象。如果不存在，则生成新实例，缓存新实例并返回新实例。我可以编写一个简单的模式方法，比如这样。。。

private static T CachePattern<T>(string key, Func<T> create) where T : class
{
    if (cache[key] == null)
    {
        cache.Add(key, create());
    }

    return cache[key] as T;
}

…然后，通过在自定义缓存管理器中使用以下内容，我可以大大简化缓存获取/设置代码

public static IUser CurrentUser
{
    get
    {
        return CachePattern<IUser>("CurrentUserKey", () => repository.NewUpUser());
    }
}

现在，简单的“日常”代码模式可以编写一次，并且可以更容易地重用IMHO。我不必编写委托类型，也不必弄清楚我想如何实现回调等。如果我能在10秒内编写它，我就不太适合于剪切/粘贴简单的代码模式，无论它们是懒惰初始化还是上面显示的其他示例。。。

“TODO”属性和任务列表

//TODO: [something] 

将其添加到代码中（间距很重要）会在任务列表中抛出一个项目，双击该项目会将您跳转到代码中的适当位置。

我不知道泛型方法有助于避免使用方法重载。下面是打印int和double数字的重载方法。

    private static void printNumbers(int [] intNumbers)
    { 
        foreach(int element in intNumbers)
        {
            Console.WriteLine(element);
        }

    }

    private static void printNumbers(double[] doubleNumbers)
    {
        foreach (double element in doubleNumbers)
        {
            Console.WriteLine(element);
        }
    }

泛型方法，有助于为上述两种方法提供一种方法

    private static void printNumbers<E>(E [] Numbers)
    {
        foreach (E element in Numbers)
        {
            Console.WriteLine(element);
        }
    }

连接？到一个类型可为null，例如：int？“c:\dir”而不是@“c:\dir”

使用LINQ使眼睛更容易/精简ORM映射

考虑下表：

[MessageId] INT,
[MessageText] NVARCHAR(MAX)
[MessageDate] DATETIME

…这种结构：

struct Message
{
    Int32 Id;
    String Text;
    DateTime Date;
}

而不是像这样做：

List<Message> messages = new List<Message>();

foreach (row in DataTable.Rows)
{
    var message = new Message
    {
        Id = Convert.ToInt32(row["MessageId"]),
        Text = Convert.ToString(row["MessageText"]),
        Date = Convert.ToDateTime(row["MessageDate"])
    };

    messages.Add(message);
}

在我看来，你可以使用LINQ，用更少的代码行做同样的事情；更时尚。像这样：

var messages = DataTable.AsEnumerable().Select(r => new Message
{
    Id = Convert.ToInt32(r["MessageId"]),
    Text = Convert.ToString(r["MessageText"]),
    Date = Convert.ToDateTime(r["MessageDate"])
}).ToList();

这种方法可以是嵌套的，就像循环一样。

读完这本书的全部9页后，我觉得我必须指出一个不为人知的特点。。。

对于.NET 1.1，这是正确的，对gzip文件使用压缩/解压缩，必须：

下载ICSharpCode.ZipLib或者，将Java库引用到项目中，并使用Java的内置库来利用GZip的压缩/解压缩方法。

它没有得到充分利用，这是我不知道的，（仍然使用ICSharpCode.ZipLib，即使在.NET 2/3.5中也是如此）它被合并到了标准BCL版本2以上的System.IO.Compression命名空间中。。。请参见MSDN页面“GZipStream类”。

我发现在VisualStudio中使用条件中断函数非常有用。我喜欢这样的方式，它允许我将值设置为某些值，例如，只有在少数情况下才能满足这些值，然后我可以进一步检查代码。

不知道这本身是否是秘密，但我喜欢System.Linq中添加的Enumerable（添加到IEnumerable）类。

http://msdn.microsoft.com/en-us/library/system.linq.enumerable_members.aspx

而yield关键字已列出。迭代器块非常惊人。我用它们来构建列表，这些列表将被测试，以确定它们是否是联合素数。它基本上允许您遍历一个逐个返回值的函数，并随时停止。

哦，当你不能再优化它时，我几乎忘记了世界上最好的课程。后台工作人员！！！！

http://msdn.microsoft.com/en-us/library/system.componentmodel.backgroundworker.aspx

我找不到任何使用字符串的人。请使用分隔符连接字符串。每个人都在写同样丑陋的for循环

var sb = new StringBuilder();
var count = list.Count();
for(int i = 0; i < count; i++)
{
  if (sb.Length > 0) sb.Append(seperator);
  sb.Append(list[i]);
}

return sb.ToString();

而不是

return string.Join(separator, list.ToArray());

通过yield获取IEnumerable的另一种方法，无需显式创建IEnumeraable对象

public IEnumerable<Request> SomeMethod(IEnumerable<Request> requests)
{
    foreach (Request request in requests)
       yield return DoSomthing(request);
}

我只想提一下（因为在T:struct的地方出现了OP），C#编译器的一个缺点是

where T : Enum

不会编译。它抛出错误“约束不能是特殊类”System.Enum“”。

对象初始化器中的集合初始化器：

MailMessage mail = new MailMessage {
   To = { new MailAddress("a@example.com"), new MailAddress("b@example.com") },
   Subject = "Password Recovery"
};

可以在单个表达式中初始化整个树。

我在这次谈话中有些晚了，我想贡献以下内容。对于一些开发人员来说，这可能是一件新鲜事。

public class User
{
    public long UserId { get; set; }
    public String Name { get; set; }
    public String Password { get; set; }
    public String Email { get; set; }
}

声明和初始化它的通常方法是使用构造函数或类似的方法。

User user = new User();
user.UserId = 1;
user.Name = "myname";
etc

但我学会了以下方法来初始化它。我知道Visual Basic开发人员会喜欢它，因为它就像只在VB.NET中而不是在C#中提供的运算符一样，如下所示。

User user = new User()
{
    UserId = 1,
    Name = "myname",
    Email = "myemail@domain.com",
    Password = "mypassword"
};

可以在枚举中存储颜色。

public enum MyEnumColors : uint
{
    Normal          = 0xFF9F9F9F,
    Active          = 0xFF8EA98A,
    Error           = 0xFFFF0000
}

使用Delegate.CreateDelegate调用私有方法的技巧非常简单。

var subject = new Subject();
var doSomething = (Func<String, String>)
    Delegate.CreateDelegate(typeof(Func<String, String>), subject, "DoSomething");
Console.WriteLine(doSomething("Hello Freggles"));

这是一个有用的上下文

我不知道这是否是隐藏功能（“”）。任何字符串函数。

要使用LINQ测试IEnumerable＜T＞是否为空，请使用：

IEnumerable＜T＞.Any（）；

起初，我使用（IEnumerable＜T＞.Count（）！=0)...这不必要地导致枚举IEnumerable＜T＞中的所有项。作为对此的改进，我继续使用（IEnumerable＜T＞.FirstOrDefault（）==null）。。。哪个更好。。。但是IEnumerable<T>.Any（）是最简洁的，并且性能最好。

大多数P/Invoke内容都有点奇怪。

属性示例：

[DllImport ("gdi32.dll")] 
[return : MarshalAs(UnmanagedType.I4)]
[StructLayout(LayoutKind.Sequential)]

允许使用带大括号的空块。

你可以这样写代码

{
    service.DoTonsOfWork(args);
}

当你想尝试一些没有使用或尝试的东西时，这是很有帮助的。。。最后，你已经写好了。

//using(var scope = new TransactionScope)
{
    service.DoTonsOfWork(args);
}

Visual Studio最有用的功能之一是“生成对象id”。它生成一个id并“附加”到对象，因此无论您在何处查看对象，都会看到该id（无论线程如何）。

调试时，右键单击变量工具提示，即可看到它。它也适用于watched/autos/locals变量。

在FlagAttribute和enum中使用“~”运算符有时我们会将Flag属性与enum一起使用，以对枚举执行逐位操作。

 [Flags]
 public enum Colors
 {
    None  = 0,
    Red   = 1,
    Blue  = 2,
    White = 4,
    Black = 8,
    Green = 16,
    All   = 31 //It seems pretty bad...
 }

注意，enum中选项“All”的值非常奇怪。相反，我们可以使用带有标记枚举的“~”运算符。

 [Flags]
 public enum Colors
 {
    None  = 0,
    Red   = 1,
    Blue  = 2,
    White = 4,
    Black = 8,
    Green = 16,
    All   = ~0 //much better now. that mean 0xffffffff in default.
 }

使用LINQ，可以根据参数创建新函数。如果你有一个非常经常执行的小函数，这很好，但是参数需要一些时间来计算。

    public Func<int> RandomGenerator
    {
        get
        {
            var r = new Random();
            return () => { return r.Next(); };
        }
    }

    void SomeFunction()
    {
        var result1 = RandomGenerator();

        var x = RandomGenerator;
        var result2 = x();
    }

任意嵌套作用域｛｝

1.对于更精细的范围界定行为

｛成员内部的任何位置｝，｛仅使用大括号｝，｝不使用控制语句｝。

void MyWritingMethod() {

    int sameAge = 35;


    { // scope some work
        string name = "Joe";
        Log.Write(name + sameAge.ToString());
    }


    { // scope some other work
        string name = "Susan";
        Log.Write(name + sameAge.ToString());
    }

    // I'll never mix up Joe and Susan again
}

在大型、混乱或过时的成员（但它们不应该存在）中，它帮助我防止使用错误的变量名。将内容范围扩大到更精细的级别。

2.用于代码美化或视觉语义

例如，此XML编写代码遵循实际生成的XML的缩进级别（即Visual Studio将相应地缩进范围大括号）

XmlWriter xw = new XmlWriter(..);

//<root>
xw.WriteStartElement("root");
{
    //<game>
    xw.WriteStartElement("game");
    {
        //<score>#</score>
        for (int i = 0; i < scores.Length; ++i) // multiple scores
            xw.WriteElementString("score", scores[i].ToString());

    }
    //</game>
    xw.WriteEndElement();
}
//</root>
xw.WriteEndElement();

3.模仿“with”语句

（另一种用途是将临时工作排除在主要范围之外）Patrik提供：有时用于模仿C#中的VB“with语句”。

var somePerson = this.GetPerson();  // whatever 
{ 
    var p = somePerson; 
    p.FirstName = "John"; 
    p.LastName = "Doe"; 
    //... 
    p.City = "Gotham"; 
} 

对于有眼光的程序员。

可以使用以下方法更改舍入方案：

var value = -0.5;
var value2 = 0.5;
var value3 = 1.4;

Console.WriteLine( Math.Round(value, MidpointRounding.AwayFromZero) ); //out: -1
Console.WriteLine(Math.Round(value2, MidpointRounding.AwayFromZero)); //out: 1
Console.WriteLine(Math.Round(value3, MidpointRounding.ToEven)); //out: 1

这与静态构造函数有关。这是一种执行静态销毁的方法（即当程序退出时清理资源）。

第一堂课：

class StaticDestructor
{
    /// <summary>
    /// The delegate that is invoked when the destructor is called.
    /// </summary>
    public delegate void Handler();
    private Handler doDestroy;

    /// <summary>
    /// Creates a new static destructor with the specified delegate to handle the destruction.
    /// </summary>
    /// <param name="method">The delegate that will handle destruction.</param>
    public StaticDestructor(Handler method)
    {
        doDestroy = method;
    }

    ~StaticDestructor()
    {
        doDestroy();
    }
}

然后，作为类的成员，您希望使用“静态析构函数”：

private static readonly StaticDestructor destructor = new StaticDestructor
(
    delegate()
    {
        //Cleanup here
    }
);

现在，当最终垃圾收集发生时，将调用此函数。如果您确实需要释放某些资源，这很有用。

表现出这种行为的快速而肮脏的程序：

using System;

namespace TestStaticDestructor
{
    class StaticDestructor
    {
        public delegate void Handler();
        private Handler doDestroy;

        public StaticDestructor(Handler method)
        {
            doDestroy = method;
        }

        ~StaticDestructor()
        {
            doDestroy();
        }
    }

    class SomeClass
    {
        static SomeClass()
        {
            Console.WriteLine("Statically constructed!");
        }

        static readonly StaticDestructor destructor = new StaticDestructor(
            delegate()
            {
                Console.WriteLine("Statically destructed!");
            }
        );
    }

    class Program
    {
        static void Main(string[] args)
        {
            SomeClass someClass = new SomeClass();
            someClass = null;
            System.Threading.Thread.Sleep(1000);
        }
    }
}

当程序退出时，调用“静态析构函数”。

Nullable.GetValueOrDefault？

我喜欢

#if DEBUG
           //Code run in debugging mode

#else
           //Code run in release mode

#endif

关于帖子w/perma链接“隐藏的C#特性？”，还有另一种方法可以实现同样的效果-缩进/换行。看看这个。。

XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
xmlWriterSettings.NewLineOnAttributes = true;
xmlWriterSettings.Indent = true;


XmlWriter xml = XmlWriter.Create(@"C:\file.xml", xmlWriterSettings);

// Start writing the data using xml.WriteStartElement(), xml.WriteElementString(...), xml.WriteEndElement() etc

我不确定这是否是一个未知的特性！

IOobservable怎么样？

几乎每个人都知道IEnumerable，但他们的数学对偶似乎是未知的IOobservable。可能是因为它是.NET4。

它所做的不是拉取信息（像可枚举的），而是将信息推送给观察者的订阅者。

与Rx扩展一起，它将改变我们处理事件的方式。为了说明它有多强大，请查看这里的一个非常简短的示例。

当类实现INotifyPropertyChanged，并且您希望通知绑定系统（WPF、Silverlight等）一个对象（ViewModel）的多个绑定财产已更改时，可以使用null或String.Empty引发PropertyChanged-Event。

MSDN中记录了这一点，但代码示例和文章通常不会解释这种可能性。我发现它非常有用。

public class BoundObject : INotifyPropertyChanged {

    private int _value;
    private string _text;

    public event PropertyChangedEventHandler PropertyChanged;

    public int Value {
        get {
            return _value;
        }
        set {
            if (_value != value) {
                _value = value;
                OnPropertyChanged("Value");
            }
        }
    }

    public string Text {
        get {
            return _text;
        }
        set {
            if (_text != value) {
                _text = value;
                OnPropertyChanged("Text");
            }
        }
    }

    public void Init(){
        _text = "InitialValue";
        _value = 1;
        OnPropertyChanged(string.Empty);
    }

    public void Reset() {
        _text = "DefaultValue";
        _value = 0;
        OnPropertyChanged(string.Empty);
    }

    private void OnPropertyChanged(string propertyName) {
        PropertyChangedEventArgs e = new PropertyChangedEventArgs(propertyName);

        if (PropertyChanged != null) {
            PropertyChanged(this, e);
        }
    }
}

这意味着T必须有一个公共的无参数构造函数：

 class MyClass<T> where T : new()
 {

 }

我正在阅读《Pro ASP.NET MVC Framework》（APress）一书，并观察到作者对我陌生的Dictionary对象所做的一些事情。

他在没有使用Add（）方法的情况下添加了一个新的键/值对。然后，他重写了相同的键/值对，而不必检查该键是否已经存在。例如：

Dictionary<string, int> nameAgeDict = new Dictionary<string, int>();
nameAgeDict["Joe"] = 34;      // no error. will just auto-add key/value
nameAgeDict["Joe"] = 41;      // no error. key/value just get overwritten
nameAgeDict.Add("Joe", 30);   // ERROR! key already exists

在很多情况下，我不需要检查字典是否已经有一个键，我只想添加相应的键/值对（如有必要，覆盖现有的键/值对）。在发现之前，我总是要在添加之前检查键是否已经存在。

根据周围类的泛型类型分离静态字段。

    public class StaticConstrucEx2Outer<T> {

 // Will hold a different value depending on the specicified generic type
 public T SomeProperty { get; set; }

 static StaticConstrucEx2Outer() {
  Console.WriteLine("StaticConstrucEx2Outer " + typeof(T).Name);
 }

 public class StaticConstrucEx2Inner<U, V> {

  static StaticConstrucEx2Inner() {

   Console.WriteLine("Outer <{0}> : Inner <{1}><{2}>",
    typeof(T).Name,
    typeof(U).Name,
    typeof(V).Name);
  }

  public static void FooBar() {}
 }

 public class SCInner {

  static SCInner() {
   Console.WriteLine("SCInner init <{0}>", typeof(T).Name);
  }

  public static void FooBar() {}
 }
}


StaticConstrucEx2Outer<int>.StaticConstrucEx2Inner<string, DateTime>.FooBar();
StaticConstrucEx2Outer<int>.SCInner.FooBar();

StaticConstrucEx2Outer<string>.StaticConstrucEx2Inner<string, DateTime>.FooBar();
StaticConstrucEx2Outer<string>.SCInner.FooBar();

StaticConstrucEx2Outer<string>.StaticConstrucEx2Inner<string, Int16>.FooBar();
StaticConstrucEx2Outer<string>.SCInner.FooBar();

StaticConstrucEx2Outer<string>.StaticConstrucEx2Inner<string, UInt32>.FooBar();

StaticConstrucEx2Outer<long>.StaticConstrucEx2Inner<string, UInt32>.FooBar();

将产生以下输出

Outer <Int32> : Inner <String><DateTime>
SCInner init <Int32>

Outer <String> : Inner <String><DateTime>
SCInner init <String>

Outer <String> : Inner <String><Int16>

Outer <String> : Inner <String><UInt32>

Outer <Int64> : Inner <String><UInt32>

好的，这看起来很明显，但我想提到Object.Equals方法（静态方法，有两个参数）。

我敢肯定，很多人甚至不知道它，或者忘记它就在那里，但在某些情况下，它确实会有所帮助。例如，当您想比较两个对象是否相等时，不知道它们是否为空。你写过多少次这样的东西：

if ((x == y) || ((x != null && y != null) && x.Equals(y)))
{
    ...
}

当你可以写：

if (Object.Equals(x, y))
{
    ...
}

（Object.Equals实际上与第一个代码示例中的实现完全相同）

string.Format（）中的宽度

Console.WriteLine("Product: {0,-7} Price: {1,5}", product1, price1);
Console.WriteLine("Product: {0,-7} Price: {1,5}", product2, price2);

生产

来自Prabir的博客|隐藏的C#功能

最近我了解了String.Join方法。当构建字符串（如列）以供查询选择时，它非常有用。

类型定义

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

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

并声明为

ListOfDictionary list = new ListOfDictionary();

下面是C#4.0中字符串类的一个新方法：

String.IsNullOrWhiteSpace(String value)

是时候了。

不是很隐蔽，但很有用。当你有一个带有标志的枚举时，你可以使用shift left来使事情更清楚。例如

[Flags]
public enum ErrorTypes {
    None              = 0,
    MissingPassword   = 1 << 0,
    MissingUsername   = 1 << 1,
    PasswordIncorrect = 1 << 2 
}

关于事件处理程序的另一个注意事项：您可以简单地创建一个raise扩展方法，如下所示：

public static class EventExtensions {
    public static void Raise<T>(this EventHandler<T> @event, 
                                object sender, T args) where T : EventArgs {
        if(@event!= null) {
            @event(sender, args);
        }
    }
}

然后可以使用它引发事件：

public class MyImportantThing {
    public event EventHandler<MyImportantEventEventArgs> SomethingHappens;
    ...
    public void Bleh() {
        SomethingHappens.Raise(this, new MyImportantEventEventArgs { X=true });
    }
}

此方法的另一个优点是强制执行编码标准（使用EventHandler＜＞）。

一次又一次地编写相同的精确函数是没有意义的。也许下一个版本的C#最终会有一个InlineAttribute，它可以放在扩展方法上，并使编译器内联方法定义（这将使这种方式接近标准，而且速度最快）。

编辑：基于注释删除扩展方法中的临时变量

调试时，您可以在Watch\QuickWatch\Immediate窗口中键入$exception，并获取当前帧异常的所有信息。如果你打开了第一次机会例外，这非常有用！

我不宽恕它，但我很惊讶后藤仍然围绕着鸭子飞来的炮弹

RealProxy允许您为现有类型创建自己的代理。

这是非常先进的，我没有见过其他人使用它——这可能意味着它对大多数人来说真的没有那么有用——但这是值得了解的事情之一。

基本上，.NET RealProxy类允许您创建另一种类型的透明代理。在这种情况下，透明意味着它看起来完全像客户端的代理目标对象——但实际上不是：它是从RealProxy派生的类的实例。

这使您可以在客户端和在实际目标对象上调用的任何方法或财产之间应用强大而全面的拦截和“中介”服务。将此功能与工厂模式（IoC等）结合起来，您可以将透明代理而不是真实对象交回，从而允许您拦截对真实对象的所有调用，并在每次方法调用前后执行操作。事实上，我相信这正是.NET用于跨应用程序域、进程和计算机边界远程处理的功能：.NET拦截所有访问，向远程对象发送序列化信息，接收响应，并将其返回到代码。

也许有一个例子可以说明这是如何有用的：我为我作为企业架构师的最后一份工作创建了一个参考服务堆栈，它指定了部门内任何新WCF服务的标准内部组合（“堆栈”）。该模型要求Foo服务的数据访问层实现IDAL＜Foo＞：创建Foo，读取Foo，更新Foo，删除Foo。服务开发人员使用（来自我的）提供的公共代码来定位和加载服务所需的DAL：

IDAL<T> GetDAL<T>(); // retrieve data access layer for entity T

该公司的数据访问策略常常受到性能挑战。作为一名架构师，我不能监督每一个服务开发人员，以确保他/她编写了一个高性能的数据访问层。但我在GetDAL工厂模式中可以做的是为请求的DAL创建一个透明的代理（一旦公共服务模型代码找到了DLL并加载了它），并使用高性能计时API来配置对DAL的任何方法的所有调用。然后，对落后者进行排名只是按照总时间降序排序DAL呼叫计时的问题。与开发评测（例如在IDE中）相比，这种评测的优势在于它也可以在生产环境中进行，以确保SLA。

下面是我为“实体分析器”编写的测试代码示例，这是用一行为任何类型创建分析代理的常见代码：

[Test, Category("ProfileEntity")]
public void MyTest()
{
    // this is the object that we want profiled.
    // we would normally pass this around and call
    // methods on this instance.
    DALToBeProfiled dal = new DALToBeProfiled();

    // To profile, instead we obtain our proxy
    // and pass it around instead.
    DALToBeProfiled dalProxy = (DALToBeProfiled)EntityProfiler.Instance(dal);

    // or...
    DALToBeProfiled dalProxy2 = EntityProfiler<DALToBeProfiled>.Instance(dal);

    // Now use proxy wherever we would have used the original...
    // All methods' timings are automatically recorded
    // with a high-resolution timer
    DoStuffToThisObject(dalProxy);

    // Output profiling results
    ProfileManager.Instance.ToConsole();
}

同样，这让您可以截获客户端对目标对象调用的所有方法和财产！在RealProxy派生类中，必须重写Invoke：

[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
[SecurityPermission(SecurityAction.LinkDemand, 
    Flags = SecurityPermissionFlag.Infrastructure)] // per FxCop
public override IMessage Invoke(IMessage msg)
{
    IMethodCallMessage msgMethodCall = msg as IMethodCallMessage;
    Debug.Assert(msgMethodCall != null); // should not be null - research Invoke if this trips. KWB 2009.05.28

    // The MethodCallMessageWrapper
    // provides read/write access to the method 
    // call arguments. 
    MethodCallMessageWrapper mc =
        new MethodCallMessageWrapper(msgMethodCall);

    // This is the reflected method base of the called method. 
    MethodInfo mi = (MethodInfo)mc.MethodBase;

    IMessage retval = null;

    // Pass the call to the method and get our return value
    string profileName = ProfileClassName + "." + mi.Name;

    using (ProfileManager.Start(profileName))
    {
        IMessage myReturnMessage =
           RemotingServices.ExecuteMessage(_target, msgMethodCall);

        retval = myReturnMessage;
    }

    return retval;
}

.NET的功能是不是很迷人？唯一的限制是目标类型必须从MarshalByRefObject派生。我希望这对某人有帮助。

同样有用，但不常用：约束执行区域。

BCL团队博客中的一句话：

受限执行区域（CER）存在以帮助开发人员编写代码以保持一致性。CLR不能保证开发商代码正确，但CLR正确提升所有运行时引发的故障点（即异步异常）在代码运行之前，或在它完成之后。与…结合对开发人员能力的限制加入CER，这是一种有用的方法对是否执行代码。CER的准备得很好，这意味着当我们看到一个时，我们会迫不及待地JIT在其中找到的任何代码静态可发现的调用图。如果CLR的主机关心堆栈溢出，我们将探测一些数量堆栈空间（尽管可能没有足够的堆栈空间任意方法*）。我们也会延迟线程中止，直到CER已完成运行。

当以原子方式编辑数据结构的多个字段时，它非常有用。因此，对对象进行事务处理是有帮助的。

而且CriticalFinalizerObject似乎是隐藏的（至少是那些没有编写不安全代码的人）。CriticalFinalizerObject保证垃圾收集将执行终结器。分配后，终结器及其调用图将提前准备好。

AppDomain.UnhandledException事件也可能隐藏。

此事件提供未捕获异常的通知。它允许应用程序在系统默认处理程序向用户报告异常并终止应用程序之前记录有关异常的信息。如果有关应用程序状态的足够信息可用，则可以执行其他操作，例如保存程序数据以备以后恢复。建议谨慎，因为如果不处理异常，程序数据可能会损坏。

我们可以看到，即使在这个网站上，很多人都在想为什么他们的应用程序没有启动，为什么会崩溃等等。AppDomain.UnhandledException事件对于这种情况非常有用，因为它至少可以记录应用程序失败的原因。

string.Empty

我知道这不是异想天开（可笑的奇怪），但我一直用它代替“”。

在有人告诉它在那里之前，它是相当隐蔽的。

固定报表

此语句防止垃圾收集器重新定位可移动变量。Fixed也可用于创建固定大小的缓冲区。

fixed语句设置一个指向托管变量的指针，并在语句执行期间“固定”该变量。

斯塔卡尔洛克

stackalloc在堆栈上分配一块内存。

可以将多个属性放在一对方括号中：

    [OperationContract, ServiceKnownType(typeof(Prism)), ServiceKnownType(typeof(Cuboid))]
    Shape GetShape();

不确定是否有人提到过这一点（11页！！）

但是，当您对要序列化的类/对象进行版本控制时，类的OptionalField属性非常令人惊讶。

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

通过从匿名方法访问本地变量，您可以使用新的控制流逻辑包装任何代码，而不必将该代码分解到另一个方法中。方法外部声明的局部变量在方法内部可用，例如以下示例中的endOfLineChar局部变量：

http://aaronls.wordpress.com/2010/02/02/retrying-on-exception-conditionally/

您可以将受保护的访问器和内部访问器组合起来，使其在同一程序集中公开，但在不同的程序集中受保护。这可以用于字段、财产、方法甚至常量。