当变量类型明显来自赋值的右侧时，或者当精度类型不重要时，请对本地变量进行隐式类型化。
    C#

    // When the type of a variable is clear from the context, use var 
    // in the declaration.
    var var1 = "This is clearly a string.";
    var var2 = 27;
    var var3 = Convert.ToInt32(Console.ReadLine());

    当类型并非明显来自赋值的右侧时，请勿使用 var。
    C#

    // When the type of a variable is not clear from the context, use an
    // explicit type.
    int var4 = ExampleClass.ResultSoFar();

    请勿依靠变量名称来指定变量的类型。  它可能不正确。  
    C#

    // Naming the following variable inputInt is misleading. 
    // It is a string.
    var inputInt = Console.ReadLine();
    Console.WriteLine(inputInt);

    避免使用 var 来代替 dynamic。

    使用隐式类型化来确定 for 和 foreach 循环中循环变量的类型。

    下面的示例在 for 语句中使用隐式类型化。
    C#

    var syllable = "ha";
    var laugh = "";
    for (var i = 0; i < 10; i++)
    {
        laugh += syllable;
        Console.WriteLine(laugh);
    }

    下面的示例在 foreach 语句中使用隐式类型化。
    C#

    foreach (var ch in laugh)
    {
        if (ch == ‘h‘)
            Console.Write("H");
        else
            Console.Write(ch);
    }
    Console.WriteLine();

通常，使用 int 而非无符号类型。   int 的使用在整个 C# 中都很常见，并且当你使用 int 时，更易于与其他库交互。  

    当在声明行上初始化数组时，请使用简洁的语法。
    C#

    // Preferred syntax. Note that you cannot use var here instead of string[].
    string[] vowels1 = { "a", "e", "i", "o", "u" };


    // If you use explicit instantiation, you can use var.
    var vowels2 = new string[] { "a", "e", "i", "o", "u" };

    // If you specify an array size, you must initialize the elements one at a time.
    var vowels3 = new string[5];
    vowels3[0] = "a";
    vowels3[1] = "e";
    // And so on.

    对大多数异常处理使用 try-catch 语句。
    C#

    static string GetValueFromArray(string[] array, int index)
    {
        try
        {
            return array[index];
        }
        catch (System.IndexOutOfRangeException ex)
        {
            Console.WriteLine("Index is out of range: {0}", index);
            throw;
        }
    }

    通过使用 C# using 语句简化你的代码。  如果你具有 try-finally 语句（该语句中 finally 块的唯一代码是对 Dispose 方法的调用），请使用 using 语句代替。  
    C#

    // This try-finally statement only calls Dispose in the finally block.
    Font font1 = new Font("Arial", 10.0f);
    try
    {
        byte charset = font1.GdiCharSet;
    }
    finally
    {
        if (font1 != null)
        {
            ((IDisposable)font1).Dispose();
        }
    }


    // You can do the same thing with a using statement.
    using (Font font2 = new Font("Arial", 10.0f))
    {
        byte charset = font2.GdiCharSet;
    }

    若要通过跳过必要的比较来避免异常和提高性能，请在执行比较时使用 && 来代替 &，使用 || 来代替 | ，如下面的示例所示。
    C#

    Console.Write("Enter a dividend: ");
    var dividend = Convert.ToInt32(Console.ReadLine());

    Console.Write("Enter a divisor: ");
    var divisor = Convert.ToInt32(Console.ReadLine());

    // If the divisor is 0, the second clause in the following condition
    // causes a run-time error. The && operator short circuits when the
    // first expression is false. That is, it does not evaluate the
    // second expression. The & operator evaluates both, and causes 
    // a run-time error when divisor is 0.
    if ((divisor != 0) && (dividend / divisor > 0))
    {
        Console.WriteLine("Quotient: {0}", dividend / divisor);
    }
    else
    {
        Console.WriteLine("Attempted division by 0 ends up here.");
    }

    隐式类型化时，请使用对象实例化的简洁形式，如下面的声明所示。
    C#

    var instance1 = new ExampleClass();

    上一行等同于下面的声明。
    C#

    ExampleClass instance2 = new ExampleClass();

    使用对象初始值设定项来简化对象创建。
    C#

    // Object initializer.
    var instance3 = new ExampleClass { Name = "Desktop", ID = 37414, 
        Location = "Redmond", Age = 2.3 };

    // Default constructor and assignment statements.
    var instance4 = new ExampleClass();
    instance4.Name = "Desktop";
    instance4.ID = 37414;
    instance4.Location = "Redmond";
    instance4.Age = 2.3;

    对查询变量使用有意义的名称。  下面的示例为位于西雅图的客户使用 seattleCustomers。  
    C#

    var seattleCustomers = from cust in customers
                           where cust.City == "Seattle"
                           select cust.Name;

    使用别名确保匿名类型的属性名称都使用 Pascal 大小写格式正确大写。
    C#

    var localDistributors =
        from customer in customers
        join distributor in distributors on customer.City equals distributor.City
        select new { Customer = customer, Distributor = distributor };

    如果结果中的属性名称模棱两可，请对属性重命名。  例如，如果你的查询返回客户名称和分销商 ID，而不是在结果中将它们保留为 Name 和 ID，请对它们进行重命名以明确 Name 是客户的名称，ID 是分销商的 ID。  
    C#

    var localDistributors2 =
        from cust in customers
        join dist in distributors on cust.City equals dist.City
        select new { CustomerName = cust.Name, DistributorID = dist.ID };

    在查询变量和范围变量的声明中使用隐式类型化。
    C#

    var seattleCustomers = from cust in customers
                           where cust.City == "Seattle"
                           select cust.Name;

    对齐 from 子句下的查询子句，如上面的示例所示。

    在其他查询子句之前使用 where 子句，以确保后面的查询子句作用于经过减少和筛选的数据集。
    C#

    var seattleCustomers2 = from cust in customers
                            where cust.City == "Seattle"
                            orderby cust.Name
                            select cust;

    使用多行 from 子句代替 join 子句以访问内部集合。  例如，Student 对象的集合可能包含测验分数的集合。  当执行以下查询时，它返回高于 90 的分数，并返回得到该分数的学生的姓氏。  
    C#

    // Use a compound from to access the inner sequence within each element.
    var scoreQuery = from student in students
                     from score in student.Scores
                     where score > 90
                     select new { Last = student.LastName, score };