C#编程基础知识点介绍

以下是 C# 中常见元素（属性、方法、枚举、函数等）的详细定义及示例：

1. 类（Class）

类是 C# 中最基本的类型，它是对象的蓝图，封装了数据和行为。

// 定义一个名为Person的类
public class Person
{
    // 类的成员定义将在下面详细介绍
}

2. 属性（Property）

属性是一种特殊的成员，用于提供对类的私有字段的访问和修改。属性可以包含 get 和 set 访问器。

public class Person
{
    // 私有字段，用于存储数据
    private string _name;

    // 公共属性，提供对_name字段的访问
    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }

    // 自动实现的属性，编译器会自动生成私有字段
    public int Age { get; set; }
}

使用示例：

Person person = new Person();
person.Name = "John";
person.Age = 30;
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");

3. 方法（Method）

方法是类中包含一系列语句的代码块，用于执行特定的任务。方法可以有参数和返回值。

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

    // 无参数、无返回值的方法
    public void SayHello()
    {
        Console.WriteLine($"Hello, my name is {_name}.");
    }

    // 有参数、有返回值的方法
    public int Add(int a, int b)
    {
        return a + b;
    }
}

使用示例：

Person person = new Person();
person.Name = "John";
person.SayHello();

int result = person.Add(2, 3);
Console.WriteLine($"2 + 3 = {result}");

4. 枚举（Enum）

枚举是一种值类型，用于定义一组命名的常量。

// 定义一个名为DayOfWeek的枚举
public enum DayOfWeek
{
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
    Sunday
}

使用示例：

DayOfWeek today = DayOfWeek.Monday;
Console.WriteLine($"Today is {today}.");

5. 函数（Function）

在 C# 中，函数通常指的就是方法。不过，也可以将委托看作是一种函数类型。委托是一种引用类型，它可以封装一个或多个方法。

// 定义一个委托类型
public delegate int MathOperation(int a, int b);

public class Calculator
{
    // 加法方法
    public static int Add(int a, int b)
    {
        return a + b;
    }

    // 减法方法
    public static int Subtract(int a, int b)
    {
        return a - b;
    }
}

class Program
{
    static void Main()
    {
        // 创建委托实例并指向Add方法
        MathOperation operation = Calculator.Add;
        int result = operation(5, 3);
        Console.WriteLine($"5 + 3 = {result}");

        // 改变委托指向Subtract方法
        operation = Calculator.Subtract;
        result = operation(5, 3);
        Console.WriteLine($"5 - 3 = {result}");
    }
}

6. 构造函数（Constructor）

构造函数是一种特殊的方法，用于在创建对象时初始化对象的状态。构造函数的名称与类名相同，且没有返回类型。

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

    // 构造函数
    public Person(string name)
    {
        _name = name;
    }
}

使用示例：

Person person = new Person("John");
Console.WriteLine($"Name: {person.Name}");

7. 析构函数（Destructor）

析构函数用于在对象被销毁时执行清理操作。析构函数的名称是在类名前加上波浪号 ~。

public class MyClass
{
    // 析构函数
    ~MyClass()
    {
        // 执行清理操作
        Console.WriteLine("Object is being destroyed.");
    }
}

8. 静态成员（Static Members）

静态成员属于类本身，而不是类的实例。静态成员可以是字段、属性、方法等。

public class MathUtils
{
    // 静态字段
    public static readonly double Pi = 3.14159;

    // 静态方法
    public static double CalculateCircleArea(double radius)
    {
        return Pi * radius * radius;
    }
}

使用示例：

double area = MathUtils.CalculateCircleArea(5);
Console.WriteLine($"Area of circle with radius 5: {area}");

9. 接口（Interface）

接口定义了一组方法的签名，但不包含实现。类可以实现一个或多个接口。

// 定义一个接口
public interface IAnimal
{
    void Eat();
    void Sleep();
}

// 实现接口的类
public class Dog : IAnimal
{
    public void Eat()
    {
        Console.WriteLine("Dog is eating.");
    }

    public void Sleep()
    {
        Console.WriteLine("Dog is sleeping.");
    }
}

使用示例：

Dog dog = new Dog();
dog.Eat();
dog.Sleep();

10. 结构体（Struct）

结构体是一种值类型，类似于类，但结构体是轻量级的，通常用于存储简单的数据。

// 定义一个结构体
public struct Point
{
    public int X;
    public int Y;

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

使用示例：

Point point = new Point(10, 20);
Console.WriteLine($"X: {point.X}, Y: {point.Y}");

在 C# 里，using 关键字有三种主要用途，每种用途后面所带的内容也不同，

1. 引入命名空间

当 using 用于引入命名空间时，后面跟的是命名空间的名称。命名空间是一种组织代码的方式，它能避免命名冲突，让代码结构更清晰。

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        // 使用引入的命名空间中的类
        List<int> numbers = new List<int> { 1, 2, 3 };
        var sum = numbers.Sum();
        Console.WriteLine("Sum: " + sum);
    }
}

在上述代码中，using System; 引入了 System 命名空间，该命名空间包含了像 Console 这样的基础类；using System.Collections.Generic; 引入了 System.Collections.Generic 命名空间，这里面有 List<T> 这样的泛型集合类；using System.Linq; 引入了 System.Linq 命名空间，其中包含了用于集合操作的扩展方法。

2. 为命名空间或类型创建别名

using 可以为命名空间或类型创建一个简短易记的别名，此时后面会先跟别名，然后是 =，最后是要起别名的命名空间或类型

using System;
using MyList = System.Collections.Generic.List<int>;

class Program
{
    static void Main()
    {
        // 使用别名来创建对象
        MyList numbers = new MyList { 1, 2, 3 };
        foreach (var number in numbers)
        {
            Console.WriteLine(number);
        }
    }
}

在这个例子中，using MyList = System.Collections.Generic.List<int>; 为 System.Collections.Generic.List<int> 创建了一个别名 MyList，之后就可以用 MyList 来替代完整的类型名。

3. 确保对象的正确清理

using 语句可确保实现了 IDisposable 接口的对象在使用完毕后能正确释放资源，这时后面跟的是实现了 IDisposable 接口的对象的声明

using System;
using System.IO;

class Program
{
    static void Main()
    {
        // 使用using语句确保文件流对象正确关闭
        using (FileStream fileStream = new FileStream("test.txt", FileMode.OpenOrCreate))
        {
            // 对文件流进行操作
            byte[] data = new byte[] { 1, 2, 3 };
            fileStream.Write(data, 0, data.Length);
        } // 离开using语句块时，fileStream会自动调用Dispose方法
    }
}

在这段代码里，using (FileStream fileStream = new FileStream("test.txt", FileMode.OpenOrCreate)) 声明了一个 FileStream 对象，当代码执行到 using 语句块结束时，FileStream 对象会自动调用 Dispose 方法，从而释放相关资源。

在面向对象编程中，字段（Field）是类或结构体中用于存储数据的成员，它具有以下多方面的重要作用：

1. 存储对象状态

字段的主要用途之一是存储对象的状态信息。每个对象可以有自己的字段值，这些值代表了对象在特定时刻的属性或数据。例如，在一个表示人的 Person 类中，可以使用字段来存储人的姓名、年龄等信息：

public class Person
{
    // 字段用于存储姓名
    private string name;
    // 字段用于存储年龄
    private int age;

    public Person(string name, int age)
    {
        this.name = name;
        this.age = age;
    }
}

2. 封装数据

字段可以使用访问修饰符（如 private、protected 等）来限制对数据的访问，从而实现数据的封装。封装是面向对象编程的重要原则之一，它可以隐藏对象的内部实现细节，只暴露必要的接口给外部使用。通过将字段设置为 private，可以防止外部代码直接访问和修改字段的值，而是通过公共的属性或方法来间接操作字段，这样可以更好地控制数据的访问和修改：

public class Person
{
    private string name;
    private int age;

    // 公共属性用于访问和修改 name 字段
    public string Name
    {
        get { return name; }
        set { name = value; }
    }

    // 公共属性用于访问和修改 age 字段
    public int Age
    {
        get { return age; }
        set
        {
            if (value >= 0)
            {
                age = value;
            }
        }
    }
}

3. 支持类的行为

字段可以为类的方法提供必要的数据，从而支持类的各种行为。类的方法可以使用字段的值进行计算、处理或执行其他操作。例如，在一个表示矩形的 Rectangle 类中，可以使用字段来存储矩形的长和宽，并提供一个方法来计算矩形的面积：

public class Rectangle
{
    private double length;
    private double width;

    public Rectangle(double length, double width)
    {
        this.length = length;
        this.width = width;
    }

    // 方法用于计算矩形的面积
    public double CalculateArea()
    {
        return length * width;
    }
}

4. 实现对象之间的关联

字段可以引用其他对象，从而实现对象之间的关联关系。例如，在一个表示订单的 Order 类中，可以使用字段来引用一个表示客户的 Customer 对象：

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

public class Order
{
    private Customer customer;

    public Order(Customer customer)
    {
        this.customer = customer;
    }

    public string GetCustomerName()
    {
        return customer.Name;
    }
}

5. 保存静态数据

除了实例字段，类还可以有静态字段。静态字段属于类本身，而不是类的实例，所有实例共享同一个静态字段的值。静态字段常用于保存类级别的数据，如常量、计数器等：

public class Counter
{
    // 静态字段用于记录创建的实例数量
    public static int InstanceCount = 0;

    public Counter()
    {
        InstanceCount++;
    }
}