C#中使用list封装多个同类型对象以及组合拓展实体的应用

一、list使用方法

在C#中，使用List集合是封装多个同类型对象的常用方式。List是泛型集合，T是集合中元素的类型。下面是一个简单的例子，演示如何创建一个List，并向其中添加对象。

首先，假设我们有一个类，比如一个Person类，它有一些属性：

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    
    // 假设还有其他属性和方法
}
1
2
3
4
5
6
7

然后，我们可以这样使用List：

using System;
using System.Collections.Generic;  // 确保引入了这个命名空间

public class Program
{
    public static void Main()
    {
        // 创建一个Person对象的List
        List<Person> people = new List<Person>();

        // 创建Person对象并添加到List中
        people.Add(new Person() { Name = "Alice", Age = 30 });
        people.Add(new Person() { Name = "Bob", Age = 25 });
        people.Add(new Person() { Name = "Charlie", Age = 35 });

        // 遍历List并打印每个Person对象的信息
        foreach (Person p in people)
        {
            Console.WriteLine($"Name: {p.Name}, Age: {p.Age}");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

上面的代码首先导入了必要的命名空间System.Collections.Generic来使用List。然后，创建了一个Person类型的List，并添加了几个Person对象到这个列表中。foreach循环被用来遍历这个列表并打印每个人的信息。

这样，我们就可以管理一个动态数组（列表）的同类型对象了，而且List提供了许多方便的方法，如Add、Remove、Find等，来操作集合中的元素。

二、C#组合拓展实体

在C#中，“组合”（Composition）通常是指一种设计模式，它表明一个类包含了一个或者多个其他类的实例来实现代码复用或者增加新的功能。这与"继承"不同，继承表示一个类是另一个类的子类。“拓展实体”（Extended Entities）一般指的是在组合模式中被用来拓展功能的那些包含的类的实例。 （定义有些复杂，不用管直接看例子也行）

组合被用于当我们想要将一些行为或者状态封装到一个单独的类中，并且希望通过含有这些类的实例的方式在多个地方重用它们。这通常是在希望建立一个对象，其行为是由多个源对象组成的时候，比如在创建一个复杂对象时，这个对象的功能需要来自于多个不同的源对象。

具体例子如下：

设想我们正在构建一个游戏，有一个Weapon类（武器）和一个Character类（人物）。在这个游戏中，每个角色可以拥有不同的武器。在这里，Weapon是一个可以被组合到Character中的实体。

首先，定义一个Weapon类：

public class Weapon //这个类代表游戏中的武器，它有两个公共属性和一个构造函数，以及一个用于执行攻击动作的方法
{
//这是两个公开属性
    public string Name { get; set; }  //武器的名称
    public int Damage { get; set; }   //使用这个武器进行攻击时造成的伤害
//构造函数，用来创建weapon类的新实例，就是说我们创建Weapon类的时候，要提供Name和Damage来初始化对象
    public Weapon(string name, int damage)
    {
        Name = name;
        Damage = damage;
    }
//一个不返回任何值的方法，调用这个方法后，会显示武器的名称和攻击造成的伤害
    public void Attack()
    {
        Console.WriteLine($"{Name} attacks for {Damage} damage!");
        //在这个字符串中，{Name}和{Damage}是插值表达式，它们会被替换为对象当前的Name和Damage属性的值。
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

然后，定义一个Character类，并在其中组合Weapon：

public class Character     //这个是游戏中的角色，并演示了怎样通过组合来使用之前定义的Weapon类
{
// 两个公开属性
    public string Name { get; set; }  //用于存储角色的名称
    public Weapon EquippedWeapon { get; set; }  //用于存储角色当前装备的武器，这个属性可以持有一个Weapon类的实例，或者为null（如果角色没有装备武器）

//构造函数，它接收一个参数name，用于在创建Character实例时设置角色的名称
    public Character(string name)
    {
        Name = name;
    }
//这是一个方法，用于为角色准备一个武器，这个方法接收一个Weapon实例作为参数，并将其分配给EquippedWeapon 属性。然后，它打印一条消息到控制台，表示角色已经装备了该武器。
    public void EquipWeapon(Weapon weapon)
    {
        EquippedWeapon = weapon;
        Console.WriteLine($"{Name} equipped {weapon.Name}!");
    }
// Attack方法用于执行攻击，它首先检查EquippedWeapon属性是否为null，如果角色有武器，那么就调用attack方法，要是么得，就在控制台上打印一条消息，说明角色无法攻击，因为没武器。
    public void Attack()
    {
        if (EquippedWeapon != null)
        {
            EquippedWeapon.Attack();
        }
        else
        {
            Console.WriteLine($"{Name} has no weapon to attack!");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

现在，我们可以创建Weapon和Character的实例，并将一个武器实体组合到一个角色中：

public class Program //Program是一个包含Main方法的类。Main方法是C#程序的入口点，也就是运行程序时第一个被调用的方法。
{
    public static void Main()
    {
        Weapon sword = new Weapon("Sword", 50); //创建武器对象，Sword 武器是一把剑,伤害是50
        Character knight = new Character("Knight"); //创建一个名为Knight（大侠）的角色

        knight.EquipWeapon(sword);//装备武器：这里调用了knight对象的EquipWeapon方法，并将之前创建的sword实例作为参数传递进去。这个方法会将sword对象赋值给knight对象的EquippedWeapon属性，并在控制台输出一条消息表明"Knight"装备了"Sword"。
        knight.Attack();//执行攻击：这行代码调用了knight对象的Attack方法。Attack方法检查EquippedWeapon是否不为空（在这个例子中，我们刚刚装备了"Sword"），然后调用EquippedWeapon（即sword对象）的Attack方法。这最终将在控制台输出一条消息，表明"Sword"攻击并造成了50点伤害。
    }
}
1
2
3
4
5
6
7
8
9
10
11

在这个例子中，当knight.Attack()被调用时，它实际上会调用EquippedWeapon的Attack()方法，这是组合在工作的例子。这样，Character类通过组合Weapon实体来拓展它的功能。这种方式允许Character获得Weapon的功能并且可以动态地改变，这是相对于继承更加灵活的设计方法。