C# dictionary - one key, many values

Question

I want to create a data store to allow me to store some data.

The first idea was to create a dictionary where you have one key with many values, so a bit like a one-to-many relationship.

I think the dictionary only has one key value.

How else could I store this information?

Answer 1

As of .NET 3.5+, instead of using a Dictionary<IKey, List<IValue>>, you can use a Lookup from the LINQ namespace:

// 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]; 

From MSDN:

A Lookup<TKey, TElement> resembles a Dictionary<TKey, TValue>. The difference is that a Dictionary<TKey, TValue> maps keys to single values, whereas a Lookup<TKey, TElement> maps keys to collections of values.

You can create an instance of a Lookup<TKey, TElement> by calling ToLookup on an object that implements IEnumerable.

You may also want to read this answer to a related question. For more information, consult MSDN.

Full example:

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

Remark on Immutability

By default, lookups are kind of immutable and accessing the internals would involve reflection. If you need mutability and don't want to write your own wrapper, you could use MultiValueDictionary (formerly known as MultiDictionary) from corefxlab (formerly part ofMicrosoft.Experimental.Collections which isn't updated anymore).

Answer 2

You can use a list for the second generic type. For example a dictionary of strings keyed by a string:

Dictionary<string, List<string>> myDict;