一、成员

常量：与类相关联的常量值
字段：与类关联的变量
方法：类可执行的操作
属性：与读取和写入类的已命名属性相关联的操作
索引器：与将类实例编入索引（像处理数组一样）相关联的操作
事件：类可以生成的通知
运算符：类支持的转换和表达式运算符
构造函数：初始化类实例或类本身所需的操作
终结器：永久放弃类实例之前执行的操作
类型：类声明的嵌套类型

二、辅助功能

每个类成员都有关联的可访问性，用于控制能够访问成员的程序文本区域。可访问性有六种可能的形式。以下
内容对访问修饰符进行了汇总。

public ：访问不受限制。
private ：访问仅限于此类。
protected ：访问仅限于此类或派生自此类的类。
internal ：仅可访问当前程序集（ .exe 或 .dll ）。
protected internal ：仅可访问此类、从此类中派生的类，或者同一程序集中的类。
private protected ：仅可访问此类或同一程序集中从此类中派生的类。

三、字段

字段是与类或类实例相关联的变量。
使用静态修饰符声明的字段定义的是静态字段。静态字段只指明一个存储位置。无论创建多少个类实例，永远
只有一个静态字段副本。
不使用静态修饰符声明的字段定义的是实例字段。每个类实例均包含相应类的所有实例字段的单独副本。

public class Color
{
public static readonly Color Black = new Color(0, 0, 0);
public static readonly Color White = new Color(255, 255, 255);
public static readonly Color Red = new Color(255, 0, 0);
public static readonly Color Green = new Color(0, 255, 0);
public static readonly Color Blue = new Color(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;
}
}

四、方法

方法是实现对象或类可执行的计算或操作的成员。静态方法是通过类进行访问。实例方法是通过类实例进行访问。
方法可能包含一个参数列表，这些参数表示传递给方法的值或变量引用。方法具有返回类型，它用于指定方法计算和返回的值的类型。如果方法未返回值，则它的返回类型为 void 。
方法可能也包含一组类型参数，必须在调用方法时指定类型自变量，这一点与类型一样。与类型不同的是，通常可以根据方法调用的自变量推断出类型自变量，无需显式指定。
在声明方法的类中，方法的签名必须是唯一的。方法签名包含方法名称、类型参数数量及其参数的数量、修饰符和类型。方法签名不包含返回类型。
当方法主体是单个表达式时，可使用紧凑表达式格式定义方法，如下例中所示：

五、参数

参数用于将值或变量引用传递给方法。方法参数从调用方法时指定的自变量中获取其实际值。有四类参数：值参数、引用参数、输出参数和参数数组
值参数用于传递输入自变量。值参数对应于局部变量，从为其传递的自变量中获取初始值。 修改值形参不会影响为其传递的实参。
可以指定默认值，从而省略相应的自变量，这样值参数就是可选的。
引用参数用于按引用传递自变量。为引用参数传递的自变量必须是一个带有明确值的变量。 在方法执行期间，引用参数指出的存储位置与自变量相同。

public class Program
    {
        static void Main(string[] args)
        {
            int i = 1, j = 2;
            // 调用的时候参数也要加上ref关键字
            Swap(ref i, ref j);
            Console.WriteLine($"{i}{j}");
            Console.ReadKey();
        }

        // 引用变量，要引用那一个呢你传给我我才知道
        static void Swap(ref int x, ref int y)
        {
            int temp = x;
            x = y;
            y = temp;
        }

    }

public class Program
    {
        static void Main(string[] args)
        {
            // 输出参数不用额外定义了，直接拿来用就是了
            Divide(10, 3, out int res, out int rem);
            Console.WriteLine($"{res},{rem}");
            Console.ReadKey();
        }

        // 函数中的局部变量函数一执行完毕就被释放
        // 所以用输出参数将数据传递出去
        static void Divide(int x, int y, out int result, out int remainder)
        {
            result = x / y;
            remainder = x % y;
        }

    }

六、静态和实例方法

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

如果实例方法声明中有 virtual 修饰符，可以将实例方法称为“虚方法”。如果没有 virtual 修饰符，可以将实例方法称为“非虚方法”
可以在派生类中重写虚方法。如果实例方法声明中有 override 修饰符，那么实例方法可以重写签名相同的继承虚方法。虚方法声明引入了新方法。重写方法声明通过提供现有继承的虚方法的新实现，专门针对该方法。
抽象方法是没有实现代码的虚方法。抽象方法使用 abstract 修饰符进行声明，仅可在抽象类中使用。必须在所有非抽象派生类中重写抽象方法。

demo

public class Program
    {
        static void Main(string[] args)
        {
            Expression e = new Operation(
                new VariableReference("x"),
                '*',
                new Operation(
                    new VariableReference("y"),
                    '+',
                    new Constant(2)
                )
            );
            Dictionary<string, object> vars = new Dictionary<string, object>();
            vars["x"] = 3;
            vars["y"] = 5;
            Console.WriteLine(e.Evaluate(vars));
        }
    }

    public abstract class Expression
    {
        public abstract double Evaluate(Dictionary<string, object> vars);
    }

    public class Constant : Expression
    {
        double _value;
        public Constant(double value)
        {
            _value = value;
        }

        public override double Evaluate(Dictionary<string, object> vars)
        {
            return _value;
        }
    }

    public class VariableReference : Expression
    {
        string _name;
        public VariableReference(string name)
        {
            _name = name;
        }

        public override double Evaluate(Dictionary<string, object> vars)
        {
            // vars[_name]不为空返回，为空抛出异常
            object value = vars[_name] ?? throw new Exception($"Unknown variable: {_name}");
            return Convert.ToDouble(value);
        }
    }

    public class Operation : Expression
    {
        Expression _left;
        char _op;
        Expression _right;
        public Operation(Expression left, char op, Expression right)
        {
            _left = left;
            _op = op;
            _right = right;
        }

        public override double Evaluate(Dictionary<string, object> vars)
        {
            // 递归如果Expression是Operation就会执行归递
            double x = _left.Evaluate(vars);
            double y = _right.Evaluate(vars);
            switch (_op)
            {
                case '+': return x + y;
                case '-': return x - y;
                case '*': return x * y;
                case '/': return x / y;
                default: throw new Exception("Unknown operator");
            }
        }
    }