Skip to content

Tutorial1.ja

houzkin edited this page Nov 9, 2026 · 4 revisions

ツリー構造の構築・変換

以下のクラスを定義した上で説明します。

public class NamedNode : GeneralTreeNode<NamedNode> {
    public NamedNode() { }
    public string Name { get; set; }
    public override string ToString() => this.Name;
}
public class NamedLayer {
    public string Name { get; set; }
    public List<NamedLayer> ChildLayers { get; } = new List<NamedLayer>();
	public override string ToString() => this.Name;
}
public class NamedRow {
  public int Id { get; set; }
  public int? ParentId { get; set; }
  public string Name { get; set; }
}	
  • NamedNode:ツリー構造をなすクラス。当ライブラリにて定義されているGeneralTreeNodeを継承。
  • NamedLayer:階層構造をなすクラス。
  • NamedRow:自身のIDと親IDを保持するクラス。

追加メソッドを使って組立てる

var NodeA = new NamedNode() { Name = "A" };
var NodeB = new NamedNode() { Name = "B" };
var NodeC = new NamedNode() { Name = "C" };
var NodeD = new NamedNode() { Name = "D" };
var NodeE = new NamedNode() { Name = "E" };
var NodeF = new NamedNode() { Name = "F" };

NodeA.AddChild(NodeB).AddChild(NodeC);
NodeB.AddChild(NodeD);
NodeC.AddChild(NodeE);
NodeA.InsertChild(0, NodeF);

Console.WriteLine(NodeA.ToTreeDiagram(x => x.Name));
/*
A
├ F
├ B
│ └ D
└ C
  └ E
*/

N分木として組立てる

次のコードで、コレクションの各要素から三分木を組立てます。

var nodes = "ABCDEFGH".Select(x=> x.ToString()).AssembleAsNAryTree(3, x => new NamedNode() { Name = x });
Console.WriteLine(nodes.ToTreeDiagram(x => x.Name));
/*
A
├ B
│ ├ E
│ ├ F
│ └ G
├ C
│ └ H
└ D
*/

NodeIndexを使って組立てる

唯一のルートからなるツリー構造を組立てることができます。
ノードインデックスが途切れていた場合、それ以降のノードは除外されます。

var dic = new Dictionary<NodeIndex, string>() {
  [new NodeIndex()] = "A",
  [new NodeIndex(0)] = "B",
  [new NodeIndex(1)] = "C",
  [new NodeIndex(0,0)] = "D",
  [new NodeIndex(1,0,5)] = "E",
  [new NodeIndex(1,8)] = "F",
};
var root1 = dic.AssembleTree(x => new NamedNode() { Name = x });
Console.WriteLine(root1.ToTreeDiagram(x => x.Name));

/* Node node "E" is excluded because there is no node corresponding to NodeIndex [1,0].
A
├ B
│ └ D
└ C
  └ F
  */

各ノードはレベル順に追加処理されます。
結果的にノードFはノードCの子ノードとして追加されますが、末端のインデックスは反映されません。
以下のように、インデックスを指定した場合はエラーとなります。

try {
  var root2 = dic.AssembleTree(x=> new NamedNode() { Name = x.ToString() }, (p, c, i) => p.InsertChild(i,c));
  Console.WriteLine(root2.ToTreeDiagram(x => x.Name));
}catch(ArgumentOutOfRangeException e) {
  Console.WriteLine(e.Message);
}
/* An error occurs when attempting to add node "F" to node "C" with index [8].
Index must be within the bounds of the List. (Parameter 'index')
*/

NodePathを使って組立てる

パスとパスに対応するノードから組立てます。
パスが途切れていた場合、それ以降のノードは除外されます。

var dic = new Dictionary<NodePath<string>, NamedNode>() {
  [new NodePath<string>("A")] = new NamedNode() { Name = "A"},
  [new NodePath<string>("A","B")] = new NamedNode() { Name = "B"},
  [new NodePath<string> ("A","C","D")] = new NamedNode() { Name ="D"},
};
var root = dic.AssembleTreeByPath();
Console.WriteLine(root.ToTreeDiagram(x=>x.Name));

/* There is no node corresponding to the node path("A", "C"). 
A
└ B
*/

ノードパスのコレクションから組立てる場合、全ノードの生成関数を補完できます。 そのため、末端のノードを示すパスだけで組立てることができます。

var paths = new List<NodePath<string>>() {
  new NodePath<string>("A","B"),
  new NodePath<string>("A","C","D"),
};
var root1 = paths.AssembleTreeByPath(path => new NamedNode() { Name = path.Last() });
Console.WriteLine(root1.ToTreeDiagram(x => x.Name));
/*
A
├ B
└ C
  └ D
*/

NodeIndexと異なり他のツリーを識別できるので、コレクション内に含まれる複数のツリーを組立てることができます。

var paths2 = new List<NodePath<string>>() {
  new NodePath<string>("A"),
  new NodePath<string>("A","B"),
  new NodePath<string>("A","C","D"),
  new NodePath<string>("E","F","G"),
  new NodePath<string>("E","F","H"),
};
var roots = paths2.AssembleForestByPath(path => new NamedNode() { Name = path.Last() });

foreach(var tr in roots) {
  Console.WriteLine(tr.ToTreeDiagram(x => x.Name));
}
/*
A
├ B
└ C
  └ D

E
└ F
  ├ G
  └ H
  */

隣接リストから組立てる

隣接リストから、各データのIDと親となるデータのIDを指定してツリー構造を組立てます。
親となるデータのIDがnullまたは該当するIDが見つからなかった場合、そのノードはルートとなります。

var kernels = new List<NamedRow>() {
  new(){ Id = 0, ParentId = null, Name = "Unix" },
  new(){ Id = 1, ParentId = 0, Name = "SystemV" },
  new(){ Id = 2, ParentId = 0, Name = "BSD" },
  new(){ Id = 3, ParentId = 2, Name = "MacOS" },
  new(){ Id = 4, ParentId = null, Name = "Linux" },
  new(){ Id = 5, ParentId = 4, Name = "zen" },
  new(){ Id = 6, ParentId = 4, Name = "pf" },
};
var kernelRoots = kernels.AssembleForestById(x=>x.Id, x=>x.ParentId, x => new NamedNode() { Name = x.Name });

foreach(var kernel in kernelRoots) {
  Console.WriteLine(kernel.ToTreeDiagram(x => x.Name));
}
/*
Unix
├ SystemV
└ BSD
  └ MacOS

Linux
├ zen
└ pf
*/

他階層構造(ITreeNode否実装)を組立てる

ここまで使用してきたAssembleAsNAryTree、AssembleTree、AssembleTreeByPath、AssembleForestByPath、AssembleForestByIdは、ITreeNodeを実装していない階層構造も組立てることもできます。

var layer1 = "ABCDEF".ToCharArray()
  .AssembleAsNAryTree(3, x => new NamedLayer() { Name = x.ToString() }, x => x.ChildLayers, (p, c) => p.ChildLayers.Add(c));

PrintHierarchy(layer1);
/*
└ A
 └ B
  └ E
  	└ F
 └ C
 └ D
*/

var layer2 = new Dictionary<NodeIndex, string>() {
  [new NodeIndex(0,1)]="D",
  [new NodeIndex(1)]="C",
  [new NodeIndex(0)]="B",
  [new NodeIndex()]="A",
}.AssembleTree(x => new NamedLayer() { Name = x }, (p, c) => p.ChildLayers.Add(c));

PrintHierarchy(layer2);
/*
└ A
 └ B
 	└ D
 └ C
*/

var layer3 = new List<NodePath<string>>() {
  new NodePath<string>("A","B"),
  new NodePath<string>("A","C","D"),
  new NodePath<string>("E","F","G"),
  new NodePath<string>("E","F","H"),
}.AssembleForestByPath(x => new NamedLayer() { Name = x.Last() }, (p, c) => p.ChildLayers.Add(c));

foreach (var t in layer3) PrintHierarchy(t);
/*
└ A
 └ B
 └ C
  └ D
└ E
 └ F
  └ G
  └ H
*/

var layer4 = new List<NamedRow>() {
  new NamedRow(){ Id = 0, ParentId = null, Name="RedHat"},
  new NamedRow(){ Id = 1, ParentId = 0, Name="Fedora"},
  new NamedRow(){ Id = 2, ParentId = 1, Name="Nobara"},
  new NamedRow(){ Id = 3, ParentId = 0, Name="SentOS"},
  new NamedRow(){ Id = 4, ParentId = null, Name="Arch"},
  new NamedRow(){ Id = 5, ParentId = 4, Name="Manjaro"},
  new NamedRow(){ Id = 6, ParentId = null, Name="Debian"},
  new NamedRow(){ Id = 7, ParentId = 6, Name="Ubuntu"},
  new NamedRow(){ Id = 8, ParentId = 7, Name="Mint"},
  new NamedRow(){ Id = 9, ParentId = 7, Name="ZorinOS"},

}.AssembleForestById(x => x.Id, x => x.ParentId, x => new NamedLayer() { Name = x.Name }, (p, c) => p.ChildLayers.Add(c));

foreach (var t in layer4) PrintHierarchy(t);
/*
└ RedHat
   └ Fedora
     └ Nobara
   └ SentOS
└ Arch
   └ Manjaro
└ Debian
   └ Ubuntu
     └ Mint
     └ ZorinOS
*/

他階層構造との相互変換

Convertメソッドは、ツリー構造から他のツリー構造または他階層構造(ITreeNode否実装)に変換することができます。 他階層構造からツリー構造に変換する場合はReadOnlyValuedTreeNode(簡易的なラッパーノード)を経由する必要があります。
以下のコードで、NamedNode → NamedLayer → ReadOnlyValuedTreeNode → NamedNode に変換しています。

var root = new List<NodePath<string>>() {
  new NodePath<string>("A","B"),
  new NodePath<string>("A","C","D"),
}.AssembleTreeByPath(x => new NamedNode() { Name = x.Last() });
Console.WriteLine(root.ToTreeDiagram(x => x.Name));
/*
A
├ B
└ C
  └ D
*/

// NamedNode -> NamedLayer
var layer = root.Convert(x => new NamedLayer() { Name = x.Name.ToLower() }, (p, c) => p.ChildLayers.Add(c));
PrintHierarchy(layer);
/*
└ a
  └ b
  └ c
  	└ d
*/

// NamedLayer -> ReadOnlyValuedTreeNode<NamedLayer,NamedLayer>
var valuedTreeRoot = layer.AsValuedTreeNode(x => x.ChildLayers, x => x);
Console.WriteLine(valuedTreeRoot.ToTreeDiagram(wrapper => wrapper.Value.Name));
/*
a
├ b
└ c
  └ d
*/

// ReadOnlyValuedTreeNode -> NamedNode
var root2 = valuedTreeRoot.Convert(x => new NamedNode() { Name = x.Value.Name.ToUpper() });
Console.WriteLine(root2.ToTreeDiagram(node => node.Name));
/*
A
├ B
└ C
  └ D
*/

Dictionaryへの変換

キーをNodeIndexとするDictionary<NodeIndex,T>へ変換します。

var t = "ABCDEFG".ToCharArray().AssembleAsNAryTree(2, x => new NamedNode() { Name = x.ToString() });
Console.WriteLine(t.ToTreeDiagram(x=> x.Name));
/*
A
├ B
│ ├ D
│ └ E
└ C
  ├ F
  └ G
  */

var dic = t.ToNodeMap(x => x.Name);
foreach(var pair in dic) {
  Console.WriteLine($"key:{pair.Key},value:{pair.Value}");
}
/*
key:[],value:A
key:[0],value:B
key:[1],value:C
key:[0,0],value:D
key:[0,1],value:E
key:[1,0],value:F
key:[1,1],value:G
  */

シリアライズ・デシリアライズ

TreeNodeはそのままシリアライズできますが非推奨です。
SetupChildCollectionをオーバライドして初期化時に要素を設定していた場合、デシリアライズの過程で意図しない構造になる可能性があります。
よって、各ノードをシリアライズ用のオブジェクトに変換して出力します。

単一のツリーをシリアライズ・デシリアライズ

階層構造を維持した状態でシリアライズします。

string path = "Text1.xml";
var root = new List<NodePath<string>>() {
  new("A","B","C"),
  new("A","D","E"),
}.AssembleForestByPath(x => new NamedNode() { Name = x.Last() }).Single();

// Serialize
var sLayer = root.Convert(x => new NamedLayer() { Name = x.Name }, (p, c) => p.ChildLayers.Add(c));
var serializer = new XmlSerializer(typeof(NamedLayer));
using(var sw = new StreamWriter(path)) {
  serializer.Serialize(sw, sLayer);
}
/*
<?xml version="1.0" encoding="utf-8"?>
<NamedLayer xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Name>A</Name>
  <ChildLayers>
  <NamedLayer>
    <Name>B</Name>
    <ChildLayers>
    <NamedLayer>
      <Name>C</Name>
      <ChildLayers />
    </NamedLayer>
    </ChildLayers>
  </NamedLayer>
  <NamedLayer>
    <Name>D</Name>
    <ChildLayers>
    <NamedLayer>
      <Name>E</Name>
      <ChildLayers />
    </NamedLayer>
    </ChildLayers>
  </NamedLayer>
  </ChildLayers>
</NamedLayer>
*/

// Deserialize
NamedLayer layer;
using(StreamReader sr = new StreamReader(path)) {
  layer = (NamedLayer)serializer.Deserialize(sr);
}
var root2 = layer.AsValuedTreeNode(x => x.ChildLayers, x => x)
  .Convert(x => new NamedNode() { Name = x.Value.Name});
Console.WriteLine(root2.ToTreeDiagram(x => x.Name));
/*
A
├ B
│ └ C
└ D
  └ E
  */

単一のツリーを平坦化してシリアライズ・デシリアライズ

シリアライズ可能なDictionary型に変換してシリアライズ・デシリアライズします。

string path = "Text2.xml";
var root = new List<NodePath<string>>() {
  new("A", "B", "C"),
  new("A", "D", "E"),
  new("A", "D", "F", "G"),
}.AssembleForestByPath(x => new NamedNode() { Name = x.Last() }).Single();

// Serialize
var serializable = root.ToSerializableNodeMap(x => x.Name);
var serializer = new XmlSerializer(typeof(SerializableNodeMap<string>));
using (StreamWriter fs = new StreamWriter(path)) {
  serializer.Serialize(fs, serializable);
}
/*
<?xml version="1.0" encoding="utf-8"?>
<SerializableNodeMapOfString>
  <KeyValueItemOfNodeIndexCodeOfStringString>
  <Key>
    <NodeIndex>[]</NodeIndex>
  </Key>
  <Value>A</Value>
  </KeyValueItemOfNodeIndexCodeOfStringString>
  <KeyValueItemOfNodeIndexCodeOfStringString>
  <Key>
    <NodeIndex>[0]</NodeIndex>
  </Key>
  <Value>B</Value>
  </KeyValueItemOfNodeIndexCodeOfStringString>
  <KeyValueItemOfNodeIndexCodeOfStringString>
  <Key>
    <NodeIndex>[1]</NodeIndex>
  </Key>
  <Value>D</Value>
  </KeyValueItemOfNodeIndexCodeOfStringString>
  <KeyValueItemOfNodeIndexCodeOfStringString>
  <Key>
    <NodeIndex>[0,0]</NodeIndex>
  </Key>
  <Value>C</Value>
  </KeyValueItemOfNodeIndexCodeOfStringString>
  <KeyValueItemOfNodeIndexCodeOfStringString>
  <Key>
    <NodeIndex>[1,0]</NodeIndex>
  </Key>
  <Value>E</Value>
  </KeyValueItemOfNodeIndexCodeOfStringString>
  <KeyValueItemOfNodeIndexCodeOfStringString>
  <Key>
    <NodeIndex>[1,1]</NodeIndex>
  </Key>
  <Value>F</Value>
  </KeyValueItemOfNodeIndexCodeOfStringString>
  <KeyValueItemOfNodeIndexCodeOfStringString>
  <Key>
    <NodeIndex>[1,1,0]</NodeIndex>
  </Key>
  <Value>G</Value>
  </KeyValueItemOfNodeIndexCodeOfStringString>
</SerializableNodeMapOfString>
  */

// Deserialize
SerializableNodeMap<string> snm;
using (StreamReader sr = new StreamReader(path)) {
  snm =(SerializableNodeMap<string>)serializer.Deserialize(sr);
}
var root2 = snm.AssembleTree(x=> new NamedNode() { Name = x});
Console.WriteLine(root2.ToTreeDiagram(x => x.Name));
/*
A
├ B
│ └ C
└ D
  ├ E
  └ F
  └ G
  */

複数のツリーを平坦化してシリアライズ・デシリアライズ

各データにIDとParentIDを設定し、隣接リストとしてシリアライズ・デシリアライズします。

string path = "Text3.xml";
var forest1 = new List<NodePath<string>>() {
  new("A", "B", "C"),
  new("A", "B", "D"),
  new("E", "F", "G"),
}.AssembleForestByPath(x => new NamedNode() { Name = x.Last() });

// Assign ID and ParentID to each row.
var adjList = forest1.Select(x => x.AsValuedTreeNode(a => new NamedRow() { Name = a.Name })).ToArray();
foreach (var pair in adjList.SelectMany(x => x.LevelOrder()).Select((x, i) => (Row: x, Index: i))) {
  pair.Row.Value.Id = pair.Index;
  pair.Row.Value.ParentId = pair.Row.Parent?.Value.Id;
}

// Serialize
var rows1 = adjList.SelectMany(x => x.LevelOrder()).Select(x => x.Value).ToList();
var serializer = new XmlSerializer(typeof(List<NamedRow>));
using (var sw = new StreamWriter(path)) {
  serializer.Serialize(sw, rows1);
}
/*
<?xml version="1.0" encoding="utf-8"?>
<ArrayOfNamedRow xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <NamedRow>
  <Id>0</Id>
  <ParentId xsi:nil="true" />
  <Name>A</Name>
  </NamedRow>
  <NamedRow>
  <Id>1</Id>
  <ParentId>0</ParentId>
  <Name>B</Name>
  </NamedRow>
  <NamedRow>
  <Id>2</Id>
  <ParentId>1</ParentId>
  <Name>C</Name>
  </NamedRow>
  <NamedRow>
  <Id>3</Id>
  <ParentId>1</ParentId>
  <Name>D</Name>
  </NamedRow>
  <NamedRow>
  <Id>4</Id>
  <ParentId xsi:nil="true" />
  <Name>E</Name>
  </NamedRow>
  <NamedRow>
  <Id>5</Id>
  <ParentId>4</ParentId>
  <Name>F</Name>
  </NamedRow>
  <NamedRow>
  <Id>6</Id>
  <ParentId>5</ParentId>
  <Name>G</Name>
  </NamedRow>
</ArrayOfNamedRow>
  */

// Deserialize
List<NamedRow> rows2;
using (StreamReader sr = new StreamReader(path)) {
  rows2 = (List<NamedRow>)serializer.Deserialize(sr);
}
var forest2 = rows2.AssembleForestById(x => x.Id, x => x.ParentId, x => new NamedNode() { Name = x.Name });
foreach (var t in forest2) Console.WriteLine(t.ToTreeDiagram(x => x.Name));
/*
A
└ B
  ├ C
  └ D

E
└ F
  └ G
*/

Clone this wiki locally