《C# 教程》菜鸟教程学习笔记

ゝ一世哀愁。 2021-06-24 16:11 706阅读 0赞

[学习地址][Link 1]

###### C\#有用的网站 ######

*  [C\# Programming Guide][C_ Programming Guide] \- 介绍了有关关键的 C\# 语言特征以及如何通过 .NET 框架访问 C\# 的详细信息。
 *  [Visual Studio][] \- 下载作为 C\# 集成开发环境的 Visual Studio 的最新版本。
 *  [Go Mono][] \- Mono 是一个允许开发人员简单地创建跨平台应用程序的软件平台。
 *  [C Sharp (programming language) ][C Sharp _programming language_]\- 维基百科解释 C\#（编程语言）。

#### C\#简介 ####

下面列出 C\# 一些重要的功能：

*  布尔条件（Boolean Conditions）
 *  自动垃圾回收（Automatic Garbage Collection）
 *  标准库（Standard Library）
 *  组件版本（Assembly Versioning）
 *  属性（Properties）和事件（Events）
 *  委托（Delegates）和事件管理（Events Management）
 *  易于使用的泛型（Generics）
 *  索引器（Indexers）
 *  条件编译（Conditional Compilation）
 *  简单的多线程（Multithreading）
 *  LINQ 和 Lambda 表达式
 *  集成 Windows

#### C\# 环境 ####

###### .Net 框架（.Net Framework） ######

.Net 框架由一个巨大的代码库组成，用于 C\# 等客户端语言。下面列出一些 .Net 框架的组件：

*  公共语言运行库（Common Language Runtime - CLR）
 *  .Net 框架类库（.Net Framework Class Library）
 *  公共语言规范（Common Language Specification）
 *  通用类型系统（Common Type System）
 *  元数据（Metadata）和组件（Assemblies）
 *  Windows 窗体（Windows Forms）
 *  ASP.Net 和 ASP.Net AJAX
 *  ADO.Net
 *  Windows 工作流基础（Windows Workflow Foundation - WF）
 *  Windows 显示基础（Windows Presentation Foundation）
 *  Windows 通信基础（Windows Communication Foundation - WCF）
 *  LINQ

#### C\# 程序结构 ####

以下几点值得注意：

*  C\# 是大小写敏感的。
 *  所有的语句和表达式必须以分号（;）结尾。
 *  程序的执行从 Main 方法开始。
 *  与 Java 不同的是，文件名可以不同于类的名称。

#### C\# 基本语法 ####

![2789632-5a93f2947cece833.png][]

保留关键字

![2789632-35590588bc46cc1c.png][]

上下文关键字

#### C\# 数据类型 ####

在 C\# 中，变量分为以下几种类型：

*  值类型（Value types）
 *  引用类型（Reference types）
 *  指针类型（Pointer types）

###### 指针类型（Pointer types） ######

指针类型变量存储另一种类型的内存地址。C\# 中的指针与 C 或 C++ 中的指针有相同的功能。  
声明指针类型的语法：

type* identifier

#### C\# 类型转换 ####

类型转换从根本上说是类型铸造，或者说是把数据从一种类型转换为另一种类型。在 C\# 中，类型铸造有两种形式：

*  隐式类型转换 - 这些转换是 C\# 默认的以安全方式进行的转换, 不会导致数据丢失。例如，从小的整数类型转换为大的整数类型，从派生类转换为基类。
 *  显式类型转换 - 显式类型转换，即强制类型转换。显式转换需要强制转换运算符，而且强制转换会造成数据丢失。

#### C\# 变量 ####

一个变量只不过是一个供程序操作的存储区的名字。在 C\# 中，每个变量都有一个特定的类型，类型决定了变量的内存大小和布局。范围内的值可以存储在内存中，可以对变量进行一系列操作。

#### C\# 常量 ####

常量是固定值，程序执行期间不会改变。常量可以是任何基本数据类型，比如整数常量、浮点常量、字符常量或者字符串常量，还有枚举常量。  
常量可以被当作常规的变量，只是它们的值在定义后不能被修改。

#### C\# 运算符 ####

其他运算符  
下表列出了 C\# 支持的其他一些重要的运算符，包括 sizeof、typeof 和 ? :。

![2789632-356cb59ff0021b0e.png][]

添加：  
?? 运算符称作 null 合并运算符。 如果此运算符的左操作数不为 null，则此运算符将返回左操作数；否则返回右操作数。

#### C\# 判断 ####

判断结构要求程序员指定一个或多个要评估或测试的条件，以及条件为真时要执行的语句（必需的）和条件为假时要执行的语句（可选的）。

![2789632-a6921f5d53604018.png][]

#### C\# 循环 ####

![2789632-8ff8e2139c1c4762.png][]

![2789632-34670de925964402.png][]

#### C\# 封装 ####

封装 被定义为"把一个或多个项目封闭在一个物理的或者逻辑的包中"。在面向对象程序设计方法论中，封装是为了防止对实现细节的访问。  
C\# 封装根据具体的需要，设置使用者的访问权限，并通过 访问修饰符 来实现。  
一个 访问修饰符 定义了一个类成员的范围和可见性。C\# 支持的访问修饰符如下所示：

*  public：所有对象都可以访问；
 *  private：对象本身在对象内部可以访问；
 *  protected：只有该类对象及其子类对象可以访问
 *  internal：同一个程序集的对象可以访问；
 *  protected internal：访问限于当前程序集或派生自包含类的类型。

#### C\# 方法 ####

ref和out的区别在C\# 中，既可以通过值也可以通过引用传递参数。通过引用传递参数允许函数成员更改参数的值，并保持该更改。若要通过引用传递参数， 可使用ref或out关键字。ref和out这两个关键字都能够提供相似的功效，其作用也很像C中的指针变量。它们的区别是：  
1、使用ref型参数时，传入的参数必须先被初始化。对out而言，必须在方法中对其完成初始化。  
2、使用ref和out时，在方法的参数和执行方法时，都要加Ref或Out关键字。以满足匹配。  
3、out适合用在需要retrun多个返回值的地方，而ref则用在需要被调用的方法修改调用者的引用的时候。  
out  
方法参数上的 out 方法参数关键字使方法引用传递到方法的同一个变量。当控制传递回调用方法时，在方法中对参数所做的任何更改都将反映在该变量中。  
当希望方法返回多个值时，声明 out 方法非常有用。使用 out 参数的方法仍然可以返回一个值。一个方法可以有一个以上的 out 参数。  
若要使用 out 参数，必须将参数作为 out 参数显式传递到方法。out 参数的值不会传递到 out 参数。  
不必初始化作为 out 参数传递的变量。然而，必须在方法返回之前为 out 参数赋值。  
属性不是变量，不能作为 out 参数传递。

#### C\# 可空类型（Nullable） ####

C\# 提供了一个特殊的数据类型，nullable 类型（可空类型），可空类型可以表示其基础值类型正常范围内的值，再加上一个 null 值。  
声明一个 nullable 类型（可空类型）的语法如下：

< data_type> ? <variable_name> = null;

Null 合并运算符（ ?? ）  
Null 合并运算符用于定义可空类型和引用类型的默认值。Null 合并运算符为类型转换定义了一个预设值，以防可空类型的值为 Null。Null 合并运算符把操作数类型隐式转换为另一个可空（或不可空）的值类型的操作数的类型。  
例如：  
int y = x ?? 1;  
假设此时x == null ,那么就将1赋值给y;

#### C\# 数组（Array） ####

数组是一个存储相同类型元素的固定大小的顺序集合。数组是用来存储数据的集合，通常认为数组是一个同一类型变量的集合。  
所有的数组都是由连续的内存位置组成的。最低的地址对应第一个元素，最高的地址对应最后一个元素。

![2789632-07ee91bd28dcdefb.png][]

#### C\# 类（Class） ####

*  类的 构造函数 是类的一个特殊的成员函数，当创建类的新对象时执行。  
    构造函数的名称与类的名称完全相同，它没有任何返回类型。  
    默认的构造函数没有任何参数。但是如果你需要一个带有参数的构造函数可以有参数，这种构造函数叫做参数化构造函数。
 *  类的 析构函数 是类的一个特殊的成员函数，当类的对象超出范围时执行。  
    析构函数的名称是在类的名称前加上一个波浪形（~）作为前缀，它不返回值，也不带任何参数。  
    析构函数用于在结束程序（比如关闭文件、释放内存等）之前释放资源。析构函数不能继承或重载。  
    例如：

~Line() //析构函数
          {
             Console.WriteLine("对象已删除");
          }

#### C\# 文件的输入与输出 ####

一个 文件 是一个存储在磁盘中带有指定名称和目录路径的数据集合。当打开文件进行读写时，它变成一个 流。  
从根本上说，流是通过通信路径传递的字节序列。有两个主要的流：输入流 和 输出流。输入流用于从文件读取数据（读操作），输出流用于向文件写入数据（写操作）。

![2789632-d82dddce2a8f5815.png][]

FileStream 类

![2789632-a4cc6dfd7724d796.png][]

## C\# 高级教程 ##

#### C\# 特性（Attribute） ####

特性（Attribute）是用于在运行时传递程序中各种元素（比如类、方法、结构、枚举、组件等）的行为信息的声明性标签。您可以通过使用特性向程序添加声明性信息。一个声明性标签是通过放置在它所应用的元素前面的方括号（\[ \]）来描述的。  
特性（Attribute）用于添加元数据，如编译器指令和注释、描述、方法、类等其他信息。.Net 框架提供了两种类型的特性：预定义特性和自定义特性。

*  规定特性（Attribute）

[attribute(positional_parameters, name_parameter = value, ...)]
    element

*  预定义特性（Attribute）  
    1.AttributeUsage  
    预定义特性 AttributeUsage 描述了如何使用一个自定义特性类。它规定了特性可应用到的项目的类型。

[AttributeUsage(
       validon,
       AllowMultiple=allowmultiple,
       Inherited=inherited
    )]

2.Conditional  
这个预定义特性标记了一个条件方法，其执行依赖于指定的预处理标识符。  
它会引起方法调用的条件编译，取决于指定的值，比如 Debug 或 Trace。例如，当调试代码时显示变量的值。

[Conditional("DEBUG")]

3.Obsolete  
这个预定义特性标记了不应被使用的程序实体。它可以让您通知编译器丢弃某个特定的目标元素。例如，当一个新方法被用在一个类中，但是您仍然想要保持类中的旧方法，您可以通过显示一个应该使用新方法，而不是旧方法的消息，来把它标记为 obsolete（过时的）。

[Obsolete(
       message
    )]
    [Obsolete(
       message,
       iserror
    )]

#### C\# 反射（Reflection） ####

反射指程序可以访问、检测和修改它本身状态或行为的一种能力。  
程序集包含模块，而模块包含类型，类型又包含成员。反射则提供了封装程序集、模块和类型的对象。  
您可以使用反射动态地创建类型的实例，将类型绑定到现有对象，或从现有对象中获取类型。然后，可以调用类型的方法或访问其字段和属性。  
优点：

*  1、反射提高了程序的灵活性和扩展性。
 *  2、降低耦合性，提高自适应能力。
 *  3、它允许程序创建和控制任何类的对象，无需提前硬编码目标类。  
    缺点：
 *  1、性能问题：使用反射基本上是一种解释操作，用于字段和方法接入时要远慢于直接代码。因此反射机制主要应用在对灵活性和拓展性要求很高的系统框架上，普通程序不建议使用。
 *  2、使用反射会模糊程序内部逻辑；程序员希望在源代码中看到程序的逻辑，反射却绕过了源代码的技术，因而会带来维护的问题，反射代码比相应的直接代码更复杂。

###### 反射（Reflection）的用途 ######

*  反射（Reflection）有下列用途：
 *  它允许在运行时查看特性（attribute）信息。
 *  它允许审查集合中的各种类型，以及实例化这些类型。
 *  它允许延迟绑定的方法和属性（property）。
 *  它允许在运行时创建新类型，然后使用这些类型执行一些任务。

###### 查看元数据 ######

System.Reflection.MemberInfo info = typeof(MyClass);

#### C\# 属性（Property） ####

属性（Property） 是类（class）、结构（structure）和接口（interface）的命名（named）成员。类或结构中的成员变量或方法称为 域（Field）。属性（Property）是域（Field）的扩展，且可使用相同的语法来访问。它们使用 访问器（accessors） 让私有域的值可被读写或操作。  
属性（Property）不会确定存储位置。相反，它们具有可读写或计算它们值的 访问器（accessors）。  
例如，有一个名为 Student 的类，带有 age、name 和 code 的私有域。我们不能在类的范围以外直接访问这些域，但是我们可以拥有访问这些私有域的属性。

###### 访问器（Accessors） ######

属性（Property）的访问器（accessor）包含有助于获取（读取或计算）或设置（写入）属性的可执行语句。访问器（accessor）声明可包含一个 get 访问器、一个 set 访问器，或者同时包含二者。

#### C\# 索引器（Indexer） ####

索引器（Indexer） 允许一个对象可以像数组一样被索引。当您为类定义一个索引器时，该类的行为就会像一个 虚拟数组（virtual array） 一样。您可以使用数组访问运算符（\[ \]）来访问该类的实例。

###### 语法 ######

一维索引器的语法如下：

element-type this[int index] 
    {
       // get 访问器
       get 
       {
          // 返回 index 指定的值
       }
    
       // set 访问器
       set 
       {
          // 设置 index 指定的值 
       }
    }

###### 索引器（Indexer）的用途 ######

索引器的行为的声明在某种程度上类似于属性（property）。就像属性（property），您可使用 get 和 set 访问器来定义索引器。但是，属性返回或设置一个特定的数据成员，而索引器返回或设置对象实例的一个特定值。换句话说，它把实例数据分为更小的部分，并索引每个部分，获取或设置每个部分。

using System;
    namespace IndexerApplication
    {
       class IndexedNames
       {
          private string[] namelist = new string[size];
          static public int size = 10;
          public IndexedNames()
          {
             for (int i = 0; i < size; i++)
             namelist[i] = "N. A.";
          }
          public string this[int index]
          {
             get
             {
                string tmp;
    
                if( index >= 0 && index <= size-1 )
                {
                   tmp = namelist[index];
                }
                else
                {
                   tmp = "";
                }
    
                return ( tmp );
             }
             set
             {
                if( index >= 0 && index <= size-1 )
                {
                   namelist[index] = value;
                }
             }
          }
    
          static void Main(string[] args)
          {
             IndexedNames names = new IndexedNames();
             names[0] = "Zara";
             names[1] = "Riz";
             names[2] = "Nuha";
             names[3] = "Asif";
             names[4] = "Davinder";
             names[5] = "Sunil";
             names[6] = "Rubic";
             for ( int i = 0; i < IndexedNames.size; i++ )
             {
                Console.WriteLine(names[i]);
             }
             Console.ReadKey();
          }
       }
    }

###### 重载索引器（Indexer） ######

索引器（Indexer）可被重载。索引器声明的时候也可带有多个参数，且每个参数可以是不同的类型。没有必要让索引器必须是整型的。C\# 允许索引器可以是其他类型，例如，字符串类型。

using System;
    namespace IndexerApplication
    {
       class IndexedNames
       {
          private string[] namelist = new string[size];
          static public int size = 10;
          public IndexedNames()
          {
             for (int i = 0; i < size; i++)
             {
              namelist[i] = "N. A.";
             }
          }
          public string this[int index]
          {
             get
             {
                string tmp;
    
                if( index >= 0 && index <= size-1 )
                {
                   tmp = namelist[index];
                }
                else
                {
                   tmp = "";
                }
    
                return ( tmp );
             }
             set
             {
                if( index >= 0 && index <= size-1 )
                {
                   namelist[index] = value;
                }
             }
          }
          public int this[string name]
          {
             get
             {
                int index = 0;
                while(index < size)
                {
                   if (namelist[index] == name)
                   {
                    return index;
                   }
                   index++;
                }
                return index;
             }
    
          }
    
          static void Main(string[] args)
          {
             IndexedNames names = new IndexedNames();
             names[0] = "Zara";
             names[1] = "Riz";
             names[2] = "Nuha";
             names[3] = "Asif";
             names[4] = "Davinder";
             names[5] = "Sunil";
             names[6] = "Rubic";
             // 使用带有 int 参数的第一个索引器
             for (int i = 0; i < IndexedNames.size; i++)
             {
                Console.WriteLine(names[i]);
             }
             // 使用带有 string 参数的第二个索引器
             Console.WriteLine(names["Nuha"]);
             Console.ReadKey();
          }
       }
    }

#### C\# 委托（Delegate） ####

C\# 中的委托（Delegate）类似于 C 或 C++ 中函数的指针。委托（Delegate） 是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。  
委托（Delegate）特别用于实现事件和回调方法。所有的委托（Delegate）都派生自 System.Delegate 类。  
声明委托的语法如下：

delegate <return type> <delegate-name> <parameter list>

###### 委托的多播（Multicasting of a Delegate） ######

委托对象可使用 "+" 运算符进行合并。一个合并委托调用它所合并的两个委托。只有相同类型的委托可被合并。"-" 运算符可用于从合并的委托中移除组件委托。  
使用委托的这个有用的特点，您可以创建一个委托被调用时要调用的方法的调用列表。这被称为委托的 多播（multicasting），也叫组播。

#### C\# 事件（Event） ####

事件（Event） 基本上说是一个用户操作，如按键、点击、鼠标移动等等，或者是一些出现，如系统生成的通知。应用程序需要在事件发生时响应事件。例如，中断。事件是用于进程间通信。

###### 声明事件（Event） ######

在类的内部声明事件，首先必须声明该事件的委托类型。例如：

public delegate void BoilerLogHandler(string status);

然后，声明事件本身，使用 event 关键字：

// 基于上面的委托定义事件
    public event BoilerLogHandler BoilerEventLog;

#### 编译不安全代码 ####

步骤如下：

*  通过双击资源管理器（Solution Explorer）中的属性（properties）节点，打开项目属性（project properties）。
 *  点击 Build 标签页。
 *  选择选项"Allow unsafe code"。

#### C\# 多线程 ####

线程 被定义为程序的执行路径。每个线程都定义了一个独特的控制流。如果您的应用程序涉及到复杂的和耗时的操作，那么设置不同的线程执行路径往往是有益的，每个线程执行特定的工作。

线程是轻量级进程。一个使用线程的常见实例是现代操作系统中并行编程的实现。使用线程节省了 CPU 周期的浪费，同时提高了应用程序的效率。

到目前为止我们编写的程序是一个单线程作为应用程序的运行实例的单一的过程运行的。但是，这样子应用程序同时只能执行一个任务。为了同时执行多个任务，它可以被划分为更小的线程。

###### 线程生命周期 ######

线程生命周期开始于 System.Threading.Thread 类的对象被创建时，结束于线程被终止或完成执行时。

下面列出了线程生命周期中的各种状态：

*  未启动状态：当线程实例被创建但 Start 方法未被调用时的状况。
 *  就绪状态：当线程准备好运行并等待 CPU 周期时的状况。
 *  不可运行状态：下面的几种情况下线程是不可运行的：  
    已经调用 Sleep 方法  
    已经调用 Wait 方法  
    通过 I/O 操作阻塞
 *  死亡状态：当线程已完成执行或已中止时的状况。

![2789632-dc93e9d1d574415d.png][]

![2789632-3342ed83a597a3cb.png][]

![2789632-8c629feda3f83b64.png][]

![2789632-2397160d570c8b1b.png][]

![2789632-3b18269684ea9294.png][]

公众号.png

[Link 1]: https://links.jianshu.com/go?to=http%3A%2F%2Fwww.runoob.com%2Fcsharp%2Fcsharp-tutorial.html
[C_ Programming Guide]: https://links.jianshu.com/go?to=http%3A%2F%2Fmsdn.microsoft.com%2Fen-us%2Flibrary%2F67ef8sbd.aspx
[Visual Studio]: https://links.jianshu.com/go?to=http%3A%2F%2Fwww.microsoft.com%2Fvisualstudio%2Feng%2Fdownloads
[Go Mono]: https://links.jianshu.com/go?to=http%3A%2F%2Fwww.mono-project.com%2FMain_Page
[C Sharp _programming language_]: https://links.jianshu.com/go?to=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FC_Sharp_%28programming_language%29
[2789632-5a93f2947cece833.png]: /images/20210615/ee085ceecae44501a8c98e0f3b7a8eb9.png
[2789632-35590588bc46cc1c.png]: /images/20210615/78072c33680146aa8672b9e89f89494d.png
[2789632-356cb59ff0021b0e.png]: /images/20210615/48b828daa4df452f91b90644e52a7270.png
[2789632-a6921f5d53604018.png]: /images/20210615/bada09d218df4d348f876034b8de7981.png
[2789632-8ff8e2139c1c4762.png]: /images/20210615/2ca8cfcdd8c947ca94466ab0db307860.png
[2789632-34670de925964402.png]: /images/20210615/2d28a4b61e3148588ef10f88813ce9d9.png
[2789632-07ee91bd28dcdefb.png]: /images/20210615/6806c8a42e1240d78cd0300986d08aea.png
[2789632-d82dddce2a8f5815.png]: /images/20210615/07c32dd11fdd4f268fb4ee2dd90624db.png
[2789632-a4cc6dfd7724d796.png]: /images/20210615/fa6d40054ea544438bb8a48068a5a335.png
[2789632-dc93e9d1d574415d.png]: /images/20210615/8712258439ec4b9d963fb5f238247937.png
[2789632-3342ed83a597a3cb.png]: /images/20210615/fbd09c02b5f647b9bd1ebc94ad123e8a.png
[2789632-8c629feda3f83b64.png]: /images/20210615/bcdce17445b745119a192b8d76bf529c.png
[2789632-2397160d570c8b1b.png]: /images/20210615/2cb59eaaedd34680b5a4eeb94489b758.png
[2789632-3b18269684ea9294.png]: /images/20210615/e0a2ad9965da4f31a9acbab78e1687f2.png