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

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

__arglist也是

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

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

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

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

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

混合是一个很好的功能。基本上，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;
  }
}

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