Chaptor 1 . C# Language Basics
内容来自书籍《C# 10 in a Nutshell》
Author：Joseph Albahari
需要该电子书的小伙伴，可以留下邮箱，有空看到就会发送的
A First C# Program
int x = 12 * 30;
System.Console.WriteLine (x);
计算 12 * 30的结果，然后存储在变量x中，因为C#是强类型的语言，所以所有变量的类型都必须是编译期间已知
然后Console类的静态方法WriteLine，前面的System是命名空间，我们也可以用using System来导入这个命名空间下的所有公开的API，这样就不需要频繁编写前缀了Console.WriteLine (x);
using System;
Console.WriteLine (FeetToInches (100));
int FeetToInches (int feet)
{
int inches = feet * 12;
return inches;
}
方法的声明，前面是返回值类型，方法名，入参的形参变量类型和名称。方法体是用一个大括号包裹着。和Java的不一样，它的大括号是都在方法签名的下方，Java的是有一个大括号在方法签名的末尾。如果方法没有返回值，那么应该使用void类型，代表这个方法没有返回值
Compilation
C#的编译器会将源码编译到assembly.，一个assembly是包的集合。它可以是一个应用或者库，它们之间的不同是，应用是有一个入口的执行函数，但是库没有入口。
库的目的是被应用所引用或者被其他库引用。
每个程序的的都有一个被叫做top-level statements的入口文件，这个文件会隐式创建一个入口函数，也就是常说的Main函数
dotnet命令行工具，是可以用来管理.NET源码和二进制程序的，它可以构建程序，运行程序
// 创建一个Console程序
dotnet new Console -n MyFirstProgram
// 构建程序，然后运行这个程序
dotnet run MyFirstProgram
// 构建这个程序
dotnet build MyFirstProgram.csproj
需要注意的是，在执行dotnet命令的时候，最好处于项目内部
Syntax
Identifiers and Keywords
using System;
int x = 12 * 30;
Console.WriteLine (x);
System, x, Console, WriteLine，都是标识符，是开发者用来选择类、方法、变量等
标识符可以使用下划线、字母开头的Unicode字符集，区分大小写，按照约定，参数、变量和私有字段应该用camel case，而其他的所有标识符应该用Pascal case
Keywords关键字，指的是对编译器来说，是有特殊含义的一些单词，这里使用到了using, int，要注意的是，不能使用关键字作为标识符
如果真的希望使用关键字作为标识符，可以添加@前缀给标识符
Comments
单行注释//
多行注释/* ... */
文档注释///
Type Basics
在C#中，所有的值都是类型的实例
Predefined Type Examples
预定义类型是编译器提供的特殊的类型。比如说基本数字类型int，还有字符串类型string，布尔值bool
Custom Types
public class UnitConverter
{
int ratio; // Field 字段
public UnitConverter(int unitRatio) // Constructor 构造函数
{
ratio = unitRatio;
}
public int Convert(int unit) // Method 方法
{
return unit * ratio;
}
}
The public keyword
如果标注了public关键字，会将这个类型的成员暴露出来，如果没有标注访问权限，默认是private的权限
Defining namespaces
namespace A
{
public class B
{
...
}
}
类型B的命名空间在A，在调用B的时候，需要带上new A.B()，才能使用
Types and Conversions
两个合适的类型可以进行转换，可以进行隐式或者显式的自动转换
int x = 12345;
long y = x; // Implicit
short z = (short)x; // Explicit
Implicit的转换会发生在两种情况：
- 编译器可以保证这个转换总是成功的
- 没有信息会在转换中丢失
Explicit的转换只需要其中一种：
- 编译器不能保证转换是成功
- 信息可能在转换中丢失
Value Types Versus Reference Types
所有的c# 类型都可以区分为下面的几种类别中：
- Value types 值类型
- Reference types 引用类型
- Pointer types 指针类型
- Generic type parameters 范型类型参数
值类型一般是内建的基础类型，比如那些数字类型int、long，还有字符类型char等，还有就是我们自定义的struct类型和enum类型也算是值类型
引用类型包括所有的class、array、delegate和interface类型（包括string也是引用类型）
值类型和引用类型的不同之处在，它们处理内存的方式不同
Value types
值类型或者常量的内容，只是一个简单的值，比如int内置类型，它是一个32bit的数据，也可以自定义struct类型
public struct Point
{
public int X, Y;
}
它的内存视图：
值类型的实例在赋值的时候，总是copy的行为
Point p1 = new Point();
p1.X = 7;
Point p2 = p1;// Assignment causes copy
p1.X = 9;
Reference types
引用类型要更加复杂，它有两个部分组成一个是对象，一个是指向对象的引用。
它的内存视图
在对引用类型做赋值动作的时候，只会cpoy引用，而不是对象实例。这样就造成，可以同时有多个引用变量指向同一个对象。
Point p1 = new Point();
p1.X = 7;
Point p2 = p1;// Copies p1 reference
p1.X = 9;// Change p1.X
Null
一个引用类型，可以被赋值为null，表明这个引用没有指向任何对象
Storage overhead
值类型占用的内存大小是刚刚好的，比如说结构体Point，它的占用大小是8bytes
struct Point
{
int x; // 4 bytes
int y; // 4 bytes
}
需要注意的是，这个大小是会有内存对齐的原因，而导致和你预想的不一样
struct A { byte b; long l; }
这个看起来可能是占用7bytes，但是实际是16bytes，因为会对齐最大的那个字段的大小
Specialized Operations on Integral Types
Overflow check operators
checked操作符可以在运行时生成一个错误OverflowException，这样比变量溢出了，但是没有任何反馈。
int c = checked (a * b);// 只是检查这个表达式
// 检查block内的代码
checked
{
...
c = a * b;
...
}
也可以解除这种检查，通过使用关键字unchecked
关于常量的计算溢出，是在编译时做检查，所以不会隐式溢出
8- and 16-Bit Integral Types
8bit和16bit的整数类型，有byte、sbyte、short和ushort，这些类型的计算操作，C#会隐式地转换为更大的类型，而这会造成一个编译时错误
short x = 1, y = 1;
short z = x + y; // Compile-time error
short z = (short) (x + y); // OK
Strings and Characters
C#的char类型代表了一个Unicode字符，占用2bytes（UTF-16）
String Type
C#的一个字符串代表一个不可变的Unicode字符序列
在字符串的前面添加@，代表字符串的内容不做转义
String interpolation
插值字符串
int x = 4;
Console.Write ($"A square has {x} sides");
Arrays
char[] vowels = new char[5]; // 声明一个字符数组
char[] vowels = new char[] {'a','e','i','o','u'}; 声明并初始化一个字符数组
char[] vowels = {'a','e','i','o','u'};
Default Element Initialization
创建一个数组，总是会预初始化数组元素为默认值。默认值在元素是值类型或者引用类型是有性能影响的。
如果元素是值类型，那么每个元素都会作为元素的一部分初始化
Point[] a = new Point[1000];
int x = a[500].X; // 0
public struct Point { public int X, Y; }
如果是引用类型，那么元素会是null
Point[] a = new Point[1000];
int x = a[500].X; // Runtime error, NullReferenceException
public class Point { public int X, Y; }
Indices and Ranges
Indices
索引可以让你引用一个相对数组的末尾的元素，使用^操作符。比如，^1就是获取到数组的最后一个元素，^2是数组的倒数第二个元素
char[] vowels = new char[] {'a','e','i','o','u'};
char lastElement = vowels [^1]; // 'u'
char secondToLast = vowels [^2]; // 'o'
这个操作符其实结果是一个Index类型
Index first = 0;
Index last = ^1;
char firstElement = vowels [first]; // 'a'
char lastElement = vowels [last]; // 'u'
Ranges
Ranges让你可以对一个数组切片，用..操作符
char[] firstTwo = vowels [..2]; // 'a', 'e'
char[] lastThree = vowels [2..]; // 'i', 'o', 'u'
char[] middleOne = vowels [2..3]; // 'i'
操作符的结果是一个类型Range
Range firstTwoRange = 0..2;
char[] firstTwo = vowels [firstTwoRange]; // 'a', 'e'
Multidimensional Arrays
多维数组有两种形式： rectangular和jagged
矩形数组表示 n 维内存块，锯齿数组是数组的数组。
Rectangular arrays
int[,] matrix = new int[3,3];
int[,] matrix = new int[,]
{
{0,1,2},
{3,4,5},
{6,7,8}
};
Jagged arrays
int[][] matrix = new int[3][];
int[][] matrix = new int[][]
{
new int[] {0,1,2},
new int[] {3,4,5},
new int[] {6,7,8,9}
};
它是数组的数组，所以在声明的时候，可以声明第一个数组，内部元素都是null，然后内部的数组可以每一个的长度都不一致
Simplified Array Initialization Expressions
char[] vowels = {'a','e','i','o','u'};
int[,] rectangularMatrix =
{
{0,1,2},
{3,4,5},
{6,7,8}
};
int[][] jaggedMatrix =
{
new int[] {0,1,2},
new int[] {3,4,5},
new int[] {6,7,8,9}
};
var vowels = new[] {'a','e','i','o','u'};
var rectMatrix = new int[,]
{
{0,1,2},
{3,4,5},
{6,7,8}
};
var jaggedMat = new int[][]
{
new int[] {0,1,2},
new int[] {3,4,5},
new int[] {6,7,8,9}
};
Bounds Checking
在运行时会对数组做边界检查
Variables and Parameters
一个变量代表的是一个可变的存储位置，它可以是一个本地变量、参数（value,ref,out,in）、字段(实例、静态)，或者是一个数组的元素
The Stack and the Heap
栈和堆是存储变量的地方，它们有着不同的生命周期
Stack
栈是用来存储本地变量和参数的。随着方法或者函数的进入和退出，栈会逻辑地增长和收缩。
Heap
堆是对象（即是引用类型）的驻留内存。每当一个对象创建，就会在堆中申请内存，并有一个引用指向这个对象。运行时有垃圾收集器来将对象的占用内存释放。当对象不再被引用之后，就会被垃圾收集器回收
Default Values
可以用关键字default获取任何类型的默认值
Console.WriteLine (default (decimal));
decimal d = default;
Parameters
可以控制参数传递的额外的行为
Passing arguments by value
在默认情况下，C#是值传递，这意味着会copy一个值传递到方法内部，所以在方法的内部，对参数的修改，不会影响到方法外部的变量；但是如果将一个引用使用值传递的方式传递到方法，那么会变成两个变量指向一个对象，所以在方法内部对这个对象的修改，会影响到外部的变量，而如果是给这个引用参数赋值，其实是将这个引用指向其他的对象，对外部变量没有影响。
int x = 8;
Foo (x);
Console.WriteLine (x);
static void Foo (int p)
{
p = p + 1;
Console.WriteLine (p);
}
StringBuilder sb = new StringBuilder();
Foo (sb);
Console.WriteLine (sb.ToString()); // test
static void Foo (StringBuilder fooSB)
{
fooSB.Append ("test");
fooSB = null;
}
The ref modifier
参数传递的时候，添加了ref关键字在方法签名中，这相当于给实参起了一个别名，它们同时指向同一个内存地址，或者说一个内存地址有两个变量名。注意的是，ref是传递方和声明方都要写
int x = 8;
Foo (ref x); // Ask Foo to deal directly with x
Console.WriteLine (x); // x is now 9
static void Foo (ref int p)
{
p = p + 1; // Increment p by 1
Console.WriteLine (p); // Write p to screen
}
The out modifier
out关键字和ref差不多，除了：
- 在进入函数之前，它不需要被赋值
- 在函数返回之前，必须被赋值
Split ("Stevie Ray Vaughan", out string a, out string b);
void Split (string name, out string firstNames, out string lastName)
{
int i = name.LastIndexOf (' ');
firstNames = name.Substring (0, i);
lastName = name.Substring (i + 1);
}
The in modifier
in关键字也是和ref差不多，唯一区别是，in修饰的参数，在方法中是不可变的，如果改了，会有编译错误。
The params modifier
params关键字是用在方法的最后一个参数的修饰符。它允许方法接收指定类型的多个参数。参数的类型必须是数组形式的
int total = Sum (1, 2, 3, 4);
int Sum (params int[] ints)
{
int sum = 0;
for (int i = 0; i < ints.Length; i++)
sum += ints [i];
return sum;
}
Optional parameters
可选参数，在方法声明中已经给定某个值
Foo();
Foo (23);
void Foo (int x = 23) { Console.WriteLine (x); }
可选参数，不可以用ref或者out修饰符
Named arguments
Foo (x:1, y:2); // 1, 2
void Foo (int x, int y) { Console.WriteLine (x + ", " + y); }
Ref Locals
int[] numbers = { 0, 1, 2, 3, 4 };
ref int numRef = ref numbers [2];
numRef是numbers[2]的引用，修改numRef，会影响到numbers[2]
而且，Ref locals只能应用在数组元素、字段、或者本地变量，不能应用在属性上
一般是和ref returns一起使用
Ref Returns
可以在方法中返回一个Ref locals，这就是ref returns
static string x = "Old Value";
static ref string GetX() => ref x;
static void Main()
{
ref string xRef = ref GetX();
xRef = "New Value";
Console.WriteLine (x);`
}
// 这也是合法的，只是方法返回值不是ref的
string localX = GetX(); // Legal: localX is an ordinary non-ref variable.
// 可以在返回值添加只读限制
static ref readonly string Prop => ref x;
Target-Typed new Expressions
System.Text.StringBuilder sb1 = new();
System.Text.StringBuilder sb2 = new ("Test");
等价于
System.Text.StringBuilder sb1 = new System.Text.StringBuilder();
System.Text.StringBuilder sb2 = new System.Text.StringBuilder ("Test");
Expressions and Operators
Operator Table
Null Operators
C#提供了三种操作符让操作null值更简单：null-coalescing、null-coalescing assignment、null-conditional
Null-Coalescing Operator
??操作符。语义是“如果左边的操作数不是null，将它给我；否则，给我另外一个值（右操作数）”
string s1 = null;
string s2 = s1 ?? "nothing"; // s2 evaluates to "nothing"
它同样适用于nullable value types，可空值类型
Null-Coalescing Assignment Operator
??=操作符。它的语义是“如果左操作数是null，那就将右操作数赋值给左操作数”
myVariable ??= someDefault;
这个操作符特别适用于延迟加载的属性
Null-Conditional Operator
?.操作符。它允许你在调用方法或者访问成员时，和正常的dot操作符一样，除了当你的左操作数是null的时候，整个表达式的结果是null，而不是抛出异常NullReferenceException
System.Text.StringBuilder sb = null;
string s = sb?.ToString(); // No error; s instead evaluates to null
同样还有个索引访问的时候，也可以使用?[]
Statements
Selection Statements
The switch statement
switch语句，语句是没有结果的
switch (cardNumber)
{
case 13:
Console.WriteLine ("King");
break;
case 12:
Console.WriteLine ("Queen");
break;
case 11:
Console.WriteLine ("Jack");
break;
default:
Console.WriteLine (cardNumber);
break;
}
还可以匹配类型
switch (x)
{
case int i:
Console.WriteLine ("It's an int!");
Console.WriteLine ($"The square of {i} is {i * i}");
break;
case string s:
Console.WriteLine ("It's a string");
Console.WriteLine ($"The length of {s} is {s.Length}");
break;
default:
Console.WriteLine ("I don't know what x is");
break;
}
Switch expressions
switch表达式，是有计算结果的，可以作为右值赋值给左值
string cardName = cardNumber switch
{
13 => "King",
12 => "Queen",
11 => "Jack",
_ => "Pip card" // equivalent to 'default'
};
Iteration Statements
foreach loops
对一个enumerable对象迭代。
foreach (char c in "beer")
Console.WriteLine (c);
Miscellaneous Statements
using语句，为IDisposable对象在finallyblock里面调用Dispose方法
lock语句是一个是调用 Monitor 类的 Enter 和 Exit 方法的快捷方式
Namespaces
命名空间是类型名称的域。类型通常组织为分层命名空间，这样容易防止命名冲突
类型就包裹在namespaceblock下
namespace Outer.Middle.Inner
{
class Class1 {}
class Class2 {}
}
等价于
namespace Outer
{
namespace Middle
{
namespace Inner
{
class Class1 {}
class Class2 {}
}
}
}
using static
导入了这个类型的所有公开静态成员
Rules Within a Namespace
声明在外部的命名空间，可以不需要导入就能让它的内部的命名空间访问
namespace Outer
{
class Class1 {}
namespace Inner
{
class Class2 : Class1
{}
}
}
Aliasing Types and Namespaces
起别名
using PropertyInfo2 = System.Reflection.PropertyInfo;
Advanced Namespace Features
Extern
当程序引用的两个库，都有相同的命名空间和类型名称时，可通过以下方式解决
<ItemGroup>
<Reference Include="Widgets1">
<Aliases>W1</Aliases>
</Reference>
<Reference Include="Widgets2">
<Aliases>W2</Aliases>
</Reference>
</ItemGroup>
extern alias W1;
extern alias W2;
W1.Widgets.Widget w1 = new W1.Widgets.Widget();
W2.Widgets.Widget w2 = new W2.Widgets.Widget();
原创文章，作者：506227337，如若转载，请注明出处：https://blog.ytso.com/271155.html