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

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

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

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”的这个小技巧使它真正起作用。

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

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

要调用基类构造函数，只需将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（）就可以调用基类的方法

表达式

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

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

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

真、假、文件未找到？