在C＃2.0中使用HashSet，与3.5兼容-UsingHashSetinC#2.0,compatiblewith3.5

23  

You can use HashSet in a 2.0 application now - just reference System.Core.dll and you should be good to go.

您现在可以在2.0应用程序中使用HashSet - 只需参考System.Core.dll，您应该很高兴。

Note: This would require you to install the .NET 3.5 framework which is free and separate from Visual Studio. Once you have that installed you will have the new System.Core assembly which contains the HashSet type. Since the .NET frameworks versions 2.0 - 3.5 all share the same CLR you can use this assembly in your 2.0 application without any issues.

注意：这将要求您安装免费且独立于Visual Studio的.NET 3.5框架。安装完成后，您将拥有包含HashSet 类型的新System.Core程序集。由于.NET框架版本2.0 - 3.5都共享相同的CLR，因此您可以在2.0应用程序中使用此程序集而不会出现任何问题。

24  

Here's one I wrote for 2.0 that uses a Dictionary internally. It's not an exact match of the 3.5 HashSet, but it does the job for me.

这是我为2.0编写的一个内部使用Dictionary 的。它不是3.5 HashSet 的精确匹配，但它为我完成了这项工作。

using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.Serialization;

public class HashSet : ICollection, ISerializable, IDeserializationCallback
{
    private readonly Dictionary dict;

    public HashSet()
    {
        dict = new Dictionary();
    }

    public HashSet(IEnumerable items) : this()
    {
        if (items == null)
        {
            return;
        }

        foreach (T item in items)
        {
            Add(item);
        }
    }

    public HashSet NullSet { get { return new HashSet(); } }

    #region ICollection Members

    public void Add(T item)
    {
        if (null == item)
        {
            throw new ArgumentNullException("item");
        }

        dict[item] = null;
    }

    /// 

    /// Removes all items from the .
    /// 
    /// The  is read-only. 
    public void Clear()
    {
        dict.Clear();
    }

    public bool Contains(T item)
    {
        return dict.ContainsKey(item);
    }

    /// 

    /// Copies the items of the  to an , starting at a particular  index.
    /// 
    /// The one-dimensional  that is the destination of the items copied from . The  must have zero-based indexing.The zero-based index in  at which copying begins. is null. is less than 0. is multidimensional.-or- is equal to or greater than the length of .-or-The number of items in the source  is greater than the available space from  to the end of the destination .-or-Type T cannot be cast automatically to the type of the destination .
    public void CopyTo(T[] array, int arrayIndex)
    {
        if (array == null) throw new ArgumentNullException("array");
        if (arrayIndex <0 || arrayIndex >= array.Length || arrayIndex >= Count)
        {
            throw new ArgumentOutOfRangeException("arrayIndex");
        }

        dict.Keys.CopyTo(array, arrayIndex);
    }

    /// 

    /// Removes the first occurrence of a specific object from the .
    /// 
    /// 
    /// true if  was successfully removed from the ; otherwise, false. This method also returns false if  is not found in the original .
    /// 
    /// The object to remove from the .The  is read-only.
    public bool Remove(T item)
    {
        return dict.Remove(item);
    }

    /// 

    /// Gets the number of items contained in the .
    /// 
    /// 
    /// The number of items contained in the .
    /// 
    public int Count
    {
        get { return dict.Count; }
    }

    /// 

    /// Gets a value indicating whether the  is read-only.
    /// 
    /// 
    /// true if the  is read-only; otherwise, false.
    /// 
    public bool IsReadOnly
    {
        get
        {
            return false;
        }
    }

    #endregion

    public HashSet Union(HashSet set)
    {
        HashSet uniOnSet= new HashSet(this);

        if (null == set)
        {
            return unionSet;
        }

        foreach (T item in set)
        {
            if (unionSet.Contains(item))
            {
                continue;
            }

            unionSet.Add(item);
        }

        return unionSet;
    }

    public HashSet Subtract(HashSet set)
    {
        HashSet subtractSet = new HashSet(this);

        if (null == set)
        {
            return subtractSet;
        }

        foreach (T item in set)
        {
            if (!subtractSet.Contains(item))
            {
                continue;
            }

            subtractSet.dict.Remove(item);
        }

        return subtractSet;
    }

    public bool IsSubsetOf(HashSet set)
    {
        HashSet setToCompare = set ?? NullSet;

        foreach (T item in this)
        {
            if (!setToCompare.Contains(item))
            {
                return false;
            }
        }

        return true;
    }

    public HashSet Intersection(HashSet set)
    {
        HashSet intersectiOnSet= NullSet;

        if (null == set)
        {
            return intersectionSet;
        }

        foreach (T item in this)
        {
            if (!set.Contains(item))
            {
                continue;
            }

            intersectionSet.Add(item);
        }

        foreach (T item in set)
        {
            if (!Contains(item) || intersectionSet.Contains(item))
            {
                continue;
            }

            intersectionSet.Add(item);
        }

        return intersectionSet;
    }

    public bool IsProperSubsetOf(HashSet set)
    {
        HashSet setToCompare = set ?? NullSet;

        // A is a proper subset of a if the b is a subset of a and a != b
        return (IsSubsetOf(setToCompare) && !setToCompare.IsSubsetOf(this));
    }

    public bool IsSupersetOf(HashSet set)
    {
        HashSet setToCompare = set ?? NullSet;

        foreach (T item in setToCompare)
        {
            if (!Contains(item))
            {
                return false;
            }
        }

        return true;
    }

    public bool IsProperSupersetOf(HashSet set)
    {
        HashSet setToCompare = set ?? NullSet;

        // B is a proper superset of a if b is a superset of a and a != b
        return (IsSupersetOf(setToCompare) && !setToCompare.IsSupersetOf(this));
    }

    public List ToList()
    {
        return new List(this);
    }

    #region Implementation of ISerializable

    /// 

    /// Populates a  with the data needed to serialize the target object.
    /// 
    /// The  to populate with data. The destination (see ) for this serialization. The caller does not have the required permission. 
    public void GetObjectData(SerializationInfo info, StreamingContext context)
    {
        if (info == null) throw new ArgumentNullException("info");
        dict.GetObjectData(info, context);
    }

    #endregion

    #region Implementation of IDeserializationCallback

    /// 

    /// Runs when the entire object graph has been deserialized.
    /// 
    /// The object that initiated the callback. The functionality for this parameter is not currently implemented. 
    public void OnDeserialization(object sender)
    {
        dict.OnDeserialization(sender);
    }

    #endregion

    #region Implementation of IEnumerable

    /// 

    /// Returns an enumerator that iterates through the collection.
    /// 
    /// 
    /// A  that can be used to iterate through the collection.
    /// 
    /// 1
    public IEnumerator GetEnumerator()
    {
        return dict.Keys.GetEnumerator();
    }

    /// 

    /// Returns an enumerator that iterates through a collection.
    /// 
    /// 
    /// An  object that can be used to iterate through the collection.
    /// 
    /// 2
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    #endregion
}

8  

You could use Iesi.Collections (used by NHibernate) or Mono's HashSet

您可以使用Iesi.Collections（由NHibernate使用）或Mono的HashSet

3  

The C5 Library also has a HashSet implementation.

C5库还有一个HashSet实现。

2  

I think PowerCollections library should fit your needs. It's an open source library that contains several collection classes that were missing in .NET, including Set, Bag, MultiDictionary etc. It runs on .NET 2.0. I've been using it for couple of years now and I'm very pleased with it.

我认为PowerCollections库应该符合您的需求。它是一个开源库，包含.NET中缺少的几个集合类，包括Set ，Bag ，MultiDictionary等。它运行在.NET 2.0上。我已经使用它几年了，我对它非常满意。

1  

You can alias the Dictionary as Hashset with a using directive. Not really the same thing, but it might simplify things for you later.

您可以使用using指令将Dictionary替换为Hashset。不是一回事，但它可能会在以后简化你的事情。