Skip to content

Tutorial6.ja

houzkin edited this page Nov 14, 2026 · 3 revisions

コレクション

当ライブラリ制作にあたり必要となったコレクションを紹介します。

ObservableMirrorCollection

ソースコレクション<T>の各要素に対応する<U>型へ変換し、コレクション<U>として振舞う代理コレクションです。
追加・削除などソースコレクションの変更が反映され、対応する要素が連動します。
コンストラクタで指定したIEnumerable<T> sourceがINotifyCollectionChangedを実装していなかった場合、 追加・削除などの変更は反映されません。

public interface IObservableMirrorCollection<T> 
    : IReadOnlyList<T>, 
    INotifyCollectionChanged,
    INotifyPropertyChanged, 
    IDisposable {
}

public class ObservableMirrorCollection<T, U> 
    : ReadOnlyObservableCollection<U>, IObservableMirrorCollection<U> {

    public ObservableMirrorCollection(
        IEnumerable<T> source, 
        Func<T, U> convert, 
        Func<T, U, bool> equality, 
        Action<U>? removedHandler = null) { }
}

public class ObservableMirrorCollection<T> 
    : ObservableMirrorCollection<T, T> {

    public ObservableMirrorCollection(
        IEnumerable<T> source, 
        Action<T>? addingAction = null, 
        Action<T>? removedAction = null, 
        IEqualityComparer<T>? equality = null) { }
}

public static class EnumerableExtensions{
    public static ObservableMirrorCollection<U> ToObservableMirror<T,U>(
		this IEnumerable<T> self, Func<T,U> convert, Func<T,U,bool> equality, Action<U>? removedHandler = null) { }

    public static ObservableMirrorCollection<T> ToObservableMirror<T>(
		this IEnumerable<T> self) { }
}

使用例を示します。

var srcList = new ObservableCollection<char>("ABCDEFG".ToCharArray());
var mrrList = new ObservableMirrorCollection<char, string>(
    srcList, 
    x => x.ToString().ToLower(), 
    (chr, str) => chr.ToString().ToLower() == str);

Console.WriteLine($"source:{string.Join(",", srcList)}");
//source:A,B,C,D,E,F,G
Console.WriteLine($"mirror:{string.Join(",", mrrList)}");
//mirror:a,b,c,d,e,f,g

srcList.Add('X');
srcList.Move(1, 0);
srcList.Remove('F');

Console.WriteLine($"source:{string.Join(",", srcList)}");
//source:B,A,C,D,E,G,X
Console.WriteLine($"mirror:{string.Join(",", mrrList)}");
//mirror:b,a,c,d,e,g,x

//Unsubscribe from the collection change notifications
mrrList.Dispose();

ObservableMirrorCollection<char,string>は、IEnumerable<string>型として使用できます。

使用後はイベント購読解除のため破棄してください。
この時、各要素は削除されません。よって、removedActionで指定した処理は実行されません。
破棄が必要な要素に変換していた場合は、別途、各要素に対して破棄処理を行ってください。

var srcList = new ObservableCollection<char>("ABCDE".ToCharArray());

var proxy1 = srcList.ToObservableMirror(
	x => x.ToString(),
	(chr, str) => chr.ToString() == str, 
	rm => Console.WriteLine($"{rm} removed."));

srcList.Remove('A');
//A removed

//Unsubscribe from the collection change notifications
proxy1.Dispose();
//

var proxy2 = srcList.ToObservableMirror(
	x => new DisposableNamedObj() { Name = x.ToString() },
	(s, d) => s.ToString() == d.Name,
	d => d.Dispose());

srcList.Remove('B');
//B Dispose

proxy2.CombineDisposables().Dispose();
/*
C Dispose
D Dispose
E Dispose
*/

//Unsubscribe from the collection change notifications
proxy2.Dispose();
//

拡張メソッドCombineDisposablesAndSelf()を使用して、各要素の破棄とソースコレクションの購読解除を同時に行えます。

var srcList = new ObservableCollection<char>("ABC".ToCharArray());

var proxy3 = srcList.ToObservableMirror(
    chr => new DisposableNamedObj() { Name = chr.ToString() },
    (chr, obj) => chr.ToString() == obj.Name,
    obj => obj.Dispose());

srcList.Remove('A');
//A Dispose

//Dispose each elements and Unsubscribe from the collection change notifications
proxy3.CombineDisposablesAndSelf().Dispose();
//B Dispose
//C Dispose

srcList.Add('D');
//

ObservableFilterSortMirrorCollection

ObservableMirrorCollectionにフィルターとソート機能を追加したコレクションです。

public class ObservableFilterSortMirrorCollection<T> : ObservableMirrorCollection<T>{
	//constructor
	public ObservableFilterSortMirrorCollection(IEnumerable<T> source, IEqualityComparer<T>? equality = null){ }

	public void FilterBy(Func<T, bool> filterFunc, Expression<Func<T, object>> triggerProperty, params Expression<Func<T, object>>[] triggerProperties);
	public void FilterBy(Func<T, bool> filterFunc);

	public void FilterProperty(Expression<Func<T,bool>> filterProperty);

	public void ClearFilter();

	public void SortBy<TKey>(Func<T, TKey> getComparerKey, Expression<Func<T, object>> triggerProperty, params Expression<Func<T, object>>[] triggerProperties) 
		where TKey : IComparable<TKey>;
	public void SortBy<TKey>(Func<T, TKey> getComparerKey, IComparer<TKey>? keyComparer = null, params Expression<Func<T, object>>[] triggerProperties);

	public void SortProperty<TKey>(Expression<Func<T, TKey>> keyProperty, IComparer<TKey>? keyComparer = null);

	public void ClearSort();
}

FilterBy、SortByで指定した関数を使用してフィルターやソートを適用します。
コレクションの要素がINotifyPropertyChangedを実装している場合、Expression式で指定した各要素のプロパティの変更によって再評価されます。
可変長引数で指定することで、複数のプロパティ変更通知に反応できます。
プロパティの指定はx=>x.Property1.Property2.Valueのようにネストして指定することもできます。 このとき、Property1とProperty2の値はINotifyPropertyChangedを実装している必要があります。

次のコードで、ソースコレクションに対してフィルターとソートを掛けます。

var rmd = new Random();
var srcList = new ObservableCollection<int>(Enumerable.Range(0,5).Select(x=> rmd.Next(100)));
var mrrList = srcList.ToObservableFilterSortMirror();

Console.WriteLine($"source:{string.Join(",", srcList)}");
Console.WriteLine($"mirror:{string.Join(",", mrrList)}");
//source:92,32,90,13,83
//mirror:92,32,90,13,83

mrrList.SortBy(x => x);
Console.WriteLine($"mirror:{string.Join(",", mrrList)}");
//mirror:13,32,83,90,92

mrrList.FilterBy(x => 30 < x);
Console.WriteLine($"mirror:{string.Join(",", mrrList)}");
//mirror:32,83,90,92


srcList.Add(rmd.Next(100));//add element
Console.WriteLine($"mirror:{string.Join(",", mrrList)}");
//mirror:31,32,83,90,92

mrrList.ClearSorts();
Console.WriteLine($"mirror:{string.Join(",", mrrList)}");
//mirror:92,32,90,83,31

mrrList.ClearFilter();
Console.WriteLine($"mirror:{string.Join(",", mrrList)}");
//mirror:92,32,90,13,83,31

// after use
mrrList.Dispose();

次のコードで、要素のプロパティを使用してフィルターを掛けます。

public class ItemData : NotifyObjA {

	public string Name {
		get => Properties.GetValue("No name");
		set => Properties.TrySetValue(value);
	}	
	public int Number {
		get => Properties.GetValue(0);
		set => Properties.TrySetValue(value);
	}
	public bool IsActive {
		get => Properties.GetValue<bool>();
		set => Properties.TrySetValue(value);
	}
	public override string ToString() {
		return $"Name:{this.Name}, Number:{Number}, IsActive:{IsActive}";
	}
}
var srcList = new ObservableCollection<ItemData>() {
	new ItemData(){ Name = "Alice", Number = 50, IsActive = true },
	new ItemData(){ Name = "Bob", Number = 30, IsActive = true },
	new ItemData(){ Name = "Charlie", Number = 25, IsActive = false },
	new ItemData(){Name = "Diana", Number = 42, IsActive = true},
	new ItemData(){Name = "Eve", Number = 28, IsActive = false},
	new ItemData(){Name = "Frank", Number = 35, IsActive = true},
	new ItemData(){Name = "Grace", Number = 22, IsActive = false},
	new ItemData(){Name = "Hank", Number = 60, IsActive = true},
	new ItemData(){Name = "Ivy", Number = 33, IsActive = false}
};

var mrrList = srcList.ToObservableFilterSortMirror();
mrrList.FilterBy(x => x.IsActive && 30 < x.Number, x=>x.IsActive,x=>x.Number);
foreach(var p in mrrList) {
	Console.WriteLine(p);
}
/*
Name:Alice, Number:50, IsActive:True
Name:Diana, Number:42, IsActive:True
Name:Frank, Number:35, IsActive:True
Name:Hank, Number:60, IsActive:True
*/

srcList.First(x => x.Name == "Alice").IsActive = false;
foreach(var p in mrrList) {
	Console.WriteLine(p);
}
/*
Name:Diana, Number:42, IsActive:True
Name:Frank, Number:35, IsActive:True
Name:Hank, Number:60, IsActive:True
*/

mrrList.FilterProperty(x => x.IsActive);
foreach(var p in mrrList) {
	Console.WriteLine(p);
}
/*
Name:Bob, Number:30, IsActive:True
Name:Diana, Number:42, IsActive:True
Name:Frank, Number:35, IsActive:True
Name:Hank, Number:60, IsActive:True
*/

//after use
mrrList.Dispose();

ObservableCombinableCollection

INotifyCollectionChangedを実装したコレクションを結合するためのクラスです。
否実装のコレクションも結合はできますが、変更は反映されません。

public class ObservableCombinableCollection<T> : ObservableMirrorCollection<T> {
	public ObservableCombinableCollection(Action<T>? addingAction = null, Action<T>? removedAction = null, IEqualityComparer<T>? equality = null);
	
	public bool AppendCollection(IEnumerable<T> collection) { }

	public bool InsertCollection(int index, IEnumerable<T> collection) { }

	public bool RemoveCollection(IEnumerable<T> collection) { }

	public void ClearCollections() { }
}
var obs1List = new ObservableCollection<string>("ABC".Select(x => x.ToString()));
var obs2List = new ObservableCollection<string>("efg".Select(x=>x.ToString()));

var cmbList = new ObservableCombinableCollection<string>();

cmbList.CollectionChanged += (s, e) => {
    Console.Write($"action:{e.Action}, ");
    Console.Write($"OldIndex:{e.OldStartingIndex}, ");
    Console.Write($"OldItems:{string.Join(" ", e.OldItems?.OfType<string>() ?? Array.Empty<string>())}, ");
    Console.Write($"NewIndex:{e.NewStartingIndex}, ");
    Console.Write($"NewItems:{string.Join(" ", e.NewItems?.OfType<string>() ?? Array.Empty<string>())} \n");
};
cmbList.AppendCollection(obs1List);
/*
action:Add, OldIndex:-1, OldItems:, NewIndex:0, NewItems:A
action:Add, OldIndex:-1, OldItems:, NewIndex:1, NewItems:B
action:Add, OldIndex:-1, OldItems:, NewIndex:2, NewItems:C
*/
cmbList.AppendCollection(obs2List);
/*
action:Add, OldIndex:-1, OldItems:, NewIndex:3, NewItems:e
action:Add, OldIndex:-1, OldItems:, NewIndex:4, NewItems:f
action:Add, OldIndex:-1, OldItems:, NewIndex:5, NewItems:g
*/

Console.WriteLine(string.Join(",", cmbList));
//A,B,C,e,f,g

obs1List.Remove("C");
//action:Remove, OldIndex:2, OldItems:C, NewIndex:-1, NewItems:

Console.WriteLine(string.Join(",", cmbList));
//A,B,e,f,g

obs1List[1] = "D";
//action:Replace, OldIndex:1, OldItems:B, NewIndex:1, NewItems:D

Console.WriteLine(string.Join(",", cmbList));
//A,D,e,f,g

obs2List.Move(0, 1);
//action:Move, OldIndex:2, OldItems:e, NewIndex:3, NewItems:e

Console.WriteLine(string.Join(",", cmbList));
//A,D,f,e,g

obs2List.Clear();
/*
action:Remove, OldIndex:2, OldItems:f, NewIndex:-1, NewItems:
action:Remove, OldIndex:2, OldItems:e, NewIndex:-1, NewItems:
action:Remove, OldIndex:2, OldItems:g, NewIndex:-1, NewItems:
*/

Console.WriteLine(string.Join(",", cmbList));
//A,D

//after use
cmbList.Dispose();

PropertyTrackingCollection

指定したコレクションに含まれる各要素に対して、プロパティ変更通知を購読します。
INotifyCollectionChangedが実装されているコレクションであれば、要素の追加や削除が監視対象へ反映されます。
プロパティ値がINotifyPropertyChangedを実装していれば、プロパティの指定はネスト可能です。

public class PropertyTrackingCollection<T> : IReadOnlyList<T>, IDisposable, INotifyCollectionChanged {
    //constructor
    public PropertyTrackingCollection(IEnumerable<T> items);

    public event NotifyCollectionChangedEventHandler? CollectionChanged;

    public event Action<T, ChainedPropertyChangedEventArgs<object>>? TrackingPropertyChanged;

    public IDisposable TrackHandler(Expression<Func<T, object>> property, Action<T, ChainedPropertyChangedEventArgs<object>> handle);

    public TrackingPropertyList<T> CreateTrackingList();
}

public class TrackingPropertyList<T> : IEnumerable<Expression<Func<T,object>>>, IDisposable {

    public void Register(Expression<Func<T, object>> property);

    public void Remove(Expression<Func<T, object>> property);

    public void Clear();

    public void Dispose();

    public IDisposable AttachHandler(Action<T, ChainedPropertyChangedEventArgs<object>> handle);
}

通知を受け取るプロパティの登録・購読をする方法は2通りあります。

  1. TrackHandler()で登録・購読する
  2. TrackingPropertyListを取得し、Register()で登録、AttachHandler()にて購読する。

TrackingPropertyChangedイベントを購読すると、TrackHandler()とTrackingPropertyList.Register()で登録している全ての通知を受け取れます。

TrackHandler()を使用する

次のコードで、各ノードのGrandParentの変更を監視します。

var nds = "ABCDE".ToCharArray().ToDictionary(x => x, x => new ObservableNamedNode() { Name = x.ToString()});

var trackings = new PropertyTrackingCollection<ObservableNamedNode>(nds.Values);

var disp = trackings.TrackHandler(
	x => x.Parent.Parent,
	(s,e) => Console.WriteLine($"GrandParent changed, sender:{s.Name}, Property:{e.ChainedName}, G-parent:{e.PropertyValue ?? "null"}"));

var root = nds.Values.AssembleAsNAryTree(2);
//GrandParent changed, sender:D, Property:Parent.Parent, G-parent:A
//GrandParent changed, sender:E, Property:Parent.Parent, G-parent:A

Console.WriteLine(root.ToTreeDiagram(x => $"{x.Name}"));
/*
A
├ B
│ ├ D
│ └ E
└ C
	*/

nds['A'].AddChild(nds['E']);
//GrandParent changed, sender:E, Property:Parent.Parent, G-parent:null

Console.WriteLine(root.ToTreeDiagram(x => $"{x.Name}"));
/*
A
├ B
│ └ D
├ C
└ E
	*/

//after use
trackings.Dispose();

TrackingPropertyListを使用する

前述のTracHandlerでは、監視するプロパティと処理を同時に登録または解除することになりますが、TrackingPropertyListを経由することで別々に登録または解除できます。
重複したプロパティを指定した場合は登録されません。
リストを破棄するとハンドラーも同時に破棄されます。

var data = new ObservableCollection<ItemData>() {
	new(){ Name = "Alice", Number = 50, IsActive = true },
	new(){ Name = "Bob", Number = 30, IsActive = true },
	new(){ Name = "Charlie", Number = 25, IsActive = false },
	new(){ Name = "Diana", Number = 42, IsActive = true},
	new(){ Name = "Eve", Number = 28, IsActive = false},
};

var trackings = new PropertyTrackingCollection<ItemData>(data);

var trcList = trackings.CreateTrackingList();
trcList.AttachHandler((s, e) 
	=> Console.WriteLine($"Property changed:{e.PropertyName}, Name:{s.Name}, Number:{s.Number}, IsActive:{s.IsActive}"));

trcList.Register(x => x.Number);
data[0].Number = 30;
//Property changed:Number, Name:Alice, Number:30, IsActive:True
data[1].IsActive = false;
//

trcList.Clear();
trcList.Register(x => x.IsActive);
data[0].Number = 33;
//
data[1].IsActive = true;
//Property changed:IsActive, Name:Bob, Number:30, IsActive:True

//after use
trackings.Dispose();

TrackingPropertyChangedイベントを購読する

TrackHandler()とTrackingPropertyList.Register()で登録されている全ての通知を受け取れます。

次のコードでTrackingPropertyChangedイベントを購読します。
TrackHandlerメソッドでNumberプロパティを、TrackingListからNumberとIsActiveプロパティを登録しています。

var data = new ObservableCollection<ItemData>() {
	new(){ Name = "Alice", Number = 50, IsActive = true },
	new(){ Name = "Bob", Number = 30, IsActive = true },
	new(){ Name = "Charlie", Number = 25, IsActive = false },
};

var trackings = new PropertyTrackingCollection<ItemData>(data);

trackings.TrackingPropertyChanged += (s, e) => {
	Console.WriteLine($"Handle all, Property:{e.ChainedName} Name:{s.Name}, Number:{s.Number}, IsActive:{s.IsActive}");
};

trackings.TrackHandler(x => x.Number, (s, e) => { });

var trcList = trackings.CreateTrackingList();
trcList.Register(x => x.IsActive);
trcList.Register(x => x.Number);

data[0].Number = 30;
//Handle all, Property:Number Name:Alice, Number:30, IsActive:True
//Handle all, Property:Number Name:Alice, Number:30, IsActive:True

data[1].IsActive = false;
//Handle all, Property:IsActive Name:Bob, Number:30, IsActive:False

trackings.Dispose();

ImitableCollection

ソースコレクション<TSrc>の各要素を、対応する<TDst>型へ変換し、コレクション<TDst>として振舞います。

public abstract class ImitableCollection 
    : INotifyPropertyChanged, INotifyCollectionChanged, IDisposable, IEnumerable {

    /// <summary>If not in synchronization state, starts synchronization.</summary>
    public abstract void Imitate();

    /// <summary>Stops synchronization.</summary>
    public abstract void Pause();

    /// <summary>Stops synchronization and clears the imitable collection.</summary>
    public abstract void ClearAndPause();

    /// <summary>Indicates whether the current state is in synchronization.</summary>
    public abstract bool IsImitating { get; }
}
public abstract class ImitableCollection<TDst> 
    : ImitableCollection,IObservableMirrorCollection<TDst> {
    
    public abstract TDst this[int index] { get; }

    public abstract int Count { get; }
}
public static class EnumerableExtensions{

    /// <summary>Assists in initializing an instance.</summary>
    /// <typeparam name="TSrc">The type of elements in the source collection for synchronization.</typeparam>
    /// <typeparam name="TDst">The type of elements in the target imitable collection.</typeparam>
    /// <param name="source">The source collection for synchronization.</param>
    /// <param name="convert">A function to convert elements from <typeparamref name="TSrc"/> to corresponding <typeparamref name="TDst"/>.</param>
    /// <param name = "removedAction" > Action to be performed when an element is removed from the collection or this instance disposed.</param>
    /// <param name="isImitate">Specifies whether to initialize in a synchronized state.</param>
    public static ImitableCollection<TDst> ToImitable<TSrc, TDst>(this IEnumerable<TSrc> source, Func<TSrc, TDst> convert, Action<TDst>? removedAction = null, bool isImitate = true) {
        return new ImitableCollection<TSrc,TDst>(source, convert, removedAction, isImitate);
    }
}

IsImitatingプロパティがtrueの状態であれば、追加・削除などソースコレクションの変更が反映され、対応する要素が連動します。
指定したIEnumerable<TSrc> sourceがINotifyCollectionChangedを実装していなかった場合は、Imitateメソッドを呼び出すことで変更を反映できます。

ObservableMirrorCollection<T,U>との違いは、

  1. インスタンス生成時、変換元と変換先の比較が不要
  2. 連動の開始・停止の制御が可能
  3. removedActionは、ソースの変更時だけでなくClearAndPause()、Dispose()によっても実行される

の3点です。
ソースコレクションの要素同士の比較は、値型であれば同値性、参照型であれば同一性を使用します。

変換元と変換先の比較が不要であるため、関連のない値同士を連動できます。

var rdm = new Random();
var nameList = new ObservableCollection<char>("ABCD".ToArray()); 
var imitList = nameList.ToImitable(x => rdm.Next(10));

Console.WriteLine(string.Join(",", nameList));
//A,B,C,D
Console.WriteLine(string.Join(",", imitList));
//5,4,5,7

nameList.Add('E');
Console.WriteLine(string.Join(",", nameList));
//A,B,C,D,E
Console.WriteLine(string.Join(",", imitList));
//5,4,5,7,4

nameList.Move(0, 1);
Console.WriteLine(string.Join(",", nameList));
//B,A,C,D,E
Console.WriteLine(string.Join(",", imitList));
//4,5,5,7,4

nameList[0] = 'F';
Console.WriteLine(string.Join(",", nameList));
//F,A,C,D,E
Console.WriteLine(string.Join(",", imitList));
//8,5,5,7,4

続けて、連動の停止と再開を制御します。

imitList.Pause();

nameList.Remove('F');
Console.WriteLine(string.Join(",", nameList));
//A,C,D,E
Console.WriteLine(string.Join(",", imitList));
//8,5,5,7,4

imitList.Imitate();
Console.WriteLine(string.Join(",", imitList));
//5,5,7,4

imitList.ClearAndPause();
Console.WriteLine(string.Join(",", imitList));
//

imitList.Imitate();
Console.WriteLine(string.Join(",", imitList));
//1,2,5,4

//after use
imitList.Dispose();

次のコードで、INotifyCollectionChangedを実装していないソースコレクションを指定します。

var rdm = new Random();
//Collection whoes elements are reference types.
var lst = new List<string>("ABCD".ToArray().Select(x=>x.ToString()));
var imitList = lst.ToImitable(x => rdm.Next(10));

Console.WriteLine(string.Join(",", lst));
//A,B,C,D
Console.WriteLine(string.Join(",", imitList));
//9,7,0,3

lst.Remove("A");
lst.Remove("B");
lst.Add("A");

Console.WriteLine(string.Join(",", lst));
//C,D,A
Console.WriteLine(string.Join(",", imitList));
//9,7,0,3

imitList.Imitate();
Console.WriteLine(string.Join(",", lst));
//C,D,A
Console.WriteLine(string.Join(",", imitList));
//0,3,8

Listを編集した直後はImitableCollectionに変更はありません。
Imitate()を実行すると変更が反映されています。
List<string>の各要素は参照型なので、再度追加された"A"は別の要素として乱数を割り当てられています。

次のコードで、ソースの変更、ClearAndPause()、Dispose()によって要素が削除された時の処理を実行します。

var srcList = new ObservableCollection<string>("ABC".ToCharArray().Select(x => x.ToString()));
var imitList = srcList.ToImitable(
    x => new DisposableNamedObj() { Name = x },
    obj => obj.Dispose());

srcList.Remove("A");
//A Dispose

srcList.Clear();
//B Dispose
//C Dispose

srcList.Add("D");
srcList.Add("E");

imitList.ClearAndPause();
//D Dispose
//E Dispose

imitList.Imitate();

imitList.Dispose();
//D Dispose
//E Dispose

ListAligner

操作可能なコレクションを指定した順に並べ替えます。

public class ListAligner<S,T,TList> where TList : IList<T> {
    public ListAligner(TList editList, Func<S, T> convert, Func<S, T, bool> equality, 
        Action<TList, int, T>? insert = null, 
        Action<TList, int, T>? replace = null, Action<TList, int, int>? move = null, 
        Action<TList, int>? remove=null, Action<TList>? clear=null) {
    }

    /// <summary>Aligns the list according to the specified order.</summary>
    /// <param name="order">A collection defining the desired order of elements in the list.</param>
    public void AlignBy(IEnumerable<S> order) { }
}

public class ListAligner<T, TList> : ListAligner<T,T,TList>  where TList : IList<T> {
    public ListAligner(TList editList,
        Action<TList, int, T>? insert = null, Action<TList, int, T>? replace = null,
        Action<TList, int>? remove = null, Action<TList, int, int>? move = null, 
        Action<TList>? clear = null, IEqualityComparer<T>? comparer = null) { }
}

public static class EnumerableExtensions{

    public static void AlignBy<T>(this IList<T> self,IEnumerable<T> sequence, IEqualityComparer<T>? equality = null) { }
 
	public static void AlignBy<S,T>(this IList<T> self, IEnumerable<S> sequence,Func<S,T> convert, Func<S,T,bool> equality) { }

    public static void AlignBy<T>(this ObservableCollection<T> self, IEnumerable<T> sequence, IEqualityComparer<T>? equality = null) { }

    public static void AlignBy<S,T>(this ObservableCollection<T> self, IEnumerable<S> sequence,Func<S,T> convert,Func<S,T,bool> equality) { }
}

ListAlignerを介して、操作対象のIListまたはObservableCollectionを、指定した順になるように並び替え処理を実行します。
同一の要素が含まれていた場合、順序は保証されないので不安定ソートとなります。

var lst = new List<string>(new string[] {"C","O","N","F","I","N"});
var algnr = new ListAligner<char, string, List<string>>(
    lst,
    c => c.ToString().ToUpper(),
    (c, s) => Equals(c.ToString().ToUpper(), s));

Console.WriteLine(string.Join(",", lst));
//C,O,N,F,I,N

algnr.AlignBy("finance");
Console.WriteLine(string.Join(",", lst));
//F,I,N,A,N,C,E

algnr.AlignBy("finance".Reverse());
Console.WriteLine(string.Join(",", lst));
//E,C,N,A,N,I,F

次のコードで、ObservableCollectionを操作し、過程を示します。

var obsLst = new ObservableCollection<string>(new string[] {"C","O","N","F","I","N"});

obsLst.CollectionChanged += (s, e) => {
    Console.Write($"action:{e.Action}, ");
    Console.Write($"OldIndex:{e.OldStartingIndex}, ");
    Console.Write($"OldItems:{string.Join(" ", e.OldItems?.OfType<string>() ?? Array.Empty<string>())}, ");
    Console.Write($"NewIndex:{e.NewStartingIndex}, ");
    Console.Write($"NewItems:{string.Join(" ", e.NewItems?.OfType<string>() ?? Array.Empty<string>())} \n");
};
var algnr2 = new ListAligner<char, string, ObservableCollection<string>>(
    obsLst,
    c => c.ToString().ToUpper(),
    (c, s) => Equals(c.ToString().ToUpper(), s),
    move: (collection, i, j) => collection.Move(i, j));

Console.WriteLine(string.Join(",", obsLst));
//C,O,N,F,I,N

algnr2.AlignBy("finance");
/*
action:Move, OldIndex:0, OldItems:C, NewIndex:5, NewItems:C
action:Move, OldIndex:2, OldItems:F, NewIndex:0, NewItems:F
action:Remove, OldIndex:1, OldItems:O, NewIndex:-1, NewItems:
action:Move, OldIndex:2, OldItems:I, NewIndex:1, NewItems:I
action:Add, OldIndex:-1, OldItems:, NewIndex:3, NewItems:A
action:Add, OldIndex:-1, OldItems:, NewIndex:6, NewItems:E
*/
Console.WriteLine(string.Join(",", obsLst));
//F,I,N,A,N,C,E

algnr2.AlignBy("infinite");
/*
action:Move, OldIndex:0, OldItems:F, NewIndex:2, NewItems:F
action:Replace, OldIndex:3, OldItems:A, NewIndex:3, NewItems:I
action:Replace, OldIndex:5, OldItems:C, NewIndex:5, NewItems:I
action:Add, OldIndex:-1, OldItems:, NewIndex:6, NewItems:T
*/
Console.WriteLine(string.Join(",", obsLst));
//I,N,F,I,N,I,T,E

algnr2.AlignBy("finery");
/*
action:Move, OldIndex:0, OldItems:I, NewIndex:1, NewItems:I
action:Move, OldIndex:2, OldItems:F, NewIndex:0, NewItems:F
action:Move, OldIndex:1, OldItems:N, NewIndex:2, NewItems:N
action:Remove, OldIndex:3, OldItems:I, NewIndex:-1, NewItems:
action:Move, OldIndex:6, OldItems:E, NewIndex:3, NewItems:E
action:Replace, OldIndex:4, OldItems:N, NewIndex:4, NewItems:R
action:Replace, OldIndex:5, OldItems:I, NewIndex:5, NewItems:Y
action:Remove, OldIndex:6, OldItems:T, NewIndex:-1, NewItems:
*/
Console.WriteLine(string.Join(",", obsLst));
//F,I,N,E,R,Y

拡張メソッドを用意しています。
操作対象がObservableCollectionであったとき、移動処理を表す引数にデフォルトでMove()が指定されます。

var obsLst = new ObservableCollection<string>("ABCD".Select(x=>x.ToString()));

obsLst.AlignBy("dcba",
    x => x.ToString().ToUpper(),
    (c, s) => Equals(c.ToString().ToUpper(), s));
/*
action:Move, OldIndex:0, OldItems:A, NewIndex:3, NewItems:A
action:Move, OldIndex:2, OldItems:D, NewIndex:0, NewItems:D
action:Move, OldIndex:1, OldItems:B, NewIndex:2, NewItems:B
*/

Console.WriteLine(string.Join(",", obsLst));
//D,C,B,A

ICollectionAddRemoveObserver

コレクション変更通知にて、追加・削除された要素を捕捉するObserverです。

public interface ICollectionAddRemoveObserver<out T> : IDisposable {
    
    ICollectionAddRemoveObserver<T> Added(Action<T> added);
    
    ICollectionAddRemoveObserver<T> Removed(Action<T> removed);
}

public static class ExtensionMethods{

    public static ICollectionAddRemoveObserver<T> AddRemoveObserver<T>(this ObservableCollection<T> self) => new CollectionObserver<T>(self);

    public static ICollectionAddRemoveObserver<T> AddRemoveObserver<T>(this ReadOnlyObservableCollection<T> self) => new CollectionObserver<T>(self);

    public static ICollectionAddRemoveObserver<T> AddRemoveObserver<T>(this IObservableMirrorCollection<T> self) => new CollectionObserver<T>(self);
}

コレクションに追加された要素、除外された要素をシンプルに捕捉できます。

var list = new ObservableCollection<string>(new string[] {"A","B","C"});

IDisposable listener = list.AddRemoveObserver()
    .Added(x => Console.WriteLine($"added : {x}"))
    .Removed(x => Console.WriteLine($"removed : {x}"));

list.Add("D"); 
// added : D
Console.WriteLine(string.Join(",", list));
//A,B,C,D

list[0] = "E";
//adeed : E
//removed : A
Console.WriteLine(string.Join(",", list));
//E,B,C,D

list.Move(1, 2);
Console.WriteLine(string.Join(",", list));
//E,C,B,D

list.RemoveAt(0);
//removed : E
Console.WriteLine(string.Join(",", list));
//C,B,D

list.Clear();
//removed : C
//removed : B
//removed : D
Console.WriteLine(string.Join(",", list));
//

listener.Dispose();

list.Add("G");
//

Clone this wiki locally