正在加载···
AI摘要
HunYuan-Lite

一、C#介绍

源于c语言，简单易学，入门超快，减少了烦人的指针，有统一的操作符/修饰符/运算符，使用起来简洁称心。不仅如此：

  1. 它是结构化语言，能产生高效率的程序
  2. 面向组件，开发快速
  3. 在多种计算机平台上编译，良好兼容性
  4. 优秀的版本管理控制，安装卸载和其他程序不影响
  5. .Net框架一部分

都是她被广泛应用的原因。

它不仅是按照面向对象设计的语言，而且还类型安全，还有更多让人舒心的功能：

  1. 自动垃圾回收
  2. 属性、事件、委托等
  3. 标准库
  4. 简单多线程
  5. Lambad表达式

二、.NET简介

.NET框架是一个集成、一个环境、一个非常强大的平台，是微软推出的核心技术。开发式的体系结构，覆盖的内容非常广：

熬夜爆肝整理万字C#基础入门大总结【建议收藏】

由上图看出.NET Framework是.NET最重要的核心技术。Framework提供了多语言开发，而C#是其中核心语言。

熬夜爆肝整理万字C#基础入门大总结【建议收藏】

三、VS快捷键

先来普及回顾下VS中的常用快捷键

Ctrl+K+D:快速对齐代码

Ctrl+Z:撤销

Ctrl+S:保存(一定要经常保存！)

Ctrl+J:快速弹出智能提示

Shift+End 、Shift+Home

Ctrl+K+C:注释所选代码

Ctrl+K+U:取消对所选代码的注释

F1：转到帮助文档

折叠冗余代码：#Region 和#EndRegion（Android Studio也可以自定义折叠代码 //region //endregion 快捷键 Ctrl+Alt+T）

单行注释：//

多行注释：/要注释的内容/

文档注释：/// 多用来解释类或者方法

四、数据类型

编程基础就不强调了，主要看看拼写和其他语言有什么不同就行了

熬夜爆肝整理万字C#基础入门大总结【建议收藏】

除了这些值类型还有引用类型，包含对象类型，动态类型，字符串类型

字符串类型：string或者String，注意s大小写，平时都能用，但也有小区别。

字符串有个@符号可以将转移字符当成普通字符，且@符会保留字符串里面的换行符空格符等

例：string str=”D:\alibaba”; 等价于string str=@”D:\alibaba”;

动态类型：dynami，他会根据内容自动存储对应类型

例：dynamic str=”这是字符”; dynamic number=10; 就像前端的var类型

对象类型：ogject，所有类型的最低基类，能分配任何类型的值，麻烦就是用的时候可能经常得进行类型转换。

五、转义字符

熬夜爆肝整理万字C#基础入门大总结【建议收藏】

六、运算符

仍然是直接上表格图，编程基础。

熬夜爆肝整理万字C#基础入门大总结【建议收藏】
熬夜爆肝整理万字C#基础入门大总结【建议收藏】
熬夜爆肝整理万字C#基础入门大总结【建议收藏】
熬夜爆肝整理万字C#基础入门大总结【建议收藏】

七、判断/循环

逻辑判断仍然是编程老鸟的基基础，只是简单概括一下

  • 判断语句：if else switch
  • 循环语句：while for foreach do…while break continue

八、访问修饰符

C#可以设置使用者的访问权限，这样开发者可以指定该模块或逻辑是公开，封闭，还是指定访问者。不知道其他语言什么样，跟Java是一样样的。

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

九、可变类型/合并运算符

  • 可空类型（Nullable）：表示其基础类型除了默认的值外，再添加一个null值。例如：int? num = 1; double? num= new double?();
  • Null合并运算符（？？）：如果第一个操作数为null，则返回第二个操作数，否则返回第一个，就像Java的？：运算。

例如 A=B??C 如果B为空则将C赋值给A，如果B 不为空则将B赋值给A。

十、数组

数组类型是若干个数据类型相同的数据元素组成的数据结构。C#也是分为一维数组和多维数组，多维数组又包括矩形数组和交错数据。
还有一个参数数组，可以传递未知数量参数给函数。这个就像Java中的(int… num)。

例:

1
2
ParamArray app = new ParamArray();
int sum = app.AddElements(512, 720, 250, 567, 889);

数组类型基本是System.Array类的派生类，快捷键Ctrl+左键进入源码，快速学习都有什么功能实现。

十一、结构体

它能用单一变量存储多个数据类型，举例：一个书变量，可以存作者，标题，出版社，价钱等基础变量。超好理解，和Java的实体一样，就是需要struct关键字来修饰创建结构体。特点：

  1. 结构可带有方法、字段、索引、属性、运算符方法和事件。
  2. 结构可定义构造函数，但不能定义析构函数。但是，您不能为结构定义无参构造函数。无参构造函数 (默认)是自动定义的，且不能被改变。
  3. 与类不同，结构不能继承其他的结构或类。
  4. 结构不能作为其他结构或类的基础结构。
  5. 结构可实现一个或多个接口。
  6. 结构成员不能指定为 abstract、virtual 或 protected。
  7. 当您使用 New 操作符创建一个结构对象时，会调用适当的构造函数来创建结构。与类不同，结构可以不使用 New 操作符即可被实例化。
  8. 如果不使用 New 操作符，只有在所有的字段都被初始化之后，字段才被赋值，对象才被使用。
  9. 结构体的字段可以加前缀”_”来和变量区分
  10. 结构体快捷键：首选选中你要自动完成的变量，先按ctrl+R,再按ctrl+E这两个组合键，可以自动生成属性中的get和set方法

十二、枚举

就是命名一组整型常量，不能继承或传递继承，只能当常量使用。举例：enum Number{one,two,three}; 则Number.one等于0 Number.two等于1，以此类推枚举可以和结构体结合：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public struct Person{        

public string _name;//字段        

public int _age;        

public Gender _gender;    

}    

public enum Gender   {         男,        女}

Person zsPerson;

zsPerson._name = "张三";

zsPerson._age = 21;

zsPerson._gender = Gender.男;

十三、类/函数

类仍然是class修饰，在class前面可以指定对类及成员的访问规则，若没写则类默认是internal，成员访问是private。

例：public class ClassName { }

函数和Java同样含有构造函数和带参函数，在这多了一个析构函数，是一个特殊的成员函数。是一个新知识需要记一下。

析构函数以~作为前缀，不需要任何修饰符，不返回值，也不带参数，不能继承或重载。官方文档大致意思就是用来释放资源的，只不过并非是在不使用的时候立即释放，它是懒惰的，垃圾回收机制会在适当的时候回收，比如内存紧张，关闭程序等时候。这和Android里面的onDestory有异曲同工之妙，同样的，也有GC方法来强制回收。

十四、继承/多重继承

继承是面向对象设计的最重要概念之一，一个类继承自另一个类，举例：

1
2
class A{ } 
class B:A{ }

B继承自A，B可以称为派生类也可以称为子类，A可以称为基类也可以称为父类。（派生类和基类，子类和父类） 。B拥有访问A的能力，形象点说就是子类可以拿到父类的财产，父类拿不到子类的财产。

C#不支持多重继承，我咨询过C++同事，C++支持多重继承。

十五、多态

面向对象程序的核心功能之一，是同一个行为具有多个不同表现的能力。C#和Java都是面向对象的，它们的多态思想基本是一致的。优点多多：

  1. 消除类型间耦合关系
  2. 具有可扩充性，增强灵活性
  3. 接口性，实现简单

C#包含静态多态和动态多态，静态多态又包含：函数重载和运算符重载。

函数重载：就是相同的函数名有多个定义。函数的参数类型或个数不同来实现。例如：

1
2
3
4
5
int test(int num1){}

int test(int num1,int num2){}

int test(int num1,string str1){}

运算符重载看示例更形象，但是示例代码多，就不在这记了，感兴趣的可以自己去搜索学习

动态重载使用的是用abstract创建的抽象类，另一个是借助关键字virtual修饰的虚方法类似实现。示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
namespace Test
{
   abstract class Shape
   {
       abstract public int area();
   }
   class Rectangle:  Shape
   {
      private int length;
      private int width;
      public Rectangle( int a=0, int b=0)
      {
         length = a;
         width = b;
      }
    //注意着的override
      public override int area ()
      {
         Console.WriteLine("Rectangle 类的面积：");
         return (width * length);
      }
   }

   class RectangleTester
   {
      static void Main(string[] args)
      {
         Rectangle r = new Rectangle(10, 7);
         double a = r.area();
         Console.WriteLine("面积：{0}",a);
         Console.ReadKey();
      }
   }
}
//虚方法示例
namespace Test
{
   class Shape
   {
      protected int width, height;
      public Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      // 关键字virtual
      public virtual int area()
      {
         Console.WriteLine("父类的面积：");
         return 0;
      }
   }
   class Rectangle: Shape
   {
      public Rectangle( int a=0, int b=0): base(a, b)
      {
      }
      public override int area ()
      {
         Console.WriteLine("Rectangle 类的面积：");
         return (width * height);
      }
   }
   class Triangle: Shape
   {
      public Triangle(int a = 0, int b = 0): base(a, b)
      {

      }
      public override int area()
      {
         Console.WriteLine("Triangle 类的面积：");
         return (width * height / 2);
      }
   }  
   class Tester
   {

      static void Main(string[] args)
      {
         Rectangle r = new Rectangle(10, 7);
         Triangle t = new Triangle(10, 5);
         c. area ();
         c. area ();
         Console.ReadKey();
      }
   }
}

十六、接口

接口使用interface关键字声明，和类class的声明差不多，默认是public类型的。但是当有多个类，多个类有多个相同的方法，使用接口来实现方便管理，且不会丢失。和Java使用基本是一致的。示例：

1
2
3
4
5
6
7
8
9
10
11
12
interface ITestInterface
{
    void TestInterfaceMethod();
}

public class Test : ITestInterface
{
    public void TestInterfaceMethod()    
    {  

    }
}

十七、命名空间

Namespace这玩意就是用来方便管理的，而且在计算机中相同的设计思想到处可见，比如同一个文件夹下不能有同名的文件，你放在不同文件夹下可以有同名文件。
其他编程语言比如Java有包路径，不同路径名字可以有同名的类。这种思想方便管理文件/代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
namespace first_space{  

 class namespace_cl   {   }

//比如这样，程序是会报错的  

 class namespace_cl   {   }

}

//但是你是下面的状态就不会报错

namespace first_space{  

 class namespace_cl   {   }

}

namespace second_space{ 

  class namespace_cl   { }

}

到这有的人就开始有疑问了：如果是不同的文件或者想访问其他的空间怎么办呢？

细心的已经发现了，就和Java的导包一样，C#使用using导入空间，在每个编程文件的最上面几行都是这样的引入，想要哪些空间的功能导入哪个。

这时候又有人有疑问了，能不能修仙小说那样天外有天，天上还有天。能不能命名空间套命名空间，套套套，此处禁止套娃。

答案是可以的，引入的时候：using namespaceone.namespacetwo 用英文符号.即可，跟Java包路径同理。

十八、预处理器

从字面理解就是提前对信息进行处理。她确实也是这样的，她会根据你指定的条件，只编译满足条件的代码，不满足条件的代码不编译。既区分了软件版本，代码还在一块，管理方便。预处理指令是#开始的，且只能作为开头，一般指令单独占一行。都有哪些指令在这就不单独写了。在Unity中指令挺有用的，因为PC是键盘，Android事件是手势，用预处理提前写好不同端的不同实现代码（当然它们功能可能是一致的），打包发布的时候利人利己。

十九、异常

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

二十、反射

通俗的讲就是可以访问一个类的所有属性和方法，且能够调用。有人提问了：随便写的public类不都是能任意访问调用的吗，这有什么区别？

区别在于一个是正常写代码，你知道代码逻辑和内容，且都在你的掌控之内，当然能访问；而反射不同它能够访问你不清楚的类，比如三方框架你遇到这个框架里某个类某个方法没有对外开放，而你又需要使用，就可以用反射把它抛出来。

优点：

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

缺点：

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

二十一、属性

get/set方法,没什么可讲的。

二十二、委托

使用关键字delegate来修饰，必须用new关键字来创建，且与某个特定方法关联。

比较官方的说法：表示对具有特定参数列表和返回类型的方法的引用。通过委托，可以将方法视为可分配给变量并可作为参数传递的实体。委托还类似于其他一些语言中存在的“函数指针”概念。与函数指针不同，委托是面向对象且类型安全的。

按照自己的理解：委托就是包一个外壳，操作外壳就是调用壳内的内容。就好像老板让你板砖，你委托给另一个人让她板砖。这就是委托。

委托中还能通过加减号来实现多个，称之为多播。只有相同类型的委托可以合并。

使用场景：因刚需C#没什么实际经验，大家知道有什么好的实际应用环境吗?

委托示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
//这个是声明个委托
    delegate int NumberChanger(int n);
    static int num = 10;
    public static int AddNum(int p)
    {
        num += p;
        return num;
    }
    public static int MultNum(int q)
    {
        num *= q;
        return num;
    }

    static void Main(string[] args)
    {
        // 创建委托实例
        NumberChanger nc;
        NumberChanger nc1 = new NumberChanger(AddNum);
        NumberChanger nc2 = new NumberChanger(MultNum);
        // 使用委托对象调用方法
        nc1(25);
        Console.WriteLine("Value of Num: {0}", num);
        nc2(5);
        Console.WriteLine("Value of Num: {0}", num);
        //下面是组播 使用  +或- 符号操作
        nc = nc1;
        nc += nc2;
        // 调用多播
        nc(5);
        Console.WriteLine("Value of Num: {0}", num);
        Console.ReadKey();
       //输出结果为：
            //Value of Num: 35
            //Value of Num: 175
            //Value of Num: 75
}