C# 编码约定

Posted 2020-08-22 Different life，the same belief

参考自 MSDN     https://msdn.microsoft.com/zh-cn/library/ff926074.aspx ， 只摘要个人觉得有用部分

命名约定

在不包括 using 指令的短示例中，使用命名空间限定。 如果你知道命名空间默认导入项目中，则不必完全限定来自该命名空间的名称。 如果对于单行来说过长，则可以在点 (.) 后中断限定名称，如下面的示例所示

 

var currentPerformanceCounterCategory = new System.Diagnostics.
                PerformanceCounterCategory();

语言准则

String 数据类型

 

• 使用 + 运算符来连接短字符串，如下面的代码所示。

 

string displayName = nameList[n].LastName + ", " + nameList[n].FirstName;

若要在循环中追加字符串，尤其是在使用大量文本时，请使用 StringBuilder 对象。

 

  var phrase = "lalalalalalalalalalalalalalalalalalalalalalalalalalalalalala";
  var manyPhrases = new StringBuilder();
  for (var i = 0; i < 10000; i++)
  {
      manyPhrases.Append(phrase);
  }

 

隐式类型的局部变量

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

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

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

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

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

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

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

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

数组

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

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

委托

使用简洁的语法来创建委托类型的实例。

// First, in class Program, define the delegate type and a method that  
        // has a matching signature.

        // Define the type.
        public delegate void Del(string message);

        // Define a method that has a matching signature.
        public static void DelMethod(string str)
        {
            Console.WriteLine("DelMethod argument: {0}", str);
        }

            // In the Main method, create an instance of Del.

            // Preferred: Create an instance of Del by using condensed syntax.
            Del exampleDel2 = DelMethod;

            // The following declaration uses the full syntax.
            Del exampleDel1 = new Del(DelMethod);

异常处理中的 try-catch 和 using 语句

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

 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 语句代替。

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

&& 和 || 运算符

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

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

New 运算符

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

var instance1 = new ExampleClass();

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

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

 

事件处理

如果你正定义一个稍后不需要删除的事件处理程序，请使用 lambda 表达式。

public Form2()
        {
            // You can use a lambda expression to define an event handler.
            this.Click += (s, e) =>
                {
                    MessageBox.Show(
                        ((MouseEventArgs)e).Location.ToString());
                };
        }

静态成员

• 通过使用类名称调用静态成员：ClassName.StaticMember。 这种做法通过明确静态访问使代码更易于阅读。 请勿使用派生类的名称限定基类中定义的静态成员。 编译该代码时，代码可读性具有误导性，如果向派生类添加具有相同名称的静态成员，代码可能会被破坏

LINQ 查询

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

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

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

            var seattleCustomers2 = from cust in customers

                                             where cust.City == "Seattle"

                                             orderby cust.Name

                                             select cust;

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

 

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