C# 将多个集合作为单个集合公开

我在WPF中的数据绑定模型中遇到了一个问题。我有一个对象，它有一个对象集合（变量），每个对象又有一个对象集合（变量代码）

我需要能够做的是以某种方式公开来自最高级别对象的单个集合-这是最低级别集合（VariableCode）的融合，其中每个成员对象都满足一个条件。这样我就可以将该集合绑定到一个列表框，该列表框应该显示属于一个或多个变量的变量代码

因此，代码如下所示：

public class CrossTab
{
  public VariableList Variables{get; set;}
}
public class Variable
{
  public VariableCodeList VariableCodes{get; set;}
}
public class VariableCode
{
  public bool IsShown{get; set;}
}

我真正想做的是在CrossTab上公开一个属性（最好是ObservableCollection），它是所有包含的变量代码的视图，其中IsShown==true。目前，它们是独立的集合-每个集合包含在各自的变量对象中

public class CrossTab
{
  public ObservableCollection<VariableCode> ShownCodes
  {
    get
    {
      //This is where I could picture some brute force looping
      //  and building of a new collection - but that's not really
      //  what I'm after.  What I want is a live view on the data
      //  that's in there
    }
  }
}

公共类交叉表
{
公共可观测集合显示代码
{
得到
{
//在这里我可以想象一些蛮力循环
//和建立一个新的收藏，但这不是真的
//我想要的是数据的实时视图
//那在里面
}
}
}

我正在玩的蛮力代码返回正确的数据——不是作为实时视图，而是作为静态集合

ObservableCollection<VariableCode> output = new ...();
Variables.ForEach(v =>
    v.VariableCodes.Where(vc => vc.IsShown)
    .ForEach(vc => output.Add(vc))
  );
return output;

ObservableCollection输出=new…（）；
Variables.ForEach（v=>
v、 VariableCodes.Where（vc=>vc.IsShown）
.ForEach（vc=>output.Add（vc））
);
返回输出；

---

想法？这是可能的吗？

您是否考虑过使用LINQ查询从数据结构中获得所需的结果，而不是向其添加更多属性？

您是否考虑过使用LINQ查询从数据结构中获得所需的结果，而不是向其添加更多属性？

我认为SelectMany（LINQ）这就是你要找的。
看看是否有帮助

尝试将上述链接用于您的示例，并将其写入SO（无编译器）。
如果这能奏效，我会感到惊讶；）

我认为SelectMany（LINQ）是您需要的。
看看是否有帮助

尝试将上述链接用于您的示例，并将其写入SO（无编译器）。
如果这能奏效，我会感到惊讶；）

---

我认为重写索引操作符是个好主意。下面的代码是如何执行此操作的示例。此代码经过充分测试，甚至检测到“IndexOutfrange”异常

class Collection
   {
   //                                   [0]    [1]
   static String[] a1 = new String[] { "one", "two" };
   //                                   [2]      [3]
   static String[] a2 = new String[] { "three", "four" };
   //                                   [4]     [5]
   static String[] a3 = new String[] { "five", "six" };

   static Object[] collections = new Object[] { a1, a2, a3 };

   public String this[int i]
      {
      get
         {
         int add_to_index = 0;
         int collection_num = 0;

         int calculated_index = i - add_to_index;

         for ( String[] pointer = (String[])collections[collection_num];
            1 == 1;
            pointer = (String[])collections[++collection_num],
            calculated_index = i - add_to_index)
            {
            if (calculated_index < pointer.Length)
               return pointer[calculated_index];
            else if (collection_num == (collections.Length - 1))
               throw new IndexOutOfRangeException();
            add_to_index += pointer.Length;
            }

         throw new IndexOutOfRangeException();
         }
      set { throw new NotImplementedException(); }
      }

   }

类集合
{
//                                   [0]    [1]
静态字符串[]a1=新字符串[]{“一”，“二”}；
//                                   [2]      [3]
静态字符串[]a2=新字符串[]{“三”，“四”}；
//                                   [4]     [5]
静态字符串[]a3=新字符串[]{“五”，“六”}；
静态对象[]集合=新对象[]{a1、a2、a3}；
公共字符串this[int i]
{
得到
{
int add_to_index=0；
int collection_num=0；
int计算的指数=i-将指数添加到指数中；
对于（字符串[]指针=（字符串[]）集合[collection_num]；
1 == 1;
指针=（字符串[]）集合[++collection_num]，
计算的_指数=i-将_添加到_指数）
{
if（计算的索引<指针长度）
返回指针[计算的_索引]；
else if（collection_num==（collections.Length-1））
抛出新的IndexOutOfRangeException（）；
将_添加到_index+=指针.Length；
}
抛出新的IndexOutOfRangeException（）；
}
设置{抛出新的NotImplementedException（）；}
}
}

我认为重写索引操作符是个好主意。下面的代码是如何执行此操作的示例。此代码经过充分测试，甚至检测到“IndexOutfrange”异常

class Collection
   {
   //                                   [0]    [1]
   static String[] a1 = new String[] { "one", "two" };
   //                                   [2]      [3]
   static String[] a2 = new String[] { "three", "four" };
   //                                   [4]     [5]
   static String[] a3 = new String[] { "five", "six" };

   static Object[] collections = new Object[] { a1, a2, a3 };

   public String this[int i]
      {
      get
         {
         int add_to_index = 0;
         int collection_num = 0;

         int calculated_index = i - add_to_index;

         for ( String[] pointer = (String[])collections[collection_num];
            1 == 1;
            pointer = (String[])collections[++collection_num],
            calculated_index = i - add_to_index)
            {
            if (calculated_index < pointer.Length)
               return pointer[calculated_index];
            else if (collection_num == (collections.Length - 1))
               throw new IndexOutOfRangeException();
            add_to_index += pointer.Length;
            }

         throw new IndexOutOfRangeException();
         }
      set { throw new NotImplementedException(); }
      }

   }

类集合
{
//                                   [0]    [1]
静态字符串[]a1=新字符串[]{“一”，“二”}；
//                                   [2]      [3]
静态字符串[]a2=新字符串[]{“三”，“四”}；
//                                   [4]     [5]
静态字符串[]a3=新字符串[]{“五”，“六”}；
静态对象[]集合=新对象[]{a1、a2、a3}；
公共字符串this[int i]
{
得到
{
int add_to_index=0；
int collection_num=0；
int计算的指数=i-将指数添加到指数中；
对于（字符串[]指针=（字符串[]）集合[collection_num]；
1 == 1;
指针=（字符串[]）集合[++collection_num]，
计算的_指数=i-将_添加到_指数）
{
if（计算的索引<指针长度）
返回指针[计算的_索引]；
else if（collection_num==（collections.Length-1））
抛出新的IndexOutOfRangeException（）；
将_添加到_index+=指针.Length；
}
抛出新的IndexOutOfRangeException（）；
}
设置{抛出新的NotImplementedException（）；}
}
}

您可以使用SelectMany Linq方法来实现这一点，如下所示：

public class CrossTab
{
    public VariableList Variables { get; set; }

    public ObservableCollection<VariableCode> ShownCodes
    {
        get
        {
            return new ObservableCollection<VariableCode>(
                Variables
                    .SelectMany(variable => variable.VariableCodes)
                    .Where(code => code.IsShown)
                );
        }
    }
}

公共类交叉表
{
公共变量列表变量{get；set；}
公共可观测集合显示代码
{
得到
{
返回新的ObservableCollection(
变量
.SelectMany（变量=>variable.VariableCodes）
.Where（code=>code.IsShown）
);
}
}
}

您可以使用SelectMany Linq方法来实现这一点，如下所示：

public class CrossTab
{
    public VariableList Variables { get; set; }

    public ObservableCollection<VariableCode> ShownCodes
    {
        get
        {
            return new ObservableCollection<VariableCode>(
                Variables
                    .SelectMany(variable => variable.VariableCodes)
                    .Where(code => code.IsShown)
                );
        }
    }
}

公共类交叉表
{
公共变量列表变量{get；set；}
公共可观测集合显示代码
{
得到
{
返回新的ObservableCollection(
变量
.SelectMany（变量=>variable.VariableCodes）
.Where（code=>code.IsShown）