使用Linq查詢替換for-switch循環

Question

我有一個消息對象，它封裝了我無法控制的消息格式。格式是鍵/值對的簡單列表。我想從給定的消息中提取用戶列表。例如，給出以下消息...

1. 200->.... 
2. 300->.... 
3. .... 
4. 405->.... 
5. 001->first_user_name 
6. 002->first_user_phone 
7. 003->first_user_fax 
8. 001->second_user_name 
9. 001->third_user_name 
10. 002->third_user_phone 
11. 003->third_user_fax 
12. 004->third_user_address 
13. ..... 
14. 001->last_user_name 
15. 003->last_user_fax 

我想提取四個用戶提供的屬性集。初始密鑰200/300 .... 405表示我不需要的字段，可以跳過以獲取用戶數據。

每個用戶的數據都在連續的字段中，但字段的數量取決於有多少用戶知道的信息。以下方法做我正在尋找的東西。它使用枚舉可能的鍵類型和方法來查找包含用戶數據的第一個字段的索引。

private List<User> ParseUsers(Message message) 
{ 
    List<User> users = new List<User>(); 
    User user = null; String val = String.Empty; 

    for(Int32 i = message.IndexOfFirst(Keys.Name); i < message.Count; i++) 
    { 
     val = message[ i ].Val; 

     switch(message[ i ].Key) 
     { 
      case Keys.Name: 
       user = new User(val); 
       users.Add(user); 
       break; 
      case Keys.Phone: 
       user.Phone = val; 
       break; 
      case Keys.Fax: 
       user.Fax = val; 
       break; 
      case Keys.Address: 
       user.Address = val; 
       break; 
      default: 
       break; 
     } 
    } 

    return users; 
} 

我想知道是否有可能用Linq查詢替換方法。我無法告訴Linq選擇一個新用戶並填充其所有匹配數據的字段，直到找到下一個用戶條目的開始。

注意：相對密鑰號碼是真實消息格式的隨機數（不是1,2,3,4）。

Answer 1

我沒有看到改變你的代碼LINQ查詢的利益，但它絕對有可能：

private List<User> ParseUsers(Message message) 
{ 
    return Enumerable 
     .Range(0, message.Count) 
     .Select(i => message[i]) 
     .SkipWhile(x => x.Key != Keys.Name) 
     .GroupAdjacent((g, x) => x.Key != Keys.Name) 
     .Select(g => g.ToDictionary(x => x.Key, x => x.Val)) 
     .Select(d => new User(d[Keys.Name]) 
     { 
      Phone = d.ContainsKey(Keys.Phone) ? d[Keys.Phone] : null, 
      Fax  = d.ContainsKey(Keys.Fax)  ? d[Keys.Fax]  : null, 
      Address = d.ContainsKey(Keys.Address) ? d[Keys.Address] : null, 
     }) 
     .ToList(); 
} 

使用

static IEnumerable<IEnumerable<T>> GroupAdjacent<T>(
    this IEnumerable<T> source, Func<IEnumerable<T>, T, bool> adjacent) 
{ 
    var g = new List<T>(); 
    foreach (var x in source) 
    { 
     if (g.Count != 0 && !adjacent(g, x)) 
     { 
      yield return g; 
      g = new List<T>(); 
     } 
     g.Add(x); 
    } 
    yield return g; 
} 

Answer 2

如何將郵件拆分爲List<List<KeyValuePait<int, string>>>，其中每個List<KeyValuePair<int, string>>代表單個用戶。然後，你可以這樣做：

// SplitToUserLists would need a sensible implementation. 
List<List<KeyValuePair<int,string>>> splitMessage = message.SplitToUserLists(); 
IEnumerable<User> users = splitMessage.Select(ConstructUser); 

隨着

private User ConstructUser(List<KeyValuePair<int, string>> userList) 
{ 
    return userList.Aggregate(new User(), (user, keyValuePair) => user[keyValuePair.Key] = keyValuePair.Val); 
} 

Answer 3

否，其原因是，在一般情況下，大多數LINQ功能，以同樣的方式作爲SQL查詢，處理無序數據，即他們不會對傳入數據的順序做出假設。這使得他們可以靈活地進行並行化處理等。您的數據具有固有的順序，因此不符合查詢模型。

Answer 4

我不認爲有任何性能優勢，但在我看來，它提高了可讀性。

一個可能的解決辦法是這樣的：

var data = File.ReadAllLines("data.txt") 
      .Select(line => line.Split(new[] {"->"}, StringSplitOptions.RemoveEmptyEntries)) 
      .GroupByOrder(ele => ele[0]); 

真正神奇正在發生的事情背後GroupByOrder，這是一個擴展方法。

public static IEnumerable<IEnumerable<T>> GroupByOrder<T, K>(this IEnumerable<T> source, Func<T, K> keySelector) where K : IComparable { 
    var prevKey = keySelector(source.First()); 
    var captured = new List<T>(); 
    foreach (var curr in source) { 
    if (keySelector(curr).CompareTo(prevKey) <= 0) { 
     yield return captured; 
     captured = new List<T>(); 
    } 
    captured.Add(curr); 
    } 
    yield return captured; 
} 

（免責聲明：從托馬斯Petricek被盜想法）

你的樣本數據得出以下組，現在只需要被解析成你的用戶對象。

User: 
    first_user_name 
    first_user_phone 
    first_user_fax 
User: 
    second_user_name 
User: 
    third_user_name 
    third_user_phone 
    third_user_fax 
    third_user_address 
User: 
    last_user_name 
    last_user_fax