两个ObservableCollections的双向同步

最新推荐文章于 2024-01-29 12:45:16 发布
最新推荐文章于 2024-01-29 12:45:16 发布
阅读量348 收藏
点赞数
分类专栏： WPF
原文链接：https://qiita.com/soi/items/c8508cddbb75c353a512
版权

总览

有时您想在两个方向上同步两个ObservableCollections。
下面的GIF绑定到左侧和ObservableCollection<int>右侧ObservableCollection<string>。这是一个在两个方向上同步两个ObservableCollection的演示，如果您更改一个，则另一个将被反映。

 

Demo

我在WPF中创建了演示，但是ObservableCollection本身不依赖于WPF，因此可以在UWP和控制台中使用。

代码

我要CollectionChanged订阅两个事件，然后更改另一端以同步两个ObservableCollections 。
为了避免无限循环，局部变量isChanging保持已存在或正在更改的状态。

  
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Linq;
using System.Text;

namespace ObservableColletionSyncedTest
{
    public static class ObservableCollectionExtension
    {
        /// <summary>
        /// 生成存储从指定的收藏库复制的元素的ObservableCollection
        /// </summary>
        public static ObservableCollection<T> ToObservableCollection<T>(this IEnumerable<T> source) => new ObservableCollection<T>(source);

        /// <summary>
        /// 生成指定的ObservableCollection和双向同步的ObservableCollection
        /// </summary>
        public static ObservableCollection<TargetT> ToObservableCollctionSynced<SourceT, TargetT>(this ObservableCollection<SourceT> sources,
        Func<SourceT, TargetT> sourceToTarget, Func<TargetT, SourceT> targetToSource)
        {
            ///sources元素转换后生成收藏
            var targets = sources.Select(sourceToTarget).ToObservableCollection();

            //同步两个收藏集
            SyncCollectionTwoWay(sources, targets, sourceToTarget, targetToSource);

            //返回同步的收藏集
            return targets;
        }

        /// <summary>
        /// 两个ObservableCollection双向同步
        /// </summary>
        public static void SyncCollectionTwoWay<SourceT, TargetT>(ObservableCollection<SourceT> sources, ObservableCollection<TargetT> targets,
            Func<SourceT, TargetT> sourceToTarget, Func<TargetT, SourceT> targetToSource)
        {
            bool isChanging = false;

            //Source -> Target
            sources.CollectionChanged += (o, e) =>
                ExcuteIfNotChanging(() => SyncByChangedEventArgs(sources, targets, sourceToTarget, e));

            //Target -> Source
            targets.CollectionChanged += (o, e) =>
                ExcuteIfNotChanging(() => SyncByChangedEventArgs(targets, sources, targetToSource, e));


            //为了不发生变更，用本地变量检查
            //为了访问本地变量，用本地函数描述
            void ExcuteIfNotChanging(Action action)
            {
                if (isChanging)
                    return;
                isChanging = true;
                action.Invoke();
                isChanging = false;
            }
        }

        private static void SyncByChangedEventArgs<OriginT, DestT>(ObservableCollection<OriginT> origin, ObservableCollection<DestT> dest,
            Func<OriginT, DestT> originToDest, NotifyCollectionChangedEventArgs originE)
        {
            switch (originE.Action)
            {
                case NotifyCollectionChangedAction.Add:
                    if (originE.NewItems?[0] is OriginT addItem)
                        dest.Insert(originE.NewStartingIndex, originToDest(addItem));
                    return;

                case NotifyCollectionChangedAction.Remove:
                    if (originE.OldStartingIndex >= 0)
                        dest.RemoveAt(originE.OldStartingIndex);
                    return;

                case NotifyCollectionChangedAction.Replace:
                    if (originE.NewItems?[0] is OriginT replaceItem)
                        dest[originE.NewStartingIndex] = originToDest(replaceItem);
                    return;

                case NotifyCollectionChangedAction.Move:
                    dest.Move(originE.OldStartingIndex, originE.NewStartingIndex);
                    return;

                case NotifyCollectionChangedAction.Reset:
                    dest.Clear();
                    foreach (DestT item in origin.Select(originToDest))
                        dest.Add(item);
                    return;
            }
        }
    }
}

 

如何使用

用法很简单，只需使用原始ObservableCollection中的扩展方法调用即可。那时，将双向元素转换的委托指定为参数。
在此，Source-> Target是转换为字符串的数字，并添加了固定字符串，Target-> Source是从第三个字符转换为数字的字符串。

  
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;

namespace ObservableColletionSyncedTest
{
class MainWindowViewModel
{
    public ObservableCollection<int> Sources { get; } = new ObservableCollection<int>(new[] { 10, 20, 30 });
    public ObservableCollection<string> Targets { get; }

    public MainWindowViewModel()
    {

        Targets = Sources
            .ToObservableCollctionSynced(
            x => $"C:{x}",
            x => int.Parse(x.Substring(2)));
    }
}
}

 

在演示中，View是直接更改的，因此我敢在后面的代码中更改它。

  
<Window
   x:Class="ObservableColletionSyncedTest.MainWindow"
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
   xmlns:local="clr-namespace:ObservableColletionSyncedTest"
   xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
   Title="MainWindow"
   mc:Ignorable="d">
   <Window.DataContext>
      <local:MainWindowViewModel />
   </Window.DataContext>
   <UniformGrid Columns="2">
      <StackPanel>
         <Label HorizontalContentAlignment="Center" Content="Source" />
         <Button Click="AddSourceButton_Click" Content="Add" />
         <Button Click="RemoveSourceButton_Click" Content="Remove" />
         <Button Click="ReplaceSourceButton_Click" Content="Replace" />
         <Button Click="MoveSourceButton_Click" Content="Move" />
         <Button Click="ClearSourceButton_Click" Content="Clear" />
         <ListBox x:Name="sources" ItemsSource="{Binding Sources}" />
      </StackPanel>
      <StackPanel>
         <Label HorizontalContentAlignment="Center" Content="Target" />
         <Button Click="AddTargetButton_Click" Content="Add" />
         <Button Click="RemoveTargetButton_Click" Content="Remove" />
         <Button Click="ReplaceTargetButton_Click" Content="Replace" />
         <Button Click="MoveTargetButton_Click" Content="Move" />
         <Button Click="ClearTargetButton_Click" Content="Clear" />
         <ListBox x:Name="targets" ItemsSource="{Binding Targets}" />
      </StackPanel>
   </UniformGrid>
</Window>

 

  
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace ObservableColletionSyncedTest
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow() { InitializeComponent(); }

        Random random = new Random();
        ObservableCollection<string> targetItems => (targets.ItemsSource as ObservableCollection<string>);
        ObservableCollection<int> sourcesItems => (sources.ItemsSource as ObservableCollection<int>);
        private int CreateSourceValue() => random.Next(0, 99);
        private int GetRandomIndex<T>(Collection<T> collection) => random.Next(0, collection.Count);

        private void AddSourceButton_Click(object sender, RoutedEventArgs e) =>
            sourcesItems.Add(CreateSourceValue());
        private void AddTargetButton_Click(object sender, RoutedEventArgs e) =>
            targetItems.Add($"A:{CreateSourceValue()}");

        private void RemoveSourceButton_Click(object sender, RoutedEventArgs e) =>
            sourcesItems.RemoveAt(GetRandomIndex(sourcesItems));
        private void RemoveTargetButton_Click(object sender, RoutedEventArgs e) =>
            targetItems.RemoveAt(GetRandomIndex(targetItems));
        private void ReplaceSourceButton_Click(object sender, RoutedEventArgs e) =>
            sourcesItems[GetRandomIndex(sourcesItems)] = CreateSourceValue();
        private void ReplaceTargetButton_Click(object sender, RoutedEventArgs e) =>
            targetItems[GetRandomIndex(targetItems)] = $"R:{CreateSourceValue()}";

        private void Move<T>(ObservableCollection<T> collection)
        {
            int indexOld = GetRandomIndex(collection);
            int indexNew = GetRandomIndex(collection);
            collection.Move(indexOld, indexNew);
        }
        private void MoveSourceButton_Click(object sender, RoutedEventArgs e) => Move(sourcesItems);
        private void MoveTargetButton_Click(object sender, RoutedEventArgs e) => Move(targetItems);

        private void ClearSourceButton_Click(object sender, RoutedEventArgs e) => sourcesItems.Clear();
        private void ClearTargetButton_Click(object sender, RoutedEventArgs e) => targetItems.Clear();
    }
}

 

很重要的一点

在演示中，为了清楚起见，两个ObservableCollections都绑定到了View，但是为此目的，最好将双向转换Converter放在任一ListBox中。
实际上，我认为有很多用途，例如想要同步Model层和ViewModel层的ObservableCollection。

无法取消订阅ColletionChanged事件，因此，如果两个ObservableCollection具有不同的生存期，则它们将泄漏内存。

参考

http://nomoredeathmarch.hatenablog.com/entry/2019/03/02/180147

整个代码

将其放置在以下位置。
https://github.com/soi013/ObservableColletionSyncedTest/

环境

VisualStudio 2019版本16.8.3
.NET Core 3.1
C＃8

君子居易
关注
专栏目录
Observable和Promise
qq_38376634的博客
05-27 1397
二者的区别 promise解决了嵌套地狱的问题； 建立promise时立即执行操作； 可使用async,await让多个异步进行同步过程； promise只可以被执行一次，重复执行，promise内部的变量不会再变化。 promise一定是异步的，即使内部操作是同步的，依旧会异步执行。 Observable解决了promise只有一个结果，和不可以取消的问题。 在Observable被订阅时，开始执行操作。 要使用徒步操作，需先使用toPromise()变成Promise对象才可以。 重复执行一个O
oracle两个数据库之间,如何实现oracle两个数据库之间的同步
weixin_40001967的博客
04-13 4075
如何实现oracle两个数据库之间的同步关注:166答案:2手机版解决时间 2021-01-23 22:02提问者美人如画皮2021-01-23 13:26如何实现oracle两个数据库之间的同步最佳答案二级知识专家回憶沒有意義2021-01-23 14:25DataGurd：主要备库的方式，就是数据库对数据库的备份方式，主要是解决容灾的。流复制：主要是利用ORACLE的归档日志，进行增量...
在WPF中合并两个ObservableCollection
weixin_34353714的博客
02-28 384
WPF中的ObservableCollection是一个非常常用的集合对象，我们可以通过将它绑定到ListBox之类的集合控件上时，当集合发生变更时，会同步更新到界面上。但是，有的时候我们需要合并两个集合，将他们的拼接后显示在界面上，此时该何如做呢? 乍一看来，这是个非常简单的事情，.Net的BCL本身就提供了IEnumerate集合连接函数——Concat，可以通过它轻松连接两个集合。但当你使...
Observable与Observer
enoeht的专栏
07-26 1295
    在Java中通过Observable类和Observer接口实现了观察者模式。一个Observer对象监视着一个Observable对象的变化，当Observable对象发生变化时，Observer得到通知，就可以进行相应的工作。例如在文档/视图结构中，文档被修改了，视图就会得到通知。       java.util.Observable中有两个方法对Observer特别重要，一个是set
ObservableCollection 类
shanyou的专栏
01-17 1657
Windows Presentation Foundation (WPF) 在 Microsoft .NET Framework 中添加了一些功能，您可以可靠地使绑定控件与其数据源保持一致。这个类就是ObservableCollection。 利用 ObservableCollection 类，WPF /Silverlight 应用程序可以使绑定控件与基础数据源保持同步，但它还提供了更有
高级基础知识：ObservableCollection 类
thebesttome的专栏
06-09 1784
ObservableCollection 类Ken Getz代码下载位置：MSDN 代码库 <a id="ctl00_MTContentSelector1_mainContentContainer_ctl01" onclick="function onclick(){Track(ctl00_MTContentSelector1_mainContentContainer_ctl
Git管理实战（四）：多Gitlab数据同步
01-27
GitlabAPI实现一套简单灵活的数据同步机制，从而实现在多个Gitlab 站点间同步数据。 在继续写数学系列前，我想切回去之前的Git系列写点东西。我想写系列文章也可以像操作系统的进程调度一样，一个系列暂时写不动了，...
Mysql5.5数据库双向同步
06-14
根据给定的文件信息，“Mysql5.5数据库双向同步”这一主题深入探讨了如何在两个MySQL 5.5服务器之间建立稳定的数据同步机制，确保数据的一致性和高可用性。以下是对该知识点的详细解析： ### 一、理解MySQL双向同步...
java多个数据库实现数据同步
03-16
数据同步是指在两个或多个数据库之间，当某个数据库中的数据发生改变时，这些变化能够被实时或者近实时地反映到其他数据库中。这有助于防止数据丢失和减少数据冲突，保证各个节点的数据一致性。 在Java中，实现多...
Sql_2000数据库双向同步
08-27
SQL Server 2000 数据库双向同步是一个高级特性，用于在两个或多个数据库之间保持数据的一致性。这种同步允许数据更改在两个方向上流动，即从一个数据库到另一个数据库，反之亦然，这对于分布式系统和灾难恢复策略至...
【Observable】与多线程。同步 异步
u012196940的博客
04-06 854
相关依赖 io.reactivex rxjava 1.3.8 toBlocking 的意思是主线程是否等待执行结果 需要注意的是flatMap后面的左括弧对应的右括弧 应该在subscribeOn之后。否则无法实现多线程的效果。 private static ExecutorService service= new ThreadPoolExecutor(4, 4, 0L, TimeUnit.MILLISECONDS, new
ObservableCollection是什么
weixin_33778778的博客
11-03 275
表示一个动态数据集合，在添加项、移除项或刷新整个列表时，此集合将提供通知。在许多情况下，所使用的数据是对象的集合。例如，数据绑定中的一个常见方案是使用ItemsControl（如 ListBox、ListView或TreeView）来显示记录的集合。可以枚举实现IEnumerable接口的任何集合。但是，若要设置动态绑定，以使集合中的插入或移除操作可以自动更新 UI，则该集合...
WPF ObservableCollection＜T＞
weixin_42365213的博客
09-06 269
2. 还有一种情况(T类型) 对象的属性 发生变化时 需要通知到UI界面，此时就需要T类型实现 INotifyPropertyChange接口。当我们new一个对象赋值给infos时候，infos的地址指向变更了。由此可见 WPF的数据绑定 要求绑定的对象不能发生变化，也就是赋值给DataContext的对象地址不能发生变化, 变化的只是对象里面的属性.1. ObservableCollection 类 表示一个动态数据集合，在添加项、移除项或刷新整个列表时，此集合将提供通知。
WPF Observablecollection Clear 卡顿
最新发布
大黄鸭在发光的专栏
01-29 770
WPF Observablecollection Clear 卡顿
ObservableCollection<T>排序
qq_36710541的博客
06-21 1373
1.直接Insert至指定位置ObservableCollection&lt;T&gt;方便界面自动更新列表，默认添加至末尾，当列表需要排序时希望能能直接添加至指定位置，下为“经典二分”获取InsertIndexprivate int GetIndex(ObservableCollection&lt;Struct&gt; lstData, string name)        {        ...
ObservableCollection類介紹
学习ing......
01-14 2271
<br />System.Collections.ObjectModel.ObservableCollection不是什麼新鮮的東西，早在幾年前，就存在Silverlight與WPF中，它跟一般的Collection最大的不同地方在，它可以被監控，當集合有所變動，會產生事件，可以控制變化，如UI亓件需要監控集合，當變動時UI必需有所調整，或新增資料到集合中，要做一些初始化的動作等等。<br />NOTE:<br />在3.0中ObservableCollection建置在WindowsBase.dll中，不
c#集合类笔记之八 ObservableCollection
purpuck的博客
03-21 1712
如果需要集合中的元素何时删除或添加的信息,就可以使用ObservableCollection类。这个类是为WPF定义的,这样UI就可以得知集合的变化,因此这个类在程序集WindowsBase中定义,同时用户需要引用这个程序集。这个类的名称空间是system,Collection.ObjectModel。 ObservableCollection类派生自Collection,该基类可用于创建自定义集...
FreeFileSync双向同步教程：实现服务器间文件同步
本文档详细介绍了如何使用FreeFileSync在两台服务器之间进行双向同步的步骤，包括软件下载、目录映射、同步配置以及通过计划任务实现定时同步。" FreeFileSync是一个免费且多语言支持的文件同步工具，它主要功能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值