C#初学笔记

初步学习网址

https://www.runoob.com/csharp/csharp-intro.html
本文基于有C语言c++基础 着重讲解c#与c语言c++有所不同的地方

Console.writeline的参数

static void Main(string[] args)
{
Console.WriteLine(“A:{0}，a:{1}”,65,97);
Console.ReadLine();
}

占位符从零开始计数,且占位符中的数字不能大于第二个参数的个数减一(要求占位符必须有可替换的值).占位符数字与第二个参数字符位置一一对应.

C#数据类型

值类型
int char float等
引用类型
object

using System;
namespace RectangleApplication
{
class ExecuteRectangle
{
static void Main(string[] args)
{
int a=9;
object obj;
obj = a;
obj =10;
Console.WriteLine(“2: {0}”, a); // 输出：2: 9
Console.WriteLine(“1: {0}”, obj); // 输出：1: 10
Console.ReadLine();
}
}
}

设置值 int a=9; obj=a; 当obj改变不会对 int a 进行改变，object 只是复制了 int a 的值出来然后对其操作而已。不会影响到 int 原来的值。

dynamic
String

string str = @“C:\Windows”;

等价于

string str = “C:\Windows”;

string 是 C# 中的类，String 是 .net Framework 的类(在 C# IDE 中不会显示蓝色) C# string 映射为 .net Framework 的String 如果用 string, 编译器会把它编译成 String，所以如果直接用 String 就可以让编译器少做一点点工作。

如果使用 C#，建议使用 string，比较符合规范 string 始终代表 System.String(1.x) 或 ::System.String(2.0) ，String 只有在前面有 using System;的时候并且当前命名空间中没有名为 String 的类型（class、struct、delegate、enum）的时候才代表 System.String string 是关键字，String 不是，也就是说 string 不能作为类、结构、枚举、字段、变量、方法、属性的名称，而 String 可以。

String 是 CLR 的类型名称（也算是关键字），而 string 是 C# 中的关键字。string 在编译时候 C# 编译器会默认将其转换为 String，在这里会多增加几行转换的代码。很多时候都是建议使用 CLR 的类型而不要使用 C# 的类型（这是专家的建议）。比如说还有：使用 int 的时候最好使用 Int32 等。很多时候都是一个习惯问题，规范问题。还有一个不同就是在 VS 中表现的颜色不一样：String 是绿色，string 是蓝色。
指针类型

关于值类型、引用类型以及“栈”跟“堆”的关系

值类型，声明一个值类型的时候，是在“栈”中开辟一个内存空间来存放对应的值，当值类型的值发生改变的时候，则直接修改该内存空间所保存的值。例：

int n1 = 5;
int n2 = n1;
Console.WriteLine(n1 + " "+ n2); // 5 5
n2 = 7;
Console.WriteLine(n1 + " " + n2) // 5 7

这里首先在“栈”中开辟一个内存空间用来保存 n1 的值 5，接着再在“栈”中开辟一个新的内存空间用来保存 n2 的值 5，所以显示出来的结果是 5 5。然后将 n2 在“栈”中对应的内存空间保存的值修改成 7，故显示出来的结果是 5 7。

引用类型，声明一个引用类型的时候，首先是在“堆”中开辟一个内存空间来存放对应的值，然后在“栈”中开辟一个内存空间用于保存在“堆”中开辟的内存空间的地址。当系统调用引用类型的时候，首先去“栈”中获取到地址，然后根据地址在“堆”中找到对应的内存空间来获取到对应值。像数组这样的引用类型

string[] a1 = new string[]{ “a” , “b” , “c” };
string[] a2 = a1;
for(int i = 0; i < a2.Length; i++)
{
Console.Write(a2[i] + " "); //a b c
}
a1[2] = “d”;
Console.WriteLine(); //换行
for(int i = 0; i < a2.Length; i++)
{
Console.Write(a2[i] + " "); //a b d
}
Console.WriteLine();

这里首先是在“堆”中开辟一个内存空间(假设：0X55)用来保存数组a1的值，然后在“栈”中开辟一个内存空间（a1）用于保存地址 0X55。当将 a1 赋给 a2 时，是将地址赋给 a2，即在“栈”中开辟一个内存空间（a2）用于保存地址 0X55，所以输出 a2 的值是 a b c。当将 a1[2]修改成”d”的时候，修改的是“堆”中 0X55 内存空间保存的值，因为 a2 的地址和 a1 的地址一样，所以输出结果是 a b d。

而 string 是一个特殊的引用类型，先看下面代码：

string a = “123”;
string b = a;
Console.WriteLine(a+" “+b); //123 123
string b = “456”;
Console.WriteLine(a+” "+b); //123 456

和数组类似的，这里首先在“堆”中开辟一个内存空间(假设：0X88)用来保存 a 的值 123，然后在“栈”中开辟一个内存空间（a）用于保存地址 0X88。

和数组不同的是，当将 a 赋给 b 的时候，首先是在“堆”中开辟一个新的内存空间(假设：0X101)用于保存值 123，然后在“栈”中开辟一个内存空间（b）用于保存地址 0X101，所以输出的结果是 123 123。

当修改 b 值时，并不是修改“堆”中 0X101 内存空间的值，而是在“堆”中重新开辟一个新的内存空间(假设：0X210)用于保存 b 修改后的值，然后将 b 在“栈”中对应的内存空间的所保存的地址修改成 0X210，所以输出的结果是 123 456。而“堆”中的 0X101 内存空间将在下次的垃圾回收中被回收利用。

C#类型转换

c#提供了很多转换的api接口

string locstr = 123.ToString();
//如果要将"locstr"转成整型数
//方法一: 用 Convert
int i = Convert.ToInt16(locstr);
//方法二: 用 Parse
int ii = int.Parse(locstr);

int.TryParse(string s,out int i)

该方式也是将数字内容的字符串转换为int类型，但是该方式比int.Parse(string s) 好一些，它不会出现异常，最后一个参数result是输出值，如果转换成功则输出相应的值，转换失败则输出0。

class test
{
static void Main(string[] args)
{
string s1=“abcd”;
string s2=“1234”;
int a,b;
bool bo1=int.TryParse(s1,out a);
Console.WriteLine(s1+" “+bo1+” “+a);
bool bo2=int.TryParse(s2,out b);
Console.WriteLine(s2+” “+bo2+” "+b);
}
}

Convert.ToInt32() 与 int.Parse() 的区别

没搞清楚 Convert.ToInt32 和 int.Parse() 的细细微区别时千万别乱用，否则可能会产生无法预料的结果，举例来说：假如从 url 中取一个参数 page 的值，我们知道这个值是一个 int，所以即可以用 Convert.ToInt32(Request.QueryString[“page”])，也可以用 int.Parse(Request.QueryString[“page”])，但是如果 page 这个参数在 url 中不存在，那么前者将返回 0，0 可能是一个有效的值，所以你不知道 url 中原来根本就没有这个参数而继续进行下一下的处理，这就可能产生意想不到的效果，而用后一种办法的话没有 page 这个参数会抛出异常，我们可以捕获异常然后再做相应的处理，比如提示用户缺少参数，而不是把参数值当做 0 来处理。

(1) 这两个方法的最大不同是它们对 null 值的处理方法： Convert.ToInt32(null) 会返回 0 而不会产生任何异常，但 int.Parse(null) 则会产生异常。

(2) 对数据进行四舍五入时候的区别

a. Convert.ToInt32(double value) 如果 value 为两个整数中间的数字，则返回二者中的偶数；即 3.5 转换为 4，4.5 转换为 4，而 5.5 转换为 6。不过 4.6 可以转换为 5，4.4 转换为 4 。
b. int.Parse(“4.5”) 直接报错:“输入字符串的格式不正确”。
c. int(4.6) = 4 Int 转化其他数值类型为 Int 时没有四舍五入，强制转换。

(3) 对被转换类型的区别 int.Parse 是转换 String 为 int, Convert.ToInt32 是转换继承自 Object 的对象为 int 的(可以有很多其它类型的数据)。你得到一个 object 对象, 你想把它转换为 int, 用 int.Parse 就不可以, 要用 Convert.ToInt32。

C#变量

方法的局部变量必须在代码中显式初始化，之后才能在语句中使用它们的值。此时，初始化不是在声明该变量时进行的，但编译器会通过方法检查所有可能的路径，如果检测到局部变量在初始化之前就使用了它的值，就会产生错误。

例如：

public static int Main(){
int d;
Console.WriteLine(d);
}

在这段代码中，演示了如何定义 Main()，使之返回一个 int 类型的数据，而不是 void。但在编译这些代码时，会得到下面的错误消息：

Use of unassigned local variable ‘d’

正确的做法是初始化它 int d = 0 或者其他值。

C#常量

1.静态常量（编译时常量）const

在编译时就确定了值，必须在声明时就进行初始化且之后不能进行更改，可在类和方法中定义。定义方法如下：

const double a=3.14；// 正确声明常量的方法
const int b; // 错误，没有初始化

2.动态常量（运行时常量）readonly

在运行时确定值，只能在声明时或构造函数中初始化，只能在类中定义。定义方法如下：

class Program
{
readonly int a=1; // 声明时初始化
readonly int b; // 构造函数中初始化
Program()
{
b=2;
}
static void Main()
{
}
}

C#运算符 判断 循环

C# 也支持 foreach 循环，使用foreach可以迭代数组或者一个集合对象。

以下实例有三个部分：
通过 foreach 循环输出整型数组中的元素。
通过 for 循环输出整型数组中的元素。
foreach 循环设置数组元素的计算器。

实例

class ForEachTest
{
static void Main(string[] args)
{
int[] fibarray = new int[] { 0, 1, 1, 2, 3, 5, 8, 13 };
foreach (int element in fibarray)
{
System.Console.WriteLine(element);
}
System.Console.WriteLine();
// 类似 foreach 循环
for (int i = 0; i < fibarray.Length; i++)
{
System.Console.WriteLine(fibarray[i]);
}
System.Console.WriteLine();
// 设置集合中元素的计算器
int count = 0;
foreach (int element in fibarray)
{
count += 1;
System.Console.WriteLine(“Element #{0}: {1}”, count, element);
}
System.Console.WriteLine(“Number of elements in the array: {0}”, count);
}
}

c#封装

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

Internal 访问修饰符
Internal 访问说明符允许一个类将其成员变量和成员函数暴露给当前程序中的其他函数和对象。换句话说，带有 internal 访问修饰符的任何成员可以被定义在该成员所定义的应用程序内的任何类或方法访问。
下面的实例说明了这点：

using System;
namespace RectangleApplication
{
class Rectangle
{
//成员变量
internal double length;
internal double width;
double GetArea()
{
return length * width;
}
public void Display()
{
Console.WriteLine(“长度： {0}”, length);
Console.WriteLine(“宽度： {0}”, width);
Console.WriteLine(“面积： {0}”, GetArea());
}
}//end class Rectangle
class ExecuteRectangle
{
static void Main(string[] args)
{
Rectangle r = new Rectangle();
r.length = 4.5;
r.width = 3.5;
r.Display();
Console.ReadLine();
}
}
}

c#方法

也就是函数

ref 和 out 的区别
一个用关键字 ref 标示，一个用 out 标示。
牵扯到数据是引用类型还是值类型。
一般用这两个关键字你是想调用一个函数将某个值类型的数据通过一个函数后进行更改。传 out 定义的参数进去的时候这个参数在函数内部必须初始化。否则是不能进行编译的。ref 和 out 都是传递数据的地址，正因为传了地址，才能对源数据进行修改。
一般情况下不加 ref 或者 out 的时候，传值类型的数据进去实际上传进去的是源数据的一个副本，也就是在内存中新开辟了一块空间，这里面存的值是与源数据相等的，这也就是为什么在传值类型数据的时候你如果不用 return 是无法修改原值的原因。但是你如果用了 ref,或者 out，这一切问题都解决了，因为他们传的是地址。
out 比起 ref 来说，还有一个用法就是可以作为多返回值来用，都知道函数只能有一个返回值，C#里，如果你想让一个函数有多个返回值，那么OUT能很容易解决。

c#可空类型

? 单问号用于对 int、double、bool 等无法直接赋值为 null 的数据类型进行 null 的赋值，意思是这个数据类型是 Nullable 类型的。

int? i = 3;
等同于：
Nullable i = new Nullable(3);
int i; //默认值0
int? ii; //默认值null

?? 双问号用于判断一个变量在为 null 的时候返回一个指定的值。

接下来我们详细说明。

c#数组 字符串 结构体 枚举

C# 结构的特点
您已经用了一个简单的名为 Books 的结构。在 C# 中的结构与传统的 C 或 C++ 中的结构不同。C# 中的结构有以下特点：

结构可带有方法、字段、索引、属性、运算符方法和事件。
结构可定义构造函数，但不能定义析构函数。但是，您不能为结构定义无参构造函数。无参构造函数(默认)是自动定义的，且不能被改变。
与类不同，结构不能继承其他的结构或类。
结构不能作为其他结构或类的基础结构。
结构可实现一个或多个接口。
结构成员不能指定为 abstract、virtual 或 protected。
当您使用 New 操作符创建一个结构对象时，会调用适当的构造函数来创建结构。与类不同，结构可以不使用 New 操作符即可被实例化。
如果不使用 New 操作符，只有在所有的字段都被初始化之后，字段才被赋值，对象才被使用。
类 vs 结构
类和结构有以下几个基本的不同点：

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