Есть ли у C # способ дать мне неизменный словарь?
-
09-06-2019 - |
Вопрос
Есть ли что-нибудь встроенное в основные библиотеки C #, которое может дать мне неизменный словарь?
Что-то вроде Java's :
Collections.unmodifiableMap(myMap);
И чтобы уточнить, я не собираюсь останавливать изменение самих ключей / значений, а просто структуру словаря. Я хочу что-то, что не работает быстро и громко, если вызывается любой из методов мутатора IDictionary ( Add, Remove, Clear
).
Решение
Нет, но обертка довольно тривиальна:
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 [], если хотите разрешить изменение значений. Р>
Другие советы
Насколько я знаю, нет. Но, может быть, вы можете скопировать некоторый код (и многому научиться) из этих статей:
Неизменяемость в C #, часть первая: виды неизменяемости
Неизменяемость в C # Часть вторая: простой неизменный стек
Неизменяемость в C # Часть третья: ковариантный неизменяемый стек
неизменяемость в C # Часть четвертая: неизменная очередь
Неизменяемость в C # Часть шестая: простое двоичное дерево
Неизменность в C # Часть седьмая: подробнее о двоичных деревьях
Неизменность в C # Часть восьмая: еще больше о двоичных деревьях
Неизменяемость в C # Часть девятая: Академическая? Плюс моя реализация дерева AVL
Неизменяемость в C # Часть 10. Двусторонняя очередь
Неизменность в C #, часть одиннадцатая: рабочая двусторонняя очередь
В выпуске .NET 4.5 появился новый ReadOnlyDictionary а> класс. Вы просто передаете IDictionary
в конструктор, чтобы создать неизменный словарь.
Здесь - это полезный метод расширения, который можно использовать для упрощения создания словаря только для чтения.
Я так не думаю. Есть способ создать список только для чтения и коллекцию только для чтения, но я не думаю, что есть встроенный словарь только для чтения. System.ServiceModel имеет реализацию ReadOnlyDictinoary, но внутреннюю. Вероятно, не будет слишком сложно скопировать его, используя Reflector, или просто создать свой собственный с нуля. Он в основном оборачивает словарь и выбрасывает, когда вызывается мутатор.
Добавление в dbkk's ответ , я хотел иметь возможность использовать инициализатор объекта при первом создании моего 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"}
};
библиотека PowerCollections с открытым исходным кодом содержит оболочку словаря только для чтения (а также оболочки только для чтения) почти для всего остального), доступный через статический метод ReadOnly ()
класса Algorithms
. Р>
Один из обходных путей: добавьте новый список 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;
Таким образом, исходный словарь не будет изменен.
" Из коробки " нет способа сделать это. Вы можете создать его, создав собственный класс Dictionary и реализовав необходимые ограничения.
Здесь я нашел реализацию Inmutable (не READONLY) реализации AVLTree для C #. Р>
Дерево AVL имеет логарифмическую (не постоянную) стоимость для каждой операции, но все еще быстро.
http://csharpfeeds.com/post/7512/i__play_x_Player_Player_Ip_Im_MB р>
Начиная с Linq, существует универсальный интерфейс ILookup . Подробнее читайте в MSDN .
Поэтому, чтобы просто получить неизменный словарь, вы можете позвонить:
using System.Linq;
// (...)
var dictionary = new Dictionary<string, object>();
// (...)
var read_only = dictionary.ToLookup(kv => kv.Key, kv => kv.Value);
Вы можете попробовать что-то вроде этого:
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");
В целом, гораздо лучше не передавать словари в первую очередь (если вы этого НЕ ДОЛЖНЫ).
Вместо этого - создайте объект домена с интерфейсом, который не предлагает никаких методов модификации словаря (который он переносит). Вместо этого предлагается обязательный 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...};
}
Есть также другая альтернатива, как я описал на:
http://www.softwarerockstar.com/2010/10/readonlydictionary -tkey-TValue / р>
По сути, это подкласс ReadOnlyCollection > ;, который выполняет работу более элегантным образом. Элегантный в том смысле, что он имеет поддержку во время компиляции для того, чтобы сделать Словарь доступным только для чтения, а не выбрасывать исключения из методов, которые изменяют элементы в нем.