C# 快速入门

随着业务的不断变化,开始在不同的编程语言之间左右横跳,今天又要搞搞C#了,写一篇快速入门的博客来做做记录。

CLR#

公共语言运行时,类似LVVMCLR 会将 C# 代码先编译成IL Code(中间语言),然后再根据对应的运行平台编译成对于平台能识别的机器码。(但是C#无法像JAVA那样去跨平台)

#

C#的类和大多数高级语言是一样的,都是由 属性 和 方法 组成,或者说 类 是 属性和方法的容器。

1
2
3
4
5
6
7
8
9
class World
{
string name;
int age = 10;

int score() {
return minScore;
}
}

namespace#

简单的理解就是 类 的容器。通常一个 包 包含多个namespace ,一个 namespace 包含多个类。

1
2
3
4
5
6
7
namespace Hello
{
class World
{

}
}

变量 & 常量#

C# 中,既可以使用 类型 + 变量名 的方式,也可以使用var + 变量名的方式

1
2
3
string name;
int age = 10;
var minScore = 100;

而常量则通常使用 const 而不是像Swift一样使用let

1
2
3
const float BASE_SCORE = 1.2;

var finalScore = BASE_SCORE * 10;

数据类型在转换#

隐式转换#

1
2
3
byte bNum = 20;
int iNum = bNum; // iNum = 20
float fNum = iNum; // fNum = 20.00

显示转换(强制转换)#

1
2
float fNum = 10.00f;
int iNum = (int)fNum; // iNum = 10

而通过这种强制转换的方法,是不能把 string 转为 int 的。而这个时候就可以使用转换类的解析方法。

1
2
3
string s = "100";
int i = Convert.ToInt32(s); // Convert是.NET框架的一部分
int n = int.Parse(s);

运算符#

绝大多数运算符都和其他语言是一致的,比较值得注意的一点是自增自减问题:

1
2
3
4
var a = 1;
b = ++a;
// b = 2, a = 2
// 因为a在赋值给b之前,完成了自加。
1
2
3
4
var a = 1;
b = a++;
// b = 1, a = 2
// 因为a会先赋值给b,然后再进行自加

方法#

C#的方法使用非常简单,按照 返回类型 方法名(参数类型 参数名)

1
2
3
int main(string[] arg) {
return 0;
}

条件语句 & 循环语句#

1
2
3
4
5
6
7
int a = 10;
if (a == 10) {
// true
}
else {
// false
}
1
2
3
4
5
6
7
8
9
10
11
int i = 0;
while (i < 100) {
// i >= 100 时会跳出循环
i++;
}

int j = 0;
do {
// do-while相比while,第一次会先执行一次do里面的内容。
j++
} while (j < 100)

C#的数据结构#

Array#

1
2
3
4
5
6
7
8
int[] arr = new int[3]{2,3,1};
Console.write(arr[1]) // 3

int[] list = new int[3];
Console.write(list[1]) // 0

list[2] = 20;
Console.write(list[2]) // 20

数组最好不要去修改的

List#

用法类似动态数组。

1
2
3
4
List<int> arr = new List<int>();
arr.Add(2); // 添加一个元素
arr.Rmove(2); // 删除一个元素
arr.RemoveAt(2); // 根据索引删除一个元素

Dictionary#

1
2
3
4
Dictionary<string, int> dic = new Dictionary<string, int>();
dic.Add("key_0",10);
dic.Add("key_1",20);
dic.clear();

Queue#

1
2
3
4
5
6
// 创建内容为Int的队列
Queue<int> que = new Queue<int>();
que.Enqueue(10); // 该队列加入一个元素
que.Dequeue(); // 该队列删除一个元素
que.Clear(); // 清除队列的所有数据
que.Peek(); // 查询队列的所有数据

先进先出

Stack#

1
2
3
4
5
Stack<int> stack = new Stack<int>();
stack.Push(69);
stack.Pop();
stack.Clear();
stack.Peek();

后进先出

委托与事件#

主要作用:

  1. 把方法当作参数进行传递,通常和闭包配合。
  2. 通过委托,实现模块解耦。

常见类型:

  1. Action
  2. Func
  3. Delegate
  4. Event

Action#

Action是C#最简单的一种委托,适用于无返回值的函数

1
2
3
4
5
6
7
8
9
10
11
12
13
void initProgram(Action action) {
aciotn();
}

void TestAction() {
}

// 当参数类型是Action的时候,就可以直接传入一个函数
initProgram(TestAction);
// 或者使用匿名函数
initProgram(()=>{
// Content...
});

如果需要参数:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Action<int> mainAction;

void TestAction(int a) {
Console.Write("TestAction:" + a);
}

void ResultAction(int a) {
Console.Write("ResultAction:" + a);
}

// 只有一个对象赋值的时候就直接等号,多个对象就加等
mainAction += TestAction;
mainAction += ResultAction;

mainAction(10);
// 结果:TestAction:10 ResultAction:10
1
2
3
4
5
6
7
8
9
10
11
// Func泛型中的三个参数,前两个是参数类型,最后一个返回值类型
void initProgram(Func<int, int, string> callBack) {
if (callBack != null) {
var result = callBack(10, 23);
Console.Write(result);
}
}

initProgram((a, b)=>{
return "String:" + (a + b);
}

Func#

Func 是对于 Action 的补充,在支持 Action 的基础功能,还支持返回值。
Func 的泛型中必须有类型:Func,其中类型中的类型的最后一个便是返回值类型。

1
2
3
4
5
6
7
8
9
10
11
// Func泛型中的三个参数,前两个是参数类型,最后一个返回值类型
void initProgram(Func<int, int, string> callBack) {
if (callBack != null) {
var result = callBack(10, 23);
Console.Write(result);
}
}

initProgram((a, b)=>{
return "String:" + (a + b);
}

Delegate#

Delegate 在 C# 中不如 Objective-C 中那样常用。因为有着更加灵活的 Action 和 Func。
但是在用法上和功能上都和OC非常的类似,比如有需要使用函数指针或者代理的时候等等。

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
namespace Learn {
class LearnDelegate {
// 创建一个 delegate 函数
public delegate string DelegateHandler(int a);
// 用这个函数申明一个对象
public DelegateHandler handler;

public void ExecuteDelegateHandler() {
if (handler != null) {
// 在需要执行这个函数的地方使用
handler(99);
}
}
}
}



namespace Learn
{
class Program
{
static void Main(string[] args)
{
var file = new Program();
file.initProgram();
}

void initProgram() {
var delegateHandler = new LearnDelegate();
delegateHandler.handler = ResultAction;
// 在实现这个委托的类里面写一个符合这个委托格式的函数,并赋值。
delegateHandler.ExecuteDelegateHandler();
}

string ResultAction(int a) {
Console.WriteLine();
Console.Write("ResultAction:" + a);
return "ResultAction:" + a;
}
}
}

Event#

Event 在 C# 中就是特色的 Delegate,在代码层面的区别很小:

1
2
3
delegate string DelegateHandler(int a);
event DelegateHandler handler;
// 创建方式和Delegate一样,只是需要添加event关键字

使用方式和Delegate也是一样的,但是区别在于,Event 只能在本类中调用,不能在类外调用。

同时类外注册的时候,必须通过 += 的方式,而不是 =

1
2
3
delegateHandler.handler = ResultAction;    // Error

delegateHandler.handler += ResultAction; // Right

多线程#

1
2
3
4
5
6
7
8
9
10
11
12
13
void initProgram() {
// 使用ThreadStart委托注册一个threadStartFunc函数
var ts = new ThreadStart(threadStartFunc);
var thr = new Thread(ts);
var thr1 = new Thread(ts);
thr.Start(); // 执行
thr1.Start();
Console.Write("initProgram\n");
}

void threadStartFunc() {
Console.Write("threadStartFunc:\n");
}

参考#

快速入门C#
C#教程

学习Unity Script ( C# ) Visual Studio Code 学习

Comments

Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×