C# 备忘清单

class Hello {
  // main method
  static void Main(string[] args)
  {
    // 输出: Hello, world!
    Console.WriteLine("Hello, world!");
  }
}

编译运行（确保在项目目录下）

$ dotnet run
Hello, world!

//使用时 using 命名名称
using Test;
//创建：
namespace Test{
  class Test_className{
    // main方法是程序的主入口
    public void Myclass() {
      console.writeline("Test")
    }
  }
}

string first = "John";
string last = "Doe";
// 字符串连接
string name = first + " " + last;
Console.WriteLine(name); // => John Doe

查看: C#字符串

// 单行注释

/* 
 * 多行
 * 注释 - 用于文档 
 */

// TODO：
// 向IDE中的任务列表添加注释（VS、Rider都支持）
/// XML 单行注释，用于文档

int j = 10;
if (j == 10) {
  Console.WriteLine("I get printed");
} else if (j > 10) {
  Console.WriteLine("I don't");
} else {
  Console.WriteLine("I also don't");
}

int intNum = 9;
long longNum = 9999999;
float floatNum = 9.99F;
double doubleNum = 99.999;
decimal decimalNum = 99.9999M;
char letter = 'D';
bool @bool = true;
string site = "jaywcjlove.github.io";
var num = 999;
var str = "999";
var bo = false;

char[] chars = new char[10];
chars[0] = 'a';
chars[1] = 'b';
string[] letters = {"A", "B", "C"};
int[] mylist = {100, 200};
bool[] answers = {true, false};

关键字	名称	System 别名	说明
(除指针型外的全部原始数据类型)	-	-	原始数据类型都是值类型，基本数据类型包含部分本质上是引用的数据类型
string	字符串	String	可变长度
decimal	十进制浮点数	Decimal	适合处理货币等计算，16字节长，不遵循 IEEE 754 关于浮点数的规则

string first = "John";
string last = "Doe";
string name = first + " " + last;
Console.WriteLine(name); // => John Doe

string first = "John";
string last = "Doe";
string name = $"{first} {last}";
Console.WriteLine(name); // => John Doe

string longString = @"I can type any characters in here !#@$%^&*()__+ '' \n \t except double quotes and I will be taken literally. I even work with multiple lines.";

// 使用 System.String 的属性
string lengthOfString = "How long?";
lengthOfString.Length           // => 9
// 使用 System.String 的方法
lengthOfString.Contains("How"); // => true

var sb = new StringBuilder();
for (int i = 0; i < 100; i++)
{
    sb.Append(i.ToString());
}
Console.WriteLine(sb.ToString());
// => 123456789....

对于频繁拼接字符串的场景（如：成百上千次循环），使用 System.Text.StringBuilder 提升性能

string Str = "字符串截取";
Str = Str.Substring(2, 1);
Console.WriteLine(Str);
// 输出结果“串”，意为从第二个下标开始截取一位字符

string Rep = "字符1替换";
Rep = Rep.Replace("1", "串");
Console.WriteLine(Rep);
// 会把字符中的 “1”替换成“串”

bool passed = false;
Console.WriteLine(!passed); // 输出: True
Console.WriteLine(!true);   // 输出: False

bool SecondOperand()
{
    Console.WriteLine("计算第二个操作数");
    return true;
}

bool a = false & SecondOperand();
Console.WriteLine(a);
// 输出:
// 计算第二个操作数
// False

bool b = true & SecondOperand();
Console.WriteLine(b);
// 输出:
// 计算第二个操作数
// True

Console.WriteLine(true ^ true);  // 输出: False
Console.WriteLine(true ^ false); // 输出: True
Console.WriteLine(false ^ true); // 输出: True
Console.WriteLine(false ^ false);// 输出: False

bool SecondOperand()
{
    Console.WriteLine("计算第二个操作数");
    return true;
}

bool a = true | SecondOperand();
Console.WriteLine(a);
// 输出:
// 计算第二个操作数
// True

bool b = false | SecondOperand();
Console.WriteLine(b);
// 输出:
// 计算第二个操作数
// True

bool SecondOperand()
{
    Console.WriteLine("计算第二个操作数");
    return true;
}

bool a = false && SecondOperand();
Console.WriteLine(a);
// 输出:
// False

bool b = true && SecondOperand();
Console.WriteLine(b);
// 输出:
// 计算第二个操作数
// True

bool SecondOperand()
{
    Console.WriteLine("计算第二个操作数");
    return true;
}

bool a = true || SecondOperand();
Console.WriteLine(a);
// 输出:
// True

bool b = false || SecondOperand();
Console.WriteLine(b);
// 输出:
// 计算第二个操作数
// True

public class MyClass
{
    // 私有变量
    private int myVariable;
    // 公有属性
    public string MyProperty { get; set; }
}

public class MyClass
{
    public static int StaticVariable = 10;
    public static void StaticMethod()
    {
        // 静态方法体
    }
}

public class MyClass
{
    // 无返回值方法
    public void MyMethod()
    {
        // 方法体
    }
    // 有返回值方法
    public int Add(int a, int b)
    {
        return a + b;
    }
}

public class MyClass
{
    private string myField;
    
    public string MyProperty
    {
        get { return myField; }
        set { myField = value; }
    }
}

public interface IMyInterface
{
    void MyMethod(); // 接口方法声明
}

public class MyClass : IMyInterface
{
    public void MyMethod() // 实现接口方法
    {
        // 实现代码
    }
}

:--	:--
readonly	表示这个字段只能在执行构造函数的过程中赋值，或由初始化赋值语句赋值
static	静态字段，必须通过类名来访问，例如：Class.staticField
const	常量字段，但同时也是静态字段，自带static

public class MyClass
{
  ...
}

添加 public 声明为公共类

private class MyClass
{
  ...
}

添加 public 声明为公共类

• 类名使用 PascalCase 格式
• 成员变量和方法名使用 camelCase 格式
• 公有成员和类型名应该使用有意义的名字

class MyClass 
{
  ...
}
internal class MyCalss
{
  ...
}

上面两个类相同，声明为内部（internal）类，只能在当前项目中的代码才能访问它

---

• 抽象类与密封类为互斥关系
• 抽象类不能实例化，允许继承
• 可以有抽象成员，密封类不允许继承
• 都可以声明为公共类（public）和内部类（internal）

不带名称的基本元组创建

(
    int item1,
    string item2,
    bool item3
) tuple1 = (1, "Hello", true);

Console.WriteLine(
    $"Item1: {tuple1.Item1}, " +
    $"Item2: {tuple1.Item2}, " +
    $"Item3: {tuple1.Item3}"
);

带名称的元组创建（C# 7.0及以上版本）

(
    string FirstName,
    string LastName,
    int Age
) person = ("Alice", "Smith", 30);

Console.WriteLine(
    $"First Name: {person.FirstName}, " +
    $"Last Name: {person.LastName}, " +
    $"Age: {person.Age}"
);

public (int Id, string Name, double Score) GetStudentInfo()
{
    return (123, "John Doe", 95.5);
}

使用

(
    var id,
    var name,
    var score
) = GetStudentInfo();

Console.WriteLine(
    $"Id: {id}, " +
    $"Name: {name}, " +
    $"Score: {score}"
);

public class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
    public double GPA { get; set; }

    public void Deconstruct(out int id, out string name, out double gpa)
    {
        id = this.Id;
        name = this.Name;
        gpa = this.GPA;
    }
}

使用Deconstruct方法创建元组

Student student = new Student
{
    Id = 1,
    Name = "Jane",
    GPA = 3.8
};

(int id, string name, double gpa) = student;
Console.WriteLine($"Student Id: {id}, Name: {name}, GPA: {gpa}");

集合	有序	已排序	线程安全	允许空值
List	Y	N	N	是
ArrayList (非泛型)	Y	N	N	是
Vector (非泛型)	N	N	Y	是
LinkedList	Y	N	N	是
ConcurrentBag	N	N	Y	是
HashSet	N	N	N	是
SortedSet	Y	Y	N	是
ConcurrentDictionary	Y	N	Y	是
Dictionary	N	N	N	是
SortedDictionary	Y	Y	N	是
Stack	N	N	N	是
Queue	N	N	N	是
ConcurrentQueue	N	N	Y	是
ConcurrentStack	N	N	Y	是
HashTable	N	Y	Y	否

// 创建一个整数类型的List
List<int> numbers = new List<int>();

// 增加（Add）
numbers.Add(10);
numbers.Add(20);
//增加30，40两个元素
numbers.AddRange(new[] { 30, 40 });

// 删除（Remove）
if (numbers.Contains(20))
{
    numbers.Remove(20);
}

// 修改（更改特定索引处的元素）
numbers[0] = 50; // 直接替换元素

// 查询（Find/Contains）
bool isPresent = numbers.Contains(50);

// 查找索引
int index = numbers.IndexOf(40);
if (index != -1)
{
    numbers[index] = 45; // 修改找到的元素
}

// 创建一个字符串类型的HashSet
HashSet<string> words = new HashSet<string> { "apple", "banana" };

// 增加（Add）
words.Add("cherry");

// 返回 false，因为"apple"已存在
bool wasAdded = words.Add("apple"); 

// 删除（Remove）
words.Remove("banana");

// 修改 - HashSet不允许直接修改元素
// 需删除后重新添加
if (words.Contains("cherry"))
{
    words.Remove("cherry");
    words.Add("cherries");
}

// 查询（Contains）
bool containsCherries = words.Contains("cherries");

// 创建一个整数栈
Stack<int> stack = new Stack<int>();
stack.Push(1);
stack.Push(2);

// 增加（Push）
stack.Push(3);

// 删除（Pop）并返回栈顶元素
int topNumber = stack.Pop();

// 修改（Stack不支持直接修改元素，需先Pop再Push）
int poppedValue = stack.Pop();
// 替换刚弹出的值
stack.Push(poppedValue * 2); 

// 查询（Peek / Contains） 但不移除栈顶元素
int peekedValue = stack.Peek();
bool hasTwo = stack.Contains(2);

// 创建一个哈希表
Hashtable hashTable = new Hashtable();
hashTable.Add("key1", "value1");
hashTable.Add("key2", "value2");

// 增加（Add）
hashTable.Add("key3", "value3");

// 删除（Remove）
hashTable.Remove("key1");

// 修改（Replace）
object oldValue;
if (hashTable.ContainsKey("key2"))
{
    oldValue = hashTable["key2"];
    hashTable["key2"] = "new_value2";
}

// 查询（Contains / GetValue）
bool hasKey2 = hashTable.ContainsKey("key2");
string valueOfKey2 = (string)hashTable["key2"];

分组查询

// 示例数据源
List<Student> students = new List<Student>
{
    new Student { Name = "Alice", Age = 25, Grade = "A" },
    new Student { Name = "Bob", Age = 30, Grade = "B" },
    new Student { Name = "Barry", Age = 35, Grade = "C" },
    new Student { Name = "Charlie", Age = 22, Grade = "A" },
    new Student { Name = "David", Age = 21, Grade = "C" },
    new Student { Name = "Damon", Age = 28, Grade = "B" },
    new Student { Name = "Echo", Age = 18, Grade = "C" }
};

// 使用GROUP BY按成绩进行分组查询
var groupedByGrade = students.GroupBy(student => student.Grade);

排序

// 示例数据源
List<Student> students = new List<Student>
{
    new Student { Name = "Alice", Age = 25, Grade = "A" },
    new Student { Name = "Bob", Age = 30, Grade = "B" },
    new Student { Name = "Barry", Age = 35, Grade = "C" },
    new Student { Name = "Charlie", Age = 22, Grade = "A" },
    new Student { Name = "David", Age = 21, Grade = "C" },
    new Student { Name = "Damon", Age = 28, Grade = "B" },
    new Student { Name = "Echo", Age = 18, Grade = "C" }
};

// 使用LINQ的OrderBy进行排序
var result1 = students.OrderBy(student => student.Age);

// 使用LINQ的OrderByDescending进行降序排序
var result2 = students.OrderByDescending(student => student.Age);

public static class CustomExtensions
{
    public static IEnumerable<T> CustomFilter<T>(this IEnumerable<T> source, Func<T, bool> predicate)
    {
        foreach (var item in source)
        {
            if (predicate(item))
            {
                yield return item;
            }
        }
    }
}
// 使用自定义扩展方法
var filteredData = students.CustomFilter(s => s.Age > 20);

// 可空类型
int? nums = null;

// 判断值是否为空，并进行不同的赋值
if(nums == null)
{
  result = -1;
} 
else 
{
  result = nums;
}

// 简化的语法糖
int result = nums ?? -1;

判断数组或 list 不能 null 且有元素

if(list != null && list.Count > 0)

简化的语法糖当 list 为 null 时，将直接返回 false

if(list?.Count > 0)

同样可运用在赋值时，如果 obj 为 null，将不会取 obj.text 的值，而是将会为 text 赋值 null

string text = obj?.text;

• 判断 value 是否为 string 类型，如果 value 是 string 类型
• 那么将 value 转换为 string 类型，并赋值给 stringValue
• 再判断 stringValue 是否不为 Null 或 空

if(value is string stringValue && !string.IsNullOrEmpty(stringValue))

public string GetNums(int num)
{
  // 使用这种方式的switch时，要求返回类型统一
  string str = num switch
  {
    1 => "num的值是1",
    2 => "num的值是2",
    3 => "num的值是3",
    4 => "num的值是4",
    _ => "其他"
  };

  return str;
}