Evernote Sync Via EDAM （代码篇）

预备结构

这里同步某一个特定笔记本的所有笔记的实现，而且笔记都是不带资源的。另外同步笔记是不需要处理重名问题的

在同步之前首先必然需要构造两个类，分别代表服务器端的数据，和本地端的数据，以及他们的一些操作。

下面给出这两个类的定义，详细代码太长。明后天完成整个程序后，会把所有的代码放到GitHub中进行开源。

其中在服务端的构造函数中完成了登入获取NoteStroe等功能，本地端的构造函数完成了从本地文件读取数据的功能

class EvernoteServer
{
    public EvernoteServer()

    //创建AdageNotebook
    private Notebook CreateAdageNotebook()

    //获取AdageNotebook下的所有的Note的元数据
    //执行这个函数会在更新服务器中Note的Updated
    public List<Note> GetActiveNotes()

    //获取在被删除的(在回收站中)Notes的元数据
    //但是这个方法没办法获取永久性删除的数据。
    public List<Note> GetInactiveNotes()

    //向服务端添加Note
    //会对参数note的Guid 时间戳 USN等信息做修改
    public void AddNote(Note note)

    //向服务端更新Note
    //会对参数note的Guid 时间戳 USN等信息做修改
    public void UpdateNote(Note note)

    //从服务端删除Note
    public void DeleteNote(Note note)

    //从服务器获取带Content信息的Note
    //执行这个函数会在更新服务器中note的Updated
    public Note GetNote(Note note)

    //从服务器获取USN
    public Int32 USN

}

class LocalStroage
{
    public List<Note> AllNotes

    //获取本地存储的实例，从Config.LocalDataFileName读取获得。
    public LocalStroage()


    //根据模板创建一个Note，可以不添加到_list
    public Note CreateNote(String adage, Boolean isAdd)

    //在本地存储添加Note
    public void AddNote(Note note)

    //将于note.guid相同的节点，内容用newAdage替换
    public void UpdateNote(Note note, String newAdage)

    //把list中与note.guid相同的节点用note的内容更新
    //这里有可能发生，同步时服务器端把一个标记为deleted的节点更新成active的节点
    public void UpdateNote(Note note)

    //从本地存储删除Note
    public void DeleteNote(Note note)

    //永久性删除Note
    public void ExpungeNote(Note note)

    //清除有删除标记的节点
    public void Clean()

    //根据参数note的内容克隆一个Note
    //克隆出来的Guid是不同的
    //参数isAdd,时候将克隆出来的note加入到list
    public Note CloneNote(Note note, Boolean isAdd)

    //保存到文件中
    public void Save()

    //从文件中读取
    private List<Note> Read()
}

 

细节

从网络端获取的Note和本地的Note是不同对象的引用，所以做所有的本地操作的内部都要进行GUID的比对。

执行向服务器添加Note时，参数中的note的GUID和正在添加到服务器的GUID是不同的。可以通过NoteStore.createNote(...)的返回值进行修正。这个返回值是刚刚添加进去的Note的元数据

与添加和更新时传入的Note参数中的属性中的USN，Created,Updated等参数是不会被更新的，也是要根据返回值进行修正，这点对USN特别重要。

GetActiveNotes 和 GetInactiveNotes在有非常多笔记的情况下要时候多次读取合并，类似于之前理论中的同步块问题

进行读取操作（GetActiveNotes GetInactiveNotes GetNote）时会刷新服务器端的Updated时间戳，这个直接导致不能使用Updated判断服务器端是否被修改

本地要设计一个彻底删除的方法，不然本地的数据文件会越来越大

 

数据分析

通过服务器端的特性和本地操作时的一些设置。我设计出一下的数据

//本地新建的数据 是本地没有被删除的Notes和服务端所有(包括回收站中)Notes的差集

//本地删除的数据 Active == false 这个在本地执行删除时要设置
//本地修改的数据 Updated > Config.LastSyncTime 本地执行时要修改Note.Updated 因为时间我只用来判断本地数据是否被修改，所以我的LastSyncTime其实是本地时间

//服务器新建的数据 服务器没有被删除的Notes和本地所有的（包括被标记为删除的）Notes的差集

//服务器删除的数据 通过GetInactiveNotes 获取到的数据
//服务器修改的数据 USN> Config.LastUSN

同步策略

有两个个会冲突的地方

冲突1：X端删除了note1,Y端修改了note1,处理方式两端都保留被Y端删除过的note1

冲突2：X端修改了note1,Y端也修改了note1,报告给用户，让用户决定保存那个端的，或者保存两端。保存两端即做一个克隆，个头克隆出来note一个新的GUID。关于这个冲突处理，我设计了一个事件机制，里面放了一个ConfilctResolution的枚举，通过事件传递到外部，让外部处理。或者是采用默认方案（保存两侧）

同步代码

主要分为查询和执行两个部分。

执行部分的顺序是 新建 更新除了冲突2以外的东西 删除 处理冲突2

这个顺序先更新后删除很自然的处理好了冲突1。

查询部分大量的使用了LINQ语句，为了调试方便，没有进行太多优化（我也不太会优化这个东西）

具体代码如下

//将本地数据文件与网络同步
       public void Sync()
       {
           //本地新建的数据 serverNotesList.Exists(s => s.Guid == l.Guid) == false
           //本地删除的数据 Active == false
           //本地修改的数据 Updated > Config.LastSyncTime

           //服务器新建的数据 loaclNotesList.Exists(l=>l.Guid==s.Guid) == false
           //服务器删除的数据 InactiveNotesList
           //服务器修改的数据 USN > Config.LastUSN

           _server = new EvernoteServer();

           #region 查询

           //获取本地的所有Note
           List<Note> localAllNotes = new List<Note>();
           localAllNotes.AddRange(_local.AllNotes);
           //获取本地活动的Note
           List<Note> localActiveNotes =  localAllNotes.FindAll(l => l.Active == true);
           //获取本地删除掉的Notes
           List<Note> localInactiveList = localAllNotes.FindAll(n => n.Active == false);

           //获取服务器端中活动的Note
           List<Note> serverActiveNotes = _server.GetActiveNotes();
           //获取服务器端回收站中的Note
           List<Note> serverInactiveNotes = _server.GetInactiveNotes();
           //获取服务器端所有的Note
           List<Note> serverAllNotes = new List<Note>();
           serverAllNotes.AddRange(serverActiveNotes);
           serverAllNotes.AddRange(serverInactiveNotes);

           //需要添加到本地的Notes////////////////////
           var localNeedAddNotes = serverActiveNotes.FindAll(
                                s => !localAllNotes.Exists(l => l.Guid == s.Guid));

           //需要添加到服务器的Nots///////////////////
           var serverNeedAddNotes = localActiveNotes.FindAll(
                                l => !serverAllNotes.Exists(s => s.Guid == l.Guid));


           //本地修改过的Notes
           var localUpdatedNotes =
               localActiveNotes.FindAll(l =>
                   serverAllNotes.Exists(s => s.Guid == l.Guid) &&
                                            l.Updated > Config.LastSyncTime);
           //服务器端修改过的Notes
           var serverUpdatedNotes =
               serverActiveNotes.FindAll(s =>
                   localAllNotes.Exists(l => l.Guid == s.Guid) &&
                   s.UpdateSequenceNum > Config.LastUSN);

           //出现冲突的Notes///////////////////////
           var conflictList = localUpdatedNotes.FindAll(
                               l => serverUpdatedNotes.Exists(s => s.Guid == l.Guid));

           //本地需要更新的Notes/////////////////////
           var localNeedUpdateNotes = serverUpdatedNotes.FindAll(
                                    s => !conflictList.Exists(c => c.Guid == s.Guid));


           //服务器需要更新的Notes////////////////////
           var serverNeedUpdateNotes = localUpdatedNotes.FindAll(
                               l => !conflictList.Exists(c => c.Guid == l.Guid));



           //需要删除的本地Notes/////////////////////////
           var localNeedDeleteNotes = serverInactiveNotes.FindAll(
                      i => localAllNotes.Exists(l => l.Guid == i.Guid) &&
                           !localUpdatedNotes.Exists(l => l.Guid == i.Guid));


           //需要删除的服务器端的Notes////////////////////
           var serverNeedDeleteNotes = localInactiveList.FindAll(
                       l => serverActiveNotes.Exists(s => s.Guid == l.Guid) &&
                            !serverUpdatedNotes.Exists(s => s.Guid == l.Guid));
           #endregion

           #region 操作
           //向本地添加Notes
           foreach(Note metadata in localNeedAddNotes)
           {
               Note note = _server.GetNote(metadata);
               _local.AddNote(note);
           }
           //向服务器添加Notes
           foreach(Note note in serverNeedAddNotes)
           {
               _server.AddNote(note);
           }

           //更新本地
           foreach(Note metadata in localNeedUpdateNotes)
           {
               Note note = _server.GetNote(metadata);
               _local.UpdateNote(note);
           }
           //更新服务器
           foreach(Note note in serverNeedUpdateNotes)
           {
               _server.UpdateNote(note);
           }

           //本地删除
           foreach(Note note in localNeedDeleteNotes)
           {
               _local.ExpungeNote(note);
           }
           //从服务器删除
           foreach(Note note in serverNeedDeleteNotes)
           {
               _server.DeleteNote(note);
               _local.ExpungeNote(note);
           }
           ////////////冲突处理//////////
           //报告冲突，获得处理方法
           //这里只实现在在两端都保留的方法
           foreach(Note localNote in conflictList)
           {
               //获取服务器冲突的Note
               Note serverNote = _server.GetNote(localNote);

               //尝试交给外部,获取冲突解决方案
               if(ConfilctHappen  != null)
               {
                   _confilctEvenArgs.LocalAdage = localNote.Title;
                   _confilctEvenArgs.ServerAdage = serverNote.Title;
                   ConfilctHappen(this, _confilctEvenArgs);
               }

               switch(_confilctEvenArgs.Result)
               {
                   case ConfilctResolution.SaveBoth:
                       //将localNote进行一个克隆，并且把克隆的Note加入到local
                       Note cloneNote = _local.CloneNote(localNote, true);
                       //把localNote更新成serverNote
                       _local.UpdateNote(serverNote);
                       //把cloneNote提交到服务器
                       _server.AddNote(cloneNote);
                       break;
                   case ConfilctResolution.SaveServer:
                       _local.ExpungeNote(localNote);
                       _local.AddNote(serverNote);
                       break;
                   case ConfilctResolution.SaveLocal:
                       _server.DeleteNote(localNote);
                       _server.AddNote(localNote);
                       break;
                   default:
                       break;
               }

               //消除这一次验证的选择
               _confilctEvenArgs.Result = ConfilctResolution.SaveBoth;
           }

           //记录LastSyncTime
           Config.LastSyncTime = Config.NowTime;
           //记录LastUSN
           Config.LastUSN = _server.USN;
           //保持local,因为在server.addNote等方法中可能会改变Note的部分属性
           _local.Save();
           //清理local中没有用到的标记为删除的节点
           _local.Clean();
           #endregion

           //刷新内存中的列表
           RefreshAdageCollection();
           this.GenRandomAdage();
       }