如何從IEnumerable巧妙地創建一個匿名類型<T>？

Question

我想用LINQ解決以下問題，我有以下集合：

List<byte> byteList = new List<byte() { 0x01, 0x00, 0x01, 0x02, 0x01, 0x00, 0x3, 0x4, 0x02 }; 

的數據在這個例子中遵循以下圖案：

byteList [0] =地址（1， 2，3，... N）

byteList [1] =舊狀態，這基本上是代表一個枚舉

byteList [2] =新的狀態的，與上述相同的

我與嵌入式設備連接，這是我可以查看輸入更改的方式。

爲了清理代碼並使維護程序員更容易遵循我的邏輯，我想抽象出一些涉及到的細節和螺栓，並將每個三字節數據集提取爲匿名類型在函數內部使用來執行一些額外的處理。我寫了一個快速實現，但我相信它可以大大簡化。我試圖清理代碼，而不是渾水！必須有做一個簡單的方法如下：

List<byte> byteList = new List<byte>() 
{ 
    0x01, 0x09, 0x01, 0x02, 0x08, 0x02, 0x03, 0x07, 0x03 
}; 
var addresses = byteList 
    .Where((b, i) => i % 3 == 0) 
    .ToList(); 
var oldValues = byteList 
    .Where((b, i) => i % 3 == 1) 
    .ToList(); 
var newValues = byteList 
    .Where((b, i) => i % 3 == 2) 
    .ToList(); 

var completeObjects = addresses 
    .Select((address, index) => new 
    { 
     Address = address, 
     OldValue = oldValues[index], 
     NewValue = newValues[index] 
    }) 
    .ToList(); 
foreach (var anonType in completeObjects) 
{ 
    Console.WriteLine("Address: {0}\nOld Value: {1}\nNew Value: {2}\n", 
     anonType.Address, anonType.OldValue, anonType.NewValue); 
} 

Answer 1

您可以使用Enumerable.Range和一些數學：

List<byte> byteList = new List<byte>() 
{ 
    0x01, 0x09, 0x01, 0x02, 0x08, 0x02, 0x03, 0x07, 0x03 
}; 
var completeObjects = Enumerable.Range(0, byteList.Count/3).Select(index => 
    new 
    { 
     Address = byteList[index * 3], 
     OldValue = byteList[index * 3 + 1], 
     NewValue = byteList[index * 3 + 2], 
    }); 

如果字節數是不是3的倍數，額外的一個或兩個字節將被忽略。

Answer 2

爲了簡化起見，我想創建一個記錄類型和使用for循環：

class RecordType 
{ 
    //constructor to set the properties omitted 
    public byte Address { get; private set; } 
    public byte OldValue { get; private set; } 
    public byte NewValue { get; private set; } 
} 

IEnumerable<RecordType> Transform(List<byte> bytes) 
{ 
    //validation that bytes.Count is divisible by 3 omitted 

    for (int index = 0; index < bytes.Count; index += 3) 
     yield return new RecordType(bytes[index], bytes[index + 1], bytes[index + 2]); 
} 

另外，如果你肯定需要一個匿名類型，你可以做，沒有LINQ：

for (int index = 0; index < bytes.Count; index += 3) 
{ 
    var anon = new { Address = bytes[index], OldValue = bytes[index + 1], NewValue = bytes[index + 3] }; 
    //... do something with anon 
} 

的LINQ是非常有用的，但它是在這個任務尷尬，因爲序列項具有取決於其locati有不同的含義在序列中。

Answer 3

我不確定這是否是一個聰明的解決方案，但我使用該示例嘗試在不創建單獨列表的情況下完成此操作。

var completeObjects = byteList 
    // This is required to access the index, and use integer 
    // division (to ignore any reminders) to group them into 
    // sets by three bytes in each. 
    .Select((value, idx) => new { group = idx/3, value }) 
    .GroupBy(x => x.group, x => x.value) 

    // This is just to be able to access them using indices. 
    .Select(x => x.ToArray()) 

    // This is a superfluous comment. 
    .Select(x => new { 
     Address = x[0], 
     OldValue = x[1], 
     NewValue = x[2] 
    }) 

    .ToList(); 

Answer 4

如果你必須使用LINQ（不知道這是一個很好的計劃），那麼一個選項是：

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

static class LinqExtensions 
{ 
    public static IEnumerable<T> EveryNth<T>(this IEnumerable<T> e, int start, int n) 
    { 
     int index = 0; 
     foreach(T t in e) 
     { 
      if((index - start) % n == 0) 
      { 
       yield return t; 
      } 
      ++index; 
     } 
    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     List<byte> byteList = new List<byte>() 
     { 
      0x01, 0x09, 0x01, 0x02, 0x08, 0x02, 0x03, 0x07, 0x03 
     }; 

     var completeObjects = 
      byteList.EveryNth(0, 3).Zip 
      (
       byteList.EveryNth(1, 3).Zip 
       (
        byteList.EveryNth(2, 3), 
        Tuple.Create 
       ), 
       (f,t) => new { Address = f, OldValue = t.Item1, NewValue = t.Item2 } 
      ); 

     foreach (var anonType in completeObjects) 
     { 
      Console.WriteLine("Address: {0}\nOld Value: {1}\nNew Value: {2}\n", anonType.Address, anonType.OldValue, anonType.NewValue); 
     } 
    } 
} 

Answer 5

這個怎麼樣？

var addresses = 
    from i in Enumerable.Range(0, byteList.Count/3) 
    let startIndex = i * 3 
    select new 
    { 
     Address = byteList[startIndex], 
     OldValue = byteList[startIndex + 1], 
     NewValue = byteList[startIndex + 2] 
    }; 

注：我公司開發的獨立邁克爾·劉的回答這一點，而他幾乎是一樣我要去，因爲它看起來更漂亮些我離開這裏這個答案。 :-)

Answer 6

這裏試圖用擴展方法ChunkToList來做到這一點，它將IEnumerable<T>分成IList<T>的塊。

用法：

 var compObjs = byteList.ChunkToList(3) 
           .Select(arr => new { 
             Address = arr[0], 
             OldValue = arr[1], 
             NewValue = arr[2] 
           }); 

實現：

static class LinqExtensions 
{ 
    public static IEnumerable<IList<T>> ChunkToList<T>(this IEnumerable<T> list, int size) 
    { 
     Debug.Assert(list.Count() % size == 0); 

     int index = 0; 
     while (index < list.Count()) 
     { 
      yield return list.Skip(index).Take(size).ToList(); 
      index += size; 
     } 
    } 
}