enum Day { Sunday, Monday, Tuesday }

struct Point
{
	public int X;
	public int Y;
}

int? x = null; // 常用写法（语法糖）
Nullale<int> x = null; // 等价写法（本质）

bool? b;
float? f;
decimal? money;
DateTime? birthday;

public struct Nullable<T> where T : struct
{
  public T Value { get; }
  public bool HasValue { get; }
}

int? a = null;
Console.WriteLine(a.HasValue); // false

int? b = 10;
if (b.HasValue)
	Console.WriteLine(b.value); // 10

int? age = null;
int realAge = age ?? 18; // 如果age是null，则使用18

int? a = null;
int? b = 5;
int? c = a + b; // c == null, 如果任意一项是null，结果是null

Console.WriteLine(typeof(int).IsValueType); // True
Console.WriteLine(typeof(stirng).IsValueType); // False

struct Point
{
  public int X;
  public int Y;
}
Point p1 = new Point { X = 1, Y = 2 };
Point p2 = new Point { X = 1, Y = 2 };

Console.WriteLine(p1.Equals(p2)); // 比较字段而不是引用

变量声明:
Person p = new Person();

内存布局:
+--------------------+
| 栈内存             |
|--------------------|
| p (引用地址) ------|------+
+--------------------+      |
                            |
+--------------------+      |
| 堆内存             | <----+
|--------------------|
| Person 实例        |
| name = "Jeff"      |
+--------------------+

class Person { public string Name; }

Person p1 = new Person { Name = "Alice" };
Person p2 = p1; // p2引用同一个对象

p2.Name = "Bob";
Console.WriteLine(p1.Name); // Bob

public Person DeepCopy() => return new Person { Name = string.Copy(this.Name) };

namespace System
{
  public class Object
  {
    public Object();
	public virtual bool Equals(object obj);
	public static bool Equals(object objA, object objB);
	public static bool ReferenceEquals(object objA, object objB);
	public virtual int GetHashCode();
	public virtual string ToString();
	public virtual void Finalize();
	public Type GetType();
  }
}

~MyClass() { ... } // 实际上编译成 override Finalize()

object o = new object();
Object o2 = new Object();
System.Object o3 = new System.Object();

string s = "Hello";
s += " World";

string a = "abc";
string b = "abc";
Console.WriteLine(object.ReferenceEquals(a, b)); // True

string s1 = "abc";
string s2 = s1; // s2指向同一个字符串
s2 = "xyz"; // s2改指向一个新的字符串，s1不受影响
Console.WriteLine(s1) // abc

public sealed class String : IComparable, ICloneable, IEnumerable<char>
{
  private readonly int _stringLength;
  private readonly char _firstChar;
  // 实际上还有内部字段存储字符数组
}

string s = "Hello" + "World"; // 编译器优化为常量”Hello World“

string result = "";
for (int i = 0; i < 1000; ++i) result += i;

var sb = new StringBuilder();
for (int i = 0; i < 1000; i++) sb.Append(i);
string result = sb.ToString();

type* pointerName;

unsafe
{
	int x = 10;
	int* ptr = &x;
	Console.WriteLine(*ptr);
}

unsafe class UnsafeClass
{
  static void Main()
  {
    int x = 123;
	int* p = &x;
	Console.WriteLine(*p); // 123
  }
}

int i = 100;
double d = i; // 隐式转换：int -> double

float f = 3.14f;
double d2 = f; // 隐式转换：float -> double

public class Meter
{
  public double value { get; }

  public Meter(double value) => Value = value;

  // 自定义从double到Meter的隐式转换
  public static implicit operator Meter(double value) => return new Meter(value);

  // 自定义从Meter到double的隐式转换
  public static implicit operator double(Meter meter) => return meter.Value;
}

Meter m = 5.0; // 隐式double -> Meter
double d = m; // 隐式Meter -> double

Stream s = new FileStream(...); // FileStream -> Stream 是隐式转换

public struct Celsius
{
    public double Degrees { get; }

    public Celsius(double degrees)
    {
        Degrees = degrees;
    }

    public static implicit operator Fahrenheit(Celsius c)
    {
        return new Fahrenheit(c.Degrees * 9 / 5 + 32);
    }
}

public struct Fahrenheit
{
    public double Degrees { get; }

    public Fahrenheit(double degrees)
    {
        Degrees = degrees;
    }

    public static implicit operator Celsius(Fahrenheit f)
    {
        return new Celsius((f.Degrees - 32) * 5 / 9);
    }
}

// 用法
Celsius c = new Fahrenheit(98.6); // 自动转为 Celsius
Fahrenheit f = new Celsius(37);  // 自动转为 Fahrenheit

int i = (int)3.14;

double d = 3.14;
int i = (int)d; // i = 3

long l = 9999999999;
int j = (int)l; // 溢出，j的值将错误

public static explicit operator TargetType(SourceType value)

public class MyClass
{
  public int Value { get; set; }

  public MyClass(int value) => Value = value;

  public static explicit operator int(MyClass obj)
  {
    return obj.Value;
  }

  public static explicit operator MyClass(int value)
  {
    return new MyClass(value);
  }
}

MyClass a = (MyClass)42; // 显式从int转为MyClass
int x = (int)a; // 显式从MyClass转为int

public struct Health
{
    public int Value;

    public Health(int value) => Value = value;

    public static explicit operator int(Health h) => h.Value;
    public static explicit operator Health(int v) => new Health(v);
}

// 用法
int hp = (int)new Health(100);
Health h2 = (Health)hp;

public class IPAddress
{
    public string Address { get; private set; }

    private IPAddress(string addr) => Address = addr;

    public static explicit operator IPAddress(string input)
    {
        // 假设格式检查
        if (input.Contains("."))
            return new IPAddress(input);
        throw new FormatException("Invalid IP address");
    }
}

int i = 42;
object obj = i; // 装箱：int -> object

object obj = 42; // 装箱
int i = (int)obj; // 拆箱
float f = (float)obj; // 抛出异常，不能拆箱为不同类型

struct MyStruct : IMyInterface
{
  public int Value;
  public void DoSomething() => Console.WriteLine(Value);
}

IMyInterface iface = new MyStruct { Value = 10 }; // 装箱
iface.DoSometing(); // iface是一个引用

int a = 5;
object obj = a; // boxing
dynamic d = a; // boxing
IComparable cmp = a; // boxing

void Print<T>(T value) => object obj = value; // 如果T是值类型，这里会装箱

struct Health
{
  public int value;

  public static implicit operator Health(int value) => new Health { Value = value; };
  public static explicit operator int(Health h) => h.Value;
}

Health h = 100; // 隐式装箱为结构体（无引用）
int value = (int)h;

int.Parse(string);
float.Parse(string);
DateTime.Parse(string);
Enum.Parse(Type, string)

int num = int.Parse("123"); // OK
int bad = int.Parse("abc"); // FormatException

float pi = float.Parse("3.14");

bool b1 = bool.Parse("true"); // OK
bool b2 = bool.Parse("FALSE"); // OK
bool b3 = bool.Parse("yes"); // FormatException

DataTime dt = DataTime.Parse("2025-07-29");

enum Direction { Up, Down, Left, Right }

Dirction d = (Direction)Enum.Parse(typeof(Direction), "Up");

// 也可以忽略大小写
Enum.Parse(typeof(Direction), "down", true);  // 返回 Direction.Down

class Person
{
  public string Name;
  public int Age;

  public static Person Parse(string s)
  {
    var parts = s.Split(',');
    return new Person
    {
      Name = parts[0], 
      Age = int.Parse(parts[1])
    };
  }
}

Person p = Person.Parse("Jeff,24"")

bool TryParse(string s, out T result)

string input = "123";
if (int.TryParse(input, out int number))
    Console.WriteLine("转换成功：" + number);
else
    Console.WriteLine("转换失败");

float.TryParse("3.14", out float pi); // pi = 3.14
float.TryParse("abc", out float pi); // fail = 0

bool.TryParse("true", out bool b1); // true
bool.TryParse("yes", out bool b2); // false

enum Direction { Up, Down, Left, Right }

Enum.TryParse("Left", out Direction d); // 成功
Enum.TryParse("INVALID", out Dirction d2); // 失败，d2 = default(Direction)
Enum.TryParse("up", ignoreCase: true, out Direction d3); // 忽略大小写

public static class ParseHelper
{
    public static bool TryParse<T>(string input, out T result)
    {
        result = default;

        var type = typeof(T);

        if (type == typeof(int) && int.TryParse(input, out int i)) { result = (T)(object)i; return true; }
        if (type == typeof(float) && float.TryParse(input, out float f)) { result = (T)(object)f; return true; }
        if (type == typeof(bool) && bool.TryParse(input, out bool b)) { result = (T)(object)b; return true; }
        if (type.IsEnum && Enum.TryParse(type, input, true, out object e)) { result = (T)e; return true; }

        return false;
    }
}

object obj = "123";
int num = Convert.ToInt32(obj); // 结果：123

object nullObj = null;
int result = Convert.ToInt32(nullObj); // 结果：0（null 转为默认值）

object obj1 = 123;
string str1 = Convert.ToString(obj1); // 结果："123"

object obj2 = null;
string str2 = Convert.ToString(obj2); // 结果""（空字符串）

object obj = "2025-07-29";
DateTime date = Convert.ToDateTime(obj); // 结果：2025/07/-29

object obj2 = null;
DateTime date2 = Convert.ToDateTime(obj2); // 结果：01/01/0001 00：00：00（默认值）

object obj = 3.14f;
decimal dec = Convert.ToDecimal(obj);  // 结果：3.14

object obj = 123;
int num = (int)Convert.ChangeType(obj, typeof(int));  // 结果：123

object strObj = "2025-07-29";
DateTime date = (DateTime)Convert.ChangeType(strObj, typeof(DateTime));  // 结果：2025/07/29