c#入门

March 23, 2023

Hello, world

https://try.dot.net/

using System; // 命名空间

class Hello
{
    static void Main() // Main 静态方法 是 C# 程序的入口点
    {
        string str = "world";
        // Console 类在 System 命名空间下
        Console.WriteLine($"Hello, {str}");
        // 相当于 System.Console.WriteLine
    }
}

类型系统

C#语言介绍
C# 有两种类型：值类型和引用类型

值类型
- 简单类型
  - 有符号整型：sbyte、short、int、long
  - 无符号整型：byte、ushort、uint、ulong
  - Unicode 字符：char （表示 UTF-16 代码单元）
  - IEEE 二进制浮点：float、double
  - 高精度十进制浮点数：decimal
  - 布尔值：bool （true 或 false）
  - 枚举类型 enum E {...}
  - 结构 struct S {...}
  - 可以为 null 的值类型（对于所有不可以为 null 的类型 T，都有对应的可以为 null 的类型 T?）
  - 元组 (T1, T2, ...)
引用类型
- 类
  - 其他所有类型的最终基类：object
  - Unicode 字符串：string （表示 UTF-16 代码单元序列）
  - class C {...}
- 接口 interface I {...}
- 数组类型（一维、多维和交错。例如：int[]、int[,] 和 int[][]）
- 委托类型 delegate int D(...)

record 类型（record struct 或 record class）
class、struct、interface 和 delegate 类型全部支持泛型

数组隐式派生自 System.Array 类
例如： int 类型实际为 System.Int32

自动装箱

int i = 123;
object o = i;    // 将值类型的值分配给 object 对象引用时，会分配一个“箱”来保存此值。 该箱是引用类型的实例，此值会被复制到该箱。
int j = (int)o;  // 当 object 引用被显式转换成值类型时，将检查引用的 object 是否是具有正确值类型的箱。 如果检查成功，则会将箱中的值复制到值类型

类和对象

=> lambda 运算符

var p1 = new Point(0, 10); // 类型为 Point?
Point p2 = new(10, 20);    // 类型为 Point
var p3 = new Point(0, 0) { X = 20, Y = 30 }; // (20, 30)

Console.WriteLine(p1);
Console.WriteLine(p2);
Console.WriteLine(p3);

public class Point
{
    public int X;
    public int Y;

    public (int, int) Pos // 属性访问器
    {
        get => (X, Y);
        set => (X, Y) = value; // value 代表等号右边的值
    }

    public Point(int x, int y) => (X, Y) = (x, y);

    public override string ToString()
    {
        return $"({X}, {Y})";
    }
}

readonly 修饰符声明 只读字段

public class Color
{
    public static readonly Color Black = new(0, 0, 0);
    public static readonly Color White = new(255, 255, 255);

    public static readonly Color Red = new(255, 0, 0);
    public static readonly Color Green = new(0, 255, 0);
    public static readonly Color Blue = new(0, 0, 255);

    public byte R;
    public byte G;
    public byte B;

    public Color(byte r, byte g, byte b)
    {
        R = r;
        G = g;
        B = b;
    }
    public override string ToString() => $"({r},{g},{b})";
}

泛型类

public class Pair<TFirst, TSecond>
{
    public TFirst First { get; }
    public TSecond Second { get; }

    public Pair(TFirst first, TSecond second) => (First, Second) = (first, second);
}

var pair = new Pair<int, string>(1, "two");
int i = pair.First;     //TFirst int
string s = pair.Second; //TSecond string

其他类型函数成员：构造函数、属性、索引器、事件、运算符和终结器

继承

public class Point3D : Point
{
    public int Z { get; set; }

    public Point3D(int x, int y, int z) : base(x, y)
    {
        Z = z;
    }
}

Point a = new(10, 20);
Point b = new Point3D(10, 20, 30);

虚方法、重写方法和抽象方法

结构

public struct Point
{
    public double X { get; }
    public double Y { get; }

    public Point(double x, double y) => (X, Y) = (x, y);
}

接口

interface IControl
{
    void Paint();
}

interface ITextBox : IControl
{
    void SetText(string text);
}

interface IListBox : IControl
{
    void SetItems(string[] items);
}

interface IComboBox : ITextBox, IListBox { }

实现接口

interface IDataBound
{
    void Bind(Binder b);
}

public class EditBox : IControl, IDataBound
{
    public void Paint() { }
    public void Bind(Binder b) { }
}

EditBox editBox = new();
IControl control = editBox;
IDataBound dataBound = editBox;

枚举

public enum SomeRootVegetable
{
    HorseRadish,
    Radish,
    Turnip
}

[Flags]
public enum Seasons
{
    None = 0,
    Summer = 1,
    Autumn = 2,
    Winter = 4,
    Spring = 8,
    All = Summer | Autumn | Winter | Spring
}

var turnip = SomeRootVegetable.Turnip;

var spring = Seasons.Spring;
var startingOnEquinox = Seasons.Spring | Seasons.Autumn;
var theYear = Seasons.All;

元组

(string Key, int Value) tp = ("branch", 666);
Console.WriteLine($"1 little black mole {tp.Key} {tp.Value}");

var (branch, six) = tp;
Console.WriteLine(branch + " " + six);

(_, var a, string b) = ("black mole", false, "branch"); // 手动声明类型

通过Deconstruct方法实现自定义析构： https://learn.microsoft.com/zh-cn/dotnet/csharp/fundamentals/functional/deconstruct#user-defined-types

可 null 类型

可为 null 引用类型和可为 null 值类型提供类似的语义概念：变量可表示值或对象，或者该变量可以为 null。但可为 null 引用类型和可为 null 值类型的实现方式不同：可为 null 值类型是使用 System.Nullable<T> 实现的，而可为 null 引用类型是使用编译器读取的属性实现的。例如，string? 和 string 由同一类型表示：System.String。但 int? 和 int 分别由 System.Nullable<System.Int32> 和 System.Int32 表示

可 null 值类型

本质为 System.Nullable<T>

double? pi = 3.14;
char? letter = 'a';

int m2 = 10;
int? m = m2;

bool? flag = null;
int?[] arr = new int?[10];

模式匹配

is 运算符和类型模式

int? a = 42;
if (a is int valueOfA)
{
    Console.WriteLine($"a is {valueOfA}");
}
else // if (a is null)
{
    Console.WriteLine("a does not have a value");
}

或者通过 Nullable<T> 实例

int? c = 7;
if (c != null) // or:  if (c.HasValue)
{
    Console.WriteLine($"c is {c.Value}");
}
else
{
    Console.WriteLine("c does not have a value");
}

Boxing & Unboxing

int a = 41;
object aBoxed = a;
int? aNullable = (int?)aBoxed;
Console.WriteLine($"Value of aNullable: {aNullable}");
// Value of aNullable: 41

object aNullableBoxed = aNullable;
if (aNullableBoxed is int valueOfA)
{
    Console.WriteLine($"aNullableBoxed is boxed int: {valueOfA}");
// aNullableBoxed is boxed int: 41
}

可 null 引用类型

取消引用值为 null 的变量时，运行时会引发 System.NullReferenceException。

string message = null;

try {
    Console.WriteLine($"The length of the message is {message.Length}");
} catch {
    Console.Write("NullReferenceException");
}

对于返回值，T? 等效于 [MaybeNull]T
对于参数值，T? 等效于 [AllowNull]T

is 运算符

E is T
// 返回布尔值

public class Animal { }

public class Giraffe : Animal { }

public static class TypeOfExample
{
    public static void Main()
    {
        object b = new Giraffe();
        Console.WriteLine(b is Animal);  // output: True
        Console.WriteLine(b.GetType() == typeof(Animal));  // output: False

        Console.WriteLine(b is Giraffe);  // output: True
        Console.WriteLine(b.GetType() == typeof(Giraffe));  // output: True
    }
}

as 运算符

E as T
// 相当于
E is T ? (T)(E) : (T)null

typeof() 运算符， System.Type 类型

typeof 运算符的实参必须为类型（或 类型形参，即泛型参数）
返回 Type 类型实例

Console.WriteLine(typeof(List<string>));

void PrintType<T>() => Console.WriteLine(typeof(T));
PrintType<int>();
PrintType<System.Int32>();
PrintType<Dictionary<int, char>>();

switch 模式匹配

https://learn.microsoft.com/zh-cn/dotnet/csharp/fundamentals/functional/pattern-matching#compare-discrete-values

函数

引用参数 使用 ref 修饰符进行声明

static void Swap(ref int x, ref int y)
{
    int temp = x;
    x = y;
    y = temp;
}

public static void SwapExample()
{
    int i = 1, j = 2;
    Swap(ref i, ref j);
    Console.WriteLine($"{i} {j}");    // "2 1"
}

输出参数 使用 out 修饰符进行声明

static void Divide(int x, int y, out int quotient, out int remainder)
{
    quotient = x / y;
    remainder = x % y;
}

public static void OutUsage()
{
    Divide(10, 3, out int quo, out int rem);
    Console.WriteLine($"{quo} {rem}");	// "3 1"
}

参数数组 （不定参数）使用 params 修饰符进行声明

public class Console
{
    public static void Write(string fmt, params object[] args) { }
    public static void WriteLine(string fmt, params object[] args) { }
    // ...
}

int x = 3, y = 4, z = 5;
Console.WriteLine("x={0} y={1} z={2}", x,y,z);
// 相当于
object[] args = new object[3] {x,y,z};
Console.WriteLine("x={0} y={1} z={2}", args);

委托

delegate 关键字声明委托类型
委托类型可为 lambda 表达式提供类型

using System;

public class Program
{
  public delegate int Add(int a, int b);
  public static void Main()
  {
   Add add = (a, b) => a + b;
   Console.WriteLine( add(1,2) );
  }
}

async/await

异步函数返回 System.Threading.Tasks.Task 泛型类

using System;
using System.Threading.Tasks;

class Test {
  public static async Task<string> asyncMethod()
  {
    return nameof(asyncMethod);
  }
}

public class Program
{
  public static async void Main()
  {
    Console.WriteLine("before");
    Console.WriteLine(await Test.asyncMethod());
    Console.WriteLine("after");
  }
}

Attribute

https://learn.microsoft.com/zh-cn/dotnet/csharp/tour-of-csharp/features#attributes

class Program
{
    public class HelpAttribute : Attribute
    {
        string _url;
        string _topic;

        public HelpAttribute(string url) => _url = url;

        public string Url => _url;

        public string Topic
        {
            get => _topic;
            set => _topic = value;
        }
    }

    // HelpAttribute 以 Attribute 结尾，可省略为 Help
    [Help("https://docs.microsoft.com/dotnet/csharp/tour-of-csharp/features")]
    public class Widget
    {
        [Help("https://docs.microsoft.com/dotnet/csharp/tour-of-csharp/features",
        Topic = "Display")]
        public void Display(string text) { }
    }

    public static void Main()
    {
        Type widgetType = typeof(Widget);

        object[] widgetClassAttributes = widgetType.GetCustomAttributes(typeof(HelpAttribute), /* inherit */false);

        if (widgetClassAttributes.Length > 0)
        {
            HelpAttribute attr = (HelpAttribute)widgetClassAttributes[0];
            Console.WriteLine($"Widget class help URL : {attr.Url} - Related topic : {attr.Topic}");
        }

        System.Reflection.MethodInfo displayMethod = widgetType.GetMethod(nameof(Widget.Display));

        object[] displayMethodAttributes = displayMethod.GetCustomAttributes(typeof(HelpAttribute), false);

        if (displayMethodAttributes.Length > 0)
        {
            HelpAttribute attr = (HelpAttribute)displayMethodAttributes[0];
            Console.WriteLine($"Display method help URL : {attr.Url} - Related topic : {attr.Topic}");
        }
    }
}

匿名类型

https://learn.microsoft.com/zh-cn/dotnet/csharp/fundamentals/types/anonymous-types

var v = new { Amount = 108, Message = "Hello" };
Console.WriteLine(v.Amount + v.Message);

错误处理

https://learn.microsoft.com/zh-cn/dotnet/csharp/fundamentals/exceptions/

语言集成查询 (LINQ)

https://learn.microsoft.com/zh-cn/dotnet/csharp/tutorials/working-with-linq

←Back to home