Unity编辑器的线程安全文件系统监视器

using System.IO; //class, namespace, redundant info...
private static FileSystemWatcher m_Watcher;
[InitializeOnLoadMethod]
static void HookWatcher() 
{
    m_Watcher = new FileSystemWatcher("path", "*.cs");
    m_Watcher.NotifyFilter = NotifyFilters.LastWrite;
    m_Watcher.IncludeSubdirectories = true;
    //m_Watcher.Created += new FileSystemEventHandler(); //Add to the solution before compile
    //m_Watcher.Renamed += new FileSystemEventHandler(); //Rename to the solution before compile
    //m_Watcher.Deleted += new FileSystemEventHandler(); //Remove to the solution before compile
    m_Watcher.Changed += Recompile;
    m_Watcher.EnableRaisingEvents = true;
}
private static void Recompile(object sender, FileSystemEventArgs e) 
{
    Debug.Log("Origin files has been changed!");
}

根据我的经验，你可以使用线程，但你必须注意访问Unity类只能从主线程执行。我的建议是，当你的看门狗发出警报时，把控制权交给主线程。

static bool _triggerRecompile = false;
[InitializeOnLoadMethod]
static void HookWatcher() 
{
    m_Watcher = new FileSystemWatcher("path", "*.cs");
    // ....
    m_Watcher.Changed += Recompile;
    EditorApplication.update += OnEditorApplicationUpdate;
}
private static void Recompile(object sender, FileSystemEventArgs e) 
{
    bool _triggerRecompile = true;
    // Never call any Unity classes as we are not in the main thread
}
static void OnEditorApplicationUpdate ()
{
    // note that this is called very often (100/sec)
    if (_triggerRecompile)
    {
        _triggerRecompile = false;
        Debug.Log("Origin files has been changed!");
        DoRecompile();
    }
}

投票当然是一种肮脏和丑陋。一般来说，我更喜欢基于事件的方法。但是在这种特殊情况下，我认为没有机会欺骗主线程规则。

我在@Kay的帮助下解决了，谢谢@Kay!

我想做一个更通用的答案，所以我决定做我自己的类来实现我想要的。结果如下:

using System;
using System.IO;
using System.Collections.Generic;
namespace Lerp2APIEditor.Utility
{
    public class LerpedThread<T>
    {
        public T value = default(T);
        public bool isCalled = false;
        public string methodCalled = "";
        public Dictionary<string, Action> matchedMethods = new Dictionary<string, Action>();
        public FileSystemWatcher FSW
        {
            get
            {
                return (FileSystemWatcher)(object)value;
            }
        }
        public LerpedThread(string name, FSWParams pars)
        {
            if(typeof(T) == typeof(FileSystemWatcher))
            {
                FileSystemWatcher watcher = new FileSystemWatcher(pars.path, pars.filter);
                watcher.NotifyFilter = pars.notifiers;
                watcher.IncludeSubdirectories = pars.includeSubfolders;
                watcher.Changed += new FileSystemEventHandler(OnChanged);
                watcher.Created += new FileSystemEventHandler(OnCreated);
                watcher.Deleted += new FileSystemEventHandler(OnDeleted);
                watcher.Renamed += new RenamedEventHandler(OnRenamed);
                ApplyChanges(watcher);
            }
        }
        private void OnChanged(object source, FileSystemEventArgs e)
        {
            methodCalled = "OnChanged";
            isCalled = true;
        }
        private void OnCreated(object source, FileSystemEventArgs e)
        {
            methodCalled = "OnCreated";
            isCalled = true;
        }
        private void OnDeleted(object source, FileSystemEventArgs e)
        {
            methodCalled = "OnDeleted";
            isCalled = true;
        }
        private void OnRenamed(object source, RenamedEventArgs e)
        {
            methodCalled = "OnRenamed";
            isCalled = true;
        }
        public void StartFSW()
        {
            FSW.EnableRaisingEvents = true;
        }
        public void CancelFSW()
        {
            FSW.EnableRaisingEvents = false;
        }
        public void ApplyChanges<T1>(T1 obj)
        {
            value = (T)(object)obj;
        }
    }
    public class FSWParams
    {
        public string path,
                      filter;
        public NotifyFilters notifiers;
        public bool includeSubfolders;
        public FSWParams(string p, string f, NotifyFilters nf, bool isf)
        {
            path = p;
            filter = f;
            notifiers = nf;
            includeSubfolders = isf;
        }
    }
}

主类代码:

namespace Lerp2APIEditor
{
    public class LerpedEditorCore
    {
        private static LerpedThread<FileSystemWatcher> m_Watcher;
        [InitializeOnLoadMethod]
        static void HookWatchers() 
        {
            EditorApplication.update += OnEditorApplicationUpdate;
            m_Watcher.matchedMethods.Add("OnChanged", () => {
                Debug.Log("Origin files has been changed!");
            });
            m_Watcher.StartFSW();
        }
        static void OnEditorApplicationUpdate()
        {
            if(EditorApplication.timeSinceStartup > nextSeek)
            {
                if (m_Watcher.isCalled)
                {
                    foreach (KeyValuePair<string, Action> kv in m_Watcher.matchedMethods)
                        if (m_Watcher.methodCalled == kv.Key)
                            kv.Value();
                    m_Watcher.isCalled = false;
                }
                nextSeek = EditorApplication.timeSinceStartup + threadSeek;
            }
        }
    }
}

我所做的事很简单。我只创建了一个泛型类，它可以创建一个FSW实例或任何你想听的。创建一次后，我附加了只激活bool @Kay建议我使用的事件，以及调用的方法，以便确切地知道调用了哪个方法。

在主类的后面，如果检测到变化，则每秒循环列出的每个方法，并且调用链接到字符串的方法。