Repository navigation
Tutorial4.ja
ツリー構造または他階層構造(ITreeNode否実装)をラップするための抽象クラスです。
コンストラクタに渡されたソースをラッパーのルートとし、子孫方向にラップします。
ラッパー同士の親子間で相互参照を担うことと、ソースとなる構造の再現・カスタマイズが目的となります。
基礎的なラッパーです。
HierarchyWrapperは階層構造をラップするための抽象クラスです。
TreeNodeWrapperは、ITreeNodeを実装したツリー構造に限定しており、SourceChildrenプロパティのオーバーライドを省略できます。それ以外に違いはありません。
HierarchyWrapper.cs
public abstract class HierarchyWrapper<TSrc,TWrpr>
: ITreeNode<TWrpr>, IEquatable<HierarchyWrapper<TSrc,TWrpr>>
where TSrc : class
where TWrpr : HierarchyWrapper<TSrc,TWrpr> {
protected HierarchyWrapper(TSrc source) { Source = source; }
#region ITreeNode interface
public TWrpr? Parent { get;}
public IEnumerable<TWrpr> Children { get; }
#endregion
protected TSrc Source { get; }
/// <summary>Specifies a reference to the source's child node collection.</summary>
protected abstract IEnumerable<TSrc>? SourceChildren { get; }
/// <summary>Conversion function applied to child nodes, converting from <typeparamref name="TSrc"/> to <typeparamref name="TWrpr"/>.</summary>
/// <param name="sourceChildNode">Child node to be wrapped</param>
/// <returns>Wrapped child node</returns>
protected abstract TWrpr GenerateChild(TSrc sourceChildNode);
/// <summary>Sets the collection to be exposed externally.</summary>
/// <param name="children">A combinable collection wrapping each node of <see cref="SourceChildren"/>.</param>
protected virtual IEnumerable<TWrpr> SetupPublicChildCollection(CombinableChildrenProxyCollection<TWrpr> children)
=> children;
/// <summary>Handles processing of a decomposed child node.</summary>
/// <remarks>This method is intended to be overridden in derived classes to add specific processing for an already decomposed child node.</remarks>
/// <param name="removedNode">Removed child node</param>
protected virtual void HandleRemovedChild(TWrpr removedNode) { }
}各メソッドの役割は以下です。
-
SourceChildren:ソースオブジェクトからソースの子ノードコレクションを取得する。 -
GenerateChild:ソースの子ノードに対して、対応するラッパーを生成する。 -
SetupPublicChildCollection:ラッパーの子ノードコレクションをカスタマイズできる。 -
HandleRemovedChild:ソースの子ノードが削除された時、対応するラッパーに対して行う処理を指定できる。
HierarchyWrapper.Childrenプロパティは、デフォルトではIEnumerable型を返しますが、インスタンス自体はReadOnlyObservableCollectionを継承しているCombinableMirroredChildrenCollectionです。
次のコードで、NamedLayerクラスをラップするNamedLayerWrapperクラスを定義します。
public class NamedLayerWrapper : HierarchyWrapper<NamedLayer, NamedLayerWrapper> {
public NamedLayerWrapper(NamedLayer source) : base(source) {
this.Name = "(" + source.Name + ")";
Console.WriteLine($"Create new {this.Name}");
}
protected override IEnumerable<NamedLayer>? SourceChildren => this.Source.ChildLayers;
protected override NamedLayerWrapper GenerateChild(NamedLayer sourceChildNode) {
return new NamedLayerWrapper(sourceChildNode);
}
protected override void HandleRemovedChild(NamedLayerWrapper removedNode) {
Console.WriteLine($"Removed {removedNode.Name}");
}
public string Name { get; }
}Childrenプロパティは初回アクセス時に初期化され、以降、アクセス時に変更があれば反映します。
SourceChildrenにて指定されたコレクションがINotifyCollectionChangedを実装しているかどうかは影響しません。
Childrenの反映時、削除されたラッパーに対してHandleRemovedChildメソッドが処理されます。
次のコードで、各ノードの初期化と削除のタイミングを示します。
var layers = "ABCDEF".ToCharArray()
.Select(x => x.ToString())
.ToDictionary(x => x, x => new NamedLayer() { Name = x });
var root = layers.Values.AssembleAsNAryTree(1, x => x, x => x.ChildLayers, (p, c) => p.ChildLayers.Add(c));
PrintHierarchy(root);
/*
└ A
└ B
└ C
└ D
└ E
└ F
*/
var wRoot = new NamedLayerWrapper(root);
// Create new (A)
Console.WriteLine("--- Print wrapper. ---");
Console.WriteLine(wRoot.ToTreeDiagram(x => x.Name));
/*
--- Print wrapper. ---
Create new (B)
Create new (C)
Create new (D)
Create new (E)
Create new (F)
(A)
└ (B)
└ (C)
└ (D)
└ (E)
└ (F)
*/
Console.WriteLine("--- Remove layer E. ---");
layers["D"].ChildLayers.Remove(layers["E"]);
Console.WriteLine("--- Add layer E to layer A. ---");
layers["A"].ChildLayers.Add(layers["E"]);
Console.WriteLine("--- Print wrapper. ---");
Console.WriteLine(wRoot.ToTreeDiagram(x => x.Name));
/*
--- Remove layer E. ---
--- Add layer E to layer A. ---
--- Print wrapper. ---
Create new (E)
Removed (E)
Create new (F)
(A)
├ (B)
│ └ (C)
│ └ (D)
└ (E)
└ (F)
*/ToTreeDiagramメソッド内でChildrenプロパティにアクセスした順に、GenerateChildメソッドやHandleRemoveChildメソッドが呼び出されています。
親ノードに変化があった場合は、子孫ノードも含めて新規でラッパーが生成されます。
次のコードで示す兄弟間の移動では、ラッパーが移動します。
Console.WriteLine("--- Remove layer E. ---");
layers["A"].ChildLayers.Remove(layers["E"]);
Console.WriteLine("--- Insert layer E to layer A at index 0. ---");
layers["A"].ChildLayers.Insert(0, layers["E"]);
Console.WriteLine("--- Print wrapper. ---");
Console.WriteLine(wRoot.ToTreeDiagram(x => x.Name));
/*
--- Remove layer E. ---
--- Insert layer E to layer A at index 0. ---
--- Print wrapper. ---
(A)
├ (E)
│ └ (F)
└ (B)
└ (C)
└ (D)
*/ラッパーの生成や削除は不規則で、ソースのイベントを購読していた場合はメモリーリークの原因となります。
Childrenの即時反映や変更通知の購読、Disposeメソッドによるリソースの破棄が必要な場合は、BindableHierarchyWrapperやBindableTreeNodeWrapperを継承して使用してください。
簡易的なラッパーとして使用できるReadOnlyValuedTreeNodeもHierarchyWrapperを継承しているので、同様の挙動となります。
ReadOnlyValuedTreeNode.cs
public sealed class ReadOnlyValuedTreeNode<TSrc,TVal>
: HierarchyWrapper<TSrc, ReadOnlyValuedTreeNode<TSrc,TVal>>
where TSrc : class {
/// <summary>Gets the value associated with the tree node.</summary>
public TVal Value { get; private set; }
}ソースの子ノードコレクションと連動し、Dispose処理が可能なラッパーです。
MVVMパターンにおけるViewModelとしての使用も想定し、INotifyPropertyChangedを実装しています。
BindableHierarchyWrapper.cs
public abstract class BindableHierarchyWrapper<TSrc, TWrpr>
: HierarchyWrapper<TSrc, TWrpr>, INotifyPropertyChanged, IDisposable
where TSrc : class
where TWrpr : BindableHierarchyWrapper<TSrc, TWrpr> {
protected BindableHierarchyWrapper(TSrc source) : base(source) { }
/// <summary>Handles the removed child node.</summary>
/// <remarks>The base class calls the <see cref="Dispose()"/> method.</remarks>
/// <param name="removedNode">The removed child node.</param>
protected override void HandleRemovedChild(TWrpr removedNode)
=> removedNode.Dispose();
protected PropertyAccessor Properties { get; }
protected void ThrowExceptionIfDisposed() {...}
protected virtual void Dispose(bool disposing) {...}
public bool IsDisposed { get; }
}SourceChildrenにて指定されたコレクションがINotifyCollectionChangedを実装している場合、
Childrenプロパティは初回アクセス時に初期化され、それ以降、コレクションの変更は即時反映されます。
INotifyCollectionChangedを実装していなかった場合はHierarchyWrapperと同様、アクセス時に更新となります。
HandleRemovedChildメソッドにて、切り離されたラッパーを破棄しています。
後述する、Disposeによって、既に破棄されているラッパーは捕捉されません。
ラッパーを自前で管理・再利用する場合は、このメソッドとGenerateChildメソッドをオーバーライドしてください。
前述したObservableNamedNodeをラップするためのノードを定義します。
public class ReadOnlyLinkedNamedNode
: BindableTreeNodeWrapper<ObservableNamedNode, ReadOnlyLinkedNamedNode> {
public ReadOnlyLinkedNamedNode(ObservableNamedNode sourceNode) : base(sourceNode) {
this.Name = "{" + sourceNode.Name + "}";
Console.WriteLine($"Create new {this.Name}");
}
protected override ReadOnlyLinkedNamedNode GenerateChild(ObservableNamedNode sourceChildNode) {
return new ReadOnlyLinkedNamedNode(sourceChildNode);
}
protected override void HandleRemovedChild(ReadOnlyLinkedNamedNode removedNode) {
Console.WriteLine($"Removed {removedNode.Name}");
base.HandleRemovedChild(removedNode);
}
protected override void Dispose(bool disposing) {
Console.WriteLine($"{this.Name} is disposing");
//Console.WriteLine($"Start disposing {this.Name}.");
base.Dispose(disposing);
//Console.WriteLine($"Finished disposing {this.Name}.");
}
public string Name { get; }
}次のコードで、各ノードの初期化と削除のタイミングを示します。
var nodes = "ABCDEF".ToCharArray()
.Select(x => x.ToString())
.ToDictionary(x => x, x => new ObservableNamedNode() { Name = x });
var root = nodes.Values.AssembleAsNAryTree(1);
Console.WriteLine(root.ToTreeDiagram(x => x.Name));
/*
A
└ B
└ C
└ D
└ E
└ F
*/
var wRoot = new ReadOnlyLinkedNamedNode(root);
// Create new {A}
Console.WriteLine("--- Print wrapper. ---");
Console.WriteLine(wRoot.ToTreeDiagram(x => x.Name));
/*
--- Print wrapper. ---
Create new {B}
Create new {C}
Create new {D}
Create new {E}
Create new {F}
{A}
└ {B}
└ {C}
└ {D}
└ {E}
└ {F}
*/
Console.WriteLine("--- Remove node E. ---");
nodes["D"].RemoveChild(nodes["E"]);
/*
--- Remove node E. ---
Removed {E}
{E} is disposing
{F} is disposing
*/
Console.WriteLine("--- Add node E to node A. ---");
nodes["A"].AddChild(nodes["E"]);
/*
--- Add node E to node A. ---
Create new {E}
*/
Console.WriteLine("--- Print wrapper. ---");
Console.WriteLine(wRoot.ToTreeDiagram(x => x.Name));
/*
--- Print wrapper. ---
Create new {F}
{A}
├ {B}
│ └ {C}
│ └ {D}
└ {E}
└ {F}
*/ノードEが削除されると、即時反映され、子孫ノードラッパーも含めて破棄されています。
兄弟間の移動は、下記のように一旦削除して再度追加した場合は、新規インスタンスが生成されます。
Console.WriteLine("--- Remove node E. ---");
nodes["A"].RemoveChild(nodes["E"]);
/*
--- Remove node E. ---
Removed {E}
{E} is disposing
{F} is disposing
*/
Console.WriteLine("--- Insert node E to node A at index 0. ---");
nodes["A"].InsertChild(0, nodes["E"]);
/*
--- Insert node E to node A at index 0. ---
Create new {E}
*/
Console.WriteLine("--- Print wrapper. ---");
Console.WriteLine(wRoot.ToTreeDiagram(x => x.Name));
/*
--- Print wrapper. ---
Create new {F}
{A}
├ {E}
│ └ {F}
└ {B}
└ {C}
└ {D}
*/削除することなく移動しただけであれば、ラッパーも移動するだけです。
Console.WriteLine("--- Move node E ---");
nodes["A"].MoveChild(0, 1);
/*
--- Move node E ---
*/
Console.WriteLine("--- Print wrapper. ---");
Console.WriteLine(wRoot.ToTreeDiagram(x => x.Name));
/*
--- Print wrapper. ---
{A}
├ {B}
│ └ {C}
│ └ {D}
└ {E}
└ {F}
*/対象となったノードラッパーの破棄処理の過程で、子孫ノードラッパーを末端から順に破棄・切り離し処理を行います。
var nodes = "ABCD".ToCharArray()
.Select(x => x.ToString())
.ToDictionary(x=>x,x=>new ObservableNamedNode() { Name = x });
var root = nodes.Values.AssembleAsNAryTree(1);
var wRoot = new ReadOnlyLinkedNamedNode(root);
Console.WriteLine(wRoot.ToTreeDiagram(x => x.Name));
/*
Create new {A}
Create new {B}
Create new {C}
Create new {D}
{A}
└ {B}
└ {C}
└ {D}
*/
foreach (var wrp in wRoot.LevelOrder()) {
if (wrp.Children is INotifyCollectionChanged clds) {
clds.CollectionChanged += (s, e) => {
if (e.OldItems != null && e.OldItems[0] is ReadOnlyLinkedNamedNode node) {
Console.WriteLine($"sender:{node.Name}, action:{e.Action}, IsDisposed:{node.IsDisposed}");
}
};
}
}
wRoot.DescendArrivals(x => x.Name, new string[] {"{A}","{B}"}).First().Dispose();
/*
Start disposing {B}.
Start disposing {D}.
Finished disposing {D}.
Start disposing {C}.
sender:{D}, action:Remove, IsDisposed:True
Finished disposing {C}.
sender:{C}, action:Remove, IsDisposed:True
Finished disposing {B}.
*/
Console.WriteLine(wRoot.ToTreeDiagram(x=> $"{x.Name}, IsDisposed = {x.IsDisposed}"));
/*
{A}, IsDisposed = False
└ {B}, IsDisposed = True
*/削除されたラッパーD,Cは既に破棄されているのでHandleRemovedChildメソッドは呼び出されません。
- ラッパーB:破棄開始
- ラッパーD:破棄開始
- ラッパーD:破棄完了
- ラッパーC:破棄開始
- ラッパーC:子ノードコレクションを削除(Remove wrapper D)
- ラッパーC:破棄完了
- ラッパーB:子ノードコレクションを削除(Remove wrapper C)
- ラッパーB:破棄完了
| 処理過程 | 処理範囲 | 順序 |
|---|---|---|
| 破棄開始 | 対象と子孫(レベルオーダーの逆順) | B,D,C |
| 切り離し | 子孫(レベルオーダーの逆順) | D,C |
| 破棄完了 | 子孫(レベルオーダーの逆順)と対象 | D,C,B |
Disposeメソッドが直接呼び出されたラッパーに対して、切り離し処理は実行されません。
Disposeを直接呼び出されるのは、ルートであることを想定しています。
故に、ラッパーという本来の目的を放棄すると子孫のラッパーを分解します。
もし上記例のように祖先が存在していた場合、親ラッパー {A} は依然ラップを担っており、ソース子ノードに対応するラッパー {B} を参照し続けることになります。
Dispose実行時、Childrenプロパティが初期化されていなかった場合、子ノードラッパーコレクションは初期化されません。
var nodes = "ABCD".ToCharArray()
.Select(x => x.ToString())
.ToDictionary(x=>x,x=>new ObservableNamedNode() { Name = x });
var root = nodes.Values.AssembleAsNAryTree(1);
Console.WriteLine(root.ToTreeDiagram(x => x.Name));
/*
A
└ B
└ C
└ D
*/
var wRoot = new ReadOnlyLinkedNamedNode(root);
//Create new {A}
wRoot.Children.First().Dispose();
/*
Create new {B}
Start disposing {B}.
Finished disposing {B}.
*/
Console.WriteLine(wRoot.ToTreeDiagram(x=> $"{x.Name}, IsDisposed = {x.IsDisposed}"));
/*
{A}, IsDisposed = False
└ {B}, IsDisposed = True
*/ノードBのChildrenプロパティにアクセスすることなく破棄されたので、ノードC,Dは初期化されることなくノードBが破棄されました。