如何在不复制元素的情况下从 HashSet 制作 ReadOnlyCollection？

Question

我有一个私有的HashSet<string>，它是一个只读属性的支持字段，它应该返回一个只读集合，这样调用者就不能修改集合。所以我尝试：

public class MyClass
{
    private readonly HashSet<string> _referencedColumns;

    public ICollection<string> ReferencedColumns { 
        get { return new ReadOnlyCollection<string>(_referencedColumns); }
    }

这不会编译为 ReadOnlyCollection 接受 IList<T> 不是由 HashSet<T> 实现的。是否有另一个包装器可以用来让我免于复制项目？就我的目的而言，只需返回由HashSet<T> 实现的实现ICollection<T>（而不是IList<T>）的东西就足够了。

Answer 1

考虑将属性公开为IReadOnlyCollection<> 类型，这将提供HashSet<> 的只读视图。这是一种有效的实现方式，因为属性 getter 不需要底层集合的副本。

这不会阻止某人将该属性转换为 HashSet<> 并对其进行修改。如果您对此感到担忧，请考虑在属性 getter 中使用 return _referencedColumns.ToList()，这将创建您的基础集的副本。

Answer 2

您可以使用以下装饰器包装哈希集并返回只读的ICollection<T>（IsReadOnly 属性返回 true，修改方法抛出 NotSupportedException，如ICollection<T> 的合同中指定的那样):

public class MyReadOnlyCollection<T> : ICollection<T>
{
    private readonly ICollection<T> decoratedCollection;

    public MyReadOnlyCollection(ICollection<T> decorated_collection)
    {
        decoratedCollection = decorated_collection;
    }

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

    IEnumerator IEnumerable.GetEnumerator()
    {
        return ((IEnumerable) decoratedCollection).GetEnumerator();
    }

    public void Add(T item)
    {
        throw new NotSupportedException();
    }

    public void Clear()
    {
        throw new NotSupportedException();
    }

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

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

    public bool Remove(T item)
    {
        throw new NotSupportedException();
    }

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

    public bool IsReadOnly
    {
        get { return true; }
    }
}

你可以这样使用它：

public class MyClass
{
    private readonly HashSet<string> _referencedColumns;

    public ICollection<string> ReferencedColumns { 
        get { return new MyReadOnlyCollection<string>(_referencedColumns); }
    }
    //...

请注意，此解决方案不会拍摄 HashSet 的快照，而是会保存对 HashSet 的引用。这意味着返回的集合将包含 HashSet 的实时版本，即如果 HashSet 发生更改，则在更改之前获得只读集合​​的​​消费者将能够看到更改。

Answer 3

虽然它不是只读的，但微软发布了一个名为System.Collections.Immutable的nuget包，其中包含一个ImmutableHashSet<T>，它实现了IImmutableSet<T>，它扩展了IReadOnlyCollection<T>

快速使用示例：

public class TrackedPropertiesBuilder : ITrackedPropertiesBuilder
{
    private ImmutableHashSet<string>.Builder trackedPropertiesBuilder;

    public TrackedPropertiesBuilder()
    {
        this.trackedPropertiesBuilder = ImmutableHashSet.CreateBuilder<string>();
    }

    public ITrackedPropertiesBuilder Add(string propertyName)
    {
        this.trackedPropertiesBuilder.Add(propertyName);
        return this;
    }

    public IImmutableSet<string> Build() 
        => this.trackedPropertiesBuilder.ToImmutable();
}

Answer 4

这很简单，我不知道为什么微软没有提供这个，但我会发布我基于IReadOnlyCollection<T>的实现，以及完整的扩展方法。

public class MyClass {
    private readonly HashSet<string> _referencedColumns;

    public IReadonlyHashSet<string> ReferencedColumns => _referencedColumns.AsReadOnly();
}

/// <summary>Represents hash set which don't allow for items addition.</summary>
/// <typeparam name="T">Type of items int he set.</typeparam>
public interface IReadonlyHashSet<T> : IReadOnlyCollection<T> {
    /// <summary>Returns true if the set contains given item.</summary>
    public bool Contains(T i);
}

/// <summary>Wrapper for a <see cref="HashSet{T}"/> which allows only for lookup.</summary>
/// <typeparam name="T">Type of items in the set.</typeparam>
public class ReadonlyHashSet<T> : IReadonlyHashSet<T> {
    /// <inheritdoc/>
    public int Count => set.Count;
    private HashSet<T> set;

    /// <summary>Creates new wrapper instance for given hash set.</summary>
    public ReadonlyHashSet(HashSet<T> set) => this.set = set;

    /// <inheritdoc/>
    public bool Contains(T i) => set.Contains(i);

    /// <inheritdoc/>
    public IEnumerator<T> GetEnumerator() => set.GetEnumerator();
    /// <inheritdoc/>
    IEnumerator IEnumerable.GetEnumerator() => set.GetEnumerator();
}

/// <summary>Extension methods for the <see cref="HashSet{T}"/> class.</summary>
public static class HasSetExtensions {
    /// <summary>Returns read-only wrapper for the set.</summary>
    public static ReadonlyHashSet<T> AsReadOnly<T>(this HashSet<T> s)
        => new ReadonlyHashSet<T>(s);
}