Skip to content

InternalDesign1.ja

houzkin edited this page Nov 15, 2026 · 5 revisions

全体像

このライブラリはツリー構造をより扱いやすく柔軟に定義できるよう書いたつもりです。
その過程でツリー構造以外の周辺クラスも多く定義する必要がありました。
ツリー構造変更通知、コレクション周りは標準ライブラリでは不十分だったので、当ライブラリにて用意しています。

ITreeNode

UML1

ツリー内の位置を表すNodeIndexとNodePath

ツリー構造内において、任意のノードがどの位置に存在するのかを示すため、NodeIndexとNodePathを定義しています。
拡張メソッドGetNodeIndex()とGetNodePath()にて取得できます。

UML5

列挙における、nullと重複への対応

TreeNodeBaseやNAryTreeNodeの派生型では子ノードコレクションにnullを追加できます。 列挙時においてnullは不要でエラーの原因にもなり得ますが、これを禁止してしまうとBinaryTreeなどでLeftとRightの区別がつかなくなります。

また、ITreeNodeがラッパーだった場合、ソースとなるツリー構造に循環や重複があると、本来のラッパーとしての役割を果たせなくなるので許容する必要があります。

これを踏まえ、Traverseメソッドを定義しています。

public static IEnumerable<T> Traverse<T>(
    this ITreeNode<T> startNode, 
    Func<T, IEnumerable<T?>> getNodes, 
    Func<T, IEnumerable<T?>, IEnumerable<T?>, IEnumerable<T?>> updatePendingNodes) 
        where T : ITreeNode<T> {
}

第2引数getNodesでノードからコレクションを取得します。この関数は同一のノードに対してい一度しか適用されません。
第3引数updatePendingNodesで順序を変更して、先頭の要素がnullでない、且つ既にgetNodesを通過していたら列挙されます。一度列挙されたノードが再度列挙されることはありません。
これにより、nullを無視し、無限ループを回避できます。

Traverseメソッドは他の多くの拡張メソッドから使用されています。いくつか例を挙げます。

/// <summary>Generates a sequence in preorder starting from the current node.</summary>
public static IEnumerable<T> PreOrder<T>(this ITreeNode<T> self) where T : ITreeNode<T> {
    return self.Traverse(a => a.Children, (a, b, c) => b.AddHead(a).Concat(c));
}
/// <summary>Generates a sequence in the ancestor direction starting from the current node, with the root as the last element.</summary>
public static IEnumerable<T> Upstream<T>(this ITreeNode<T> self) where T : ITreeNode<T> {
    return self.Traverse(a => new T?[1] { a.Parent }, (a, b, c) => new T?[1] { a }.Concat(b).Concat(c));
}
/// <summary>Enumerates the leaf nodes in the descendant direction from the current node.</summary>
public static IEnumerable<T> Leafs<T>(this ITreeNode<T> self) where T : ITreeNode<T> {
    return self.Traverse(a => a.Children, (a, b, c) => (b.OfType<T>().Any() ? b : new T?[1] { a }).Concat(c));
}

TreeNodeBase系譜

TreeNodeBaseはITreeNodeのみ実装しており、ReadOnlyな状態です。
このクラスを継承して、公開メソッドを定義、仮想メソッドをオーバーライドしてカスタマイズします。

内部操作用のコレクションをSetupInnerChildCollectionで指定、 外部公開用のコレクションをSetupPublicChildCollectionで指定、 内部コレクションの操作をCoreメソッドで行う設計です。

IMutableTreeNodeのメンバーの戻り値

IMutableTreeNodeで定義されている追加・削除メソッドには戻り値があります。

public interface IMutableTreeNode<TNode> : ITreeNode<TNode>
    where TNode : IMutableTreeNode<TNode> {

    /// <summary>Adds a child node.</summary>
    /// <param name="child">The child node.</param>
    /// <returns>The current node.</returns>
    TNode AddChild(TNode child);

    /// <summary>Adds a child node at the specified index.</summary>
    /// <param name="index">The index.</param>
    /// <param name="child">The child node.</param>
    /// <returns>The current node.</returns>
    TNode InsertChild(int index, TNode child);

    /// <summary>Removes a child node.</summary>
    /// <param name="child">The child node to remove.</param>
    /// <returns>The removed node.</returns>
    TNode RemoveChild(TNode child);

    /// <summary>Removes all child nodes.</summary>
    /// <returns>The removed nodes.</returns>
    IReadOnlyList<TNode> ClearChildren();
}

正常に処理が完了することを前提として、追加または削除される子ノードに対するアプローチを考慮しています。
追加メソッドの場合、現在のノード(親となるノード)から追加したノードへアクセスが容易なので、現在のノードを返します。
削除メソッドでは親ノードから削除された子ノードにアクセスできないので、削除された子ノードを返します。
Tryメソッドで正常に処理された場合も同様の振る舞いとなります。正常に処理されなかった場合、返ってくる値は入れ替わります。

処理 結果 bool 戻り値
追加 正常に追加 true Self
既に追加済み false child
追加できなかった false child
削除 正常に削除された true child
該当するノードが存在しなかった false Self
削除できなかった false Self

ツリー構造の変化を観測できるObservableGeneralTreeNode

UML2

GeneralTreeNodeを継承したObservableGeneralTreeNodeは、StructureChangedイベントを購読することで、対象ノードから見た、所属するツリー内の追加・削除・移動の通知を受け取れます。INotifyPropertyChangedも実装しており、親ノードが変更されるとParentプロパティの変更通知も受け取れます。

この仕組みを実現する上で問題となるのが、実際に処理を完了させてみないとどのノードにどの通知を発行するか決定できないことです。単に追加・削除されただけなのか、同一ツリー内の移動なのか、兄弟ノード間での移動なのか、一つの処理の過程で複数回変更が行われる場合もあります。
ということで、再帰的に呼び出されても重複して呼び出されても、最後に一回だけ(場合によっては処理を行う前後の比較をして)実行する仕組みが必要でした。

処理の重複を制御するUniqueOperationExecutor`

あらかじめRegisterメソッドでキーとそれに対応するアクションを設定します。
処理前にExecuteUniqueメソッドまたはLateEvaluateメソッドでIDisposableを受け取り、処理後にDisposeします。生成されたIDisposableが全て破棄された時に、設定されていたアクションが実行されます。

事前に登録が不要な簡易メソッドとしてExecuteUnique(Action operation)メソッドも用意しています。
キーの指定も必要ありませんが、代わりにoperation.Method.MetadataTokenの値によって判別します。
ラムダ式で指定したら同じ処理内容でも異なる値になるので、ちゃんとメソッドやフィールド変数(Action型)を指定する必要があります。指定元のバージョンにも注意。
以前作っていたアプリでUIの更新タイミングを遅らせたいと思ったときに必要だったので残しています。

ツリー構造の変更通知を発行するStructureChangedEventExecutor

UniqueOperationExecutorを継承し、LateEvaluateTreeメソッドを定義しています。
以下のように、Coreメソッドにて処理前後の比較をしています。
ObservableGeneralTreeNode.cs

protected override void ShiftChildCore(int oldIndex, int newIndex,Action<IEnumerable<TNode>,int,int>? action = null) {
    action ??= (collection, idx1, idx2) =>
        ((ObservableCollection<TNode>)collection).Move(idx1, idx2);
    
    using (ChildNodes.ElementAt(oldIndex)?.UniqueExcutor.LateEvaluateTree()){
        base.ShiftChildCore(oldIndex, newIndex,action);
    }
}

IObservableTreeNodeのメンバー、OnStructureChangedメソッドは隠蔽されており、当クラスの発行プロセスで使用されます。

HierarchyWrapper系譜

HierarchyWrapperからは他の階層構造またはツリー構造をラップすることを目的としたクラスです。

UML3

ラップが主目的であるのでEqualsメソッドの実装が特徴的です。
ソースが同じであれば同一と判断しますが、共にnullだった場合はWrapper自身の同一性を比較します。
これによりソースの構造が循環していた場合や、NAryTreeNodeのようにソースの構造内に複数のnullのbranchがあっても対応できます。

子ノードラッパーコレクションは参照した時に生成または再評価される遅延評価となっています。
HierarchyWrapperとBindableHierarcyWrapperの主な違いとしては、 前者はソースの子ノードコレクションがINotifyCollectionChangedを実装したとしても変更に対して即時連動しません(参照時反映)が、 後者では即時連動します。敢えて、HierarchyWrapperクラスにてReadOnlyなコレクションでラップしています。
HierarchyWrapper.cs

private protected virtual IEnumerable<TSrc>? getSourceChildren {
    get {
        var src = this.SourceChildren;
        if (src is INotifyCollectionChanged) return src.AsReadOnly();
        return src;
    }
}

BindableHierarchyWrapper.cs

private protected override IEnumerable<TSrc>? getSourceChildren 
    => this.SourceChildren;

これは、もしソース子ノードコレクションがINotifyCollectionChangedを実装していた場合、購読の解除が必要になってしまうからです。
そもそも連動させる必要がない場合はイベントの購読をする必要もない、寧ろ連動させてしまったら使いにくくなると考えました。

現状のツリー構造を再現しておきたい(完全に連動してほしくない)場合は拡張メソッドConvert()。
参照する度に、その時のツリー構造を再現したい場合はHierarchyWrapperを継承したクラスを用意するか、拡張メソッドAsValuedTreeNode()(簡易的なラッパークラスReadonlyValuedTreeNode)の使用を推奨します。

Disposeによってソースの購読を解除するなどの必要がある、またはソースの構造と常に連動させたい場合はBindableHierarchyWrapperを継承して使用してください。

前述の通り子ノードラッパーコレクションは遅延評価であり参照時に初期化されます。
一度も参照されずにDispose処理が呼ばれた場合は、連動していない空の状態で初期化されてDisposeするのでコレクション要素の子ノードラッパーは初期化されません。
このとき内部では、参照する側(祖先または自身)は、される側(自身または子孫)のprivate protected bool IsImitatingプロパティをfalseに設定してから走査しています。

HierarchyWrapper.cs

private CombinableMirroredChildrenCollection<TWrpr>? _wrappers;
private protected CombinableMirroredChildrenCollection<TWrpr> InnerChildNodes {
    get {
        if(_wrappers is null) {
            var srccn = getSourceChildren;//ソースの子ノード
            _wrappers = new CombinableMirroredChildrenCollection<TWrpr>(
            
                //ソース子ノード→ラッパー子ノードへの変換と
                //現在連動状態かどうかを示す値を使用してImitableCollection初期化する
                (srccn ?? new ObservableCollection<TSrc>())
                    .ToImitable(GenerateChild, null, IsImitating),
                    
                //Childrenプロパティgetter内にて、SourceChildrenIsObservableプロパティに反映される値
                srccn is INotifyCollectionChanged,
                
                //子ノードラッパーが追加された時の処理
                SetupChildNode, 
                
                //子ノードラッパーが削除された時の処理
                HandleRemovedChildNode); 
        }
        return _wrappers;
    }
}
private IEnumerable<TWrpr>? _children;
public IEnumerable<TWrpr> Children {
    get {
        _children ??= SetupPublicChildCollection(InnerChildNodes);
		if (this.IsImitating && !InnerChildNodes.SourceChildrenIsObservable) {
            //強制的に反映させる
			InnerChildNodes.Imitate(); 
		}
        return _children;
    }
}
protected virtual IEnumerable<TWrpr> SetupPublicChildCollection(CombinableMirroredChildrenCollection<TWrpr> children)
    => children;

BindableHierarchyWrapper.cs

protected virtual void Dispose(bool disposing) {
    if (disposing) {
		var nd = this
			.Traverse(a => {
                //この走査でラッパーコレクションが初期化されるとき、非連動・空の状態とする
				a.IsImitating = false;
				return a.InnerChildNodes;
			}, (a, b, c) => c.AddHead(a).Concat(b))
            .Skip(1).Reverse().OfType<IDisposable>();
        foreach (var n in nd) n.Dispose();
		InnerChildNodes.Dispose();
    }
    isDisposed = true;
}

上記ソースコードにある通り、Childrenプロパティ参照時にInnerChildNodes.Imitate()を呼び出し、強制的に連動させています。前述したHierarchyWrapperの子ノードコレクションが参照時に更新されるのはこのためです。
BindableHierarcyWrapperにてソース側の子ノードコレクションがINotifyCollectionChangedを実装していない場合も同様の扱いになります。

また連動に伴い、ラッパーが削除された時の処理を差し込むためにHandleRemoveChildメソッドを用意しています。
BindableHierarchyWrapperでは子ノードラッパーが削除された時HandleRemoveChildメソッドを介して、子ノードラッパーのDisposeメソッドを呼び出すように指定しています。
削除後も参照を継続したい場合はここでインターセプトできます。
キャッシュとして保持しておきたい場合もHandleRemoveChildをオーバーライドし、再利用する場合は、合わせてGenerateChildメソッドのオーバーライドによって実現することができます。(ソースにnullを含む場合はnullのラッパーの管理や、子孫ノードのラッパーの重複防止に気を遣うかもしれませんが。)

SetupPublicChildCollectionのオーバーライドにて、子ノードラッパーコレクションのカスタマイズによってラッパーの扱いが変わってくるのですが、その話は後述します。

ラップすることが主目的である以上、使用場面はViewModelであることが多いと想定できます。その時、Modelとなる階層構造のコレクションとは別で、先頭または末尾に特定の要素を追加しておきたいとか、並び順や表示のOn-Offを指定したい、という場面もでてきます。

以上のような要望を満たすコレクションが必要だったので、名前空間Collectionsに定義しています。

Collections

要件をまとめます。
実装のために不可欠な要件を必須要件、カスタマイズ性向上が目的の要件を付帯要件と表記しました。

 No. 要件 内容 補足・例
1 必須 ソースコレクションの各要素を変換して連動する
2 必須 コレクションに対するDispose(購読解除)処理
3 必須 ソースコレクションに対する連動状態を変更できる 参照時の再評価。遅延評価に起因する、Dispose処理過程での初期化に対応。
4 必須 各要素の追加・削除時に処理を挟める 子要素に対する、追加時の設定・削除時のDispose処理
5 付帯 観測可能なコレクションを結合できる 固定ノードの設定
6 付帯 連動するコレクションに対してソートやフィルターを掛けられる ViewModelとしてのカスタマイズ性向上のため

UML4

各クラスを大別すると

  • 連動状態を指定できるImitableCollection
  • 連動を担うObservableMirrorCollectionと派生
  • 各要素のプロパティを監視するPropertyTrackingCollection

の3つになります。

最終的な成果物はCombinableMirroredChildrenCollectionとObservableFilterSortMirrorCollectionです。

連動状態を指定できるImitableCollection

拡張メソッドのToImitableにて取得できます。

型引数を1つとるImitableCollection<TDst>の型で使用されることになるかと思います。

非ジェネリクスクラスでは、連動の停止と再開を制御する抽象メンバーを定義した状態で、実装は派生先に委ねています。
ライブラリ内ではImitate()とDispose()しか使用していませんが、汎用性を考慮してPauseメソッドやClearAndPauseメソッドで連動を一時停止できます。

各抽象メンバーを実装しているのはImitableCollection<TSrc, TDst>で、連動の制御は後述するObservableMirrorCollectionを継承した、内部クラスSDPairCollectionが担っています。

ToImitableメソッドの引数isImitateにfalseを指定すると、IsImitatingプロパティはfalseとなり、連動されていない空の状態で初期化されます。
Pause()、ClearAndPause()はどちらも連動を停止しソースコレクションの購読を解除しますが、ClearAndPause()は全ての要素を削除するので、初期化時に渡したremovedActionが処理されます。

ImitableCollection<TDst>で必須要件2、3を満たします。

連動を担うObservableMirrorCollection

当ライブラリ内で並び替えのロジックは二つ記述しています。

一つ目はObservableMirrorCollectionのメンバー、ApplyCollectionChangeメソッドです。これは購読しているCollectionChangedイベントに反応して同様の処理を行います。
その過程で追加前の変換関数と削除後の処理関数を差し込みます。ClearメソッドによるコレクションのResetが飛んできても削除後の処理関数は各要素に対して処理されます。
ObservableMirrorCollection.ApplyCollectionChanged( ) #L82

protected virtual void ApplyCollectionChange(NotifyCollectionChangedEventArgs e) {
	switch (e.Action) {
	case NotifyCollectionChangedAction.Add:
		for (int i = 0; i < e.NewItems?.Count; i++) {
			var newItem = (T?)e.NewItems[i];
			int insertIndex = e.NewStartingIndex >= 0 ? e.NewStartingIndex + i : Items.Count;
			Items.Insert(insertIndex, _converter(newItem));
		}
		break;
	case NotifyCollectionChangedAction.Remove:
    
    // ( 中略 )
    
    case NotifyCollectionChangedAction.Reset:
    	var lst = _removedHandler != null ? Items.ToArray() : Array.Empty<U>();
    	Items.Clear();
    	foreach (var rm in lst)
    		_removedHandler?.Invoke(rm);
    	break;
    default:
    	throw new NotSupportedException($"Unknown collection change action: {e.Action}");
    }	
}

二つ目はListAlignerクラスのAlignByメソッドです。操作用のリストと操作関数を指定して初期化し、AlignByで渡されたコレクションと同じ並び順に丸っと並び替えます。
ListAligner.AlignBy #L86

public void AlignBy(IEnumerable<S> order) {
	if (!order.Any() && 0 < _editList.Count) { _clear(); return; }
	var orders = order.ToListScroller();
	orders.MoveForEach(odrCurItm => {
		if (_editList.Skip(orders.CurrentIndex).Any(a => _equality(odrCurItm, a))) {//editlist未編集範囲にodrCurItmに該当する要素が存在する場合
			//odrCurItmに該当する要素が、既に現在のindexにある
			if (_equality(odrCurItm, _editList[orders.CurrentIndex])) return;
			//現在のindex位置にある要素がordersに含まれている場合
			if (orders.HasNext(a => _equality(a, _editList[orders.CurrentIndex]))) {
            
				// ( 中略 )
                
				_remove(orders.CurrentIndex);
			}
			//editlist未編集範囲ある、odrCurItmに該当する要素のindexを取得
			var tgt = _editList.Skip(orders.CurrentIndex).Select((v, i) => new { v, i }).First(x => _equality(odrCurItm, x.v)).i + orders.CurrentIndex;
			_move(tgt, orders.CurrentIndex);
		} else {//editlist未編集範囲にodrCurItmに該当する要素が無い場合
			if (_editList.Count <= orders.CurrentIndex || orders.HasNext(a => _equality(a, _editList[orders.CurrentIndex]))) {
				_insert(orders.CurrentIndex, _convert(odrCurItm));//既にeditlistのindexをオーバーしている or index位置にある要素が後ろに来る
			} else {
				_replace(orders.CurrentIndex, _convert(odrCurItm));
			}
		}
	});
	for (int i = _editList.Count - 1; orders.Items.Count <= i; i--) { _remove(i); }
}

もし全くの同一要素が複数含まれていた場合、同一要素間で順序は保証されないので不安定ソートです。また、あらかじめ登録されている編集可能なコレクションを操作するので内部ソートとなっています。

ObservableMirrorCollection<T,U>はソースコレクション<T>に連動するコレクション<U>となっており、T型→U型への変換、T型とU型の同一性の比較方法の指定が必要です。コンストラクタ内でソースコレクションの変更通知を購読し、AlignByメソッドで丸っと並び替えます。

ややこしいですが、ソースコレクションを示すプロパティを仮想メソッドにしています。
protected virtual IEnumerable<T> SourceItems { get; }
C#では派生先でこのプロパティをオーバーライドした場合、基底クラスのコンストラクタ内で呼び出すとnullが返ってくるので購読・並び替えは行われません。
SDPairCollectionのように初期化時に連動開始が確定ではない場合はこの仕様が利用できました。同様に、後述する、観測・結合可能なコレクションObservableCombinableCollectionもオーバーライドしています。

標準ライブラリのReadOnlyObservableCollectionは観測対象のコレクションの購読解除方法が提供されておらず、観測対象の寿命に依存します。結果、観測対象より短いとメモリリークとなり得ます。これを回避するためIDisposableを実装しています。

ObservableMirrorCollection<T,U>は必須要件1、2、4を満たします。

ObservableMirrorCollection<T,U>はObservableMirrorCollection<T>に派生しており、ここでデフォルトとなるEqualityComparerを設定しています。

public class ObservableMirrorCollection<T>:ObservableMirrorCollection<T, T> {
	public ObservableMirrorCollection(
        IEnumerable<T> source, Action<T>? 
        addingAction = null, 
        Action<T>? removedAction = null, 
        IEqualityComparer<T>? equality = null)
		: base(source,
			  addingAction is null ? (x => x) : (x => {addingAction.Invoke(x); return x; }),
			  (x, y) => equality?.Equals(x, y) ?? Equality<T>.ValueOrReference.Equals(x, y),
			  removedAction) {
	}
}

比較は可能な限り同一かどうかを見ています。 例えIEquatableなどでオリジナルの同値性同一性を定義していても、並び順はできるだけ忠実に再現させたいので以下のような結果をとります。
両方null => true
両方値型:同型、同値 => true
両方参照型:同一インスタンス => true
それ以外 => false

ObservableMirrorCollection<T>を共通継承元としてObservableCombinableCollectionとObservableFilterSortMirrorCollectionが派生しています。

コレクションを結合するObservableCombinableCollection

INotifyCollectionChangedを実装しているコレクションを結合できます。実装していなくても追加はできますが変更は反映されません。
SourceItemsプロパティのオーバーライドにより基底クラスのコンストラクタ処理は無効です。

追加機序としては、まず追加されたコレクションは非連動状態のImitableCollectionでラップ、イベントを購読し内部変数に取り込みます。最後に連動状態とすることでコレクションの変更通知を受け取り、反映させています。
ObservableCombinableCollection.cs

bool attach(int index, IEnumerable<T> collection) {
	ThrowExceptionIfDisposed();
	if (_combines.Any(x => x.Item1 == collection)) return false;
	//keyとなるIEnumerableからImitableCollectionを生成
	var imit = collection.ToImitable(x => x, null, false);
	//imitのイベントを購読
	var lsnr = new EventListener<NotifyCollectionChangedEventHandler>(
		h => ((INotifyCollectionChanged)imit).CollectionChanged +=h,
		h=> ((INotifyCollectionChanged)imit).CollectionChanged -=h,
		(s, e) => changedAction(s,e));
	//除外時の処理
	var dsp = new DisposableObject(() => {
		imit.Dispose();
		lsnr.Dispose();
	});
	//keyとなるIEnumerable,imit,除外時の処理(IDisposable)をまとめて追加
	_combines.Insert(index, new Tuple<IEnumerable, ImitableCollection<T>, IDisposable>(collection, imit, dsp));

	imit.Imitate();//追加したコレクションを反映
	return true;
}

これで付帯要件5を満たします。

ラッパーの子ノードコレクションを内包するCombinableMirroredChildrenCollection

HierarcyWrapperにて子ノードコレクションを扱うCombinableMirroredChildrenCollectionはObservableCombinableCollectionを継承しています。 必須要件1,2,4を基底クラスにて満たしており、必須要件2,3を満たす子ノードコレクションを反映したImitableCollectionを取り込んだ状態で初期化されます。

CombinableMirroredChildrenCollectionの初期化メソッドで、追加処理(Parentの設定)と削除処理(Parentの解除とHandleRemovedChildメソッドの呼び出し)を指定しています。 Dispose処理もCombinableMirroredChildrenCollectionのDisposeメソッドを直接指定しています。

この設計により、SetupPublicChildCollectionのオーバーライドで、引数childrenに結合された要素と結合されていない要素で扱いが変わります。(寧ろこ振る舞いを実現したかったからこそ、ChildCollectionはMirrorCollectionからではなくCombinableCollectionから派生させました。)

例を示します。 BindableHierarchyWrapperクラスを継承したラッパーノードのSetupPublicChildCollectionメソッドをオーバーライドし、外部公開用コレクションをカスタマイズします。

ObservableCollection<SampleWrapper> dummyNodes = new();
ObservableCollection<SampleWrapper> optionNodes = new();

//children:ソース子ノードコレクションを結合可能な状態で引数にとる
protected override IEnumerable<SampleWrapper> SetupPublicChildCollection(CombinableMirroredChildrenCollection<SampleWrapper> children){
    //childrenにdummyNodesを結合
    children.AppendCollection(dummyNodes); 
    //children : [child1,child2,...,dummy1,dummy2,...]
    
    //結合後のchildrenにフィルターを掛けたelementListを生成
    var elementList = children.ToReadOnlyObservableFilterSort();
    elementList.FilterBy(x=>x.Status.IsActive); 
    //elementList : [child1,child4,...,dummy2,dummy5,...]

    //新たな結合可能コレクションdisplayListを生成してoptionNodesとelementListを結合
    var displayList = new ObservableCombinableCollection();
    displayList.AppendCollection(optionNodes);
    displayList.AppendCollection(elementList);
    //displayList : [opt1,opt2,...,child1,child4,...,dummy2,dummy5,...]

    return displayList;
}

上記コードでは、dummyNodesは子ノードとして取り込まれ子ノードと同様に扱いますが、optionNodesは取り込まれていません。
フィルターにより除外された要素[child2,child3,dummy1,dummy3,..]は親ノードを保持していますが親ノードから見て子ノードとして列挙されません(ITreeNode.Childrenプロパティに含まれない)。内部的には子ノードに含まれるので、ソース子ノードコレクション連動による追加・削除に伴う処理や当ノードDispose時の処理は実行されます。
要素[opt1,opt2]はChildrenプロパティには含まれるので、対外的には子ノードとして列挙されますが、optionNodesコレクション連動による追加・削除に伴う処理や当ノードDispose時の処理は実行されません。

意図としては、

  • dummyNodes : まだ保存されてない・特定の処理がされていないなどの、暫定的な要素。処理過程の理由などで、表面上はツリーに所属しているが内部的には所属していない要素。
  • optionNodes : 対象ノードのステータス表示や新規追加メニュー。視覚的な理由でツリーに所属している要素。

といったような使い分けを意識しています。

蛇足になるかもしれませんが、ここでoptionNodesも同様の処理をできるか考えてみます。

まず、Parentプロパティの設定については、設定メソッドにアクセスができないので対応不可です。

削除時の処理については以下のように追記することで、HandleRemovedChildメソッドを呼び出し、他の要素同様の処理をすることができます。

ObservableCollection<SampleWrapper> dummyNodes = new();
ObservableCollection<SampleWrapper> optionNodes = new();

protected override IEnumerable<SampleWrapper> SetupPublicChildCollection(CombinableMirroredChildrenCollection<SampleWrapper> children){
    children.AppendCollection(dummyNodes); 
    
    var elementList = children.ToReadOnlyObservable();
    elementList.FilterBy(x=>x.Status.IsActive); 
    
    var displayList = new ObservableCombinableCollection();
    displayList.AppendCollection(optionNodes);
    displayList.AppendCollection(elementList);

    //以下の1行を追加
    optionNodes.AddRemoveObserver().Removed(x => this.HandleRemoveChild(x));
    
    return displayList;
}

当ノード破棄時のDispose処理にはDisposeメソッドをオーバーライドし処理を差し込むことで対処できます。

protected override void Dispose(bool disposing){
    if(disposing){
        foreach(var opt in optionNodes.OfType<IDisposable>()) opt.Dispose();
    }
    base.Dispose(disposing);
}

これらを踏まえると以下の表になります。

コレクション Parentの設定・解除 走査 削除時の処理 Dispose時
child1,child2,.. 〇 祖先子孫方向の走査が正常 〇 〇
dummy1,dummy2,.. 〇 祖先子孫方向の走査が正常 〇 〇
opt1,opt2,.. × 子孫方向のみ正常。祖先方向はnull ×(対処可能) ×(対処可能)

フィルターとソート機能を持つObservableFilterSortMirrorCollection

ObservableMirrorCollectionにフィルターとソート機能を持たせたコレクションです。要素のプロパティを指定して、その値の変更によって即時にフィルターやソートが適用されます。
要素のプロパティ値もINotifyPropertyChangedを実装していればネストして指定できます。

//Collection of active elements only
list.FilterProperty(x => x.Option.IsActive);
//Collection of active elements with points less than 30
list.FilterBy(x => x.Point < 30 && x.Option.IsActive, x=>x.Point, x=>x.Option.IsActive);

このコレクションでラップすることにより付帯要件6を満たせます。

要素のプロパティを監視するPropertyTrackingCollection

ObservableFilterSortMirrorCollectionを作るにあたり

  1. コレクション要素の追加削除と同時に合わせて、プロパティ更通知を購読・解除
  2. プロパティ値がINotifyPropertyChangedを実装していれば、ネストして指定できる
  3. 変更されたプロパティ名を識別できる

以上の要件が必要になります。

1の機能を担うのがPropertyTrackingCollectionです。 2,3はObservedPropertyTreeクラスのインスタンスが担います。(後述)

内部では主に以下のフィールド変数を扱います。

//対象となるコレクションに連動する、各要素を観測するインスタンス
ObservableMirrorCollection<T, ObservedPropertyTree<T>> _trees;

//1次元方向にList
//2次元方向にプロパティ名をキーとするDictionary
//3次元方向に観測するインスタンスをキー、プロパティ変更通知の購読を解除する関数を値とするDictionary
List<
    Dictionary<
        string, 
        Dictionary<
            ObservedPropertyTree<T>, 
            IDisposable>>> _trackingDics;

変数trackingDicsは新規TrackingListを追加すると1次元方向に、そのリストに観測プロパティを追加すると2次元方向に、対象となるコレクションが追加されると3次元方向に伸びます。

1次元方向、TrackingPropertyListへの追加はCreateTrackingListメソッドで処理します。

public TrackingPropertyList<T> CreateTrackingList() {
	var dic = new Dictionary<string, Dictionary<ObservedPropertyTree<T>, IDisposable>>();
	_trackingDics.Add(dic);
	return new TrackingPropertyList<T>(this, dic, addExpressions, removeExpressions, clearExpressions, dispExpressions);
}

2次元方向への観測プロパティの追加削除はTrackingPropertyList<T>を介して提供しています。

void addExpressions(Dictionary<string, Dictionary<ObservedPropertyTree<T>, IDisposable>> exprDic, IEnumerable<Expression<Func<T, object>>> exps) {
	ThrowExceptionIfDisposed();
	foreach (var key in exps) {
		string keyname = string.Join(".", PropertyUtils.GetPropertyPath(key));
		if (exprDic.ContainsKey(keyname)) continue;
		var optrees = new Dictionary<ObservedPropertyTree<T>, IDisposable>();
		foreach (var trr in _trees) {
            //2次元方向に追加されたプロパティ名に対して、
            //3次元方向に、対象コレクションに対応する観測インスタンスとその解除関数を追加
            optrees.Add(trr, trr.Subscribe(key, this.handleItemPropertyChanged));
        }
		exprDic[keyname] = optrees;
	}
}

3次元方向への処理は、変数treesで対象となるコレクションの変更に連動して追加削除時に処理を挟みます。

_trees = new ObservableMirrorCollection<T, ObservedPropertyTree<T>>(
	items,
	addedItem => {//追加時の処理
		var opt = new ObservedPropertyTree<T>(addedItem);
		foreach (var exprDic in _trackingDics) {
			foreach (var expr in exprDic.Keys) {
                //全てのTrackingList・観測プロパティに対して、3次元方向に追加
				var sbsc = opt.Subscribe(PropertyUtils.CreatePropertyExpression<T>(expr), handleItemPropertyChanged);
				exprDic[expr][opt] = sbsc;
			}
		}
		return opt;
	},
	(itm, tree) => Equality.ValueOrReference.Equals(itm, tree.Root.Source),
	removedOpt => {//削除時の処理
		foreach (var exprDic in _trackingDics) {
			foreach (var expr in exprDic.Keys) {
                //全てのTrackingList・観測プロパティに対して、3次元方向に削除
				ResultWith<IDisposable>.Of(exprDic[expr].Remove, removedOpt).When(o => o.Dispose());
			}
		}
		removedOpt.Dispose();
	}
);

指定したプロパティを監視するObservedPropertyTree

上記PropertyTrackingCollectionの実装にあたり、ネストを含めて指定されたプロパティを監視する必要があります。
その役割を担うため、ObservedPropertyTreeを定義しました。

UML6

対象となるインスタンスに対してプロパティ変更通知を購読します。プロパティ値がINotifyPropertyChangedを実装している場合は更にそのプロパティを...といった感じに購読できます。

観測しているプロパティごとにPropertyChainNodeが生成され、プロパティ変更通知の購読・解除によって追加・削除されます。

ライブラリ:ReactivePropertyのObservePropertyメソッドと似たような機能です。
このクラスの代替となり得ますが、なるべく他のライブラリとの依存関係を減らしたいので、廃止するつもりはありません。

ObservePropertyメソッドとの違いは以下です。

  • 変更があったプロパティに至るまでの、各プロパティ名を取得できる
  • 現在の購読されているプロパティ名とその値を取得できる
  • ソースオブジェクトから複数のネストしたプロパティを購読する場合、共通の祖先プロパティのリスナーを共有する
  • ソースオブジェクトを差し替えることができる

NotifyObjectはライブラリ:ReactivePropertyと併用するときに使いやすいようにと作ったのですが、ObservePropertyメソッドにネストしたプロパティを指定できるので不要かと思います。勉強不足でした。廃止を考えています。

Clone this wiki locally