¿Cuál es la mejor manera de representar una lista inmutable en .NET?

Question

Recientemente comencé a usar F # para "trabajo real" y redescubrí la belleza de estructuras de datos inmutables como las uniones discriminadas y los registros en F #. También descubrí que son bastante sencillos de usar desde C#, especialmente porque no requieren ninguna dependencia directa del tiempo de ejecución F #. Sin embargo, cuando se trata de representar listas en estas estructuras, aún no he encontrado una solución ideal.

Mi primer intento fue para escribir las listas como SEQ < 'a> (IEnumerable en el C# mundo) que proporciona una interfaz agradable colección general sin exportar ningún método para la mutación de la colección de la manera ICollection <> y sus amigos lo hace. Sin embargo, dado que no tengo control sobre el constructor de una unión o registro discriminado, es posible que el creador de una instancia de estos tipos proporcione una implementación IEnumerable <> que podría cambiar o arrojarse cuando se use (como una expresión LINQ) . IEnumerable <> no me proporcionará ninguna ayuda del compilador para probar que el valor es inmutable y, por lo tanto, es seguro para la ejecución de subprocesos.

Mi estrategia actual es usar el tipo de lista F # que garantiza una colección inmutable, pero agrega una dependencia en el tiempo de ejecución F # y se ve un poco apagado cuando se usa desde proyectos que no son F #. Sin embargo, permite la coincidencia de patrón F # que IEnumerable <> no. Tampoco da ninguna opción en la representación real de una lista, y en algunos casos (como grandes listas de valores primitivos) la representación de la lista F # no encaja realmente.

Lo que realmente me gustaría ver es un tipo de matriz inmutable en .NET, representada de forma tan compacta como la matriz normal, pero con la garantía del compilador de no estar mutado. Me encantaría const como en C++, aunque probablemente no sea muy probable que suceda. Mientras tanto, ¿hay alguna otra opción que me haya perdido?

Answer 1

Si lo que desea es una implementación gama inmutable a continuación, puedes usar algo como lo siguiente

public sealed class ImmutableArray<T> : IEnumerable<T>{ 
    private readonly T[] m_array; 
    public T this[int index] { 
    get { return m_array[index]; } 
    } 
    public int Length { 
    get { return m_array.Length; } 
    } 
    public ImmutableArray(IEnumerable<T> enumerable) { 
    m_array = enumerable.ToArray(); 
    } 
    // IEnumerable<T> implementation ommitted 
} 

Answer 2

Envuelva su gama normal en una instancia ReadOnlyCollection<T>:

var readOnlyData = new ReadOnlyCollection<TheType>(theRealCollection); 

(Nota: esto hace no copiar la colección subyacente, pero contiene una referencia y se implementan miembros modificadores de IList<T> etc. para lanzar una excepción.)

Answer 3

Recomiendo mirar la serie Eric Lippert's en immutability, es una lectura muy útil. La Parte 4 sobre un immutable queue sería un buen lugar para comenzar.

Answer 4

Microsoft publica una versión estable del paquete de nugget Immutable collections. Todavía no viene con ImmutableArray. Pero estas estructuras de datos inmutables deberían ser muy útiles.

• ImmutableList
• ImmutableDictionary
• ImmutableSortedDictionary
• ImmutableHashSet
• ImmutableSortedSet
• ImmutableStack
• ImmutableQueue

http://blogs.msdn.com/b/dotnet/archive/2013/09/25/immutable-collections-ready-for-prime-time.aspx