У словаря .NET есть только отношение 1 к 1 для ключей и значений. Но это не означает, что значение не может быть другим массивом / списком / словарем.

Я не могу придумать причины, чтобы иметь отношение 1 к многим в словаре, но, очевидно, существует один.

Если у вас есть разные типы данных, которые вы хотите сохранить для ключа, это звучит как идеальное время для создания собственного класса. Тогда у вас есть от 1 до 1, но у вас есть класс значений, хранящий больше, чем 1 часть данных.

Взгляните на MultiValueDictionary из Microsoft.

Пример кода:

MultiValueDictionary<string, string> Parameters = new MultiValueDictionary<string, string>();

Parameters.Add("Malik", "Ali");
Parameters.Add("Malik", "Hamza");
Parameters.Add("Malik", "Danish");

//Parameters["Malik"] now contains the values Ali, Hamza, and Danish

Используйте словарь списков (или другой тип коллекции), например:

var myDictionary = new Dictionary<string, IList<int>>();

myDictionary["My key"] = new List<int> {1, 2, 3, 4, 5};

В качестве значения вы можете иметь словарь с коллекцией (или любым другим типом / классом). Таким образом, у вас есть один ключ, и вы сохраняете значения в своей коллекции.

Начиная с .net3.5 + вместо использования Dictionary<IKey, List<IValue>> вы можете использовать Lookup из пространства имен Linq:

// lookup Order by payment status (1:m) 
// would need something like Dictionary<Boolean, IEnumerable<Order>> orderIdByIsPayed
ILookup<Boolean, Order> byPayment = orderList.ToLookup(o => o.IsPayed);
IEnumerable<Order> payedOrders = byPayment[false];

Из msdn :

Поиск похож на словарь. Разница заключается в том, что словарь сопоставляет ключи с одиночными значениями, тогда как Lookup сопоставляет ключи с коллекциями значений.

Вы можете создать экземпляр Lookup, вызвав ToLookup для объекта, который реализует IEnumerable.

Вы также можете прочитать этот ответ на вопрос, связанный с . Для получения дополнительной информации см. msdn .

Полный пример:

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

namespace LinqLookupSpike
{
    class Program
    {
        static void Main(String[] args)
        {
            // init 
            var orderList = new List<Order>();
            orderList.Add(new Order(1, 1, 2010, true));//(orderId, customerId, year, isPayed)
            orderList.Add(new Order(2, 2, 2010, true));
            orderList.Add(new Order(3, 1, 2010, true));
            orderList.Add(new Order(4, 2, 2011, true));
            orderList.Add(new Order(5, 2, 2011, false));
            orderList.Add(new Order(6, 1, 2011, true));
            orderList.Add(new Order(7, 3, 2012, false));

            // lookup Order by its id (1:1, so usual dictionary is ok)
            Dictionary<Int32, Order> orders = orderList.ToDictionary(o => o.OrderId, o => o);

            // lookup Order by customer (1:n) 
            // would need something like Dictionary<Int32, IEnumerable<Order>> orderIdByCustomer
            ILookup<Int32, Order> byCustomerId = orderList.ToLookup(o => o.CustomerId);
            foreach (var customerOrders in byCustomerId)
            {
                Console.WriteLine("Customer {0} ordered:", customerOrders.Key);
                foreach (var order in customerOrders)
                {
                    Console.WriteLine("    Order {0} is payed: {1}", order.OrderId, order.IsPayed);
                }
            }

            // the same using old fashioned Dictionary
            Dictionary<Int32, List<Order>> orderIdByCustomer;
            orderIdByCustomer = byCustomerId.ToDictionary(g => g.Key, g => g.ToList());
            foreach (var customerOrders in orderIdByCustomer)
            {
                Console.WriteLine("Customer {0} ordered:", customerOrders.Key);
                foreach (var order in customerOrders.Value)
                {
                    Console.WriteLine("    Order {0} is payed: {1}", order.OrderId, order.IsPayed);
                }
            }

            // lookup Order by payment status (1:m) 
            // would need something like Dictionary<Boolean, IEnumerable<Order>> orderIdByIsPayed
            ILookup<Boolean, Order> byPayment = orderList.ToLookup(o => o.IsPayed);
            IEnumerable<Order> payedOrders = byPayment[false];
            foreach (var payedOrder in payedOrders)
            {
                Console.WriteLine("Order {0} from Customer {1} is not payed.", payedOrder.OrderId, payedOrder.CustomerId);
            }
        }

        class Order
        {
            // key properties
            public Int32 OrderId { get; private set; }
            public Int32 CustomerId { get; private set; }
            public Int32 Year { get; private set; }
            public Boolean IsPayed { get; private set; }

            // additional properties
            // private List<OrderItem> _items;

            public Order(Int32 orderId, Int32 customerId, Int32 year, Boolean isPayed)
            {
                OrderId = orderId;
                CustomerId = customerId;
                Year = year;
                IsPayed = isPayed;
            }
        }
    }
}

Замечание о неизменности

По умолчанию Lookups являются добрыми непреложного и доступ к internal s будет включать отражение. Если вам нужна изменчивость и вы не хотите писать свою собственную оболочку, вы можете использовать MultiValueDictionary (ранее известный как MultiDictionary ) из corefxlab (ранее часть Microsoft.Experimental.Collections , которая больше не обновляется).

Вы можете создать очень упрощенный многозадачный словарь, который автоматизирует процесс вставки таких значений:

public class MultiDictionary<TKey, TValue> : Dictionary<TKey, List<TValue>>
{
    public void Add(TKey key, TValue value)
    {
        if (TryGetValue(key, out List<TValue> valueList)) {
            valueList.Add(value);
        } else {
            Add(key, new List<TValue> { value });
        }
    }
}

Это создает перегруженную версию метода Add. Исходный позволяет вам вставить список элементов для ключа, если для этой записи еще нет записи. Эта версия позволяет вставить один элемент в любом случае.

Вот мой подход к достижению такого поведения.

Для более полного решения, включающего ILookup<TKey, TElement>, проверьте мой другой ответ .

public abstract class Lookup<TKey, TElement> : KeyedCollection<TKey, ICollection<TElement>>
{
  protected override TKey GetKeyForItem(ICollection<TElement> item) =>
    item
    .Select(b => GetKeyForItem(b))
    .Distinct()
    .SingleOrDefault();

  protected abstract TKey GetKeyForItem(TElement item);

  public void Add(TElement item)
  {
    var key = GetKeyForItem(item);
    if (Dictionary != null && Dictionary.TryGetValue(key, out var collection))
      collection.Add(item);
    else
      Add(new List<TElement> { item });
  }

  public void Remove(TElement item)
  {
    var key = GetKeyForItem(item);
    if (Dictionary != null && Dictionary.TryGetValue(key, out var collection))
    {
      collection.Remove(item);
      if (collection.Count == 0)
        Remove(key);
    }
  }
}

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

public class Item
{
  public string Key { get; }
  public string Value { get; set; }
  public Item(string key, string value = null) { Key = key; Value = value; }
}

public class Lookup : Lookup<string, Item>
{
  protected override string GetKeyForItem(Item item) => item.Key;
}

static void Main(string[] args)
{
  var toRem = new Item("1", "different");
  var single = new Item("2", "single");
  var lookup = new Lookup()
  {
    new Item("1", "hello"),
    new Item("1", "hello2"),
    new Item(""),
    new Item("", "helloo"),
    toRem,
    single
  };

  lookup.Remove(toRem);
  lookup.Remove(single);
}

Примечание: ключ должен быть неизменным (или удалять и повторно добавлять при смене ключа).

Вы также можете использовать:

 List<KeyValuePair<string, string>> Mappings;

Тип значения вашего словаря может быть списком или другим классом, который содержит несколько объектов. Что-то вроде

Dictionary<int, List<string>> 

для словаря, который вводится с помощью int и содержит список строк.

Основное внимание при выборе типа значения - это то, что вы будете использовать Словарь для, если вам придется выполнять поиск или другие операции над значениями, тогда, возможно, подумайте об использовании структуры данных, которая поможет вам делать то, что вы хотите - как HashSet.