มีวิธีการตรวจสอบว่าไฟล์มีการใช้งานหรือไม่?

ฉันกำลังเขียนโปรแกรมใน C # ที่จำเป็นต้องเข้าถึงไฟล์ภาพ 1 ไฟล์ซ้ำ ๆ เวลาส่วนใหญ่ของการทำงาน แต่หากคอมพิวเตอร์ของฉันทำงานได้อย่างรวดเร็วก็จะพยายามที่จะเข้าถึงไฟล์ก่อนที่มันจะได้รับการบันทึกกลับไปที่ระบบแฟ้มและโยนข้อผิดพลาด: "แฟ้มในการใช้งานโดยกระบวนการอื่น"

ฉันต้องการหาวิธีแก้ไขปัญหานี้ แต่ Googling ทั้งหมดของฉันให้ผลการตรวจสอบโดยใช้ข้อยกเว้นเท่านั้น นี่เป็นสิ่งที่ขัดกับศาสนาของฉันดังนั้นฉันจึงสงสัยว่าใครมีวิธีที่ดีกว่าในการทำมัน?

Updated หมายเหตุในการแก้ปัญหานี้ : การตรวจสอบด้วยจะล้มเหลวสำหรับไฟล์อ่านอย่างเดียวเพื่อแก้ปัญหาได้รับการแก้ไขตรวจสอบกับFileAccess.ReadWrite FileAccess.Readในขณะที่วิธีนี้ใช้งานได้เนื่องจากการพยายามตรวจสอบด้วยFileAccess.Readจะล้มเหลวหากไฟล์มีล็อคการเขียนหรืออ่านอย่างไรก็ตามวิธีนี้จะไม่ทำงานหากไฟล์ไม่มีล็อคการเขียนหรืออ่านอยู่เช่นเปิดแล้ว (สำหรับการอ่านหรือการเขียน) ด้วยการเข้าถึง FileShare อ่านหรือ FileShare.Write

ORIGINAL: ฉันใช้รหัสนี้มาหลายปีแล้วและฉันก็ไม่มีปัญหาอะไรกับมัน

เข้าใจความลังเลของคุณเกี่ยวกับการใช้ข้อยกเว้น แต่คุณไม่สามารถหลีกเลี่ยงได้ตลอดเวลา:

protected virtual bool IsFileLocked(FileInfo file)
{
    try
    {
        using(FileStream stream = file.Open(FileMode.Open, FileAccess.Read, FileShare.None))
        {
            stream.Close();
        }
    }
    catch (IOException)
    {
        //the file is unavailable because it is:
        //still being written to
        //or being processed by another thread
        //or does not exist (has already been processed)
        return true;
    }

    //file is not locked
    return false;
}

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

ทางออกที่ดีที่สุดของคุณคือลองจับ / ในที่สุดซึ่งพยายามที่จะได้รับการจัดการไฟล์

try
{
   using (Stream stream = new FileStream("MyFilename.txt", FileMode.Open))
   {
        // File/Stream manipulating code here
   }
} catch {
  //check here why it failed and ask user to retry if the file is in use.
}

ใช้สิ่งนี้เพื่อตรวจสอบว่าไฟล์ถูกล็อคหรือไม่:

using System.IO;
using System.Runtime.InteropServices;
internal static class Helper
{
const int ERROR_SHARING_VIOLATION = 32;
const int ERROR_LOCK_VIOLATION = 33;

private static bool IsFileLocked(Exception exception)
{
    int errorCode = Marshal.GetHRForException(exception) & ((1 << 16) - 1);
    return errorCode == ERROR_SHARING_VIOLATION || errorCode == ERROR_LOCK_VIOLATION;
}

internal static bool CanReadFile(string filePath)
{
    //Try-Catch so we dont crash the program and can check the exception
    try {
        //The "using" is important because FileStream implements IDisposable and
        //"using" will avoid a heap exhaustion situation when too many handles  
        //are left undisposed.
        using (FileStream fileStream = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None)) {
            if (fileStream != null) fileStream.Close();  //This line is me being overly cautious, fileStream will never be null unless an exception occurs... and I know the "using" does it but its helpful to be explicit - especially when we encounter errors - at least for me anyway!
        }
    }
    catch (IOException ex) {
        //THE FUNKY MAGIC - TO SEE IF THIS FILE REALLY IS LOCKED!!!
        if (IsFileLocked(ex)) {
            // do something, eg File.Copy or present the user with a MsgBox - I do not recommend Killing the process that is locking the file
            return false;
        }
    }
    finally
    { }
    return true;
}
}

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

public static byte[] ReadFileBytes(string filePath)
{
    byte[] buffer = null;
    try
    {
        using (FileStream fileStream = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
        {
            int length = (int)fileStream.Length;  // get file length
            buffer = new byte[length];            // create buffer
            int count;                            // actual number of bytes read
            int sum = 0;                          // total number of bytes read

            // read until Read method returns 0 (end of the stream has been reached)
            while ((count = fileStream.Read(buffer, sum, length - sum)) > 0)
                sum += count;  // sum is a buffer offset for next reading

            fileStream.Close(); //This is not needed, just me being paranoid and explicitly releasing resources ASAP
        }
    }
    catch (IOException ex)
    {
        //THE FUNKY MAGIC - TO SEE IF THIS FILE REALLY IS LOCKED!!!
        if (IsFileLocked(ex))
        {
            // do something? 
        }
    }
    catch (Exception ex)
    {
    }
    finally
    {
    }
    return buffer;
}

public static string ReadFileTextWithEncoding(string filePath)
{
    string fileContents = string.Empty;
    byte[] buffer;
    try
    {
        using (FileStream fileStream = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
        {
            int length = (int)fileStream.Length;  // get file length
            buffer = new byte[length];            // create buffer
            int count;                            // actual number of bytes read
            int sum = 0;                          // total number of bytes read

            // read until Read method returns 0 (end of the stream has been reached)
            while ((count = fileStream.Read(buffer, sum, length - sum)) > 0)
            {
                sum += count;  // sum is a buffer offset for next reading
            }

            fileStream.Close(); //Again - this is not needed, just me being paranoid and explicitly releasing resources ASAP

            //Depending on the encoding you wish to use - I'll leave that up to you
            fileContents = System.Text.Encoding.Default.GetString(buffer);
        }
    }
    catch (IOException ex)
    {
        //THE FUNKY MAGIC - TO SEE IF THIS FILE REALLY IS LOCKED!!!
        if (IsFileLocked(ex))
        {
            // do something? 
        }
    }
    catch (Exception ex)
    {
    }
    finally
    { }     
    return fileContents;
}

public static string ReadFileTextNoEncoding(string filePath)
{
    string fileContents = string.Empty;
    byte[] buffer;
    try
    {
        using (FileStream fileStream = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
        {
            int length = (int)fileStream.Length;  // get file length
            buffer = new byte[length];            // create buffer
            int count;                            // actual number of bytes read
            int sum = 0;                          // total number of bytes read

            // read until Read method returns 0 (end of the stream has been reached)
            while ((count = fileStream.Read(buffer, sum, length - sum)) > 0) 
            {
                sum += count;  // sum is a buffer offset for next reading
            }

            fileStream.Close(); //Again - this is not needed, just me being paranoid and explicitly releasing resources ASAP

            char[] chars = new char[buffer.Length / sizeof(char) + 1];
            System.Buffer.BlockCopy(buffer, 0, chars, 0, buffer.Length);
            fileContents = new string(chars);
        }
    }
    catch (IOException ex)
    {
        //THE FUNKY MAGIC - TO SEE IF THIS FILE REALLY IS LOCKED!!!
        if (IsFileLocked(ex))
        {
            // do something? 
        }
    }
    catch (Exception ex)
    {
    }
    finally
    {
    }

    return fileContents;
}

ลองด้วยตัวคุณเอง:

byte[] output1 = Helper.ReadFileBytes(@"c:\temp\test.txt");
string output2 = Helper.ReadFileTextWithEncoding(@"c:\temp\test.txt");
string output3 = Helper.ReadFileTextNoEncoding(@"c:\temp\test.txt");

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

ใช้ฟังก์ชั่นด้านล่างเช่น

TimeoutFileAction(() => { System.IO.File.etc...; return null; } );

วิธีการที่นำกลับมาใช้ซ้ำได้ซึ่งจะหมดเวลาหลังจาก 2 วินาที

private T TimeoutFileAction<T>(Func<T> func)
{
    var started = DateTime.UtcNow;
    while ((DateTime.UtcNow - started).TotalMilliseconds < 2000)
    {
        try
        {
            return func();                    
        }
        catch (System.IO.IOException exception)
        {
            //ignore, or log somewhere if you want to
        }
    }
    return default(T);
}

บางทีคุณสามารถใช้FileSystemWatcherและเฝ้าดูการเปลี่ยนแปลงของเหตุการณ์

ฉันไม่ได้ใช้สิ่งนี้ด้วยตัวเอง แต่มันอาจจะคุ้มค่ากับการยิง หาก filesystemwatcher กลายเป็นบิตหนักสำหรับกรณีนี้ฉันจะไปลอง / catch / sleep loop

คุณสามารถส่งคืนงานที่ให้กระแสข้อมูลแก่คุณทันทีที่พร้อมใช้งาน มันเป็นทางออกที่ง่าย แต่มันก็เป็นจุดเริ่มต้นที่ดี มันด้ายปลอดภัย

private async Task<Stream> GetStreamAsync()
{
    try
    {
        return new FileStream("sample.mp3", FileMode.Open, FileAccess.Write);
    }
    catch (IOException)
    {
        await Task.Delay(TimeSpan.FromSeconds(1));
        return await GetStreamAsync();
    }
}

คุณสามารถใช้สตรีมนี้ได้ตามปกติ:

using (var stream = await FileStreamGetter.GetStreamAsync())
{
    Console.WriteLine(stream.Length);
}

วิธีเดียวที่ฉันรู้คือใช้ Win32 exclusive lock API ซึ่งไม่รวดเร็วเกินไป แต่มีตัวอย่างอยู่

คนส่วนใหญ่สำหรับวิธีง่ายๆในการนี้เพียงลอง / จับ / นอนหลับวน

static bool FileInUse(string path)
    {
        try
        {
            using (FileStream fs = new FileStream(path, FileMode.OpenOrCreate))
            {
                fs.CanWrite
            }
            return false;
        }
        catch (IOException ex)
        {
            return true;
        }
    }

string filePath = "C:\\Documents And Settings\\yourfilename";
bool isFileInUse;

isFileInUse = FileInUse(filePath);

// Then you can do some checking
if (isFileInUse)
   Console.WriteLine("File is in use");
else
   Console.WriteLine("File is not in use");

หวังว่านี่จะช่วยได้!

คำตอบที่ได้รับการยอมรับด้านบนประสบปัญหาเมื่อไฟล์ถูกเปิดเพื่อการเขียนด้วยโหมด FileShare.Read หรือหากไฟล์นั้นมีคุณสมบัติอ่านอย่างเดียวรหัสจะไม่ทำงาน โซลูชันที่ปรับเปลี่ยนนี้ทำงานได้อย่างน่าเชื่อถือที่สุดโดยคำนึงถึงสองสิ่งที่ต้องคำนึงถึง (เป็นจริงสำหรับโซลูชันที่ยอมรับเช่นกัน):

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

เมื่อคำนึงถึงข้างต้นแล้วสิ่งนี้จะตรวจสอบว่าไฟล์ถูกล็อคเพื่อการเขียนหรือล็อคเพื่อป้องกันการอ่านหรือไม่ :

public static bool FileLocked(string FileName)
{
    FileStream fs = null;

    try
    {
        // NOTE: This doesn't handle situations where file is opened for writing by another process but put into write shared mode, it will not throw an exception and won't show it as write locked
        fs = File.Open(FileName, FileMode.Open, FileAccess.ReadWrite, FileShare.None); // If we can't open file for reading and writing then it's locked by another process for writing
    }
    catch (UnauthorizedAccessException) // https://msdn.microsoft.com/en-us/library/y973b725(v=vs.110).aspx
    {
        // This is because the file is Read-Only and we tried to open in ReadWrite mode, now try to open in Read only mode
        try
        {
            fs = File.Open(FileName, FileMode.Open, FileAccess.Read, FileShare.None);
        }
        catch (Exception)
        {
            return true; // This file has been locked, we can't even open it to read
        }
    }
    catch (Exception)
    {
        return true; // This file has been locked
    }
    finally
    {
        if (fs != null)
            fs.Close();
    }
    return false;
}

นอกเหนือจากการทำงาน 3-liners และเพียงเพื่อการอ้างอิง: หากคุณต้องการข้อมูลที่สมบูรณ์แบบ - มีโครงการเล็ก ๆ ใน Microsoft Dev Center:

https://code.msdn.microsoft.com/windowsapps/How-to-know-the-process-704839f4

จากการแนะนำ:

โค้ดตัวอย่าง C # ที่พัฒนาใน. NET Framework 4.0 จะช่วยในการค้นหาว่าเป็นกระบวนการที่มีการล็อกไฟล์หรือไม่ ฟังก์ชันRmStartSessionซึ่งรวมอยู่ใน rstrtmgr.dll ถูกใช้เพื่อสร้างเซสชันตัวจัดการการรีสตาร์ทและตามผลลัพธ์ที่ส่งคืนอินสแตนซ์ใหม่ของวัตถุ Win32Exception จะถูกสร้างขึ้น หลังจากลงทะเบียนทรัพยากรไปยังเซสชันเริ่มต้นตัวจัดการใหม่ผ่าน ฟังก์ชันRmRegisterRescourcesฟังก์ชันRmGetListจะถูกเรียกใช้เพื่อตรวจสอบว่าแอปพลิเคชันใดกำลังใช้ไฟล์ใดไฟล์หนึ่งโดยการระบุอาเรย์ RM_PROCESS_INFO

มันทำงานได้โดยเชื่อมต่อกับ "รีสตาร์ทเซสชันผู้จัดการ"

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

มันอาจจะเล็ก ๆ น้อย ๆoverengineeredสำหรับความต้องการเฉพาะของคุณ ... แต่ถ้านั่นคือสิ่งที่คุณต้องการไปข้างหน้าและคว้า VS-โครงการ

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

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

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

var originalFolder = @"c:\myHugeCollectionOfFiles"; // your folder name here
var someFolder = Path.Combine(originalFolder, "..", Guid.NewGuid().ToString("N"));

try
{
    Directory.Move(originalFolder, someFolder);

    // Use files
}
catch // TODO: proper exception handling
{
    // Inform user, take action
}
finally
{
    Directory.Move(someFolder, originalFolder);
}

สำหรับไฟล์แต่ละไฟล์ฉันจะยึดติดกับคำแนะนำการล็อคที่โพสต์โดย Jeremy Thompson

นี่คือโค้ดบางส่วนที่ดีที่สุดที่ฉันสามารถบอกได้ว่าทำแบบเดียวกับคำตอบที่ยอมรับ แต่ใช้รหัสน้อย:

    public static bool IsFileLocked(string file)
    {
        try
        {
            using (var stream = File.OpenRead(file))
                return false;
        }
        catch (IOException)
        {
            return true;
        }        
    }

อย่างไรก็ตามฉันคิดว่ามันแข็งแกร่งกว่าที่จะทำในลักษณะต่อไปนี้:

    public static void TryToDoWithFileStream(string file, Action<FileStream> action, 
        int count, int msecTimeOut)
    {
        FileStream stream = null;
        for (var i = 0; i < count; ++i)
        {
            try
            {
                stream = File.OpenRead(file);
                break;
            }
            catch (IOException)
            {
                Thread.Sleep(msecTimeOut);
            }
        }
        action(stream);
    }

คุณสามารถใช้ห้องสมุดของฉันเพื่อเข้าถึงไฟล์จากหลายแอพ

คุณสามารถติดตั้งได้จาก nuget: Install-Package Xabe.FileLock

หากคุณต้องการข้อมูลเพิ่มเติมเกี่ยวกับเรื่องนี้โปรดตรวจสอบ https://github.com/tomaszzmuda/Xabe.FileLock

ILock fileLock = new FileLock(file);
if(fileLock.Acquire(TimeSpan.FromSeconds(15), true))
{
    using(fileLock)
    {
        // file operations here
    }
}

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

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

string str_path_and_name = str_path + '\\' + str_filename;
FileInfo fInfo = new FileInfo(str_path_and_name);
bool open_elsewhere = false;
try
{
    fInfo.MoveTo(str_path_and_name);
}
catch (Exception ex)
{
    open_elsewhere = true;
}

if (open_elsewhere)
{
    //handle case
}

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

แทนที่จะล้มเหลวในลักษณะที่ไม่อัปเดตฉันตัดสินใจใช้เวอร์ชันไฟล์ที่เพิ่มขึ้นอัตโนมัติ:

private static string WriteFileToDisk(byte[] data, string fileName, int version = 0)
{
    try
    {
        var versionExtension = version > 0 ? $"_{version:000}" : string.Empty;
        var filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"{fileName}{versionExtension}.pdf");
        using (var writer = new FileStream(filePath, FileMode.Create))
        {
            writer.Write(data, 0, data.Length);
        }
        return filePath;
    }
    catch (IOException)
    {
        return WriteFileToDisk(data, fileName, ++version);
    }
}

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

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

ต้องการความช่วยเหลือนี้ไหม?

var fileWasWrittenSuccessfully = false;
while (fileWasWrittenSuccessfully == false)
{
    try
    {
        lock (new Object())
        {
            using (StreamWriter streamWriter = new StreamWriter(filepath.txt"), true))
            {
                streamWriter.WriteLine("text");
            }
        }

        fileWasWrittenSuccessfully = true;
    }
    catch (Exception)
    {

    }
}

ลองและย้าย / คัดลอกไฟล์ไปยัง temp dir หากคุณสามารถทำได้จะไม่มีการล็อคและคุณสามารถทำงานใน temp dir ได้อย่างปลอดภัยโดยไม่ต้องล็อค อื่นลองย้ายอีกครั้งในอีก x วินาที

ฉันใช้วิธีแก้ปัญหานี้ แต่ฉันมีช่วงเวลาระหว่างเมื่อฉันตรวจสอบการล็อคไฟล์ด้วยฟังก์ชั่น IsFileLocked และเมื่อฉันเปิดไฟล์ ในช่วงเวลานี้บางเธรดอื่นสามารถเปิดไฟล์ได้ดังนั้นฉันจะได้รับ IOException

ดังนั้นฉันจึงเพิ่มรหัสพิเศษสำหรับสิ่งนี้ ในกรณีของฉันฉันต้องการโหลด XDocument:

        XDocument xDoc = null;

        while (xDoc == null)
        {
            while (IsFileBeingUsed(_interactionXMLPath))
            {
                Logger.WriteMessage(Logger.LogPrioritet.Warning, "Deserialize can not open XML file. is being used by another process. wait...");
                Thread.Sleep(100);
            }
            try
            {
                xDoc = XDocument.Load(_interactionXMLPath);
            }
            catch
            {
                Logger.WriteMessage(Logger.LogPrioritet.Error, "Load working!!!!!");
            }
        }

คุณคิดอย่างไร? ฉันสามารถเปลี่ยนแปลงบางสิ่งได้ไหม? บางทีฉันไม่ต้องใช้ฟังก์ชั่น IsFileBeingUsed เลย?

ขอบคุณ