c#中自定义集合的实现

功能：集合，包含添加，删除，计算交集，并集，补集，是否为子集

using System;
using System.Collections;
using System.Collections.Generic;
public class CSet
{
    private Hashtable data;  //定义集合的散列表

    public CSet()
    {
        data = new Hashtable();  //定义散列表
    }

    //计算hash值
    private string Hash(Object item)
    {
        char[] chars;  //定义chars
        string s = item.ToString();  //将输入的值转换为字符串
        int hashvalue = 0;
        chars = s.ToCharArray();  //将字符串转换我字符数组
        for (int i = 0; i <= chars.GetUpperBound(0);i++)
        {
            hashvalue += (int) chars[i];
        }
        return hashvalue.ToString();  //转化为字符
    }

    //向集合中添加数据
    public void Add(Object item)
    {
        if (!data.Contains(item))
        {
            data.Add(Hash(item),item);  //使用字符串的asc和作为hash值来添加到散列报中

        }
    }

    //移除数据
    public void Remove(Object item)
    {
        data.Remove(Hash(item)); //首先计算hash值，并移除这个hash值的数据
    }

    //放回集合的大小
    public int Size()
    {
        return data.Count;
    }

    //计算并集
    public CSet Union(CSet aSet)
    {
        CSet tempSet=new CSet();  //定义最后的集合
        foreach (Object hashObject in data.Keys)
        {//将原来的集合的数据添加到新的集合中
            tempSet.Add(this.data[hashObject]);
        }

        foreach (Object hashObject in aSet.data.Keys)
        {
            if(!this.data.ContainsKey(hashObject))
                tempSet.Add(aSet.data[hashObject]);
     
        }
        return tempSet;  //返回这个集合

    }

    //计算交集
    public CSet Intersection(CSet aSet)
    {
        CSet tempSet=new CSet();  //最后返回的集合
        foreach(Object hashObject in data.Keys)
            if(aSet.data.Contains(hashObject))
                tempSet.Add(aSet.data[hashObject]);
        return tempSet;  //返回这个集合
    }

    //计算是否是子集
    public bool Subset(CSet aSet)
    {
        if (this.Size() > aSet.Size())
            return false;  //计算大小如果比后一个集合大返回假
        else
        {
            foreach (Object key in this.data.Keys)
            {
                if (!aSet.data.Contains(key))
                    return false;
            }
            
        }
        return true;
    }

    //计算差集合
    public CSet Difference(CSet aSet)
    {
        CSet tempSet=new CSet();
        foreach (Object hashObject in data.Keys)
         if(!aSet.data.Contains(hashObject))
             tempSet.Add(data[hashObject]);
        return tempSet;
    }

    public override string ToString()
    {
        string s = " ";
        foreach (Object key in data.Keys)
        {
            s += data[key] + " ";

        }
        return s;
    }
}

public class Test
{
    public static void Main()
    {
        CSet setA=new CSet();  //计算集合a和集合b
        CSet setB=new CSet();

        setA.Add("milk");
        setA.Add("eggs");
        setA.Add("bacon");
        setA.Add("cereal");
        setB.Add("bacon");
        setB.Add("eggs");
        setB.Add("bread");
        CSet setC=new CSet();
        setC = setA.Union(setB);
        Console.WriteLine();
        Console.WriteLine("A:"+setA.ToString());
        Console.WriteLine("B:"+setB.ToString());
        Console.WriteLine("C:"+setC.ToString());
    }
}