Czy C# może dać mi niezmienny Słownik?

Z tego co wiem, nie ma. Ale być może możesz skopiować jakiś kod (i wiele się nauczyć) z tych artykułów:

Niezmienność w C# część pierwsza: rodzaje niezmienności
niezmienność w C# Część druga: prosty stos niezmienny
niezmienność w C# Część trzecia: Kowariantny stos niezmienny
niezmienność w C# Część czwarta: niezmienna Kolejka
niezmienność w C # część szósta: proste drzewo binarne
niezmienność w C # część siódma: więcej na drzewach binarnych
niezmienność w C# część ósma: jeszcze więcej na drzewach binarnych
niezmienność w C# część dziewiąta: Akademicka? Plus moja implementacja drzewa AVL
niezmienność w C# CZ. 10: Kolejka dwukońcowa
Immutability in C# Part Eleven: a working double-ended queue

Wraz z wydaniem. NET 4.5, pojawiła się nowa klasa ReadOnlyDictionary . Po prostu przekazujesz IDictionary do konstruktora, aby utworzyć słownik niezmienny.

Tutaj {[3] } jest pomocną metodą rozszerzenia, która może być użyta do uproszczenia tworzenia słownika readonly.

Nie wydaje mi się. Istnieje sposób na stworzenie listy tylko do odczytu i kolekcji tylko do odczytu, ale nie sądzę, że istnieje wbudowany słownik tylko do odczytu. System.ServiceModel ma implementację tylko wczytaną, ale wewnętrzną. Prawdopodobnie nie byłoby zbyt trudne skopiowanie go za pomocą reflektora lub po prostu stworzenie własnego od zera. Zasadniczo zawija Słownik i rzuca, gdy wywoływany jest mutator.

Dodając do odpowiedzi dbkk , chciałem móc użyć inicjalizatora obiektu podczas pierwszego tworzenia ReadOnlyDictionary. Dokonałem następujących modyfikacji:

private readonly int _finalCount;

/// <summary>
/// Takes a count of how many key-value pairs should be allowed.
/// Dictionary can be modified to add up to that many pairs, but no
/// pair can be modified or removed after it is added.  Intended to be
/// used with an object initializer.
/// </summary>
/// <param name="count"></param>
public ReadOnlyDictionary(int count)
{
    _dict = new SortedDictionary<TKey, TValue>();
    _finalCount = count;
}

/// <summary>
/// To allow object initializers, this will allow the dictionary to be
/// added onto up to a certain number, specifically the count set in
/// one of the constructors.
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public void Add(TKey key, TValue value)
{
    if (_dict.Keys.Count < _finalCount)
    {
        _dict.Add(key, value);
    }
    else
    {
        throw new InvalidOperationException(
            "Cannot add pair <" + key + ", " + value + "> because " +
            "maximum final count " + _finalCount + " has been reached"
        );
    }
}

Teraz mogę używać klasy Tak:

ReadOnlyDictionary<string, string> Fields =
    new ReadOnlyDictionary<string, string>(2)
        {
            {"hey", "now"},
            {"you", "there"}
        };

Biblioteka open-source PowerCollections zawiera wrapper słownika tylko do odczytu (jak również wrappery tylko do odczytu dla prawie wszystkiego innego), dostępny za pomocą statycznej metody ReadOnly() w klasie Algorithms.

Jednym z obejść może być rzucenie nowej listy KeyValuePair ze słownika, aby zachować oryginał niezmodyfikowany.

var dict = new Dictionary<string, string>();

dict.Add("Hello", "World");
dict.Add("The", "Quick");
dict.Add("Brown", "Fox");

var dictCopy = dict.Select(
    item => new KeyValuePair<string, string>(item.Key, item.Value));

// returns dictCopy;

W ten sposób oryginalny słownik nie zostanie zmodyfikowany.

"po wyjęciu z pudełka" nie ma na to sposobu. Możesz ją utworzyć, wyprowadzając własną klasę słownika i wdrażając potrzebne ograniczenia.

Znalazłem implementację Niewyważalnej (nie tylko READONLY) implementacji AVLTree dla C# tutaj.

Drzewo AVL ma logarytmiczny (nie stały) koszt każdej operacji, ale nadal jest szybki.

Http://csharpfeeds.com/post/7512/Immutability_in_Csharp_Part_Nine_Academic_Plus_my_AVL_tree_implementation.aspx

Od Linq istnieje ogólny interfejs ILookup . Czytaj więcej w MSDN .

Dlatego, aby po prostu uzyskać słownik niezmienny, możesz wywołać:

using System.Linq;
// (...)
var dictionary = new Dictionary<string, object>();
// (...)
var read_only = dictionary.ToLookup(kv => kv.Key, kv => kv.Value);

Możesz spróbować czegoś takiego:

private readonly Dictionary<string, string> _someDictionary;

public IEnumerable<KeyValuePair<string, string>> SomeDictionary
{
    get { return _someDictionary; }
}

Usunęłoby to problem zmienności na korzyść konieczności przekonwertowania go do własnego słownika:

foo.SomeDictionary.ToDictionary(kvp => kvp.Key);

... lub użyć operacji porównania na kluczu, a nie Wyszukiwania indeksu, np.:

foo.SomeDictionary.First(kvp => kvp.Key == "SomeKey");

Ogólnie rzecz biorąc, o wiele lepszym pomysłem jest, aby nie przekazywać żadnych słowników w pierwszej kolejności(jeśli nie musisz).

Zamiast tego-utwórz obiekt domeny z interfejsem, który nie oferuje żadnych metod modyfikujących słownik (który zawija). Zamiast tego oferuje wymagane LookUp-metodę, która pobiera element ze słownika po kluczu (bonus jest to sprawia, że łatwiejsze w użyciu niż słownik, jak również).

public interface IMyDomainObjectDictionary 
{
    IMyDomainObject GetMyDomainObject(string key);
}

internal class MyDomainObjectDictionary : IMyDomainObjectDictionary 
{
    public IDictionary<string, IMyDomainObject> _myDictionary { get; set; }
    public IMyDomainObject GetMyDomainObject(string key)         {.._myDictionary .TryGetValue..etc...};
}

Jest też inna alternatywa, którą opisałem na:

Http://www.softwarerockstar.com/2010/10/readonlydictionary-tkey-tvalue/

Zasadniczo jest to podklasa ReadOnlyCollection>, która wykonuje pracę w bardziej elegancki sposób. Elegancki w tym sensie, że ma wsparcie w czasie kompilacji do tworzenia słownika tylko do odczytu, a nie rzucanie wyjątków od metod, które modyfikują elementy w nim zawarte.