Эффективные, неизменные, расширяемые коллекции для .NET.

Question

Мне кажется, что существует огромное количество безопасных, неизменных типов коллекций для .NET, в частности BCL, но я не видел много работы вне любой из них. У кого-нибудь есть указатели на (желательно) качество производства, быструю, неизменяемую библиотеку коллекций для .NET. Быстрый тип списка необходим. Я еще не готов переключиться на F #.

* Edit: Обратите внимание на поисковиках, это перекатываться в BCL скоро: .NET immutable collections

Answer 1

Возможно, вы захотите взглянуть на пространство имен Microsoft.FSharp.Collections в сборке FSharp.Core. Вам не нужно программировать в F #, чтобы использовать эти типы.

Имейте в виду, что имена будут отличаться при использовании снаружи F #. Например, Map в F # известен как FSharpMap от C#.

Answer 2

C5 приходит на ум, но я не уверен, насколько быстро он. Он существует уже много лет и очень стабилен.

Кроме того, List<T>.AsReadOnly() делает работу довольно хорошо ИМО, но, к сожалению, нет эквивалента для словарей или произвольных ICollection<T>.

Answer 3

Вы можете посмотреть на Extras или System.collections.concurrenttutorial

Answer 4

• Functional-dotnet по Alexey Romanov
• Sasa по Sandro Magi
• Kinet по Tony Morris

Answer 5

Я написал ImmutableList<T> класс некоторое время назад:

using System; 
using System.Collections; 
using System.Collections.Generic; 
using System.Linq; 

public class ImmutableList<T> : IList<T>, IEquatable<ImmutableList<T>> 
{ 
    #region Private data 

    private readonly IList<T> _items; 
    private readonly int _hashCode; 

    #endregion 

    #region Constructor 

    public ImmutableList(IEnumerable<T> items) 
    { 
     _items = items.ToArray(); 
     _hashCode = ComputeHash(); 
    } 

    #endregion 

    #region Public members 

    public ImmutableList<T> Add(T item) 
    { 
     return this 
       .Append(item) 
       .AsImmutable(); 
    } 

    public ImmutableList<T> Remove(T item) 
    { 
     return this 
       .SkipFirst(it => object.Equals(it, item)) 
       .AsImmutable(); 
    } 

    public ImmutableList<T> Insert(int index, T item) 
    { 
     return this 
       .InsertAt(index, item) 
       .AsImmutable(); 
    } 

    public ImmutableList<T> RemoveAt(int index) 
    { 
     return this 
       .SkipAt(index) 
       .AsImmutable(); 
    } 

    public ImmutableList<T> Replace(int index, T item) 
    { 
     return this 
       .ReplaceAt(index, item) 
       .AsImmutable(); 
    } 

    #endregion 

    #region Interface implementations 

    public int IndexOf(T item) 
    { 
     if (_items == null) 
      return -1; 

     return _items.IndexOf(item); 
    } 

    public bool Contains(T item) 
    { 
     if (_items == null) 
      return false; 

     return _items.Contains(item); 
    } 

    public void CopyTo(T[] array, int arrayIndex) 
    { 
     if (_items == null) 
      return; 

     _items.CopyTo(array, arrayIndex); 
    } 

    public int Count 
    { 
     get 
     { 
      if (_items == null) 
       return 0; 

      return _items.Count; 
     } 
    } 

    public IEnumerator<T> GetEnumerator() 
    { 
     if (_items == null) 
      return Enumerable.Empty<T>().GetEnumerator(); 

     return _items.GetEnumerator(); 
    } 

    public bool Equals(ImmutableList<T> other) 
    { 
     if (other == null || this._hashCode != other._hashCode) 
      return false; 
     return this.SequenceEqual(other); 
    } 

    #endregion 

    #region Explicit interface implementations 

    void IList<T>.Insert(int index, T item) 
    { 
     throw new InvalidOperationException(); 
    } 

    void IList<T>.RemoveAt(int index) 
    { 
     throw new InvalidOperationException(); 
    } 

    T IList<T>.this[int index] 
    { 
     get 
     { 
      if (_items == null) 
       throw new IndexOutOfRangeException(); 

      return _items[index]; 
     } 
     set 
     { 
      throw new InvalidOperationException(); 
     } 
    } 

    void ICollection<T>.Add(T item) 
    { 
     throw new InvalidOperationException(); 
    } 

    void ICollection<T>.Clear() 
    { 
     throw new InvalidOperationException(); 
    } 

    bool ICollection<T>.IsReadOnly 
    { 
     get { return true; } 
    } 

    bool ICollection<T>.Remove(T item) 
    { 
     throw new InvalidOperationException(); 
    } 

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

    #endregion 

    #region Overrides 

    public override bool Equals(object obj) 
    { 
     if (obj is ImmutableList<T>) 
     { 
      var other = (ImmutableList<T>)obj; 
      return this.Equals(other); 
     } 
     return false; 
    } 

    public override int GetHashCode() 
    { 
     return _hashCode; 
    } 

    #endregion 

    #region Private methods 

    private int ComputeHash() 
    { 
     if (_items == null) 
      return 0; 

     return _items 
      .Aggregate(
       983, 
       (hash, item) => 
        item != null 
         ? 457 * hash^item.GetHashCode() 
         : hash); 
    } 

    #endregion 
} 

Все методы, которые изменяют коллекцию, возвращают измененную копию. Чтобы выполнить контракт с IList<T>, стандартные методы «Добавить/Удалить/Удалить/Очистить» реализованы явно, но они выбрасывают InvalidOperationException.

Этот класс использует несколько нестандартных методов расширения, вот они:

public static class ExtensionMethods 
{ 
    public static IEnumerable<T> Append<T>(this IEnumerable<T> source, T item) 
    { 
     return source.Concat(new[] { item }); 
    } 

    public static IEnumerable<T> SkipFirst<T>(this IEnumerable<T> source, Func<T, bool> predicate) 
    { 
     bool skipped = false; 
     foreach (var item in source) 
     { 
      if (!skipped && predicate(item)) 
      { 
       skipped = true; 
       continue; 
      } 

      yield return item; 
     } 
    } 

    public static IEnumerable<T> SkipAt<T>(this IEnumerable<T> source, int index) 
    { 
     return source.Where((it, i) => i != index); 
    } 

    public static IEnumerable<T> InsertAt<T>(this IEnumerable<T> source, int index, T item) 
    { 
     int i = 0; 
     foreach (var it in source) 
     { 
      if (i++ == index) 
       yield return item; 

      yield return it; 
     } 
    } 

    public static IEnumerable<T> ReplaceAt<T>(this IEnumerable<T> source, int index, T item) 
    { 
     return source.Select((it, i) => i == index ? item : it); 
    } 
} 

А вот вспомогательный класс для создания экземпляров из ImmutableList<T>:

public static class ImmutableList 
{ 
    public static ImmutableList<T> CreateFrom<T>(IEnumerable<T> source) 
    { 
     return new ImmutableList<T>(source); 
    } 

    public static ImmutableList<T> Create<T>(params T[] items) 
    { 
     return new ImmutableList<T>(items); 
    } 

    public static ImmutableList<T> AsImmutable<T>(this IEnumerable<T> source) 
    { 
     return new ImmutableList<T>(source); 
    } 
} 

Вот пример использования:

[Test] 
    public void Test_ImmutableList() 
    { 
     var expected = ImmutableList.Create("zoo", "bar", "foo"); 
     var input = ImmutableList.Create("foo", "bar", "baz"); 
     var inputSave = input.AsImmutable(); 
     var actual = input 
       .Add("foo") 
       .RemoveAt(0) 
       .Replace(0, "zoo") 
       .Insert(1, "bar") 
       .Remove("baz"); 

     Assert.AreEqual(inputSave, input, "Input collection was modified"); 
     Assert.AreEqual(expected, actual); 
    } 

Я не могу сказать, что это качество продукции, поскольку у меня нет тщательно изучил его, но пока это работает нормально ...

Answer 6

Вы можете попробовать BclExtras от JaredPar.

Answer 7

Команда .NET BCL выпустила Immutable Collections preview для .NET 4.5