Skip to content

Tutorial4.ja

houzkin edited this page Nov 14, 2026 · 5 revisions

Wrapper系譜からの派生によるカスタマイズ

ツリー構造または他階層構造(ITreeNode否実装)をラップするための抽象クラスです。
コンストラクタに渡されたソースをラッパーのルートとし、子孫方向にラップします。
ラッパー同士の親子間で相互参照を担うことと、ソースとなる構造の再現・カスタマイズが目的となります。

HierarchyWrapper/TreeNodeWrapper

基礎的なラッパーです。
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(CombinableMirroredChildrenCollection<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) { }
}

各メソッドの役割は以下です。

  1. SourceChildren:ソースオブジェクトからソースの子ノードコレクションを取得する。
  2. GenerateChild:ソースの子ノードに対して、対応するラッパーを生成する。
  3. SetupPublicChildCollection:ラッパーの子ノードコレクションをカスタマイズできる。
  4. 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; }
}

参照:Tutorial1 #他階層構造との相互変換

BindableHierarchyWrapper/BindableTreeNodeWrapper

ソースの子ノードコレクションと連動し、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}
*/

Disposeの挙動

対象となったノードラッパーの破棄処理の過程で、子孫ノードラッパーを末端から順に破棄・切り離し処理を行います。

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が破棄されました。

Clone this wiki locally