通宵爆肝C#-教你如何轻松入门

C#特点

1. 编译目标：编译为中间语言代码，执行时再通过JIT将需要的模块临时编译成代码
2. 内存管理：采用垃圾回收机制，自动回收，不再使用的内存基本不使用指针。
3. 指针：基本不使用指针
4. 继承：只能单继承，但是可以实现多个接口

C#基本知识 

1. Read  从输入流 读入下一个字符，至换行符结束
2. Readkey 从输入流读入一个字符
3. ReadLine 从输入流 读一行文本，至换行符结束
4. Write 输出一行文本（不包括换行）
5. WriteLine 输出一行文本 ，结尾自动换行
6. 单行注释 //                      文档注释 ///                         块注释 /*  */
7. 关键性语句要使用注释，如变量声明，条件判断和循环类应使用文档注释。说明类的简单功能和使用方法。

viusual studio 2022 快捷键   

1. ctrl k +  ctrl c  将选中的代码快速注释

2. ctrl  k+ ctrl u 将选中的代码快速取消注释

变量：

1. 必须以字母开头
2. 只能由字母、数字和下划线组成，而不能包含空格、标点符号、运算符等
3. 名称不能与C#中的关键字名称相同
4. 要实际意义的名称，容易辨别
5. 允许变量名加前缀  @，但不建议

1、int score；   score =100；

2、string usernam    ="好好学习";

常量

1. 常量易于理解
2. 程序易于修改
3. 避免错误

在C#默认静态的，由类型来访问，不能和static使用

const 必须在字段声明时初始化

const 只可以应用在字段和变量

const 智能应用在值类型和string，其他引用类型常量，只能定义为null，否则错误 

一般什么情况使用常量？

1、用于程序中，一旦设定就不允许被修改的值

2、用于在程序中被经常使用的数值

数组：

一维数组

int [ ]  num =new int [  5 ]  { 10，20，30，40，50}；

string [  ]   name   =new string [   ] {“张一丰”，“小刘"} ;

double [  ] score  =  { 99.5, 88.5,65.5 } ;、

1、通过索引号赋值给单独的数组元素

通过使用索引号赋值给单独的数组元素

int[] array = new int[] { 1, 2, 3, 4, 5 };
array[0] = 0;

2、在声明数组的同时给数组赋值

在声明数组的同时给数组赋值

int[] array1 = new int[] { 9, 8, 7, 6, 5 };

3、创建并初始化一个数组

//创建并初始化一个数组
int[] marks = new int[5] { 99, 98, 32, 37, 95 };

4、省略数组大小

//省略数组大小
int[] array2 = new int[] { 98, 99, 32, 37, 95 };

5、赋值一个数组变量到另一个目标数组变量中，在这种情况下，目标和源会指向相同的内存位置

//赋值一个数组变量到另一个目标o数组变量中
//在这种情况下，目标和源会指向相同的内存位置

int[] marks1 = new int[] { 99, 98, 96, 34, 45 };
int[] score1 = marks1;

当您创建一个数组时，C#编译器会根据数组类型隐式转换初始化每个数组元素为一个默认值2、如果声明时未初始化数组，数组成员将自动化转为默认初始值     

二维数组

 int [ ,] num =new int [ 2,3] { { 1,2,3}, {4,5,6 } };

double [ , ] score = new  score  [ , ] { { 63.1 ,73.1.38.0}， {20.8，68.5 } } ；

string [ ， ] name = { { "刘"，“许”}， {“不”，“知”}} ;

1、访问二维数组元素

int[,] array3 = new int[3, 4]
{
    {0,1,2,3 },
    {4,5,6,7},
    {5,6,7,8},
}; //初始化二维数组
foreach (int i in array3)
{
    Console.WriteLine(i);
}
//访问二维数组元素

访问

数组可以是一维数组，二维数组或者多维数组

数值数组元素的默认值是0，而引用元素的默认值是null

数组的索引从0开始，如果数组有几个元素，数组索引从0到n-1

  C#  Array类

Array类可以直接使用Array.方法 不用写一个Array类

属性 Length Rank       变量=数组名.属性

1、Array类 表示所有维度的数组中的元素总数

int[] array5 = new int[] { 1, 10, 2, 3, 5 };
int s = array5.Length;

2、Array类 表示有几个维度 {  {  }  ，{  }  } 2个维度 

int[] array5 = new int[] { 1, 10, 2, 3, 5 };
int a = array5.Rank;
Console.WriteLine(a);

   

Array.方法 

方法 Clear Copy GetLength GetValue
        IndexOf Reverse  SetValue Sort ToString

1、清空数组

int[] array5 = new int[] { 1, 10, 2, 3, 5 };
Array.Clear(array5);

2、获取 有几个维度

int[] array5 = new int[] { 1, 10, 2, 3, 5 };
s = array5.GetLength(0);

3、逆转一维数组中的元素的顺序

int[] array5 = new int[] { 1, 10, 2, 3, 5 };
Array.Reverse(array5);
foreach (int i in array5)
{
    Console.WriteLine(i);
}

4、给一维数组中指定位置设置值 （ 数值，索引）

int[] array5 = new int[] { 1, 10, 2, 3, 5 };
array5.SetValue(100, 1);
foreach (int i in array5)
{
    Console.WriteLine(i);
}

5、升序 一维数组

int[] array5 = new int[] { 1, 10, 2, 3, 5 };
Array.Sort(array5);
foreach (int i in array5)
{
    Console.WriteLine(i);
}

6、返回一个字符串，从对象继承（object）   

int[] array5 = new int[] { 1, 10, 2, 3, 5 };
string a = array5.ToString();
Console.WriteLine(a);//无法直接打开看 需要自己转换

    

                                                                                         

C#的集合

数组的缺点： 1、数组长度不可以改变  2、数组储存数据类型单一

集合的优点： 1、集合长度可以发生改变    2 、集合存储类型多样

集合从object类存储元素，因为object类是所有类的父类，所以可以存储所有类型的值

ArrayList 集合

集合创建： ArrayLIst  list   = new ArrayList （ ）；

集合方法（函数）

1、添加元素  list.Add（数据）;

添加元素
list1.Add(1);
list1.Add(2);
list1.Add(3);
foreach (int i in list1)
{
    Console.WriteLine(i);
}

2、计算集合长度 list.Count；

计算集合长度
int s=list1.Count;
Console.WriteLine(s);

3、计算集合可用长度 list.Capacity ;

   

int a=list1.Capacity ;
Console.WriteLine(a);

4、添加数组内的元素 list .  AddRange（数组）；

int[] array ={ 1,2,3}; 
list1.AddRange(array);
foreach(int i in list1)
{
    Console.WriteLine(i);
}

5、移除集合所有元素 list.Clear（）；

list1.Clear();

6、移除集合某个元素 list.Remove（元素）；

list1.Remove(1);

7、移除集合某个元素 list.RemoveAt（元素索引）；

list1.RemoveAt(0);

8、集合元素升序排列 list.Sort（）；

list1.Sort();

9、集合元素倒序排列   list.Reverse（）； //纯倒序

list1.Reverse();

10、指定集合位置插入元素 list.Insert（ 索引位置，数据）；

list1.Insert(0,100);

11、指定集合位置插入数组元素 list.InsertRange（索引位置，数据）；

list1.InsertRange(0,1);

12、集合位置插入数组元素list.InsertRange（索引位置，数组）；

int[] array2 = { 1, 2 };
list1.InsertRange(0,array2);

13、判断集合是否包含某个元素 list.Contains（元素）； 

list1.Contains(1);

stack集合   //必须using System Collections ；

stack（堆栈）集合用于一个后进后出的机制。在这个集合中，所有元素都遵循后进后出的原则，在stack集合中最后一个元素 最先离开，第一个元素最后离开。

pop（）返回并删除集合顶部的元素

peek（）返回stack集合顶部的元素，但不删除该元素

push（）将指定元素插入到stack集合顶部

创建一个堆栈  ：               Stack mystack = new Stack（）；

入栈  ：                              mystack.Push（元素）；

打印集合的数值：

foreach （ var item in mystack）

{

Console.WriteLine（item）；

} 

获取栈顶元素的值，但是不移除栈顶元素： mystack.Pop（）；

从stack中移除所有元素：  mystack.Clear（ ）；

确定某一个元素是否在stack中

bool answer =mystack,Contains（元素）；

Console.Writeline（answer）；//True or False

从指定数组索引开始将stack复制到一堆数组array

int [ ] nums = new int  [ ] { 234,645,978,45};

mystack .Copy ( num,2);

将stack 复制到新的数组

Stack test = new  Stack（）；

test.Push（123）；

test。Push（234）；

var mya =test.ToArray（）；

获取stack包含的元素个数

mystack.Count（）；   

Queue集合 （object）

Queue（队列）集合用于实现一个先进先出的机制，所有元素都遵循先进先出的原则

Dequeue（）移除并返回于Queue集合开始处的元素 

Peek（）返回位于Queue集合开始处的对象，但不将其移除

Enqueue（）将对象添加到Queue集合的结尾处

新建队列   

using System.Collections；

Queue q =new Queue（）；

入队

byte [  ] RxBuf = new byte [ ] {1,2,3,4,5,6};

q.Enqueue （RxBuf）；//队列加入一个RxBuf 字节数组

出队 返回参数是object类型的，与入队一样，需要强制转换

 if（q.Count>0）

{

byte [ ] vxdata =（byte  [ ]）.q.Dequeue（）；

}

清除队列 

q.Clear（）；

遍历队列所有内容

foreach（ object item in a）

{

Console.WriteLine（item）；

}

C# Queue 容量默认初始容量为32，如果容量不够，根据需要自动增大

Queue 接受引用作为有效值，并且允许重复的元素

2种遍历Queue方法： foreach while（IEnumerator）

Queue转换数组，调用ToArray（）方法

BitArray集合

BitArray是一个布尔集合类，表示管理位值的压缩数组，又称为位数组，它的值只有True（1） False（0）

属性

Count 获取BitArray中包含的元素个数

IsReadOnly（）获取一个数值，表示一BitArray是否只读

Item 获取或设置BitArray（）中指定位置的量

Length获取或设置BitArray中的元素个数

BitArray myba1= new BitArray（s）；//默认False

BitArray myba2= new BitArray（5，True）；//全是True

Byte [ ] mybytes = new byte [ 5 ] {1,2,3,4,5};

Byte [ ] mybytes 1= new byte [ 5 ] {1,2,3,4,5};