.NET 中仅允许唯一项目的集合？

Question

C# 中是否有一个集合不允许您向其中添加重复项？例如，使用

public class Customer {
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Address { get; set; }

    public override int GetHashCode() {
        return (FirstName + LastName + Address).GetHashCode();
    }

    public override bool Equals(object obj) {
        Customer C = obj as Customer;
        return C != null && String.Equals(this.FirstName, C.FirstName) && String.Equals(this.LastName, C.LastName) && String.Equals(this.Address, C.Address);
    }
}

以下代码的愚蠢类（显然）会抛出异常：

Customer Adam = new Customer { Address = "A", FirstName = "Adam", LastName = "" };
Customer AdamDup = new Customer { Address = "A", FirstName = "Adam", LastName = "" };

Dictionary<Customer, bool> CustomerHash = new Dictionary<Customer, bool>();
CustomerHash.Add(Adam, true);
CustomerHash.Add(AdamDup, true);

但是是否有一个类可以类似地保证唯一性，但没有 KeyValuePairs？我认为 HashSet 会做到这一点，但阅读文档后，类似乎只是一个集合实现（去计算）。

Answer 1

HashSet 就是您要寻找的。来自 MSDN（添加了重点）：

HashSet 类提供高性能的集合操作。集合是不包含重复元素的集合，并且其元素没有特定的顺序。

请注意 HashSet.Add(T item) 方法 如果该项目已添加到集合中，则返回 bool -- true；如果该项目已存在，则 false。

Answer 2

只在 HashSet 上添加一个扩展方法怎么样？

public static void AddOrThrow<T>(this HashSet<T> hash, T item)
{
    if (!hash.Add(item))
        throw new ValueExistingException();
}

Answer 3

从 MSDN 上的 HashSet页面：

HashSet(Of T) 类提供高性能的集合操作。 集合是不包含重复元素的集合，并且其元素没有特定的顺序。

（强调我的）

Answer 4

如果您需要的只是确保元素的唯一性，那么 HashSet 就是您所需要的。

当你说“只是一套实施”时，你是什么意思？集合（根据定义）是不保存元素顺序的唯一元素的集合。

Answer 5

只是添加我的 2 美分...

如果您需要一个 ValueExistingException 抛出 HashSet 您还可以轻松创建您的集合：

public class ThrowingHashSet<T> : ICollection<T>
{
    private HashSet<T> innerHash = new HashSet<T>();

    public void Add(T item)
    {
        if (!innerHash.Add(item))
            throw new ValueExistingException();
    }

    public void Clear()
    {
        innerHash.Clear();
    }

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

    public void CopyTo(T[] array, int arrayIndex)
    {
        innerHash.CopyTo(array, arrayIndex);
    }

    public int Count
    {
        get { return innerHash.Count; }
    }

    public bool IsReadOnly
    {
        get { return false; }
    }

    public bool Remove(T item)
    {
        return innerHash.Remove(item);
    }

    public IEnumerator<T> GetEnumerator()
    {
        return innerHash.GetEnumerator();
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

例如，如果您在很多地方需要它，这可能很有用。 。

Answer 6

您可以尝试 HashSet

Answer 7

您可以查看某种唯一列表，如下所示

public class UniqueList<T>
{
    public List<T> List
    {
        get;
        private set;
    }
    List<T> _internalList;

    public static UniqueList<T> NewList
    {
        get
        {
            return new UniqueList<T>();
        }
    }

    private UniqueList()
    {            
        _internalList = new List<T>();
        List = new List<T>();
    }

    public void Add(T value)
    {
        List.Clear();
        _internalList.Add(value);
        List.AddRange(_internalList.Distinct());
        //return List;
    }

    public void Add(params T[] values)
    {
        List.Clear();
        _internalList.AddRange(values);
        List.AddRange(_internalList.Distinct());
       // return List;
    }

    public bool Has(T value)
    {
        return List.Contains(value);
    }
}

，并且可以像下面这样使用它，

var uniquelist = UniqueList<string>.NewList;
uniquelist.Add("abc","def","ghi","jkl","mno");
uniquelist.Add("abc","jkl");
var _myList = uniquelist.List;

即使在重复项被添加到其中

Answer 8

作为整体检查的不同方法，这里有 4 种方法来检查集合是否没有任何重复项：

public static bool LinqAny<T>(IEnumerable<T> enumerable)
{
    HashSet<T> set = new();

    return enumerable.Any(element => !set.Add(element));
}

public static bool LinqAll<T>(IEnumerable<T> enumerable)
{
    HashSet<T> set = new();

    return !enumerable.All(set.Add);
}

public static bool LinqDistinct<T>(IEnumerable<T> enumerable)
{
    return enumerable.Distinct().Count() != enumerable.Count();
}

public static bool ToHashSet<T>(IEnumerable<T> enumerable)
{
    return enumerable.ToHashSet().Count != enumerable.Count();
}