コレクションの反復処理時にネストされたオブジェクトを作成する

Question

反復処理中にコレクションを反復してネストしたオブジェクトを作成することはできますか？だから、フラットファイルは、（工場の集まりで、すなわち「facta」と「factbをツールオブジェクトを作成します

public class Tool 
{ 
    public List<Factory> Factories { get; set; }  
} 
public class Factory 
{  
    public string Name { get; set; } 
    public List<Machine> Machines { get; set; } 
} 
public class Machine 
{  
    public string Name { get; set; } 
    public List<Module> Modules { get; set; } 
} 

：

TOOLID FACTORY  MACHINE  MODULE 
1   facta  123   abc 
2   facta  123   def 
3   facta  123   ghi 
4   facta  789   jkl 
5   facta  789   mno 
6   factb  456   abc 
7   factb  456   def 
8   factb  456   ghi 
9   factb  456   jkl 
10  factb  456   mno 

私は次のクラスが定義されている：私は、以下のフラットなリストを持っています'）。 'facta'ファクトリには、一連のマシン（つまり、 '123'と789 '）が含まれます。 「ファクト」内の「123」マシンには、モジュールのコレクション（「abc」、「def」、「ghi」など）などが含まれます。

JSONの表現：箱から出して

{ 
 
\t "factory": [ 
 
\t \t { \t \t \t 
 
\t \t \t "name": "facta", 
 
\t \t \t "machine": [ 
 
\t \t \t \t { \t \t 
 
\t \t \t \t \t "name": "123", 
 
\t \t \t \t \t "modules": [ 
 
\t \t \t \t \t \t { "name" : "abc"}, 
 
\t \t \t \t \t \t { "name" : "def"}, 
 
\t \t \t \t \t \t { "name" : "ghi"} 
 
\t \t \t \t \t ] 
 
\t \t \t \t }, 
 
\t \t \t \t { \t \t \t \t \t 
 
\t \t \t \t \t "name": "789", 
 
\t \t \t \t \t "modules": [ 
 
\t \t \t \t \t \t { "name" : "jkl"}, 
 
\t \t \t \t \t \t { "name" : "mno"} 
 
\t \t \t \t \t ] 
 
\t \t \t \t } 
 
\t \t \t ] 
 
\t \t }, 
 
\t \t { \t \t \t 
 
\t \t \t "name": "factb", 
 
\t \t \t "machine": [ 
 
\t \t \t \t { \t \t \t \t \t 
 
\t \t \t \t \t "name": "456", 
 
\t \t \t \t \t "modules": [ 
 
\t \t \t \t \t \t { "name" : "abc"}, 
 
\t \t \t \t \t \t { "name" : "def"}, 
 
\t \t \t \t \t \t { "name" : "ghi"}, 
 
\t \t \t \t \t \t { "name" : "jkl"}, 
 
\t \t \t \t \t \t { "name" : "mno"} 
 
\t \t \t \t \t ] 
 
\t \t \t \t } 
 
\t \t \t ] 
 
\t \t } 
 
\t ] 
 
}

Answer 1

まあ：あなたは私のコードの仕組みを理解すれば、あなたはにすべてを凝縮することができます

多分、このを見てみましょう単一のLINQライン：

to = new Tool(); 
input.GroupBy(a => a[1]).ToList().ForEach(a => 
    { fa = new Factory($"{a.Key}"); a.GroupBy(b => b[2]).ToList().ForEach(b => 
     { ma = new Machine($"{b.Key}"); b.GroupBy(c => c[3]).ToList().ForEach(c => 
      { mo = new Module($"{c.Key}"); ma.Modules.Add(mo); }); fa.Machines.Add(ma); }); to.Factories.Add(fa); }); 

オリジナルコード：

static class Program 
{ 
    static void Main(string[] args) 
    { 
     Tool to; 
     Factory fa; 
     Machine ma; 
     Module mo; 
     List<ArrayList> input = new List<ArrayList>(); 

     input.Add(new ArrayList() { 1, "facta", 123, "abc" }); 
     input.Add(new ArrayList() { 2, "facta", 123, "def" }); 
     input.Add(new ArrayList() { 3, "facta", 123, "ghi" }); 
     input.Add(new ArrayList() { 4, "facta", 789, "jkl" }); 
     input.Add(new ArrayList() { 5, "facta", 789, "mno" }); 
     input.Add(new ArrayList() { 6, "factb", 456, "abc" }); 
     input.Add(new ArrayList() { 7, "factb", 456, "def" }); 
     input.Add(new ArrayList() { 8, "factb", 456, "ghi" }); 
     input.Add(new ArrayList() { 9, "factb", 456, "jkl" }); 
     input.Add(new ArrayList() { 10, "factb", 456, "mno" }); 

     //[0] = ToolId/[1] = FactoryName/[2] = MachineName/[3] = ModuleName 

     var factories = input.GroupBy(a => a[1]); 
     to = new Tool(); 

     foreach (var factory in factories) 
     { 
      fa = new Factory($"{factory.Key}"); 
      var machines = factory.GroupBy(a => a[2]); 
      foreach (var machine in machines) 
      { 
       ma = new Machine($"{machine.Key}"); 
       var modules = machine.GroupBy(a => a[3]); 
       foreach (var module in modules) 
       { 
        mo = new Module($"{module.Key}"); 
        ma.Modules.Add(mo); 
       } 
       fa.Machines.Add(ma); 
      } 
      to.Factories.Add(fa); 
     } 
    } 
} 
public class Tool 
{ 
    public List<Factory> Factories { get; set; } 
    public Tool() 
    { 
     Factories = new List<Factory>(); 
    } 
} 
public class Factory 
{ 
    public string Name { get; set; } 
    public List<Machine> Machines { get; set; } 
    public Factory(string name) 
    { 
     Name = name; 
     Machines = new List<Machine>(); 
    } 
} 
public class Machine 
{ 
    public string Name { get; set; } 
    public List<Module> Modules { get; set; } 
    public Machine(string name) 
    { 
     Name = name; 
     Modules = new List<Module>(); 
    } 
} 
public class Module 
{ 
    public string Name { get; set; } 
    public Module(string name) 
    { 
     Name = name; 
    } 
} 

あなたのフラットなリストを想定すると、

Answer 2

、私はこれを行うことができます何も知りません。 確かに可能です。

あなたは、リスト項目

public class FlatItem 
{ 
    public int ToolId {get;set;} 
    public string Factory {get;set;} 
    public int Machine {get;set;} 
    public string Module {get;set;} 
} 

List<FlatItem> flatitemlist = ... // get your flatlist into this list 

のためのクラスを作成することができ、その後、私はSystem.LinqのGroupBy拡張子（またはLINQクエリgroup by）で動作するように、あなたをお勧めします、ここで、このような：

var result = flatitemlist 
       .GroupBy(g => g.Factory) 
       .Select(t => t 
        .GroupBy(g => g.Machine) 
        .Select(x => x 
         .GroupBy(y => y.Module))).ToList(); 

構造体を取得すると、アイテムを繰り返し処理できます。これは

EDITそれを行うための一つの方法である、

var result = flatitemlist.GroupBy(x => new {x.Factory, x.Machine, x.Module}); 

Answer 3

が配列の内部配列です：

string[][] flatList = new string[10][4];

私はまた、あなたが同様にモジュールのクラスを持っていると仮定していますか？

public class Module 
{  
    public string Name { get; set; } 
} 

あなたは、データの最初の行に存在する4つの別々のエンティティの初期化と移入することから始めます。その後、あなたは残りの行に反復し、必要に応じて新しいインスタンスを作成します

Tool tool = new Tool(){Factories = new List<Factories>()}; 
Factory factory = new Factory(){Name = flatList[0][1], Machines = new List< Machine>()}; 
tool.Factories.Add(factory); 
Machine machine = new Machine(){Name = flatList[0][2], Modules = new List<Module>()}; 
factory.Machines.Add(machine); 
Module module = new Module(){Name = flatList[0][3]}; 
machine.Modules.Add(module); 
bool isNewMachine = false; 
bool isNewModule = false; 

を。階層構造を構築しているため、新しいエンティティが作成されると、そのすべての子エンティティも自動的に新しいものになります。したがって、isNewMachineとisNewModuleが必要です。

IMHO、この時点でコードは自明になります。

for(int i = 1; i < flatList.Length; i++) 
{ 
    if(factory.Name != flatList[i][1]) //factory is different from previous 
    { 
     factory = new Factory(){Name = flatList[i][1], Machines = new List< Machine>()}; 
     tool.Factories.Add(factory); 
     isNewMachine = true; 
     isNewModule = true; 
    } 
    if(isNewMachine || machine.Name != flatList[i][2]) //machine is different from previous 
    { 
     machine = new Machine(){Name = flatList[][2], Modules = new List<Module>()}; 
     factory.Machines.Add(machine); 
     isNewMachine = false; 
     isNewModule = true; 
    } 
    if(isNewModule || module.Name != flatList[i][3]) //module is different than previous 
    { 
     module = new Module(){Name = flatList[0][3]}; 
     machine.Modules.Add(module); 
     isNewModule = false; 
    } 
} 

また、使用している.NET Frameworkのバージョンによっては、クラスのListプロパティを自動的にインスタンス化することでコード量を減らすことができます。たとえば、あなたのToolエンティティは次のようになります。

public class Tool 
{ 
    public List<Factory> Factories { get; set; } = new List<Factory>(); 
} 

その後、あなたは現在、各インスタンス化リストをインスタンス化するために必要なコードのすべての行を削除することができます：

... ], Modules = new List<Module>()