Skip to content

Tutorial5.ja

houzkin edited this page Nov 10, 2026 · 3 revisions

ユーティリティ

当ライブラリ制作にあたり必要となったもの、当ライブラリを使用する上で便利なツールを紹介します。

ResultWithValue

Tryメソッドをより使いやすくするため、ResultWithValueを定義しています。
ResultWithValue.cs

public struct ResultWithValue<TValue>{
    public bool Result{get;}
    public TValue Valule{get;}

    public ResultWithValue<TValue> When(Action<TValue>? caseTrue = null, Action<TValue>? caseFalse = null){}
    public TOutput When<TOutput>(Func<TValue, TOutput> caseTrue, Func<TValue, TOutput> caseFalse) {}

    public ResultWithValue<TValue> EitherWay(Action<TValue> resultAction) {}
    public TOutput EitherWay<TOutput>(Func<TValue, TOutput> resultFunc) {}

    public static implicit operator Boolean(ResultWithValue<TValue> rwv){}
}

これを使用を用いて、次のような記述が可能となります。

treenodeA.TryAddChild(nodeX).When(
    o => o.TryRemoveChild(nodeY),
    x => treenodeB.TryAddChild(x)
);

treenodeC.TryRemoveOwn().When(o => list.Add(o));

また、以下のデリゲートとstatic methodを使うことで、従来のTryメソッドに対しても使用できます。
ResultWithValue_Extensions.cs

public delegate bool TryCallback<in TInput, TValue>(TInput input, [MaybeNullWhen(false)] out TValue value);

public delegate bool TryCallback<TValue>([MaybeNullWhen(false)] out TValue value);

public static class ResultWith<TValue>{

    public static ResultWithValue<TValue> Of<TInput>(TryCallback<TInput,TValue> tryMethod,TInput input){}
    
    public static ResultWithValue<TValue> Of<TValue>(TryCallback<TValue> tryMethod){}
}

DictionaryのTryGetValueメソッド、StackのTryPopメソッドに対して使用した例を示します。

var dic = new Dictionary<string,ItemObj>();
ResultWith<ItemObj>.Of(dic.TryGetValue,"key").When(
    o => { },
    x => { },
)
var stack = new Stack<ItemObj>();
ResultWith<ItemObj>.Of(stack.TryPop).When(
    o => { },
    x => { },
);

UniqueOperatorExcuter

指定した処理の再帰的な呼び出し、或いは重複を防止するためのクラスです。
UniqueOperationExecutor.cs

public class UniqueOperationExecutor{

    public void Register(string key, Action action){ }

    public IDisposable ExecuteUnique(string key){ }

    public IDisposable LateEvalute<TProp>(string key, Func<TProp> getPropertyValue){ }

    public IDisposable ExecuteUnique(Action operation){ }
}

Registerメソッドでキーとそれに対応する処理を設定します。
メソッドの戻り値であるIDisposableを破棄することで、最後のIDisposableが破棄された時に処理が実行されます。

LateEvaluateメソッドは、最初に呼び出された時と最後のIDisposableが破棄された時で、関数getPropertyValueの値が異なっていた場合のみ実行されます。

また、事前に登録が不要なメソッドとしてExecuteUnique(Action operation)メソッドも用意しています。
キーの設定は必要ありませんが、代わりにoperation.Method.MetadataTokenの値によって判別します。

次のコードで、Registerメソッドを使用してタイマーを走らせます。

var uniExecutor = new UniqueOperationExecutor();

var sw = new Stopwatch();
Action displayElapsedTime = () => {
    Console.WriteLine($"Time {sw.Elapsed.Seconds}.{sw.Elapsed.Milliseconds}(sec)");
};
uniExecutor.Register("keyA", displayElapsedTime);

sw.Start();

var t1 = Task.Run(() => {
    var exe = uniExecutor.ExecuteUnique("keyA");
    Thread.Sleep(1000);
    exe.Dispose();
});
var t2 = Task.Run(() => {
    Thread.Sleep(800);
    var exe = uniExecutor.ExecuteUnique("keyA");
    Thread.Sleep(800);
    exe.Dispose();
});
var t3 = Task.Run(() => {
    var exe = uniExecutor.ExecuteUnique("keyA");
    Thread.Sleep(500);
    exe .Dispose();
});
var t4 = Task.Run(() => {
    Thread.Sleep(2000);
    var exe = uniExecutor.ExecuteUnique("keyA");
    Thread .Sleep(500);
    exe .Dispose();
});

Task.WaitAll(t1, t2, t3, t4);
//Time 1.621(sec)
//Time 2.537(sec)

t1,t2,t3は重なるため、重なりが途切れた時に実行されています。

各ノードのDepth()やHeight()が絡む処理のように、 変更の前後を比較して、差異があった時だけ指定した処理を実行したい場合は、 LateEvaluateメソッドを使用してください。
次のコードで、LateEvaluateメソッドを使用しLevelプロパティの変更通知を発行します。

public class NotifyLevelChangeNode 
    : ObservableGeneralTreeNode<NotifyLevelChangeNode> {

	UniqueOperationExecutor UniOperator = new UniqueOperationExecutor();
	IDisposable reporter;

	public NotifyLevelChangeNode() {
		//Register action with key
		UniOperator.Register(nameof(Level), () => Properties.Notify(nameof(Level)));
		//Set initial status
		reporter = CreateNewReporter();

		this.StructureChanged += (s, e) => {
			if (e.IsAncestorChanged) {
				//Evaluate whether level changed
				reporter.Dispose();
				//Reset status
				reporter = CreateNewReporter();
			}
		};
	}
	IDisposable CreateNewReporter() => UniOperator.LateEvaluate(nameof(Level), () => Level);
	public int Level => this.Depth();
	public string Name { get; set; }
}

次のコードで、Levelプロパティ変更通知を購読します。

var dic = "ABCDE".ToCharArray().Select(x => x.ToString()).ToDictionary(x => x, x => new NotifyLevelChangeNode() { Name = x });
dic.Values.AssembleAsNAryTree(2);
Console.WriteLine(dic["A"].ToTreeDiagram(x => $"{x.Name}, Level:{x.Level}"));
/*
A, Level:0
├ B, Level:1
│ ├ D, Level:2
│ └ E, Level:2
└ C, Level:1
*/

foreach(var node in dic.Values) {
    node.PropertyChanged += (s, e) => {
        if(e.PropertyName == "Level" && s is NotifyLevelChangeNode nd) {
            Console.WriteLine($"{nd.Name}, Level:{nd.Level}");
        }
    };
}
dic["A"].AddChild(dic["D"]);
// D, Level:1
dic["C"].AddChild(dic["E"]);
//

Console.WriteLine(dic["A"].ToTreeDiagram(x => $"{x.Name}, Level:{x.Level}"));
/*
A, Level:0
├ B, Level:1
├ C, Level:1
│ └ E, Level:2
└ D, Level:1
*/

EventListener

イベントの購読と解除をサポートします。

次のコードで、nodeA.PropertyChangedとnodeA.StructureChangedを購読し、ツリー構造を組立てます。

var nodeA = new ObservableNamedNode() { Name ="A" };

var listener1 = new EventListener<PropertyChangedEventHandler>(
    h => nodeA.PropertyChanged += h,
    h => nodeA.PropertyChanged -= h,
    (s, e) => Console.WriteLine($"sender:{s}, Property handler1: {e.PropertyName}"));

var listener2 = new EventListener<EventHandler<StructureChangedEventArgs<ObservableNamedNode>>>(
    h => nodeA.StructureChanged += h,
    h => nodeA.StructureChanged -= h,
    (s, e) => Console.WriteLine($"sender:{s}, Structure handler: {e.TreeAction}"));

var listener3 = new EventListener<EventHandler<StructureChangedEventArgs<ObservableNamedNode>>, PropertyChangedEventArgs>(
    h => nodeA.StructureChanged += h,
    h => nodeA.StructureChanged -= h,
    ph => (s, e) => {
        if (e.IsAncestorChanged) ph(s, new PropertyChangedEventArgs("Ancestor"));
        if (e.IsDescendantChanged) ph(s, new PropertyChangedEventArgs("Descendant"));
    },
    propHandler);

void propHandler(object? sender, PropertyChangedEventArgs e) {
    Console.WriteLine($"sender:{sender}, Structure -> Property handler: {e.PropertyName}");
}

nodeA.AddChild(new ObservableNamedNode() { Name = "B" });
/*
sender:A, Structure handler: Join
sender:A, Structure -> Property handler: Descendant
*/

var nodeS = new ObservableNamedNode() { Name = "S" }.AddChild(nodeA);
/*
sender:A, Property handler1: Parent
sender:A, Structure handler: Join
sender:A, Structure -> Property handler: Ancestor
*/

nodeS.AddChild(new ObservableNamedNode() { Name = "C"});
/*
sender:A, Structure handler: Join
*/
var disposables = new ReusableCompositeDisposable(listener1, listener2, listener3);
disposables.ClearAndDispose();//Unsubscribe

nodeS.Disassemble();
//

listener3は、StructureChangedイベントを購読してNotifyPropertyChanged用のハンドラーを呼び出しています。
EventListenerはIDisposableを実装しており、破棄によって購読を解除します。

PropertyAccessor

INotifyPropertyChangedインターフェイスの実装を補助することが目的のクラスです。
PropertyAccessor.cs

public class PropertyAccessor {
	public PropertyAccessor(object? owner, Func<PropertyChangedEventHandler?> handlerGetter) { }

	public PropertyAccessor(object? owner, Action<PropertyChangedEventArgs> raiseAction) { }

	public T GetValue<T>(T initialValue = default, [CallerMemberName] string? propertyName = null) { }

	public ResultWithValue<PropertyAccessor> TrySetValue<T>(T value, [CallerMemberName] string? propertyName = null) { }

	public ResultWithValue<PropertyAccessor> TrySetField<T>(ref T storage, T value, [CallerMemberName] string? propertyName = null) { }

	public PropertyAccessor Notify([CallerMemberName] string? propertyName = null) { }

	public static PropertyChangedEventArgs GetOrAddCachedEventArgs(string name){ }
}

TryGetValueとTrySetValueを使用して、フィールド変数を省略できます。
フィールド変数を使用する場合はTrySetFieldメソッド使用してください。

イベント引数はstatic fieldでキャッシュとして保持し、インスタンスの生成を抑えます。
キャッシュの保持にはConcurrentDictionaryを使用しておりスレッドセーフです。

コンストラクタを二つ公開しています。
最小限のコードでINotifyPropertyChangedを実装するためには、
PropertyAccessor(object, Func<PropertyChangedEventHandler?>)を使用します。

public class NotifyObjA : INotifyPropertyChanged {
	public NotifyObjA() {
		Properties = new PropertyAccessor(this, () => PropertyChanged);
	}
	protected PropertyAccessor Properties { get; }
	public event PropertyChangedEventHandler? PropertyChanged;
}

public class NotifyObjAA : NotifyObjA {
	public string FirstName {
		get => Properties.GetValue<string>();
		set => Properties.TrySetValue(value)
			.When(o => o.Notify(nameof(FullName)));
	}
	public string LastName {
		get => Properties.GetValue<string>();
		set => Properties.TrySetValue(value)
			.When(o => o.Notify(nameof(FullName)));
	}
	public string FullName => FirstName + " " + LastName;

	public int Age {
		get => Properties.GetValue(0);
		set => Properties.TrySetValue(value);
	}
}
var objA = new NotifyObjAA() { FirstName = "Leonardo", LastName = "da Vinci" };
Console.WriteLine(objA.FullName);
//Leonardo da Vinci

objA.PropertyChanged += (s, e) => {
    if(e.PropertyName == "FullName")
        Console.WriteLine($"{(s as NotifyObjAA)?.FullName}");
};
objA.LastName = "DiCaprio";
//Leonardo DiCaprio

派生先でChangedイベントやRaiseEventメソッドのオーバーライドを考慮して実装するには、 PropertyAccessor(object, Action<PropertyChangedEventArgs>)を使用します。

public class NotifyObjB : INotifyPropertyChanged {
	public NotifyObjB() {
		Properties = new PropertyAccessor(this, RaisePropertyChangedEvent);
	}
	protected PropertyAccessor Properties { get; }
	protected virtual void RaisePropertyChangedEvent(PropertyChangedEventArgs e) {
		PropertyChanged?.Invoke(this, e);
	}
	public virtual event PropertyChangedEventHandler? PropertyChanged;
}

public class NotifyObjBB : NotifyObjB {
	string _firstName = "";
	string _lastName = "";
	public NotifyObjBB(string firstname, string lastname) {
		_firstName = firstname;
		_lastName = lastname;
	}
	public string FirstName {
		get => _firstName;
		set => Properties.TrySetField(ref _firstName, value)
			.When(o => o.Notify(nameof(FullName)));
	}
	public string LastName {
		get => _lastName;
		set => Properties.TrySetField(ref _lastName, value)
			.When(o => o.Notify(nameof(FullName)));
	}
	public string FullName => FirstName + " " + LastName;

	protected override void RaisePropertyChangedEvent(PropertyChangedEventArgs e) {
		Console.WriteLine($"Raise Event: {e.PropertyName}");
		base.RaisePropertyChangedEvent(e);
	}
	public override event PropertyChangedEventHandler? PropertyChanged {
		add {
			base.PropertyChanged += value;
			Console.WriteLine("Handler added.");
		}
		remove {
			base.PropertyChanged -= value;
			Console.WriteLine("Handler removed.");
		}
	}
}
var objB = new NotifyObjBB("Matt", "Reeves");
Console.WriteLine(objA.FullName);
//Matt Reeves

objB.PropertyChanged += (s, e) => {
    if (e.PropertyName == "FullName")
        Console.WriteLine($"{(s as NotifyObjBB)?.FullName}");
};
//Handler added

objB.FirstName = "Keanu";
/*
Raise Event: FirstName
Raise Event: FullName
Keanu Reeves
*/

EqualityComparer

ObservableMirrorCollection<T>、ObservableFilterSortMirrorCollectionの初期化メソッドでIEqualityComparer指定しなかった場合や、ImitableCollectionの内部などでは、以下のEquality<T>.ValueOrReferenceが使用されます。
String型やHierarchyWrapperのようにIEquatable<T>を実装していても、参照型であるならば同一性の比較を強制します。
Equality.cs

public static class Equality {
	/// <summary>Returns a comparer that compares by value if the type is a value type, and by reference if the type is a reference type. </summary>
	public static IEqualityComparer ValueOrReference { get; }
}
public static class Equality<T> {
	/// <summary>Selects the key for performing equality comparison.</summary>
	public static EqualityComparer<T> ComparerBy<TKey>(Func<T, TKey> selector, IEqualityComparer<TKey>? keyComparer = null) { }

	/// <summary>Returns a comparer that compares by value if T is a value type, and by reference if T is a reference type.</summary>
	public static EqualityComparer<T> ValueOrReference { get; } 
}

Comparer

Comparerの結果を反転します。
Comparer.cs

public class InvertibleComparer<T> : Comparer<T> {
	/// <summary>Inverts the comparison result. </summary>
	public InvertibleComparer<T> Invert() { }
}
public static class ComparerExtensions {
	/// <summary>Inverts the comparison result.</summary>
	public static InvertibleComparer<T> Invert<T>(this IComparer<T> self) { }
}

ReadOnlyObservableFilterSortCollectionの利便性向上のために定義しました。

var lst = new List<string> { "Alvin", "Ben", "Carl", "Daniel", };
var cmpr = Comparer<string>.Create((x, y) => x.Length - y.Length);

var pxyLst = lst.ToObservableFilterSortMirror();

pxyLst.SortBy(x => x, cmpr);
Console.WriteLine(string.Join (", ", pxyLst));
////Ben, Carl, Alvin, Daniel

pxyLst.SortBy(x => x, cmpr.Invert());
Console.WriteLine(string.Join (", ", pxyLst));
////Daniel, Alvin, Carl, Ben

ReusableCompositeDisposable

複数のIDisposableを一括して破棄できるようにまとめます。
ReusableCompositeDisposable.cs

public class ReusableCompositeDisposable : IEnumerable<IDisposable>, IDisposable {

    public ReusableCompositeDisposable(IEnumerable<IDisposable> disposables) { }

    public ReusableCompositeDisposable(params IDisposable[] disposables) { }

    public ReusableCompositeDisposable() { }

    public void ClearAndDispose() { }

    public void Add(IDisposable disposable) { }

    public void Remove(IEnumerable<IDisposable> disp){ }
}

public static class EnumerableExtensions{

	public static IDisposable CombineDisposables<T>(this IEnumerable<T> enumerable) { }

	public static IDisposable CombineDisposablesAndSelf<T>(this T disposable) 
		where T : IEnumerable<IDisposable>, IDisposable { }
}

ObservableMirrorCollectionを扱うときのように、各要素の破棄とコレクションの購読解除を同時に行う場合はCombineDisposablesAndSelf()を使用できます。

参照:Tutorial6 #ObservableMirrorCollection

Clone this wiki locally