C#简介

C#是一门接近于传统高级语言C和C++的现代的、通用的、面向对象的编程语言，其与Java非常相似，有许多强大的编程功能。但我是C++选手，所以下文的很多内容都将以C++语言作为对比来进行学习。

其主要的优势为：

现代的、通用的编程语言
面向对象、面向组件、容易学习的结构化语言
可以在多种计算机平台上编译，产生高效率的程序，是.Net框架的一部分

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 框架是一个创新的平台，能帮您编写出下面类型的应用程序：

Windows 应用程序
Web 应用程序
Web 服务

.Net 框架应用程序是多平台的应用程序。框架的设计方式使它适用于下列各种语言：C#、C++、Visual Basic、Jscript、COBOL 等等。所有这些语言可以访问框架，彼此之间也可以互相交互。

.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#程序结构

所有的编程语言都逃不过”hello,world”, c#语言也是，这里，我们直接上代码，编写一个最简单的程序：

using System;
namespace HelloWorldApplication
{
    class HelloWorld
    {
      static void Main(string[] args)
      {
         /* 我的第一个 C# 程序*/
         Console.WriteLine("Hello World");
         Console.ReadKey();
      }
    }
}

这里，只需要注意一下，这里的程序结构是通过在命名空间来具体实现的。

基本语法中与C++的一些相同点：

using、class关键字，using用于声明包含的命名空间，class用于声明一个类。
单行注释用//，多行注释用/* */，不同软件中也可以快速注释和取消注释，例如在Visual studio中Ctrl+K+C是快速注释，而Ctrl+K+U是取消注释。
成员函数和成员变量。
一些关键字和标识符的使用和作用。标识符是用来识别类、变量、函数或者任何其他用户定义的项目。

C#数据类型

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

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

值类型

值类型直接包含数据。比如 int、char、float，它们分别存储数字、字符、浮点数。当您声明一个 int 类型时，系统分配内存来存储值。

引用类型

引用类型不包含存储在变量中的实际数据，但它们包含对变量的引用。

换句话说，它们指的是一个内存位置。使用多个变量时，引用类型可以指向一个内存位置。如果内存位置的数据是由一个变量改变的，其他变量会自动反映这种值的变化。内置的引用类型有：object、dynamic 和 string。

对象（Object）类型

对象（Object）类型是 C# 通用类型系统（Common Type System - CTS）中所有数据类型的终极基类。Object 是 System.Object 类的别名。所以对象（Object）类型可以被分配任何其他类型（值类型、引用类型、预定义类型或用户自定义类型）的值。但是，在分配值之前，需要先进行类型转换。

当一个值类型转换为对象类型时，则被称为装箱；另一方面，当一个对象类型转换为值类型时，则被称为拆箱。

object obj;
obj = 100; // 这是装箱

动态（Dynamic）类型

您可以存储任何类型的值在动态数据类型变量中。这些变量的类型检查是在运行时发生的。

声明动态类型的语法：

dynamic <variable_name> = value;

例如：

dynamic d = 20;

动态类型与对象类型相似，但是对象类型变量的类型检查是在编译时发生的，而动态类型变量的类型检查是在运行时发生的。（相当于静态多态和动态多态，静态多态是在编译期间完成的多态，编译器根据函数实参的类型（可能会进行隐式类型转换），可以推断出要调用那个函数，如果有对应的函数就调用该函数，否则出现编译错误，静态多态的实现方式主要有函数重载，包括普通函数的重载和成员函数的重载以及函数模板的使用；动态多态即动态绑定是运行时的多态，在程序执行期间（非编译期）判断所引用对象的实际类型，根据其实际类型调用相应的方法）——顺便复习一下C++。

字符串（String）类型

字符串（String）类型允许您给变量分配任何字符串值。字符串（String）类型是 System.String 类的别名。它是从对象（Object）类型派生的。字符串（String）类型的值可以通过两种形式进行分配：引号和 @引号。

例如：
String str = “runoob.com”;
一个 @引号字符串：

@"runoob.com";

C#string 字符串的前面可以加 @（称作”逐字字符串”）将转义字符（\）当作普通字符对待，比如：

string str = @"C:\Windows";

等价于：

string str = "C:\\Windows";

@ 字符串中可以任意换行，换行符及缩进空格都计算在字符串长度之内。

string str = @"<script type=""text/javascript"">
    <!--
    -->
</script>";

用户自定义引用类型有：class、interface 或 delegate。

指针类型（Pointer types）

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

声明指针类型的语法：

type* identifier;

例如：

char* cptr;
int* iptr;

C#类型转换

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

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

下面的实例显示了一个显式的类型转换：

namespace TypeConversionApplication
{
    class ExplicitConversion
    {
        static void Main(string[] args)
        {
            double d = 5673.74;
            int i;

            // 强制转换 double 为 int
            i = (int)d;
            Console.WriteLine(i);
            Console.ReadKey();
           
        }
    }
}

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

C#变量

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

我们已经讨论了各种数据类型。C# 中提供的基本的值类型大致可以分为以下几类：

| 类型 | 举例 |
|——— | ——- |
| 整数类型 | sbyte、byte、short、ushort、int、uint、long、ulong 和 char |
| 浮点型 | float 和 double |
| 十进制类型 | decimal |
| 布尔类型 |true 或 false 值，指定的值 |
|空类型 | 可为空值的数据类型 |

C#中的变量定义

C# 中变量定义的语法：

<data_type> <variable_list>;

在这里，data_type 必须是一个有效的 C# 数据类型，可以是 char、int、float、double 或其他用户自定义的数据类型。variable_list 可以由一个或多个用逗号分隔的标识符名称组成。

一些有效的变量定义如下所示：

int i, j, k;
char c, ch;
float f, salary;
double d;

您可以在变量定义时进行初始化：

int i = 100;

C#中的变量初始化

变量通过在等号后跟一个常量表达式进行初始化（赋值）。初始化的一般形式为：

variable_name = value;

变量可以在声明时被初始化（指定一个初始值）。初始化由一个等号后跟一个常量表达式组成，如下所示：

<data_type> <variable_name> = value;

一些实例：

int d = 3, f = 5;/* 初始化 d 和 f. */
byte z = 22; /* 初始化 z. */
double pi = 3.14159; /* 声明 pi 的近似值 */
char x = 'x';/* 变量 x 的值为 'x' */

正确地初始化变量是一个良好的编程习惯，否则有时程序会产生意想不到的结果。

请看下面的实例，使用了各种类型的变量：

namespace VariableDefinition
{
    class Program
    {
        static void Main(string[] args)
        {
            short a;
            int b ;
            double c;

            /* 实际初始化 */
            a = 10;
            b = 20;
            c = a + b;
            //C#中的输出，Console.WriteLine相当于C++中的cout,C中的printf
            Console.WriteLine("a = {0}, b = {1}, c = {2}", a, b, c);
            //C#中的输入，Console.ReadLine相当于C++中的cin,C中的scanf
            Console.ReadLine();
        }
    }
}

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

a = 10, b = 20, c = 30

接受来自用户的值

System 命名空间中的 Console 类提供了一个函数 ReadLine()，用于接收来自用户的输入，并把它存储到一个变量中。
例如：

int num;
num = Convert.ToInt32(Console.ReadLine());

函数 Convert.ToInt32() 把用户输入的数据转换为 int 数据类型，因为 Console.ReadLine() 只接受字符串格式的数据。

C#中的 Lvalues 和 Rvalues

C# 中的两种表达式：

lvalue：lvalue 表达式可以出现在赋值语句的左边或右边。
rvalue：rvalue 表达式可以出现在赋值语句的右边，不能出现在赋值语句的左边。

变量是 lvalue 的，所以可以出现在赋值语句的左边。数值是 rvalue 的，因此不能被赋值，不能出现在赋值语句的左边。下面是一个有效的语句：

int g = 20;

下面是一个无效的语句，会产生编译时错误：

10 = 20;

C#常量

常量是固定值，程序执行期间不会改变。常量可以是任何基本数据类型，比如整数常量、浮点常量、字符常量或者字符串常量，还有枚举常量。

常量可以被当作常规的变量，只是它们的值在定义后不能被修改。

C#运算符

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C# 有丰富的内置运算符，分类如下：

算术运算符：同C++的+、—、*、/、%、++、–
关系运算符：同C++的==、!=、>、<、>=、<=
逻辑运算符：同C++的&&、||、|
位运算符：同C++的&、|、^、~、<<、>>
赋值运算符：同C++的=、+=、-=、*=、/=、%=、<<=、>>=、&=、^=、|=
其他运算符：sizeof()、typeof()、&、*、？、is、as

C#中的运算符优先级

|类别 |运算符 |结合性 |
|—|—|
|后缀 |() [] -> . ++ - - | 从左到右 |
|一元 |+ - ! ~ ++ - - (type)* & sizeof |从右到左|
|乘除 |* / % |从左到右|
|加减 |+ - |从左到右|
|移位 |<< >> |从左到右|
|关系 |< <= > >= 从左到右 |
|相等 |== != | 从左到右 |
|位与AND |&| 从左到右 |
|位异或XOR |^ | 从左到右 |
|位或OR | 一竖 |从左到右 |
|逻辑与AND |&& |从左到右 |
|逻辑或OR | 两竖 |从左到右 |
|条件 |?: |从右到左 |
|赋值 |= += -= *= /= %=>>= <<= &= ^= 不等于 |从右到左|
|逗号 |, |从左到右 |

C#判断

语句	描述
if 语句	一个 if 语句由一个布尔表达式后跟一个或多个语句组成。
if…else 语句	一个 if 语句后可跟一个可选的 else 语句，else 语句在布尔表达式为假时执行。
嵌套 if 语句	您可以在一个 if 或 else if 语句内使用另一个 if 或 else if 语句。
switch 语句	一个 switch 语句允许测试一个变量等于多个值时的情况。
嵌套 switch 语句	您可以在一个 switch 语句内使用另一个 switch 语句。
? : 运算符	Exp1 ? Exp2 : Exp3; 其中，Exp1、Exp2 和 Exp3 是表达式。请注意，冒号的使用和位置。? 表达式的值是由 Exp1 决定的。如果 Exp1 为真，则计算 Exp2 的值，结果即为整个 ? 表达式的值。如果 Exp1 为假，则计算 Exp3 的值，结果即为整个 ? 表达式的值。

C#循环

循环类型	描述
while 循环	当给定条件为真时，重复语句或语句组。它会在执行循环主体之前测试条件。
for/foreach 循环	多次执行一个语句序列，简化管理循环变量的代码。
do…while 循环	除了它是在循环主体结尾测试条件外，其他与 while 语句类似。
嵌套循环	您可以在 while、for 或 do..while 循环内使用一个或多个循环。
break 语句	终止 loop 或 switch 语句，程序流将继续执行紧接着 loop 或 switch 的下一条语句。
continue 语句	引起循环跳过主体的剩余部分，立即重新开始测试条件。
如果条件永远不为假，则循环将变成无限循环。for 循环在传统意义上可用于实现无限循环。由于构成循环的三个表达式中任何一个都不是必需的，您可以将某些条件表达式留空来构成一个无限循环。

C#封装

封装被定义为“把一个或多个项目封装在一个物理的或者逻辑的包中”，在面对对象程序设计方法论中，封装是为了防止对实现细节的访问，抽象和封装是面向对象程序设计的相关特性。抽象允许相关信息可视化，封装则使得开发者实现所需级别的抽象。

C#封装根据具体的需要，设置使用者的访问权限，并通过访问修饰符来实现。

一个访问修饰符定义了一个类成员的范围和可见性。C# 支持的访问修饰符如下所示：

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

C#方法

一个方法是把一些相关的语句组织在一起，用来执行一个任务的语句块。每一个C#程序至少有一个带有Main方法的类。
要使用有个方法，您需要：

定义方法
调用方法

C#中定义方法

当定义一个方法时，从根本上说是在声明它的结构的元素。在 C# 中，定义方法的语法如下：

<Access Specifier> <Return Type> <Method Name>(Parameter List)
{
   Method Body
}

下面是方法的各个元素：

Access Specifier：访问修饰符，这个决定了变量或方法对于另一个类的可见性。
Return type：返回类型，一个方法可以返回一个值。返回类型是方法返回的值的数据类型。如果方法不返回任何值，则返回类型为 void。
Method name：方法名称，是一个唯一的标识符，且是大小写敏感的。它不能与类中声明的其他标识符相同。
Parameter list：参数列表，使用圆括号括起来，该参数是用来传递和接收方法的数据。参数列表是指方法的参数类型、顺序和数量。参数是可选的，也就是说，一个方法可能不包含参数。
Method body：方法主体，包含了完成任务所需的指令集。

实例：
class NumberManipulator
{
public int FindMax(int num1, int num2)
{
/* 局部变量声明 */
int result;

      if (num1 > num2)
         result = num1;
      else
         result = num2;

      return result;
   }
   ...
}

C#中调用方法

using System;
namespace CalculatorApplication
{
   class NumberManipulator
   {
      public int FindMax(int num1, int num2)
      {
         /* 局部变量声明 */
         int result;

         if (num1 > num2)
            result = num1;
         else
            result = num2; 

         return result;
      }
      static void Main(string[] args)
      {
         /* 局部变量定义 */
         int a = 100;
         int b = 200;
         int ret;
         NumberManipulator n = new NumberManipulator();

         //调用 FindMax 方法
         ret = n.FindMax(a, b);
         Console.WriteLine("最大值是： {0}", ret );
         Console.ReadLine();
      }
   }
}

参数传递

方式	描述
值参数	这种方式复制参数的实际值给函数的形式参数，实参和形参使用的是两个不同内存中的值。在这种情况下，当形参的值发生改变时，不会影响实参的值，从而保证了实参数据的安全。
引用参数	这种方式复制参数的内存位置的引用给形式参数。这意味着，当形参的值发生改变时，同时也改变实参的值。
输出参数	这种方式可以返回多个值。

C#数组

数组是一个存储相同类型元素的固定大小的顺序集合。数组是用来存储数据的集合，通常认为数组是一个同一类型变量的集合。

声明数组变量并不是声明 number0、number1、…、number99 一个个单独的变量，而是声明一个就像 numbers 这样的变量，然后使用 numbers[0]、numbers[1]、…、numbers[99] 来表示一个个单独的变量。数组中某个指定的元素是通过索引来访问的。

所有的数组都是由连续的内存位置组成的。最低的地址对应第一个元素，最高的地址对应最后一个元素。
实例

using System;
namespace ArrayApplication
{
   class MyArray
   {
      static void Main(string[] args)
      {
         int []  n = new int[10]; /* n 是一个带有 10 个整数的数组 */初始化数组
         int i,j;
         /* 赋值给数组 n 中的元素 */        
         for ( i = 0; i < 10; i++ )
         {
            n[i] = i + 100;
         }

         /* 输出每个数组元素的值 */
         for (j = 0; j < 10; j++ )
         {
            Console.WriteLine("Element[{0}] = {1}", j, n[j]);
         }
         Console.ReadKey();
      }
   }
}

C# 字符串（String）

创建 String 对象
您可以使用以下方法之一来创建 string 对象：

通过给 String 变量指定一个字符串
通过使用 String 类构造函数
通过使用字符串串联运算符（ + ）
通过检索属性或调用一个返回字符串的方法
通过格式化方法来转换一个值或对象为它的字符串表示形式

实例：

using System;
namespace StringApplication
{
    class Program
    {
        static void Main(string[] args)
        {
           //字符串，字符串连接
            string fname, lname;
            fname = "Rowan";
            lname = "Atkinson";

            string fullname = fname + lname;
            Console.WriteLine("Full Name: {0}", fullname);

            //通过使用 string 构造函数
            char[] letters = { 'H', 'e', 'l', 'l','o' };
            string greetings = new string(letters);
            Console.WriteLine("Greetings: {0}", greetings);

            //方法返回字符串
            string[] sarray = { "Hello", "From", "Tutorials", "Point" };
            string message = String.Join(" ", sarray);
            Console.WriteLine("Message: {0}", message);

            //用于转化值的格式化方法
            DateTime waiting = new DateTime(2012, 10, 10, 17, 58, 1);
            string chat = String.Format("Message sent at {0:t} on {0:D}", waiting);
            Console.WriteLine("Message: {0}", chat);
            Console.ReadKey() ;
        }
    }
}

C#结构体

类VS结构

类和结构体有以下几个基本的不同点：

类是引用类型，结构体是值类型
结构体不支持继承
结构体不能声明默认的构造函数

C# 枚举（Enum）

枚举是一组命名整型常量。枚举类型是使用 enum 关键字声明的。C#枚举是值类型。换句话说，枚举包含自己的值，且不能继承或传递继承。

C#类

C#类和C++类的特征很相似，有类的定义，成员函数和封装，类的继承（但是C#不支持多重继承），构造函数，析构函数，静态成员，虚函数来实现多态性，运算符重载，

可重载和不可重载运算符

运算符	描述
+, -, !, ~, ++, –	这些一元运算符只有一个操作数，且可以被重载。
+, -, *, /, %	这些二元运算符带有两个操作数，且可以被重载。
==, !=, <, >, <=, >=	这些比较运算符可以被重载。
&&, 或运算（两竖）	这些条件逻辑运算符不能被直接重载。
+=, -=, *=, /=, %=	这些赋值运算符不能被重载。
=, ., ?:, ->, new, is, sizeof, typeof	这些运算符不能被重载。

c#接口

接口定义了所有类继承接口时应该遵循的语法合同。接口定义了语法合同”是什么”部分，派生类定义了语法合同”怎么做”部分。

接口定义了属性、方法、事件，这些都是接口的成员。接口只包含了成员的声明。成员的定义是派生类的责任。接口提供了派生类应该遵循的标准结构。

接口使得实现接口的类或者结构在形式上保持一致。

抽象类在某种程度上与接口类似，但是，它们大多只是用在当只有少数方法由基类声明由派生类实现时。接口本身并不实现任何功能，它只是和声明实现该接口的对象订立一个必须实现哪些行为的契约。抽象类不能直接实例化，但允许派生出具体的，具有实际功能的类。

接口可以继承，如果一个接口继承了其他的接口，那么实现类或者结构就要实现所有接口的成员。

C#命名空间(Namespace)

命名空间的设计目的是提供一种让一组名称与其他名称分割开的形式。在一个命名空间中声明的类的名称与另一个命名空间中声明的相同的类的名称不冲突。
实例

using System;
namespace first_space
{
   class namespace_cl
   {
  public void func()
      {
         Console.WriteLine("Inside first_space");
      }
   }
}
namespace second_space
{
   class namespace_cl
   {
      public void func()
      {
         Console.WriteLine("Inside second_space");
      }
   }
}  
class TestClass
{
   static void Main(string[] args)
   {
      first_space.namespace_cl fc = new first_space.namespace_cl();
      second_space.namespace_cl sc = new second_space.namespace_cl();
      fc.func();
      sc.func();
      Console.ReadKey();
   }
}

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

Inside first_space
Inside second_space

C#异常处理

异常是在程序执行期间出现的问题。C# 中的异常是对程序运行时出现的特殊情况的一种响应，比如尝试除以零。

异常提供了一种把程序控制权从某个部分转移到另一个部分的方式。C# 异常处理时建立在四个关键词之上的：try、catch、finally 和 throw。

try：一个 try 块标识了一个将被激活的特定的异常的代码块。后跟一个或多个 catch 块。
catch：程序通过异常处理程序捕获异常。catch 关键字表示异常的捕获。
finally：finally 块用于执行给定的语句，不管异常是否被抛出都会执行。例如，如果您打开一个文件，不管是否出现异常文件都要被关闭。
throw：当问题出现时，程序抛出一个异常。使用 throw 关键字来完成。

C#文件的输入与输出

一个文件是一个存储在磁盘中带有指定名称和目录路径的数据集合。当打开文件进行读写时，它变成一个流。

从根本上说，流是通过通信路径传递的字节序列。有两个主要的流：输入流 和 输出流。输入流用于从文件读取数据（读操作），输出流用于向文件写入数据（写操作）。

C#特性（Attribute）

特性（Attribute）是用于在运行时传递程序中各种元素（比如类、方法、结构、枚举、组件等）的行为信息的声明性标签。您可以通过使用特性向程序添加声明性信息。一个声明性标签是通过放置在它所应用的元素前面的方括号（[ ]）来描述的。

特性（Attribute）用于添加元数据，如编译器指令和注释、描述、方法、类等其他信息。.Net 框架提供了两种类型的特性：预定义特性和自定义特性。

规定特性（Attribute）
规定特性（Attribute）的语法如下：

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

特性（Attribute）的名称和值是在方括号内规定的，放置在它所应用的元素之前。positional_parameters 规定必需的信息，name_parameter 规定可选的信息。

预定义特性（Attribute）
.Net 框架提供了三种预定义特性：

AttributeUsage
Conditional
Obsolete

AttributeUsage

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

规定该特性的语法如下：

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

其中：

参数 validon 规定特性可被放置的语言元素。它是枚举器 AttributeTargets 的值的组合。默认值是 AttributeTargets.All。
参数 allowmultiple（可选的）为该特性的 AllowMultiple 属性（property）提供一个布尔值。如果为 true，则该特性是多用的。默认值是 false（单用的）。
参数 inherited（可选的）为该特性的 Inherited 属性（property）提供一个布尔值。如果为 true，则该特性可被派生类继承。默认值是 false（不被继承）。

C#反射（Reflection）

反射指程序可以访问、检测和修改它本身状态或行为的一种能力。

程序集包含模块，而模块包含类型，类型又包含成员。反射则提供了封装程序集、模块和类型的对象。

您可以使用反射动态地创建类型的实例，将类型绑定到现有对象，或从现有对象中获取类型。然后，可以调用类型的方法或访问其字段和属性。

优缺点
优点：
1、反射提高了程序的灵活性和扩展性。
2、降低耦合性，提高自适应能力。
3、它允许程序创建和控制任何类的对象，无需提前硬编码目标类。

缺点：
1、性能问题：使用反射基本上是一种解释操作，用于字段和方法接入时要远慢于直接代码。因此反射机制主要应用在对灵活性和拓展性要求很高的系统框架上，普通程序不建议使用。
2、使用反射会模糊程序内部逻辑；程序员希望在源代码中看到程序的逻辑，反射却绕过了源代码的技术，因而会带来维护的问题，反射代码比相应的直接代码更复杂。

反射（Reflection）的用途

反射（Reflection）有下列用途：

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

C#属性（Property）

属性（Property）是类（class）、结构（structure）和接口（interface）的命名（named）成员。类或结构中的成员变量或方法称为域（Field）。属性（Property）是域（Field）的扩展，且可使用相同的语法来访问。它们使用访问器（accessors）让私有域的值可被读写或操作。

属性（Property）不会确定存储位置。相反，它们具有可读写或计算它们值的访问器（accessors）。

例如，有一个名为Student的类，带有age、name和code的私有域。我们不能在类的范围以外直接访问这些域，但是我们可以拥有访问这些私有域的属性。

C#索引器（Indexer）

索引器（Indexer）允许一个对象可以像数组一样使用下标的方式来访问。

当您为类定义一个索引器时，该类的行为就会像一个虚拟数组（virtual array）一样。您可以使用数组访问运算符 [ ] 来访问该类的的成员。

索引器（Indexer）的用途

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

定义一个属性（property）包括提供属性名称。索引器定义的时候不带有名称，但带有 this 关键字，它指向对象实例。

C#委托（Delegate）

C#中的委托（Delegate）类似于C或C++中函数的指针。委托（Delegate）是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。

委托（Delegate）特别用于实现事件和回调方法。所有的委托（Delegate）都派生自 System.Delegate 类。

C#事件（Event）

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

C#集合（Collection）

集合（Collection）类是专门用于数据存储和检索的类。这些类提供了对栈（stack）、队列（queue）、列表（list）和哈希表（hash table）的支持。大多数集合类实现了相同的接口。

集合（Collection）类服务于不同的目的，如为元素动态分配内存，基于索引访问列表项等等。这些类创建Object类的对象的集合。在C#中，Object类是所有数据类型的基类。

C#泛型（Generic）

泛型（Generic）允许您延迟编写类或方法中的编程元素的数据类型的规范，直到实际在程序中使用它的时候。换句话说，泛型允许您编写一个可以与任何数据类型一起工作的类或方法。

您可以通过数据类型的替代参数编写类或方法的规范。当编译器遇到类的构造函数或方法的函数调用时，它会生成代码来处理指定的数据类型。

泛型（Generic）的特性
使用泛型是一种增强程序功能的技术，具体表现在以下几个方面：

它有助于您最大限度地重用代码、保护类型的安全以及提高性能。
您可以创建泛型集合类。.NET 框架类库在 System.Collections.Generic 命名空间中包含了一些新的泛型集合类。您可以使用这些泛型集合类来替代 System.Collections 中的集合类。
您可以创建自己的泛型接口、泛型类、泛型方法、泛型事件和泛型委托。
您可以对泛型类进行约束以访问特定数据类型的方法。
关于泛型数据类型中使用的类型的信息可在运行时通过使用反射获取。

C#匿名方法

我们已经提到过，委托是用于引用与其具有相同标签的方法。换句话说，您可以使用委托对象调用可由委托引用的方法。

匿名方法（Anonymous methods）提供了一种传递代码块作为委托参数的技术。匿名方法是没有名称只有主体的方法。

在匿名方法中您不需要指定返回类型，它是从方法主体内的 return 语句推断的。

C#多线程

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

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

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

C#不安全代码

当一个代码块使用 unsafe 修饰符标记时，C# 允许在函数中使用指针变量。不安全代码或非托管代码是指使用了指针变量的代码块。

参考资料

菜鸟教程-C#教程 https://www.runoob.com/csharp/csharp-tutorial.html