C# 基本语法

C# 是一种面向对象的编程语言。在面向对象的程序设计方法中，程序由各种相互交互的对象组成。相同种类的对象通常具有相同的类型，或者说，是在相同的 class 中。

例如，以 Rectangle（矩形）对象为例。它具有 length 和 width 属性。根据设计，它可能需要接受这些属性值、计算面积和显示细节。

让我们来看看一个 Rectangle（矩形）类的实现，并借此讨论 C# 的基本语法：

实例

using System;
namespace RectangleApplication
{
    class Rectangle
    {
        // 成员变量
        double length;
        double width;
        public void Acceptdetails()
        {
            length = 4.5;    
            width = 3.5;
        }
        public double GetArea()
        {
            return length * width;
        }
        public void Display()
        {
            Console.WriteLine("Length: {0}", length);
            Console.WriteLine("Width: {0}", width);
            Console.WriteLine("Area: {0}", GetArea());
        }
    }
    
    class ExecuteRectangle
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle();
            r.Acceptdetails();
            r.Display();
            Console.ReadLine();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

Length: 4.5
Width: 3.5
Area: 15.75

using 关键字

在任何 C# 程序中的第一条语句都是：

using System;

using 关键字用于在程序中包含命名空间。一个程序可以包含多个 using 语句。

class 关键字

class 关键字用于声明一个类。

C# 中的注释

注释是用于解释代码。编译器会忽略注释的条目。在 C# 程序中，多行注释以 /* 开始，并以字符 */ 终止，如下所示：

/* This program demonstrates
The basic syntax of C# programming 
Language */

单行注释是用 '//' 符号表示。例如：

}//end class Rectangle    

成员变量

变量是类的属性或数据成员，用于存储数据。在上面的程序中，Rectangle 类有两个成员变量，名为 length 和 width。

成员函数

函数是一系列执行指定任务的语句。类的成员函数是在类内声明的。我们举例的类 Rectangle 包含了三个成员函数： AcceptDetails、GetArea 和 Display。

实例化一个类

在上面的程序中，类 ExecuteRectangle 是一个包含 Main() 方法和实例化 Rectangle 类的类。

标识符

标识符是用来识别类、变量、函数或任何其它用户定义的项目。在 C# 中，类的命名必须遵循如下基本规则：

• 标识符必须以字母、下划线或 @ 开头，后面可以跟一系列的字母、数字（ 0 - 9 ）、下划线（ _ ）、@。
• 标识符中的第一个字符不能是数字。
• 标识符必须不包含任何嵌入的空格或符号，比如 ? - +! # % ^ & * ( ) [ ] { } . ; : " ' / \。
• 标识符不能是 C# 关键字。除非它们有一个 @ 前缀。 例如，@if 是有效的标识符，但 if 不是，因为 if 是关键字。
• 标识符必须区分大小写。大写字母和小写字母被认为是不同的字母。
• 不能与C#的类库名称相同。

C# 关键字

关键字是 C# 编译器预定义的保留字。这些关键字不能用作标识符，但是，如果您想使用这些关键字作为标识符，可以在关键字前面加上 @ 字符作为前缀。

在 C# 中，有些关键字在代码的上下文中有特殊的意义，如 get 和 set，这些被称为上下文关键字（contextual keywords）。

下表列出了 C# 中的保留关键字（Reserved Keywords）和上下文关键字（Contextual Keywords）：

1. static void Main(string[] args)
   {
       Console.WriteLine("A:{0}，a:{1}",65,97);
       Console.ReadLine();
   }

   运行结果：

   A:65，a:97

   当 WriteLine() 函数有多个参数时，输出第一个参数中的内容，而第二个参数中的内容替换掉第一个参数中对应位置的占位符一起输出。

   如果第一个参数没有留占位符,那么第二个参数内容不输出.

   Console.WriteLine("A:,a:",65,97);

   运行结果：

   A:,a:

   占位符从零开始计数,且占位符中的数字不能大于第二个参数的个数减一(要求占位符必须有可替换的值).

   占位符数字与第二个参数字符位置一一对应.

   static void Main(string[] args)
   {
       Console.WriteLine("A:{1}，a:{0}",65,97);
       Console.ReadLine();
   }

   运行结果：

   A:97,a:65

2. C# 中什么叫类的实例化？

   直白地解释就是：通过已有的类（class）创建出该类的一个对象（object），这一过程就叫做类的实例化。

   打个比方：你设计了一个飞机模型，交给工人师傅去加工制作，生产出一个（一批）飞机。飞机模型就相当于程序中的类，生产出来的飞机就是对象，生产飞机这一过程就叫做类的实例化。

   MyPlane  plane1= new MyPlane();        //类的实例化

3. 补充一下 C# 中 // 注释和 /// 注的区别:

   C# 引入了新的 XML 注释，即我们在某个函数前新起一行，输入 ///，VS.Net 会自动增加 XML 格式的注释

   // 不会被编译，而 /// 会被编译

   所以使用 /// 会减慢编译的速度（但不会影响执行速度）

   但使用 /// 会在其它的人调用你的代码时提供智能感知（通常在Form。Designer.cs 窗口会自动生成 /// 注释的程序）举个例子：

   /// <summary>
   /// 必需的设计器变量。  //定义属性，注意该属性为可读可写属性
   /// </summary>

   要注意必须有：

   /// <summary>
   ///
   /// </summary>

4. 一、C# 中 // 注释和 /// 注释的区别

   /// 会被编译， // 不会

   所以使用 /// 会减慢编译的速度（但不会影响执行速度）

   /// 会在其它的人调用你的代码时提供智能感知

   /// 也是一种注释，但是这种注释主要有两种作用：

   •  1.这些注释能够生成一个XML文件。这样呢,看起来会对程序的内容一目了然。
   •  2.以这种方式对你的类，属性，方法等等加上注释之后，当你在其他地方使用以这种方式加上的类，属性，方法等等地时候，黄色的提示框里面会把你写的注释显示出来，是你更加明白你要使用的功能的作用。

   /// <summary>
   ///定义用户姓名属性，该属性为可读可写属性
   /// </summary>

   C# 编码的时候，常常涉及代码注释，常见的注释包括两类：

   •  1）单行注释。格式：// Comments
   •  2）多行注释。格式：/* Comments... */

   C# 引入了新的 XML 注释，即我们在某个函数前新起一行，输入 ///，VS.Net 会自动增加XML格式的注释，这里整理一下可用的XML注释。 XML 注释分为一级注释（Primary Tags）和二级注释（Secondary Tags），前者可以单独存在，后者必须包含在一级注释内部。

   I 一级注释

   1. <remarks>对类型进行描述，功能类似<summary>，据说建议使用<remarks>;
   2. <summary>对共有类型的类、方法、属性或字段进行注释；
   3. <value>主要用于属性的注释，表示属性的制的含义，可以配合<summary>使用；
   4. <param>用于对方法的参数进行说明，格式：<param name="param_name">value</param>；
   5. <returns>用于定义方法的返回值，对于一个方法，输入///后，会自动添加<summary>、<param>列表和<returns>；
   6. <exception>定义可能抛出的异常，格式：<exception cref="IDNotFoundException">；
   7. <example>用于给出如何使用某个方法、属性或者字段的使用方法；
   8. <permission>涉及方法的访问许可；
   9. <seealso>用于参考某个其它的东东:)，也可以通过cref设置属性；
   10. <include>用于指示外部的XML注释；

   II 二级注释

   1. <c> or <code>主要用于加入代码段；
   2. <para>的作用类似HTML中的<p>标记符，就是分段；
   3. <pararef>用于引用某个参数；
   4. <see>的作用类似<seealso>，可以指示其它的方法；
   5. <list>用于生成一个列表；
   另外，还可以自定义XML标签 

   二、让C#智能注释时显示为换行

   在C#智能注释时，常常希望它能在开发时显示为换行，使得提示更加友好！原来一直想怎么实现，今天偶然发现原来如此简单，只需将<para> 标记用于诸如 <summary>、<remarks> 或 <returns> 等标记内即可。

   注释在开发时换行显示的办法

   <para> 标记用于诸如 <summary>、<remarks> 或 <returns> 等标记内，使您得以将结构添加到文本中。 

   /// <summary> 
   /// 基类（第1行） 
   ///<para>说明：（第2行）</para> 
   ///<para>　　封装一些常用的成员（第3行）</para> 
   ///<para>　　前面要用全角空格才能显示出空格来（第4行）</para> 
   /// </summary> 
   public class MyBase 
   { 
         /// <summary> 
         /// 构造函数（第1行） 
         ///<para>说明：（第2行）</para> 
         ///<para>　　初始化一些数据（第3行）</para> 
         /// </summary> 
         public MyBase() 
         { 
               // 
               //TODO: 在此处添加构造函数逻辑 
               // 
          } 
   } 

   

5. class ExecuteRectangle
   {
       static void Main(string[] args)
       {
           Rectangle r = new Rectangle();
           r.Acceptdetails();
           r.Display();
           Console.ReadLine();
       }
   }

   这段话的意义文中并没有给出解释

   其实是用来声明前面 Acceptdetails() 和 Display()。

   Console.ReadLine(); 是使程序在接受到输入后才结束，而不是马上结束并关掉命令行窗口

6.  

   using System;
   namespace RectangleApplication
   {
       class Rectangle
       {
           // 成员变量
           double length;
           double width;
           public void Acceptdetails()//顯示length = 4.5 width = 3.5
           {
               length = 4.5;    
               width = 3.5;
           }
           public double GetArea()//計算length * width數值
           {
               return length * width;
           }
           public void Display()//顯示所需要的顯示的
           {
               Console.WriteLine("Length: {0}", length);
               Console.WriteLine("Width: {0}", width);
               Console.WriteLine("Area: {0}", GetArea());
           }
       }
       
       class ExecuteRectangle
       {
           static void Main(string[] args)
           {
               Rectangle r = new Rectangle();//實體化 r
               r.Acceptdetails(); //使用Rectangle這個方法=顯示length = 4.5 width = 3.5
               r.Display();//使用Display這個方法計算length * width數值
               Console.ReadLine();
           }
       }
   }

   当一个方法有超过两件事情，就分开来写。

   物件导向 & 面相对向的原理就是善用 Class 做分类。

   不要將所有事情都写在一起，到時候有问題要全部重写。

   也有可能別人在看代码需要很多时间去理解。

   因此善用分类，让大家都能轻易读懂。

   未来Class 一定会建立很多，可能一个 Class 就只有 2-3 行。

   但这就是单一职责，高內聚 低耦合，让未来 debug 不会这么痛苦。

   写不难，逻辑分清楚，让大家都能懂，这才难。

7. 在 C# 中:

   int 相当于 System.Int32
   double 相当于 System.Double
   strin g相当于 System.String

   一般在程序开头添加 using System;，这时 string 相当于 System.String 。

8.    

   using System;namespace RectangleApplication{
       class Rectangle
       {
           // 成员变量
           double length;//声明一个double类型的变量length 
           double width;//声明一个double类型的变量width
           public void Acceptdetails() //一个用来赋值的方法
           {
               length = 4.5;    
               width = 3.5;
           }
           public double GetArea() //一个用来计算的方法
           {
               return length * width;
           }
           public void Display()  //一个用来打印的方法
           {
               Console.WriteLine("Length: {0}", length);
               Console.WriteLine("Width: {0}", width);
               Console.WriteLine("Area: {0}", GetArea()); //打印GetArea方法的计算结果
           }
       }
       
       class ExecuteRectangle
       {
           static void Main(string[] args) //程序入口方法,创建实例，调用相应的方法
           {
               Rectangle r = new Rectangle();
               r.Acceptdetails();
               r.Display();
               Console.ReadLine();
           }
       }
   }

   在这段代码中，逻辑是这样的：

   •  首先进入 Main 方法，创建一个名称为 r 的实例。
   •  然后调用 Acceptdetails 给 r 进行赋值。
   •  最后调用 Display 方法打印结果。
   •  而用于计算的 GetArea 方法在在调用 Display 时直接打印出来。