เหตุการณ์ FileSystemWatcher Changed ถูกยกสองครั้ง

ฉันมีแอปพลิเคชันที่ฉันกำลังมองหาไฟล์ข้อความและหากมีการเปลี่ยนแปลงใด ๆ ที่เกิดขึ้นกับไฟล์ที่ฉันกำลังใช้ตัวOnChangedจัดการเหตุการณ์เพื่อจัดการกับเหตุการณ์ ฉันกำลังใช้NotifyFilters.LastWriteTimeแต่ยังคงมีเหตุการณ์โดนไล่ออกสองครั้ง นี่คือรหัส

public void Initialize()
{
   FileSystemWatcher _fileWatcher = new FileSystemWatcher();
  _fileWatcher.Path = "C:\\Folder";
  _fileWatcher.NotifyFilter = NotifyFilters.LastWrite;
  _fileWatcher.Filter = "Version.txt";
  _fileWatcher.Changed += new FileSystemEventHandler(OnChanged);
  _fileWatcher.EnableRaisingEvents = true;
}

private void OnChanged(object source, FileSystemEventArgs e)
{
   .......
}

ในกรณีของฉันOnChangedถูกเรียกสองครั้งเมื่อฉันเปลี่ยนไฟล์ข้อความversion.txtและบันทึก

ฉันกลัวว่านี่เป็นข้อผิดพลาดที่รู้จักกันดีของFileSystemWatcherชั้นเรียน นี่คือจากเอกสารของคลาส:

คุณอาจสังเกตเห็นในบางสถานการณ์ที่เหตุการณ์การสร้างเดียวสร้างเหตุการณ์ที่สร้างขึ้นหลายรายการซึ่งจัดการโดยองค์ประกอบของคุณ ตัวอย่างเช่นถ้าคุณใช้ส่วนประกอบ FileSystemWatcher เพื่อตรวจสอบการสร้างไฟล์ใหม่ในไดเรกทอรีและทดสอบโดยใช้ Notepad เพื่อสร้างไฟล์คุณอาจเห็นเหตุการณ์ที่สร้างขึ้นสองเหตุการณ์แม้ว่าจะสร้างไฟล์เดียวเท่านั้น นี่เป็นเพราะ Notepad ทำการดำเนินการหลายระบบไฟล์ในระหว่างกระบวนการเขียน Notepad เขียนไปยังดิสก์เป็นชุดที่สร้างเนื้อหาของไฟล์และจากนั้นแอตทริบิวต์ของไฟล์ แอปพลิเคชันอื่นอาจทำงานในลักษณะเดียวกัน เนื่องจาก FileSystemWatcher ตรวจสอบกิจกรรมของระบบปฏิบัติการเหตุการณ์ทั้งหมดที่แอ็พพลิเคชันเหล่านี้จะเริ่มทำงาน

ทีนี้ข้อความนี้เกี่ยวกับCreatedเหตุการณ์ แต่สิ่งเดียวกันกับเหตุการณ์ไฟล์อื่นเช่นกัน ในบางแอปพลิเคชันคุณอาจสามารถแก้ไขปัญหานี้ได้โดยใช้NotifyFilterคุณสมบัติ แต่ประสบการณ์ของฉันบอกว่าบางครั้งคุณต้องทำการกรองซ้ำด้วยตนเอง (แฮ็ค) ด้วยเช่นกัน

เมื่อไม่นานมานี้ฉันได้ทำเครื่องหมายหน้าเพจด้วยเคล็ดลับ FileSystemWatcherสองสามข้อ คุณอาจต้องการตรวจสอบ

ฉันได้ "แก้ไขปัญหา" โดยใช้กลยุทธ์ต่อไปนี้ในตัวแทนของฉัน

// fsw_ is the FileSystemWatcher instance used by my application.

private void OnDirectoryChanged(...)
{
   try
   {
      fsw_.EnableRaisingEvents = false;

      /* do my stuff once asynchronously */
   }

   finally
   {
      fsw_.EnableRaisingEvents = true;
   }
}

OnChangedเหตุการณ์ที่ซ้ำกันจากFileSystemWatcherสามารถตรวจจับและทิ้งได้โดยการตรวจสอบการFile.GetLastWriteTimeประทับเวลาของไฟล์ที่เป็นปัญหา ชอบมาก

DateTime lastRead = DateTime.MinValue;

void OnChanged(object source, FileSystemEventArgs a)
{
    DateTime lastWriteTime = File.GetLastWriteTime(uri);
    if (lastWriteTime != lastRead)
    {
        doStuff();
        lastRead = lastWriteTime;
    }
    // else discard the (duplicated) OnChanged event
}

นี่คือทางออกของฉันซึ่งช่วยให้ฉันหยุดเหตุการณ์ที่ถูกยกขึ้นสองครั้ง:

watcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.Size;

ที่นี่ฉันได้ตั้งค่าNotifyFilterคุณสมบัติด้วยชื่อไฟล์และขนาดเท่านั้น
watcherเป็นวัตถุของฉันของ FileSystemWatcher หวังว่าจะช่วยได้

สถานการณ์ของฉันคือฉันมีเครื่องเสมือนที่มีเซิร์ฟเวอร์ Linux อยู่ ฉันกำลังพัฒนาไฟล์บนโฮสต์ Windows เมื่อฉันเปลี่ยนบางสิ่งในโฟลเดอร์บนโฮสต์ฉันต้องการอัปโหลดการเปลี่ยนแปลงทั้งหมดซิงค์กับเซิร์ฟเวอร์เสมือนผ่าน Ftp นี่คือวิธีที่ฉันจะกำจัดเหตุการณ์การเปลี่ยนแปลงที่ซ้ำกันเมื่อฉันเขียนไปยังไฟล์ (ซึ่งแฟล็กโฟลเดอร์ที่มีไฟล์ที่จะแก้ไขด้วย):

private Hashtable fileWriteTime = new Hashtable();

private void fsw_sync_Changed(object source, FileSystemEventArgs e)
{
    string path = e.FullPath.ToString();
    string currentLastWriteTime = File.GetLastWriteTime( e.FullPath ).ToString();

    // if there is no path info stored yet
    // or stored path has different time of write then the one now is inspected
    if ( !fileWriteTime.ContainsKey(path) ||
         fileWriteTime[path].ToString() != currentLastWriteTime
    )
    {
        //then we do the main thing
        log( "A CHANGE has occured with " + path );

        //lastly we update the last write time in the hashtable
        fileWriteTime[path] = currentLastWriteTime;
    }
}

ส่วนใหญ่ฉันสร้าง hashtable เพื่อเก็บข้อมูลเวลาเขียนไฟล์ จากนั้นถ้า hashtable มี filepath ที่แก้ไขและค่าของเวลาเหมือนกับการเปลี่ยนแปลงของไฟล์ที่ได้รับแจ้งในขณะนั้นฉันรู้ว่ามันซ้ำซ้อนกับเหตุการณ์และไม่สนใจ

ลองด้วยรหัสนี้:

class WatchPlotDirectory
{
    bool let = false;
    FileSystemWatcher watcher;
    string path = "C:/Users/jamie/OneDrive/Pictures/Screenshots";

    public WatchPlotDirectory()
    {
        watcher = new FileSystemWatcher();
        watcher.Path = path;
        watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite
                               | NotifyFilters.FileName | NotifyFilters.DirectoryName;
        watcher.Filter = "*.*";
        watcher.Changed += new FileSystemEventHandler(OnChanged);
        watcher.Renamed += new RenamedEventHandler(OnRenamed);
        watcher.EnableRaisingEvents = true;
    }



    void OnChanged(object sender, FileSystemEventArgs e)
    {
        if (let==false) {
            string mgs = string.Format("File {0} | {1}",
                                       e.FullPath, e.ChangeType);
            Console.WriteLine("onchange: " + mgs);
            let = true;
        }

        else
        {
            let = false;
        }


    }

    void OnRenamed(object sender, RenamedEventArgs e)
    {
        string log = string.Format("{0} | Renamed from {1}",
                                   e.FullPath, e.OldName);
        Console.WriteLine("onrenamed: " + log);

    }

    public void setPath(string path)
    {
        this.path = path;
    }
}

นี่คือแนวทางของฉัน:

// Consider having a List<String> named _changedFiles

private void OnChanged(object source, FileSystemEventArgs e)
{
    lock (_changedFiles)
    {
        if (_changedFiles.Contains(e.FullPath))
        {
            return;
        }
        _changedFiles.Add(e.FullPath);
    }

    // do your stuff

    System.Timers.Timer timer = new Timer(1000) { AutoReset = false };
    timer.Elapsed += (timerElapsedSender, timerElapsedArgs) =>
    {
        lock (_changedFiles)
        {
            _changedFiles.Remove(e.FullPath);
        }
    };
   timer.Start();
}

นี่เป็นวิธีแก้ปัญหาที่ฉันใช้เพื่อแก้ไขปัญหานี้ในโครงการที่ฉันส่งไฟล์เป็นไฟล์แนบในเมล มันจะหลีกเลี่ยงเหตุการณ์ที่ถูกยิงเป็นครั้งที่สองได้อย่างง่ายดายแม้ในช่วงเวลาที่สั้นกว่า แต่ในกรณีของฉัน 1,000 ก็ไม่เป็นไรเพราะฉันมีความสุขกับการเปลี่ยนแปลงเล็กน้อยที่หายไป อย่างน้อยก็ทำงานได้ดีในกรณีที่มีการเปลี่ยนแปลงหลายไฟล์ในเวลาเดียวกัน

อีกวิธีหนึ่งที่ฉันคิดว่าน่าจะแทนที่รายการด้วยไฟล์การแมปพจนานุกรมเป็น MD5 ที่เกี่ยวข้องดังนั้นคุณไม่จำเป็นต้องเลือกช่วงเวลาโดยพลการเนื่องจากคุณไม่ต้องลบรายการ แต่อัปเดตค่าและ ยกเลิกข้อมูลของคุณหากยังไม่เปลี่ยน มันมีข้อเสียของการที่พจนานุกรมเติบโตขึ้นในหน่วยความจำเมื่อไฟล์ถูกตรวจสอบและกินหน่วยความจำมากขึ้นเรื่อย ๆ แต่ฉันได้อ่านที่ไหนสักแห่งว่าจำนวนไฟล์ที่ตรวจสอบนั้นขึ้นอยู่กับบัฟเฟอร์ภายในของ FSW ดังนั้นอาจไม่สำคัญ Dunno ว่าการคำนวณเวลา MD5 จะส่งผลกระทบต่อประสิทธิภาพการทำงานของโค้ดของคุณอย่างไรอย่างระมัดระวัง = \

ฉันได้สร้าง repo Git โดยมีคลาสที่ขยายFileSystemWatcherเพื่อกระตุ้นเหตุการณ์เมื่อคัดลอกเสร็จแล้ว มันจะยกเลิกกิจกรรมที่เปลี่ยนแปลงทั้งหมดที่ผ่านมาและจะเพิ่มเฉพาะเมื่อไฟล์พร้อมให้อ่าน

ดาวน์โหลดFileSystemSafeWatcherและเพิ่มลงในโครงการของคุณ

จากนั้นใช้เป็นปกติFileSystemWatcherและตรวจสอบเมื่อมีการเรียกใช้เหตุการณ์

var fsw = new FileSystemSafeWatcher(file);
fsw.EnableRaisingEvents = true;
// Add event handlers here
fsw.Created += fsw_Created;

ฉันรู้ว่านี่เป็นปัญหาเก่า แต่มีปัญหาเดียวกันและไม่มีวิธีการแก้ปัญหาข้างต้นจริง ๆ ที่ได้ทำเคล็ดลับสำหรับปัญหาที่ฉันเผชิญ ฉันสร้างพจนานุกรมที่แมปชื่อไฟล์ด้วย LastWriteTime ดังนั้นหากไฟล์ที่ไม่ได้อยู่ในพจนานุกรมจะไปข้างหน้ากับกระบวนการตรวจสอบอื่น ๆ ที่ชาญฉลาดเพื่อดูว่าเมื่อใดที่มีการแก้ไขครั้งล่าสุดและหากแตกต่างจากสิ่งที่อยู่ในพจนานุกรมเรียกใช้รหัส

    Dictionary<string, DateTime> dateTimeDictionary = new Dictionary<string, DateTime>(); 

        private void OnChanged(object source, FileSystemEventArgs e)
            {
                if (!dateTimeDictionary.ContainsKey(e.FullPath) || (dateTimeDictionary.ContainsKey(e.FullPath) && System.IO.File.GetLastWriteTime(e.FullPath) != dateTimeDictionary[e.FullPath]))
                {
                    dateTimeDictionary[e.FullPath] = System.IO.File.GetLastWriteTime(e.FullPath);

                    //your code here
                }
            }

หนึ่งที่เป็นไปได้ 'แฮ็ค' อาจเป็นการเร่งเหตุการณ์โดยใช้ส่วนขยายที่ทำปฏิกิริยาเช่น:

var watcher = new FileSystemWatcher("./");

Observable.FromEventPattern<FileSystemEventArgs>(watcher, "Changed")
            .Throttle(new TimeSpan(500000))
            .Subscribe(HandleChangeEvent);

watcher.EnableRaisingEvents = true;

ในกรณีนี้ฉันใช้ปริมาณน้อยถึง 50ms ในระบบของฉันที่เพียงพอ แต่ค่าที่สูงกว่าควรปลอดภัยกว่า (และอย่างที่ฉันบอกไปมันยังคงเป็น 'แฮ็ค')

ฉันมีวิธีแก้ปัญหาที่ง่ายและรวดเร็วมากที่นี่ใช้ได้กับฉันและไม่ว่าจะมีการเรียกใช้เหตุการณ์หนึ่งครั้งหรือสองครั้งหรือมากกว่านั้นเป็นครั้งคราวให้ลองดู:

private int fireCount = 0;
private void inputFileWatcher_Changed(object sender, FileSystemEventArgs e)
    {
       fireCount++;
       if (fireCount == 1)
        {
            MessageBox.Show("Fired only once!!");
            dowork();
        }
        else
        {
            fireCount = 0;
        }
    }
}

นี่คือทางออกใหม่ที่คุณสามารถลองได้ ทำงานได้ดีสำหรับฉัน ในตัวจัดการเหตุการณ์สำหรับเหตุการณ์ที่เปลี่ยนไปโดยทางโปรแกรมลบตัวจัดการออกจากตัวออกแบบเอาต์พุตข้อความหากต้องการจากนั้นเพิ่มตัวจัดการกลับโดยทางโปรแกรม ตัวอย่าง:

public void fileSystemWatcher1_Changed( object sender, System.IO.FileSystemEventArgs e )
    {            
        fileSystemWatcher1.Changed -= new System.IO.FileSystemEventHandler( fileSystemWatcher1_Changed );
        MessageBox.Show( "File has been uploaded to destination", "Success!" );
        fileSystemWatcher1.Changed += new System.IO.FileSystemEventHandler( fileSystemWatcher1_Changed );
    }

สาเหตุหลักคือเวลาเข้าถึงกิจกรรมครั้งแรกของเวลาคือเวลาปัจจุบัน (เขียนไฟล์หรือเปลี่ยนเวลา) จากนั้นเหตุการณ์ที่สองคือเวลาการเข้าถึงล่าสุดของไฟล์ ฉันแก้ไขภายใต้รหัส

        var lastRead = DateTime.MinValue;

        Watcher = new FileSystemWatcher(...)
        {
            NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite,
            Filter = "*.dll",
            IncludeSubdirectories = false,
        };
        Watcher.Changed += (senderObject, ea) =>
        {
            var now = DateTime.Now;
            var lastWriteTime = File.GetLastWriteTime(ea.FullPath);

            if (now == lastWriteTime)
            {
                return;
            }

            if (lastWriteTime != lastRead)
            {
                // do something...
                lastRead = lastWriteTime;
            }
        };

        Watcher.EnableRaisingEvents = true;

ฉันใช้เวลาอย่างมากในการใช้ FileSystemWatcher และวิธีการบางอย่างที่นี่จะไม่ทำงาน ฉันชอบวิธีการปิดการใช้งานจริง ๆ แต่น่าเสียดายที่มันไม่ทำงานหากมีไฟล์ตก>> 1 ไฟล์ไฟล์ที่สองจะถูกพลาดมากที่สุดหากไม่ใช่ทุกครั้ง ดังนั้นฉันใช้วิธีการดังต่อไปนี้:

private void EventCallback(object sender, FileSystemEventArgs e)
{
    var fileName = e.FullPath;

    if (!File.Exists(fileName))
    {
        // We've dealt with the file, this is just supressing further events.
        return;
    }

    // File exists, so move it to a working directory. 
    File.Move(fileName, [working directory]);

    // Kick-off whatever processing is required.
}

รหัสนี้ใช้ได้สำหรับฉัน

        private void OnChanged(object source, FileSystemEventArgs e)
    {

        string fullFilePath = e.FullPath.ToString();
        string fullURL = buildTheUrlFromStudyXML(fullFilePath);

        System.Diagnostics.Process.Start("iexplore", fullURL);

        Timer timer = new Timer();
        ((FileSystemWatcher)source).Changed -= new FileSystemEventHandler(OnChanged);
        timer.Interval = 1000;
        timer.Elapsed += new ElapsedEventHandler(t_Elapsed);
        timer.Start();
    }

    private void t_Elapsed(object sender, ElapsedEventArgs e)
    {
        ((Timer)sender).Stop();
        theWatcher.Changed += new FileSystemEventHandler(OnChanged);
    }

ส่วนใหญ่สำหรับอนาคตฉัน :)

ฉันเขียน wrapper โดยใช้ Rx:

 public class WatcherWrapper : IDisposable
{
    private readonly FileSystemWatcher _fileWatcher;
    private readonly Subject<FileSystemEventArgs> _infoSubject;
    private Subject<FileSystemEventArgs> _eventSubject;

    public WatcherWrapper(string path, string nameFilter = "*.*", NotifyFilters? notifyFilters = null)
    {
        _fileWatcher = new FileSystemWatcher(path, nameFilter);

        if (notifyFilters != null)
        {
            _fileWatcher.NotifyFilter = notifyFilters.Value;
        }

        _infoSubject = new Subject<FileSystemEventArgs>();
        _eventSubject = new Subject<FileSystemEventArgs>();

        Observable.FromEventPattern<FileSystemEventArgs>(_fileWatcher, "Changed").Select(e => e.EventArgs)
            .Subscribe(_infoSubject.OnNext);
        Observable.FromEventPattern<FileSystemEventArgs>(_fileWatcher, "Created").Select(e => e.EventArgs)
            .Subscribe(_infoSubject.OnNext);
        Observable.FromEventPattern<FileSystemEventArgs>(_fileWatcher, "Deleted").Select(e => e.EventArgs)
            .Subscribe(_infoSubject.OnNext);
        Observable.FromEventPattern<FileSystemEventArgs>(_fileWatcher, "Renamed").Select(e => e.EventArgs)
            .Subscribe(_infoSubject.OnNext);

        // this takes care of double events and still works with changing the name of the same file after a while
        _infoSubject.Buffer(TimeSpan.FromMilliseconds(20))
            .Select(x => x.GroupBy(z => z.FullPath).Select(z => z.LastOrDefault()).Subscribe(
                infos =>
                {
                    if (infos != null)
                        foreach (var info in infos)
                        {
                            {
                                _eventSubject.OnNext(info);
                            }
                        }
                });

        _fileWatcher.EnableRaisingEvents = true;
    }

    public IObservable<FileSystemEventArgs> FileEvents => _eventSubject;


    public void Dispose()
    {
        _fileWatcher?.Dispose();
        _eventSubject.Dispose();
        _infoSubject.Dispose();
    }
}

การใช้งาน:

var watcher = new WatcherWrapper(_path, "*.info");
// all more complicated and scenario specific filtering of events can be done here    
watcher.FileEvents.Where(x => x.ChangeType != WatcherChangeTypes.Deleted).Subscribe(x => //do stuff)

ฉันเปลี่ยนวิธีตรวจสอบไฟล์ในไดเรกทอรี แทนที่จะใช้ FileSystemWatcher ฉันสำรวจสถานที่บนเธรดอื่นแล้วดู LastWriteTime ของไฟล์

DateTime lastWriteTime = File.GetLastWriteTime(someFilePath);

การใช้ข้อมูลนี้และการจัดทำดัชนีของเส้นทางของไฟล์และเป็นเวลาการเขียนล่าสุดที่ฉันสามารถตรวจสอบไฟล์ที่มีการเปลี่ยนแปลงหรือที่ถูกสร้างขึ้นในสถานที่เฉพาะ สิ่งนี้จะลบฉันออกจากสิ่งแปลกประหลาดของ FileSystemWatcher ข้อเสียเปรียบหลักคือคุณต้องมีโครงสร้างข้อมูลเพื่อจัดเก็บ LastWriteTime และการอ้างอิงไปยังไฟล์ แต่เชื่อถือได้และใช้งานง่าย

คุณสามารถลองเปิดมันเพื่อเขียนและหากประสบความสำเร็จคุณสามารถสมมติว่าแอปพลิเคชันอื่น ๆ ทำกับไฟล์

private void OnChanged(object source, FileSystemEventArgs e)
{
    try
    {
        using (var fs = File.OpenWrite(e.FullPath))
        {
        }
        //do your stuff
    }
    catch (Exception)
    {
        //no write access, other app not done
    }
}

เพียงแค่เปิดเพื่อเขียนดูเหมือนจะไม่ยกเหตุการณ์ที่เปลี่ยนแปลง ดังนั้นควรปลอดภัย

FileReadTime = DateTime.Now;

private void File_Changed(object sender, FileSystemEventArgs e)
{            
    var lastWriteTime = File.GetLastWriteTime(e.FullPath);
    if (lastWriteTime.Subtract(FileReadTime).Ticks > 0)
    {
        // code
        FileReadTime = DateTime.Now;
    }
}

ขออภัยที่ขุดหลุมฝังศพ แต่ฉันได้รับการต่อสู้ปัญหานี้ในขณะนี้และในที่สุดก็มากับวิธีการจัดการเหตุการณ์ยิงหลายเหล่านี้ ฉันอยากจะขอบคุณทุกคนในกระทู้นี้เนื่องจากฉันได้ใช้มันในการอ้างอิงจำนวนมากเมื่อต้องต่อสู้กับปัญหานี้

นี่คือรหัสที่สมบูรณ์ของฉัน มันใช้พจนานุกรมเพื่อติดตามวันที่และเวลาของการเขียนไฟล์ครั้งล่าสุด มันเปรียบเทียบค่านั้นและถ้ามันเหมือนกันมันจะหยุดเหตุการณ์ จากนั้นตั้งค่าหลังจากเริ่มเธรดใหม่

using System.Threading; // used for backgroundworker
using System.Diagnostics; // used for file information
private static IDictionary<string, string> fileModifiedTable = new Dictionary<string, string>(); // used to keep track of our changed events

private void fswFileWatch_Changed( object sender, FileSystemEventArgs e )
    {
        try
        {
           //check if we already have this value in our dictionary.
            if ( fileModifiedTable.TryGetValue( e.FullPath, out sEmpty ) )
            {              
                //compare timestamps      
                if ( fileModifiedTable[ e.FullPath ] != File.GetLastWriteTime( e.FullPath ).ToString() )
                {        
                    //lock the table                
                    lock ( fileModifiedTable )
                    {
                        //make sure our file is still valid
                        if ( File.Exists( e.FullPath ) )
                        {                               
                            // create a new background worker to do our task while the main thread stays awake. Also give it do work and work completed handlers
                            BackgroundWorker newThreadWork = new BackgroundWorker();
                            newThreadWork.DoWork += new DoWorkEventHandler( bgwNewThread_DoWork );
                            newThreadWork.RunWorkerCompleted += new RunWorkerCompletedEventHandler( bgwNewThread_RunWorkerCompleted );

                            // capture the path
                            string eventFilePath = e.FullPath;
                            List<object> arguments = new List<object>();

                            // add arguments to pass to the background worker
                            arguments.Add( eventFilePath );
                            arguments.Add( newEvent.File_Modified );

                            // start the new thread with the arguments
                            newThreadWork.RunWorkerAsync( arguments );

                            fileModifiedTable[ e.FullPath ] = File.GetLastWriteTime( e.FullPath ).ToString(); //update the modified table with the new timestamp of the file.
                            FILE_MODIFIED_FLAG.WaitOne(); // wait for the modified thread to complete before firing the next thread in the event multiple threads are being worked on.
                        }
                    }
                }
            }
        }
        catch ( IOException IOExcept )
        {
            //catch any errors
            postError( IOExcept, "fswFileWatch_Changed" );
        }
    }

เหตุการณ์ถ้าไม่ถามก็น่าเสียดายที่ไม่มีตัวอย่างโซลูชันสำเร็จรูปสำหรับ F # เพื่อแก้ไขนี่คือสูตรของฉันเพียงเพราะฉันสามารถและ F # เป็นภาษา. NET ที่ยอดเยี่ยม

เหตุการณ์ที่ซ้ำกันจะถูกกรองออกโดยใช้FSharp.Control.Reactiveแพคเกจซึ่งเป็นเพียง wrapper F # สำหรับส่วนขยายปฏิกิริยา ทั้งหมดที่สามารถกำหนดเป็นกรอบเต็มหรือnetstandard2.0:

let createWatcher path filter () =
    new FileSystemWatcher(
        Path = path,
        Filter = filter,
        EnableRaisingEvents = true,
        SynchronizingObject = null // not needed for console applications
    )

let createSources (fsWatcher: FileSystemWatcher) =
    // use here needed events only. 
    // convert `Error` and `Renamed` events to be merded
    [| fsWatcher.Changed :> IObservable<_>
       fsWatcher.Deleted :> IObservable<_>
       fsWatcher.Created :> IObservable<_>
       //fsWatcher.Renamed |> Observable.map renamedToNeeded
       //fsWatcher.Error   |> Observable.map errorToNeeded
    |] |> Observable.mergeArray

let handle (e: FileSystemEventArgs) =
    printfn "handle %A event '%s' '%s' " e.ChangeType e.Name e.FullPath 

let watch path filter throttleTime =
    // disposes watcher if observer subscription is disposed
    Observable.using (createWatcher path filter) createSources
    // filter out multiple equal events
    |> Observable.distinctUntilChanged
    // filter out multiple Changed
    |> Observable.throttle throttleTime
    |> Observable.subscribe handle

[<EntryPoint>]
let main _args =
    let path = @"C:\Temp\WatchDir"
    let filter = "*.zip"
    let throttleTime = TimeSpan.FromSeconds 10.
    use _subscription = watch path filter throttleTime
    System.Console.ReadKey() |> ignore
    0 // return an integer exit code

ในกรณีของฉันต้องได้รับบรรทัดสุดท้ายของไฟล์ข้อความที่ถูกแทรกโดยแอปพลิเคชันอื่นทันทีที่แทรกเสร็จ นี่คือทางออกของฉัน เมื่อยกเหตุการณ์แรกขึ้นฉันปิดใช้งานตัวเฝ้าดูจากการเพิ่มผู้อื่นจากนั้นฉันเรียกตัวจับเวลา TimeElapsedEvent เพราะเมื่อฟังก์ชั่นการจัดการของฉันเรียกว่า OnChanged เรียกว่าฉันต้องการขนาดของไฟล์ข้อความ แต่ขนาดในเวลานั้นไม่ใช่ขนาดจริง มันเป็นขนาดของไฟล์ imediatelly ก่อนการแทรก ดังนั้นฉันรอสักครู่เพื่อดำเนินการกับขนาดไฟล์ที่เหมาะสม

private FileSystemWatcher watcher = new FileSystemWatcher();
...
watcher.Path = "E:\\data";
watcher.NotifyFilter = NotifyFilters.LastWrite ;
watcher.Filter = "data.txt";
watcher.Changed += new FileSystemEventHandler(OnChanged);
watcher.EnableRaisingEvents = true;

...

private void OnChanged(object source, FileSystemEventArgs e)
   {
    System.Timers.Timer t = new System.Timers.Timer();
    try
    {
        watcher.Changed -= new FileSystemEventHandler(OnChanged);
        watcher.EnableRaisingEvents = false;

        t.Interval = 500;
        t.Elapsed += (sender, args) => t_Elapsed(sender, e);
        t.Start();
    }
    catch(Exception ex) {
        ;
    }
}

private void t_Elapsed(object sender, FileSystemEventArgs e) 
   {
    ((System.Timers.Timer)sender).Stop();
       //.. Do you stuff HERE ..
     watcher.Changed += new FileSystemEventHandler(OnChanged);
     watcher.EnableRaisingEvents = true;
}

ลองสิ่งนี้มันใช้งานได้ดี

  private static readonly FileSystemWatcher Watcher = new FileSystemWatcher();
    static void Main(string[] args)
    {
        Console.WriteLine("Watching....");

        Watcher.Path = @"D:\Temp\Watcher";
        Watcher.Changed += OnChanged;
        Watcher.EnableRaisingEvents = true;
        Console.ReadKey();
    }

    static void OnChanged(object sender, FileSystemEventArgs e)
    {
        try
        {
            Watcher.Changed -= OnChanged;
            Watcher.EnableRaisingEvents = false;
            Console.WriteLine($"File Changed. Name: {e.Name}");
        }
        catch (Exception exception)
        {
            Console.WriteLine(exception);
        }
        finally
        {
            Watcher.Changed += OnChanged;
            Watcher.EnableRaisingEvents = true;
        }
    }

ฉันต้องการที่จะตอบสนองเฉพาะในเหตุการณ์ที่ผ่านมาในกรณีที่ยังเปลี่ยนไฟล์ลินุกซ์ก็ดูเหมือนว่าไฟล์นั้นว่างเปล่าในการโทรครั้งแรกและจากนั้นก็เติมอีกครั้งในครั้งต่อไปและไม่รังเกียจที่จะสูญเสียเวลาในกรณีที่ระบบปฏิบัติการ ตัดสินใจที่จะทำการเปลี่ยนแปลงไฟล์ / คุณลักษณะบางอย่าง

ฉันใช้. NET async ที่นี่เพื่อช่วยให้ฉันทำเกลียว

    private static int _fileSystemWatcherCounts;
    private async void OnChanged(object sender, FileSystemEventArgs e)
    {
        // Filter several calls in short period of time
        Interlocked.Increment(ref _fileSystemWatcherCounts);
        await Task.Delay(100);
        if (Interlocked.Decrement(ref _fileSystemWatcherCounts) == 0)
            DoYourWork();
    }

ฉันคิดว่าทางออกที่ดีที่สุดในการแก้ปัญหาคือใช้ส่วนขยายปฏิกิริยาเมื่อคุณแปลงเหตุการณ์เป็นที่สังเกตได้จากนั้นคุณสามารถเพิ่ม Throttling (.. ) (เดิมเรียกว่า Debounce (.. ))

โค้ดตัวอย่างที่นี่

        var templatesWatcher = new FileSystemWatcher(settingsSnapshot.Value.TemplatesDirectory)
        {
            NotifyFilter = NotifyFilters.LastWrite,
            IncludeSubdirectories = true
        };

        templatesWatcher.EnableRaisingEvents = true;

        Observable.FromEventPattern<FileSystemEventHandler, FileSystemEventArgs>(
                addHandler => templatesWatcher.Changed += addHandler,
                removeHandler => templatesWatcher.Changed -= removeHandler)
            .Throttle(TimeSpan.FromSeconds(5))
            .Subscribe(args =>
            {
                _logger.LogInformation($"Template file {args.EventArgs.Name} has changed");
                //TODO do something
            });

ฉันสามารถทำได้โดยเพิ่มฟังก์ชั่นที่จะตรวจสอบรายการที่ซ้ำกันในอาร์เรย์บัฟเฟอร์

จากนั้นดำเนินการหลังจากที่อาร์เรย์ไม่ได้ถูกแก้ไขเป็นเวลา X โดยใช้ตัวจับเวลา: - รีเซ็ตตัวจับเวลาทุกครั้งที่บางสิ่งถูกเขียนลงในบัฟเฟอร์ - ดำเนินการกับเห็บ

นี่จะเป็นการจับคู่การทำซ้ำอีกประเภทหนึ่ง หากคุณแก้ไขไฟล์ภายในโฟลเดอร์โฟลเดอร์จะส่งเหตุการณ์ Change

Function is_duplicate(str1 As String) As Boolean
    If lb_actions_list.Items.Count = 0 Then
        Return False
    Else
        Dim compStr As String = lb_actions_list.Items(lb_actions_list.Items.Count - 1).ToString
        compStr = compStr.Substring(compStr.IndexOf("-") + 1).Trim

        If compStr <> str1 AndAlso compStr.parentDir <> str1 & "\" Then
            Return False
        Else
            Return True
        End If
    End If
End Function

Public Module extentions
<Extension()>
Public Function parentDir(ByVal aString As String) As String
    Return aString.Substring(0, CInt(InStrRev(aString, "\", aString.Length - 1)))
End Function
End Module

วิธีนี้ใช้ได้ผลกับฉันในแอปพลิเคชันการผลิต:

สิ่งแวดล้อม:

VB.Net Framework 4.5.2

ตั้งค่าคุณสมบัติของวัตถุด้วยตนเอง: NotifyFilter = Size

จากนั้นใช้รหัสนี้:

Public Class main
    Dim CalledOnce = False
    Private Sub FileSystemWatcher1_Changed(sender As Object, e As IO.FileSystemEventArgs) Handles FileSystemWatcher1.Changed
            If (CalledOnce = False) Then
                CalledOnce = True
                If (e.ChangeType = 4) Then
                    ' Do task...
                CalledOnce = False
            End If
        End Sub
End Sub

ลองนี้สิ!

string temp="";

public void Initialize()
{
   FileSystemWatcher _fileWatcher = new FileSystemWatcher();
  _fileWatcher.Path = "C:\\Folder";
  _fileWatcher.NotifyFilter = NotifyFilters.LastWrite;
  _fileWatcher.Filter = "Version.txt";
  _fileWatcher.Changed += new FileSystemEventHandler(OnChanged);
  _fileWatcher.EnableRaisingEvents = true;
}

private void OnChanged(object source, FileSystemEventArgs e)
{
   .......
if(temp=="")
{
   //do thing you want.
   temp = e.name //name of text file.
}else if(temp !="" && temp != e.name)
{
   //do thing you want.
   temp = e.name //name of text file.
}else
{
  //second fire ignored.
}

}

ฉันต้องรวมแนวคิดหลายอย่างจากโพสต์ด้านบนและเพิ่มการตรวจสอบการล็อคไฟล์เพื่อให้มันทำงานได้สำหรับฉัน:

FileSystemWatcher fileSystemWatcher;

private void DirectoryWatcher_Start()
{
    FileSystemWatcher fileSystemWatcher = new FileSystemWatcher
    {
        Path = @"c:\mypath",
        NotifyFilter = NotifyFilters.LastWrite,
        Filter = "*.*",
        EnableRaisingEvents = true
    };

    fileSystemWatcher.Changed += new FileSystemEventHandler(DirectoryWatcher_OnChanged);
}

private static void WaitUntilFileIsUnlocked(String fullPath, Action<String> callback, FileAccess fileAccess = FileAccess.Read, Int32 timeoutMS = 10000)
{
    Int32 waitMS = 250;
    Int32 currentMS = 0;
    FileInfo file = new FileInfo(fullPath);
    FileStream stream = null;
    do
    {
        try
        {
            stream = file.Open(FileMode.Open, fileAccess, FileShare.None);
            stream.Close();
            callback(fullPath);
            return;
        }
        catch (IOException)
        {
        }
        finally
        {
            if (stream != null)
                stream.Dispose();
        }
        Thread.Sleep(waitMS);
        currentMS += waitMS;
    } while (currentMS < timeoutMS);
}    

private static Dictionary<String, DateTime> DirectoryWatcher_fileLastWriteTimeCache = new Dictionary<String, DateTime>();

private void DirectoryWatcher_OnChanged(Object source, FileSystemEventArgs ev)
{
    try
    {
        lock (DirectoryWatcher_fileLastWriteTimeCache)
        {
            DateTime lastWriteTime = File.GetLastWriteTime(ev.FullPath);
            if (DirectoryWatcher_fileLastWriteTimeCache.ContainsKey(ev.FullPath))
            {
                if (DirectoryWatcher_fileLastWriteTimeCache[ev.FullPath].AddMilliseconds(500) >= lastWriteTime)
                    return;     // file was already handled
            }

            DirectoryWatcher_fileLastWriteTimeCache[ev.FullPath] = lastWriteTime;
        }

        Task.Run(() => WaitUntilFileIsUnlocked(ev.FullPath, fullPath =>
        {
            // do the job with fullPath...
        }));

    }
    catch (Exception e)
    {
        // handle exception
    }
}

ฉันเข้าหาสองครั้งสร้างปัญหาเช่นนี้ซึ่งไม่สนใจเหตุการณ์แรก:

Private WithEvents fsw As New System.IO.FileSystemWatcher
Private complete As New List(Of String)

Private Sub fsw_Created(ByVal sender As Object, _
    ByVal e As System.IO.FileSystemEventArgs) Handles fsw.Created

    If Not complete.Contains(e.FullPath) Then
        complete.Add(e.FullPath)

    Else
        complete.Remove(e.FullPath)
        Dim th As New Threading.Thread(AddressOf hprocess)
        th.Start(e)

    End If

End Sub