字段

众嗦粥汁，字段又叫成员变量
在C#中，字段（Fields）是类的成员，用于存储数据。字段可以是任何数据类型，包括基本数据类型（如 int, double, bool 等）和引用类型（如类、数组等）。字段可以是静态的static（属于类的，而不是类的实例）或实例的（属于类的对象）。

以下是一些关于C#字段的关键点：

声明字段

字段是在类中声明的，并且可以有访问修饰符（如 public, private, protected, internal 等）来指定其可访问性。

public class Person
{
    public string Name; // 公共字段
    private int age;    // 私有字段
    protected bool isStudent; // 受保护的字段，只能在此类及其派生类中访问
}

字段初始化

字段可以在声明时初始化，也可以在构造函数中初始化。

public class Person
{
    public string Name = "Unknown"; // 字段初始化
    public int Age { get; set; } // 自动属性，具有默认值0

    public Person(string name, int age)
    {
        Name = name;
        Age = age; // 构造函数中初始化
    }
}

静态字段

静态字段属于类本身，而不是类的任何特定实例。它们使用 static 关键字声明。

public class School
{
    public static int StudentCount = 0; // 静态字段

    public School()
    {
        StudentCount++; // 增加学生计数
    }
}

常量字段

使用 const 关键字声明的字段是常量，它们的值在编译时已知，并且在运行时不能更改。

public class Constants
{
    public const double Pi = 3.14159; // 常量字段
}

只读字段

只读字段使用 readonly 关键字声明，它们可以在声明时或构造函数中初始化，但之后不能被修改。

public class Product
{
    public readonly string ProductCode; // 只读字段

    public Product(string code)
    {
        ProductCode = code;
    }
}

字段的访问

字段可以通过对象实例访问（对于实例字段）或直接通过类名访问（对于静态字段）。

Person person = new Person();
person.Name = "Alice"; // 访问实例字段

School.StudentCount = 10; // 访问静态字段

字段是类定义中最基本的数据存储单元，它们提供了一种简单的方式来存储和操作数据。

然而

为了封装和数据保护，通常建议使用属性（Properties）而不是直接访问字段。属性提供了一种更灵活的方式来控制对字段的访问，并且可以在访问或设置值时添加额外的逻辑。

---

属性

在C#中，属性（Properties）是一种成员，它们提供了一种访问和设置字段值的方法，同时允许你添加逻辑来验证或处理这些值。属性可以被视为字段的替代品，但它们提供了更多的控制和灵活性。

属性通常包含两个部分：get 访问器和 set 访问器。get 访问器返回属性的值，而 set 访问器设置属性的值。属性可以是只读或只写，也可以是读写的。

以下是一些关于C#属性的关键点：

声明属性

属性使用 get 和 set 块声明，它们定义了如何获取和设置属性值。

public class Person
{
    private string _name; // 私有字段，用于存储属性值

    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }
}

自动实现的属性

C# 允许你使用自动实现的属性，这样编译器会自动生成一个私有字段来存储属性的值。

public class Person
{
    public string Name { get; set; }
}

只读属性

如果只需要 get 访问器，属性可以是只读的。

public class Person
{
    public string Name { get; }
}

只写属性

如果只需要 set 访问器，属性可以是只写的。

public class Person
{
    private string _name;
    public string Name
    {
        set { _name = value; }
    }
}

属性的逻辑处理

可以在 set 访问器中添加逻辑，比如验证输入值。

public class Product
{
    private decimal _price;

    public decimal Price
    {
        get { return _price; }
        set
        {
            if (value < 0)
                throw new ArgumentOutOfRangeException("价格不能为负数。");
            _price = value;
        }
    }
}

属性的访问修饰符

属性的 get 和 set 访问器可以有不同的访问修饰符，以控制它们的可见性。

public class Product
{
    public decimal Price
    {
        private get { return _price; }
        protected set { _price = value; }
    }
}

属性和字段的区别

属性允许你控制对数据的访问，而字段是直接的数据存储。属性通常用于封装字段，提供数据验证或逻辑处理。

属性的用途

属性通常用于封装数据，提供数据验证，以及实现数据绑定等。

总结

属性是C#中非常重要的特性，它们提供了一种安全和灵活的方式来访问和修改对象的状态。通过使用属性，你可以隐藏实现细节，同时提供对数据的控制。

---

索引器

在C#中，索引器（Indexers）是一种特殊的属性，它允许你使用数组索引的语法来访问对象的元素。索引器可以有多个参数，这使得它们非常适合用来实现类似字典或数据库表的访问模式。

索引器的基本语法

public class MyClass
{
    private Dictionary<int, string> _data = new Dictionary<int, string>();

    // 索引器声明
    public string this[int index]
    {
        get
        {
            if (_data.TryGetValue(index, out string value))
                return value;
            else
                throw new KeyNotFoundException("索引未找到。");
        }
        set
        {
            _data[index] = value;
        }
    }
}

使用索引器

class Program
{
    static void Main()
    {
        MyClass myObj = new MyClass();

        // 使用索引器设置元素
        myObj[1] = "Hello";
        myObj[2] = "World";

        // 使用索引器获取元素
        Console.WriteLine(myObj[1]); // 输出: Hello
        Console.WriteLine(myObj[2]); // 输出: World

        try
        {
            // 尝试访问不存在的索引
            Console.WriteLine(myObj[3]);
        }
        catch (KeyNotFoundException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

索引器的关键点

语法

索引器的语法与属性类似，但使用了 this 关键字，后面跟着参数列表。

参数

索引器可以有一个或多个参数，这些参数用于确定要访问或设置的元素。

访问和设置

索引器可以有 get 和 set 访问器，允许你获取和设置元素的值。

异常处理

在 get 访问器中，如果尝试访问不存在的索引，可以抛出异常，如 KeyNotFoundException。

性能

使用索引器可以提供快速的数据访问，特别是当你使用内部数据结构（如字典）来存储元素时。

重载

你可以为同一个类定义多个索引器，只要它们的参数列表不同。

使用场景

索引器非常适合实现类似数组或字典的数据结构，允许用户通过索引来访问和修改数据。

封装

索引器可以封装内部数据结构，隐藏实现细节，只暴露必要的接口给用户。

再举个例子

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace forCode2019 {
    class Program {
        static void Main(string[] args) {

            Demo d = new Demo(3);
            d[2] = 1;
            d[1] = d[2] * 5;
            d[0, 1] = 100;
            Console.WriteLine(d[1]);
            Console.ReadKey();

        }
    }

    class Demo {
        int[] a;
        public Demo(int size) {
            a = new int[size];
        }
        public int this[int index] {
            get {
                return a[index];
            }
            set {
                a[index] = value;
            }
        }
        public int this[int x, int y] {
            get {
                return a[x+y];
            }
            set {
                a[x+y] = value;
            }
        }
    }
}

总结

索引器是C#中一个强大的特性，它提供了一种自然和直观的方式来访问和操作对象的元素。通过使用索引器，你可以创建更加灵活和强大的数据结构。