c# - 对象数组上的 Linq 外连接

Question

在伪代码中考虑一组 6 个 [StringKey,Value] 数组:

object[,2][6] KeyValueArrays; //illustr as array, could also be List<> or Dict<>

我想把它转换成一个表:

object[,7] KeyWithUpTo6Values  //outer join of the 6 orig key-value sets

如果给定键出现在(比如说)6 个原始 [Key, Value] 数组中的 3 个中，则该键的连接行将包含 3 个值和 3 个空值。

问题:我可以使用 LINQ 仅使用简单的容器(如数组、通用列表和字典)来完成此操作吗？

Answer 1

我想我可能遗漏了一些东西，但事实上你的问题提到了通用列表和字典，我认为当你说数组时，你指的是矢量数据结构之王。

因此，可以使用 Dictionary<T1,T2> 存储键值对.例如，假设您的 key 是 string和一个值类 MyValueClass具有整数类型的单个属性。您的数据声明如下所示:

class Program
{
    class MyValueClass
    {
        public int Value {get;set;}
    }

    // Other elements elided for clarity

    private Dictionary<string, MyValueClass> data = new Dictionary<string, MyValueClass>();

}

现在，您声明您有 N 个这样的结构，您希望对其进行外部连接。例如，

private Dictionary<string, MyValueClass>[] data = new Dictionary<string, MyValueClass>[6]();

这里的问题是连接结构的类型中“列”的数量取决于这个N，但是除非你使用某种其他类型的数据结构(即List)来表示您的行，您将无法动态执行此操作，即对于任何 N，因为 C# 中的数据是静态声明的。

为了说明，请检查下面的查询，其中我假设数组的维度为 4:

var query = from d0 in _data[0]
            join d1 in _data[1] on d0.Key equals d1.Key into d1joined
            from d1 in d1joined.DefaultIfEmpty()
            join d2 in _data[2] on d1.Key equals d2.Key into d2joined
            from d2 in d2joined.DefaultIfEmpty()
            join d3 in _data[3] on d2.Key equals d3.Key into d3joined
            from d3 in d3joined.DefaultIfEmpty()
            select new
                     {
                         d0.Key,
                         D0 = d0.Value,
                         D1 = d1.Value,
                         D2 = d2.Value,
                         D3 = d3.Value,
                      };

不要关注联接，稍后我会解释，但请检查 select new运算符(operator)。请注意，当 Linq 组装此匿名类型时，它必须知道属性(我们的列)的确切数量，因为它是语法的一部分。

因此，如果您愿意，您可以编写一个查询来执行您的要求，但它仅适用于已知的 N 值。如果这恰好是一个足够的解决方案，它实际上很简单，尽管示例 I写的可能有点过于复杂。回到上面的查询，您会看到 from/join/from DefaultIfEmpty 的重复模式。此模式复制自 here ，它的工作原理实际上很简单:它通过某个键将两个结构连接到另一个结果结构(上面的 into dnjoined)。 Linq 将处理左侧列表中的所有记录，对于其中的每一个，它将处理右侧列表中的每个记录(N1 x N2 的笛卡尔平面)，如下所示:

foreach (var d0 in _data[0])
{
    foreach (var d1 in _data[1])
    {
        if (d0.Key == d1.Key) 
        {
            // Produces an anonymous structure of { d0.Key, d0.Value, d1.Value }
            // and returns it.
        }
    }
}

因此，内部联接 操作与组合每一行然后选择键匹配的行相同。 outer join 的不同之处在于即使键不匹配也会生成一行，因此在我们的伪代码中，它类似于:

foreach (var d0 in _data[0])
{
    foreach (var d1 in _data[1])
    {
        if (d0.Key == d1.Key) 
        {
            // Produces an anonymous structure of { d0.Key, d0.Value, d1.Value }
            // and returns it.
        }
        else
        {
            // Produce a anonymous structure of {d0.Key, d0.Value, null}
        }     
    }
}

else block 是在之前的 LINQ 代码中通过添加第二个 where 实现的子句，即使没有匹配项也会请求行，这是一个空列表，可以在调用 DefaultIfEmpty 时返回数据。 (同样，请参阅上面的链接以获取更多信息)

我将在下面复制一个完整的示例，该示例使用我上面提到的数据结构和 linq 查询。希望它是不言自明的:

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

namespace TestZone
{
    class Example
    {
        #region Types
        class MyValue
        {
            public int Value { get; set; }

            public override string ToString()
            {
                return string.Format("MyValue(Value = {0})", Value);
            }
        }
        #endregion // Types

        #region Constants
        /// <summary>
        /// Our N
        /// </summary>
        private const int NumberOfArrays = 4;

        /// <summary>
        /// How many rows per dictionary
        /// </summary>
        private const int NumberOfRows = 10; 
        #endregion // Constants

        #region Fields
        private Dictionary<string, MyValue>[] _data = new Dictionary<string, MyValue>[NumberOfArrays]; 
        #endregion // Fields

        #region Constructor
        public Example()
        {
            for (var index = 0; index < _data.Length; index++)
            {
                _data[index] = new Dictionary<string, MyValue>(NumberOfRows);
            }
        } 
        #endregion // Constructor

        public void GenerateRandomData()
        {
            var rand = new Random(DateTime.Now.Millisecond);

            foreach (var dict in _data)
            {
                // Add a number of rows
                for (var i = 0; i < NumberOfRows; i++)
                {
                    var integer = rand.Next(10);    // We use a value of 10 so we have many collisions.
                    dict["ValueOf" + integer] = new MyValue { Value = integer };
                }
            }
        }

        public void OuterJoin()
        {
            // To get the outer join, we have to know the expected N before hand, as this example will show.
            // Do multiple joins
            var query = from d0 in _data[0]
                        join d1 in _data[1] on d0.Key equals d1.Key into d1joined
                        from d1 in d1joined.DefaultIfEmpty()
                        join d2 in _data[2] on d1.Key equals d2.Key into d2joined
                        from d2 in d2joined.DefaultIfEmpty()
                        join d3 in _data[3] on d2.Key equals d3.Key into d3joined
                        from d3 in d3joined.DefaultIfEmpty()
                        select new
                                   {
                                       d0.Key,
                                       D0 = d0.Value,
                                       D1 = d1.Value,
                                       D2 = d2.Value,
                                       D3 = d3.Value,
                                   };

            foreach (var q in query)
            {
                Console.WriteLine(q);
            }
        }
    }

    class Program
    {

        public static void Main()
        {
            var m = new Example();
            m.GenerateRandomData();
            m.OuterJoin();

        }
    }
}