Есть ли у C# способ предоставить мне неизменяемый словарь?

Я так не думаю. Есть способ создать список только для чтения и коллекцию только для чтения, но я не думаю, что есть встроенный словарь только для чтения. System.ServiceModel имеет реализацию ReadOnlyDictinoary, но она внутренняя. Вероятно, было бы не так уж сложно скопировать его, используя Reflector, или просто создать свой собственный с нуля. Он в основном обертывает словарь и выдает его при вызове мутатора.

Насколько я знаю, нет. Но, возможно, вы сможете скопировать код (и многому научиться) из этих статей:

• Неизменяемость в C#, часть первая: виды неизменяемости
• Неизменяемость в C#, часть вторая: простой неизменяемый стек
• Неизменяемость в C#, часть третья: ковариантный неизменяемый стек
• Неизменяемость в C#, часть четвертая: неизменяемая очередь
• Неизменяемость в C#, часть пятая: LOLZ
• Неизменяемость в C#, часть шестая: простое двоичное дерево
• Неизменяемость в C#, часть седьмая: Подробнее о двоичных деревьях
• Неизменяемость в C#, часть восьмая: еще больше о двоичных деревьях
• Неизменяемость в C#, часть девятая: академическая? Плюс моя реализация дерева AVL
• Неизменяемость в C#, часть 10: двусторонняя очередь
• Неизменяемость в C#, часть одиннадцатая: рабочая двусторонняя очередь

«Из коробки» нет способа сделать это. Вы можете создать его, создав собственный класс Dictionary и реализовав необходимые ограничения.

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

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;

Таким образом, исходный словарь не будет изменен.

Нет, но обертка довольно тривиальна:

public class ReadOnlyDictionary<TKey, TValue> : IDictionary<TKey, TValue>
{
    IDictionary<TKey, TValue> _dict;

    public ReadOnlyDictionary(IDictionary<TKey, TValue> backingDict)
    {
        _dict = backingDict;
    }

    public void Add(TKey key, TValue value)
    {
        throw new InvalidOperationException();
    }

    public bool ContainsKey(TKey key)
    {
        return _dict.ContainsKey(key);
    }

    public ICollection<TKey> Keys
    {
        get { return _dict.Keys; }
    }

    public bool Remove(TKey key)
    {
        throw new InvalidOperationException();
    }

    public bool TryGetValue(TKey key, out TValue value)
    {
        return _dict.TryGetValue(key, out value);
    }

    public ICollection<TValue> Values
    {
        get { return _dict.Values; }
    }

    public TValue this[TKey key]
    {
        get { return _dict[key]; }
        set { throw new InvalidOperationException(); }
    }

    public void Add(KeyValuePair<TKey, TValue> item)
    {
        throw new InvalidOperationException();
    }

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

    public bool Contains(KeyValuePair<TKey, TValue> item)
    {
        return _dict.Contains(item);
    }

    public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
    {
        _dict.CopyTo(array, arrayIndex);
    }

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

    public bool IsReadOnly
    {
        get { return true; }
    }

    public bool Remove(KeyValuePair<TKey, TValue> item)
    {
        throw new InvalidOperationException();
    }

    public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
    {
        return _dict.GetEnumerator();
    }

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

Очевидно, вы можете изменить установщик this [] выше, если хотите разрешить изменение значений.

Я нашел здесь реализацию Неизменяемой (НЕ ЧИТАТЬ) реализации AVLTree для C#.

Дерево AVL имеет логарифмическую (не постоянную) стоимость каждой операции, но все равно быстро.

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

Добавляя ответ dbkk, я хотел иметь возможность использовать инициализатор объекта при первом создании моего ReadOnlyDictionary. Внес следующие изменения:

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"
        );
    }
}

Теперь я могу использовать класс так:

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

Начиная с Linq существует общий интерфейс ILookup. Подробнее читайте в MSDN.

Следовательно, чтобы просто получить неизменяемый словарь, вы можете вызвать:

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

Есть еще одна альтернатива, как я описал по адресу:

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

По сути, это подкласс ReadOnlyCollection>, который выполняет работу более элегантно. Элегантный в том смысле, что он поддерживает во время компиляции, что делает словарь доступным только для чтения, а не выбрасывает исключения из методов, которые изменяют элементы в нем.

Библиотека PowerCollections с открытым исходным кодом включает оболочку словаря только для чтения (а также оболочки только для чтения для почти всего остального), доступную через статический метод ReadOnly() в классе Algorithms.

Вы можете попробовать что-то вроде этого:

private readonly Dictionary<string, string> _someDictionary;

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

Это устранило бы проблему изменчивости в пользу того, что вызывающий абонент должен либо преобразовать ее в свой собственный словарь:

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

... или используйте операцию сравнения по ключу, а не поиск по индексу, например:

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

С выпуском .NET 4.5 появился новый класс ReadOnlyDictionary. Вы просто передаете IDictionary конструктору, чтобы создать неизменяемый словарь.

Здесь - полезный метод расширения, который можно использовать для упрощения создания словаря только для чтения.

В общем, гораздо лучше вообще не передавать какие-либо словари (если вам это не нужно).

Вместо этого - создайте объект домена с интерфейсом, который не предлагает никаких методов изменение словаря (который он обертывает). Вместо этого предлагается обязательный LookUp-метод, который извлекает элемент из словаря по ключу (бонус в том, что он также упрощает использование, чем словарь).

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...};
}

Я знаю, что это очень старый вопрос, но я каким-то образом нашел его в 2020 году, поэтому, думаю, стоит отметить, что сейчас есть способ создать неизменяемый словарь:

https://docs.microsoft.com/en-us/dotnet/api/system.collections.immutable.immutabledictionary.toimmutabledictionary?view=netcore-3.1

Использование:

using System.Collections.Immutable;

public MyClass {
    private Dictionary<KeyType, ValueType> myDictionary;

    public ImmutableDictionary<KeyType, ValueType> GetImmutable()
    {
        return myDictionary.ToImmutableDictionary();
    }
}