C＃ - 使用LINQ將帶有重復的分隔字符串數組轉換為字典

Question

特定

string[] array = new string[]
{
   "Sample1:foo",
   "Sample2:bar",
   "Sample1:foo1"
}

我知道我可以通過這種方式將其轉換為字典：

Dictionary<string, string> whatever = new Dictionary<string, string>
foreach (string s in array) do...
  string sampleNumber = s.Substring(0, indexOfColon);
  string fooOrBar= s.Substring(indexOfColon + 1);
  whatever[sampleNumber] = fooOrBar;

這將防止在添加重復鍵時拋出聚合異常（盡管覆蓋了密鑰，在這種情況下這很好）。 我可以用LINQ做到這一點嗎？ 我正在嘗試以下方面：

Dictionary<string, string> whatever = array.ToDictionary(
 key => key.Split(':')[0], value => value.Split(':')[1]);

有沒有辦法在不事先創建查找的情況下執行此操作？

Answer 1

嘗試這個：

Dictionary<string, string> whatever =
    array
        .Reverse()
        .GroupBy(key => key.Split(':')[0])
        .SelectMany(x => x.Take(1))
        .ToDictionary(key => key.Split(':')[0], value => value.Split(':')[1]);

它給：

或者你可以這樣做：

Dictionary<string, string> whatever =
    array
        .Aggregate(
            new Dictionary<string, string>(),
            (d, v) => { d[v.Split(':')[0]] = v.Split(':')[1]; return d; });

結果相同。

Answer 2

你想要的絕對不是Dictionary<string, string>因為鍵是重復的。 它可以是Dictionary<string, List<string>> ，但IMO更像是一個ILookup<string, string> ：

var result = array
            .Select(a =>
            {
                var parts = a.Split(':');
                return new
                {
                    Key = parts[0],
                    Value = parts[1]   //maybe you need to check something here
                };
            })
            .ToLookup(o => o.Key, o => o.Value);

Answer 3

我不確定你是如何處理價值的，也許你可以試試這個：

var list = array.Select(m => new { Key = m.Split(':')[0], Value = m.Split(':')[1] })
            .GroupBy(m => m.Key)
            .ToDictionary(m => m.Key, m => string.Join(",", m.Select(p => p.Value)));

Answer 4

我很難過沒有人關心表演。 浪費的分配，浪費的計算。 我在50％關鍵沖突的字符串上測試了此代碼的已接受答案：

char[] separatorArray = { ':' }; // do not create new array on every single item of the array
HashSet<string> dedupl = new HashSet<string>();

var res = array
    .Select(s => s.Split(separatorArray))
    .Where(x => dedupl.Add(x[0]))
    .ToDictionary(x => x[0], x => x[1]);

它大約快2.5倍，使用了一半的內存（我測量了最高內存使用率）。