當文件被鎖定時避免崩潰？

Question

從意見分辨率：
應用程序崩潰是由另一個問題

我讀/書面方式從2個不同的應用程序文件，當文件被讀取或寫入造成的，它總是會被鎖定應用程序A或B，他們都使用FileShare.None。

我的問題是，即使包裝讀者周圍的try/catch它仍然崩潰與IOException異常在使用在線應用程序（不與writter發生）。

我也取得漁獲作爲catch (IOException ...，我認爲它可以使再沒有其他的區別，使其更具可讀性。

是什麼時，文件被鎖定，並不斷嘗試，直到該文件是可忽略的正確方法是什麼？

while (true) 
{ 
    try 
    { 
     using (FileStream stream = new FileStream("test_file.dat", FileMode.Open, FileAccess.Read, FileShare.None)) 
     { 
      using (TextReader reader = new StreamReader(stream)) 
      { 
       // bla bla bla does not matter 
      } 
     } 
    } 
    catch 
    { 
     // bla bla bla does not matter again 
    } 
    Thread.Sleep(500); 
} 

寫

private bool WriteData(string data) 
{ 
    try 
    { 
     using (FileStream stream = new FileStream("test_file.dat", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None)) 
     { 
      stream.SetLength(0); 
      using (TextWriter writer = new StreamWriter(stream)) 
      { 
       writer.Write(data); 
      } 
     } 
     return true; 
    } 
    catch 
    { 
     return false; 
    } 
} 

請注意，當正在使用的文件的任何過程中它讀取或書面方式所以基本上我不會放棄股權（包括作者和讀者使用FileShare.None）任何人我正在處理異常情況，直到文件可用爲止。

Answer 1

下面是我們爲此目的而使用的代碼。使用

/// <summary> 
/// Executes the specified action. If the action results in a file sharing violation exception, the action will be 
/// repeatedly retried after a short delay (which increases after every failed attempt). 
/// </summary> 
/// <param name="action">The action to be attempted and possibly retried.</param> 
/// <param name="maximum">Maximum amount of time to keep retrying for. When expired, any sharing violation 
/// exception will propagate to the caller of this method. Use null to retry indefinitely.</param> 
/// <param name="onSharingVio">Action to execute when a sharing violation does occur (is called before the waiting).</param> 
public static void WaitSharingVio(Action action, TimeSpan? maximum = null, Action onSharingVio = null) 
{ 
    WaitSharingVio<bool>(() => { action(); return true; }, maximum, onSharingVio); 
} 

/// <summary> 
/// Executes the specified function. If the function results in a file sharing violation exception, the function will be 
/// repeatedly retried after a short delay (which increases after every failed attempt). 
/// </summary> 
/// <param name="func">The function to be attempted and possibly retried.</param> 
/// <param name="maximum">Maximum amount of time to keep retrying for. When expired, any sharing violation 
/// exception will propagate to the caller of this method. Use null to retry indefinitely.</param> 
/// <param name="onSharingVio">Action to execute when a sharing violation does occur (is called before the waiting).</param> 
public static T WaitSharingVio<T>(Func<T> func, TimeSpan? maximum = null, Action onSharingVio = null) 
{ 
    var started = DateTime.UtcNow; 
    int sleep = 279; 
    while (true) 
    { 
     try 
     { 
      return func(); 
     } 
     catch (IOException ex) 
     { 
      int hResult = 0; 
      try { hResult = (int) ex.GetType().GetProperty("HResult", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(ex, null); } 
      catch { } 
      if (hResult != -2147024864) // 0x80070020 ERROR_SHARING_VIOLATION 
       throw; 
      if (onSharingVio != null) 
       onSharingVio(); 
     } 

     if (maximum != null) 
     { 
      int leftMs = (int) (maximum.Value - (DateTime.UtcNow - started)).TotalMilliseconds; 
      if (sleep > leftMs) 
      { 
       Thread.Sleep(leftMs); 
       return func(); // or throw the sharing vio exception 
      } 
     } 

     Thread.Sleep(sleep); 
     sleep = Math.Min((sleep * 3) >> 1, 10000); 
    } 
} 

例子：

Utilities.WaitSharingVio(
    action:() => 
    { 
     using (var f = File.Open(file, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None)) 
     { 
      // ... blah, process the file 
     } 
    }, 
    onSharingVio:() => 
    { 
     Console.WriteLine("Sharing violation. Trying again soon..."); 
    } 
); 

Answer 2

使用Reader &作家鎖
正確捕獲的語法

catch(Exception e) 

while (true) 
{ 
    try 
    { 
     using (FileStream stream = new FileStream("test_file.dat", FileMode.Open, FileAccess.Read, FileShare.None)) 
     { 
      using (TextReader reader = new StreamReader(stream)) 
      { 
       // bla bla bla does not matter 
      } 
     } 
    } 
    catch(Exception e) 
    { 
     // bla bla bla does not matter again 
    } 
    Thread.Sleep(500); 
} 

Answer 3

您可以使用一個互斥對象來保護共享資源，從多個線程或進程同時訪問。

Answer 4

我這樣做從01​​一次使用信息。

我想結果是有點像ReaderWriterLockSlim即在多個進程，而不是線程，被訪問的資源的情況下工作。

Answer 5

您可以通過編寫如下功能檢查您的文件鎖定：

protected bool IsFileLocked(FileInfo file) 
{ 
    FileStream stream = null; 

    try 
    { 
     stream = file.Open(FileMode.Open, FileAccess.ReadWrite, FileShare.None); 
    } 
    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; 
    } 
    finally 
    { 
     if (stream != null) 
      stream.Close(); 
    } 

    //file is not locked 
    return false; 
} 

Answer 6

從Timwi答案（在另一種情況下雖然）幫助我們很多，但我發現標誌「BindingFlags.Public」也需要，如果你想加入從所有的IOExceptions獲取HRESULT：當你說「死機」

public static int GetHresult(this IOException ex) 
{ 
    return (int)ex.GetType().GetProperty("HResult", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).GetValue(ex, null); 
}