将具有不同结构的不同对象列表合并或压缩到单个列表中

Question

大家好，我有如下三个这样的课程

class A 
{
    public int number{get; set;}
    public string name{get; set;}
}
class B
{
   public string casted{get; set;}
}
class C
{
    public int Id{get; set;}
    public bool isSelect {get; set;}
}

我有这样的数据格式

var aObject = new A () { number = 11, name = "John" };
var aObject2= new A () { number = 22, name = "Steve" }; 

IList<A> ListA= new List<A>(){ aObject,aObject2 };

var bObject1 = new B () { casted = "test" };
var bObject2 = new B () { casted = "test1" };
var bObject3 = new B () { casted = "test2" };

IList<B> ListB = new List<B>(){ bObject1 , bObject2 ,bObject3 };

var cObject = new C() { Id = "1", isSelect = true };
var cObject2 = new C(){ Id = "2", isSelect = false };

IList<C> ListC = new List<C>() { cObject ,cObject2 };

所有的结构都不同，我将在上述类列表中获取数据，如List<A>, List<B> and List<C>

我希望在下面形成一种数据结构，将这三个列表合并为一个，如下所示

我正在寻找的结果列表如下所示。

结果：

Number    name    casted    Id    isSelect
 11       john    test      1     true
 22       Steve   test1     2     false
  -        -      test2     -       -

有什么方法可以实现这种结果对象，我知道如果你有相同的结构，我们可以连接列表，但这里我有不同的结构。

任何人都可以告诉我有关如何实现这一目标的任何想法，非常感谢我提前非常感谢

Answer 1

评论后添加：在我的代码的 while 部分中，我忘记了 MoveNext。修复。感谢enigma state 的关注。

所以你有三个不同项目的序列，并且你想要一个方法，它返回一个包含序列相同索引元素的序列。

这是一种很难说的方式，你想要这样的序列：

A[0] / B[0] / C[0]
A[1] / B[1] / C[1]
A[2] / null / C[2] 
etc.

因此，如果其中一个序列用完元素，您希望使用 NULL 作为值继续枚举

这个方法和Enumerable.Zip很相似，只是你有三个序列，如果其中一个序列太短，你要继续枚举。

每当您认为缺少 LINQ 方法时，请考虑为 IEnumerable 编写扩展方法。特别是如果您认为可以在其他情况下重复使用它

为 IEnumerable 创建扩展方法通常相当简单。见extension methods demystified

我将编写一个通用扩展方法，它具有三个输入序列和一个结果选择器来定义返回的输出序列。这个结果选择器类似于 Enumerable.Select 中的选择器参数。

public static IEnumerable<TResult> ZipWithNull<T1, T2, T2, TResult>(
    this IEnumerable<T1> source1,
    IEnumerable<T2> source2,
    IEnumerable<T3> source3,
    Func<T1, T2, T3, TResult> resultSelector)
{
    // get the enumerators and start enumerating until there are no more elements
    IEnumerator<T1> enumerator1 = source1.GetEnumerator();
    IEnumerator<T2> enumerator2 = source2.GetEnumerator();
    IEnumerator<T3> enumerator3 = source3.GetEnumerator();

    // check if there is at least one item available
    bool t1Available = enumerator1.MoveNext();
    bool t2Available = enumerator2.MoveNext();
    bool t3Available = enumerator3.MoveNext();
    bool anyAvailabe = t1Available || t2Available || t3Available;

    while (anyAvailable)
    {
        // if available use the Current, else use default (= null for classes)
        T1 t1 = t1Available ? enumerator1.Current ?? default(T1);
        T2 t2 = t2Available ? enumerator2.Current ?? default(T2);
        T3 t3 = t3Available ? enumerator3.Current ?? default(T3);

        TResult result = resultSelector(t1, t2, t3);
        yield return result;

        t1Available = enumerator1.MoveNext();
        t2Available = enumerator2.MoveNext();
        t3Available = enumerator3.MoveNext();
        anyAvailabe = t1Available || t2Available || t3Available;
    }
}

用法：

List<A> listA = ...
List<B> listA = ...
List<C> listA = ...

// you want a dash if the value is null
const string dash = "-";

var result = listA.ZipWithNull(listB, listC,

    // parameter ResultSelector: taks one a, b, c and create the output:
    (a, b, c) => new
    {
        Number = a?.Number.ToString() ?? dash,
        Name = a?.Name ?? dash,
        Casted = b?.Casted ?? dash,
        Id = c?.Id.ToString() ?? dash,
        IsSelect = c?.IsSelect.ToString() ?? dash,
    });

请注意，此结果选择器可以优化。例如，参数a 是否等于 null 会检查两次。稍加努力，您就可以确保 resultSelector 的每个输入只检查一次。对于这个例子，我选择了简单而不是效率。

好消息是您可以将ZipWithNull 用于任何您想用空值作为替代压缩的序列。因为我将 ZipWithNull 与任何其他 LINQ 方法一样创建，所以我可以将它与其他 LINQ 方法交织在一起：

var result = customers
    .Where(customer => customer.BirthDay.Year >= 2000)
    .ZipWithNull(
         addresses.Where(address => address.City == "Amsterdam"),
         orders.Where(order => order.Total > 1000,
         (customer, address, order) => new {...});
    .GroupBy(...)
    .OrderByDescending(...)
    // Etc();

Answer 2

目前还不是很清楚您要做什么，但我看到了 3 种方法可以实现这一点。

最简单的是，您可以创建一个List<object>，其中包含您的不同类别的数据。 然后，您将丢失有关每个对象是什么类的信息（您可以将这些对象存储在 List 中，如 Tuple 和 Type）。

List<object> joinedList = new List<object>();
joinedList.AddRange(ListA.Cast<object>());
joinedList.AddRange(ListB.Cast<object>());
joinedList.AddRange(ListC.Cast<object>());

另一种解决方案是让所有这些类共享一个基类或接口并构造该类型的List。

从List 读取时，您可以检查listItem is A 之类的类型

class z
{
}
class a : z
{
    public int number{get; set;}
    public string name{get; set;}
}
class B : z
{
   public string casted{get; set;}
}
class c : z
{
    public int Id{get; set;}
    public bool isSelect {get; set;}
}

List<z> joinedList = new List<z>();
joinedList.AddRange(ListA);
joinedList.AddRange(ListB);
joinedList.AddRange(ListC);

您还可以创建A、B 和C 的“联合”版本，这可能适合您的用例（因为看起来您可能正在根据数据创建表）。

class Aggregate
{
   A aData {get;set;}
   B bData {get;set;}
   C cData {get;set;}
}

List<Aggregate> aggregatedData = new List<Aggregate>();
// join your data together into aggregate and add to list

Answer 3

因此，您面临一些挑战，因为您提供的模型与您提供的列表不匹配（例如，类是 @987654326 上的 A 和 C 不是 a 和 c 和 Id @ 应该是 string 而不是 int)，但是在改变了所有这些之后我们可以这样做：

private static void AddAllValuesToDictionary<T>(List<Dictionary<string, object>> target, IList<T> source) {
        var properties = typeof(T).GetProperties();
        for (var i = 0; i < source.Count(); i++) 
        {
            if (target.Count() <= i) {
               target.Add(new Dictionary<string, object>()); 
            }

            foreach(var prop in properties) {
                target[i][prop.Name] = prop.GetValue(source[i]);
            }
        }
    }

然后

var result = new List<Dictionary<string, object>>();

AddAllValuesToDictionary(result, ListA);
AddAllValuesToDictionary(result, ListB);
AddAllValuesToDictionary(result, ListC);

如果你真的想要一个对象而不是字典，你可以选择ExpandoObject，但基本上你会得到与上述相反的体验。

在我的列表中，如果两个对象（例如“A”和“C”）具有重复的属性名称，则后者将覆盖前者。使用ExpandoObject，您设置的第一个值将是结果中出现的值。

更新这是Expando的示例

将using System.Dynamic; 添加到您的文件中。

然后

private static void AddAllValuesToListOfExpandos<T>(List<ExpandoObject> target, IList<T> source) {
        var properties = typeof(T).GetProperties();
        for (var i = 0; i < source.Count(); i++) 
        {
            if (target.Count() <= i) {
               target.Add(new ExpandoObject()); 
            }

            foreach(var prop in properties) {
                target[i].TryAdd(prop.Name, prop.GetValue(source[i]));
            }
        }
    }
}

        var result2 = new List<ExpandoObject>();
        AddAllValuesToListOfExpandos(result2, ListA);
        AddAllValuesToListOfExpandos(result2, ListB);
        AddAllValuesToListOfExpandos(result2, ListC);
// Since you're using ExpandoObject you can now use the properties
// the same way you do with dynamic
        Console.WriteLine(((dynamic)result2.First()).casted);
        Console.WriteLine(((dynamic)result2.First()).number);
        Console.WriteLine(((dynamic)result2.Last()).casted);
// note: Next line will fail with RuntimeBinderException
        Console.WriteLine(((dynamic)result2.Last()).number);