FileSystemWatcher和EF6：任务和列表<任务<>>

如何解决FileSystemWatcher和EF6：任务和列表<任务<>>

首先，对不起我的英语。

所以这是从学校项目开始的，但是由于我学到了很多东西，所以我决定继续进行。我的目标是制作一个适用于Windows的音乐播放器，并且开始工作非常简单，只需从给定目录中获取所有文件，然后在应用程序的主窗口中列出它们即可。但是随着这种情况的逐步升级，我开始使用MVVM，SQL Server和EF6，我必须自己学习，因此，显然有些事情我还没有完全理解。然后，当我制作了一个可以运行并且很好用的版本后，我想到了实现一个“新功能”：File Watcher。每当特定文件夹中的某些内容发生更改时，我都会收到一个事件，并且我必须对此进行处理。

对于与数据库相关的代码，我使用了存储库模式和工作单元，即使我不得不进行大量研究，反复试验和错误，我也很确定我的应用程序的这一部分工作正常。 / p>

问题来自文件观察器。我会尽量简洁。

这是SystemWatcher类：

public class SystemWatcher
{
    private Handler _handler;
    private FileSystemWatcher _fileSystemWatcher;
    private UnitOfWork _unitOfWork = new UnitOfWork();
    private MetadataParser _metadataParser = new MetadataParser();

    public SystemWatcher(string path,string fileType)
    {

        _fileSystemWatcher = new FileSystemWatcher(path,fileType);
        _handler = new Handler(_unitOfWork,_metadataParser,path);

        _fileSystemWatcher.Path = path;
        _fileSystemWatcher.Filter = fileType;
        _fileSystemWatcher.EnableRaisingEvents = true;
        _fileSystemWatcher.Created += FileChanged;
        _fileSystemWatcher.Changed += FileChanged;
        _fileSystemWatcher.Deleted += FileChanged;
        _fileSystemWatcher.Renamed += FileRenamed;  
        
    }

    public void FileChanged(object sender,FileSystemEventArgs e)
    {
        Console.WriteLine("{0} ----- {1}",e.FullPath,e.ChangeType);
        _handler.FileChangedHandler(e);
    }

    public void FileRenamed(object sender,RenamedEventArgs e)
    {
        Console.WriteLine("{0} ----- {1}",e.ChangeType);
        _handler.FileRenamedHandler(e);
    }
}

在测试控制台应用程序中，我是这样实例化的：

SystemWatcher systemWatcher = new SystemWatcher("C:\\Users\\ricar\\Music\\Música","*.mp3");

我创建一个单独的处理程序类的想法是抽象一点代码，并且在System Watcher类中不要包含太多代码。

这是Handler类：

public class Handler
{
    private UnitOfWork _unitOfWork;
    private MetadataParser _metadataParser;

    private string _path;

    public Handler(UnitOfWork unitOfWork,MetadataParser metadataParser,string path)
    {
        this._unitOfWork = unitOfWork;
        this._metadataParser = metadataParser;

        this._path = path;
    }


    public void FileChangedHandler(FileSystemEventArgs e)
    {
        if(e.ChangeType == WatcherChangeTypes.Deleted)
        {
            int affectedRecordId = this._unitOfWork.SongRepository.GetAll().First(_song => _song.musicCompletePath == e.FullPath).id;
            this._unitOfWork.SongRepository.Delete(affectedRecordId);
        }
        else if(e.ChangeType == WatcherChangeTypes.Created)
        {
            //My idea here is to have a list of tasks,add a task when a file has been created/inserted,and then loop through this list and run each task
            song newSongToDB = this._metadataParser.GetSongObjectAsync(e.FullPath,_path).Result;
            this._unitOfWork.SongRepository.Insert(newSongToDB);
        }
        this._unitOfWork.Save();
    }

    public void FileRenamedHandler(RenamedEventArgs e)
    {
        //TODO Encapsulate inside a try/catch
        //Gets the ID of the renamed file to use in the Update() function
        int affectedRecordId = this._unitOfWork.SongRepository.GetAll().First(_song => _song.musicCompletePath == e.OldFullPath).id; 
        //Gets the object that corresponds to the id
        song affectedRecord = this._unitOfWork.SongRepository.GetByID(affectedRecordId);

        //Updates the path and the file name
        affectedRecord.musicCompletePath = e.FullPath;
        affectedRecord.musicFilename = e.Name;

        //Creates a new object,for the sake of comprehension
        song newDBRecord = affectedRecord;

        this._unitOfWork.SongRepository.Update(affectedRecordId,newDBRecord);
        this._unitOfWork.Save();
    }


}

这是MetadataParser类

public class MetadataParser
{
    int i = 0;
    public async Task<song> GetSongObjectAsync(string targetSongPath,string path)
    {
        return await Task.Run(() => {
            song newSong = new song()
            {
                title = !string.IsNullOrEmpty(TagLib.File.Create(targetSongPath).Tag.Title) ?
                        TagLib.File.Create(targetSongPath).Tag.Title :
                        targetSongPath.Substring(path.Length + 1),artist = !string.IsNullOrEmpty(TagLib.File.Create(targetSongPath).Tag.FirstPerformer) ?
                            TagLib.File.Create(targetSongPath).Tag.FirstPerformer :
                            !string.IsNullOrEmpty(TagLib.File.Create(targetSongPath).Tag.FirstAlbumArtist) ?
                            TagLib.File.Create(targetSongPath).Tag.FirstAlbumArtist :
                            "Desconhecido",fileIndex = i++,sourceDirectory = path,musicCompletePath = targetSongPath,albumName = TagLib.File.Create(targetSongPath).Tag.Album,musicFilename = targetSongPath.Remove(0,path.Length + 1)
            };
            return newSong;
        });
    }
}

最后，这是UnitOfWork类

public class UnitOfWork : IDisposable
{

    private HubohDBEntities _context = new HubohDBEntities();
    private GenericRepository<song> _songRepository;
    private GenericRepository<playlist> _playlistRepository;


    public GenericRepository<song> SongRepository
    {
        get
        {
            if(this._songRepository == null)
            {
                this._songRepository = new GenericRepository<song>(_context);
            }
            return _songRepository;
        }
    }

    public GenericRepository<playlist> PlaylistRepository
    {
        get
        {
            if (this._playlistRepository == null)
            {
                this._playlistRepository = new GenericRepository<playlist>(_context);
            }
            return _playlistRepository;
        }
    }

    public bool Save()
    {
        try
        {
            _context.SaveChanges();
            return true;
        }
        catch
        {
            return false;
        }        
    }



    #region IDisposable Support
    private bool disposed = false; // To detect redundant calls

    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (disposing)
            {
                _context.Dispose();
            }
            this.disposed = true;
        }
    }
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
    #endregion
}

因此，您可以看到MetadataPaser类具有一个方法，该方法是一个异步任务，该方法返回使用给定文件路径（第一个参数）和目录路径（第二个参数）创建的song对象。最初，该方法不是异步Task，只是一个简单的方法，它返回类型为song的对象，然后将其用于插入数据库。刚开始时效果很好，但后来我决定将200个文件移到该文件夹中，以查看会发生什么。你猜怎么着？ ...

不，你必须猜出来！

开玩笑。有些对象被插入，而其他对象没有被插入。因此，我认为Windows文件的移动/创建/删除等操作对于应用程序而言太快了，无法从mp3文件中提取元数据并将其插入数据库中。

我的解决方案（这里是我需要您帮助的地方）是创建一个List<Task<song>>，每次触发该事件时，将相应的任务插入该列表，并且一旦List<Task<song>>具有一个{ {1}}大于0开始执行其中的所有任务。

那我该怎么实现呢？
我应该在我的应用程序中的Count()上使用一些设计模式吗？
我应该将已移动到.txt文件的文件路径存储起来，然后使用计时器，每2分钟检查一下.txt文件是否包含某些内容并将其插入数据库中吗？
我应该更改发布的代码中的某些内容吗？

我希望我足够简洁，以至于有人可以理解和帮助。在此先感谢：）

FileSystemWatcher和EF6：任务和列表<任务<>>

如何解决FileSystemWatcher和EF6：任务和列表<任务<>>

相关推荐