Creare 2 FileStream sullo stesso file nello stesso processo

Question

Sto provando a creare un file temporaneo che verrà automaticamente eliminato.

stream = new FileStream(
      tmpFilePath, 
      FileMode.OpenOrCreate, 
      FileAccess.ReadWrite, 
      FileShare.ReadWrite, 
      4096, 
      FileOptions.DeleteOnClose|FileOptions.RandomAccess 
      ); 

Questo file verrà utilizzato da un API 3rd party che sarà anche creare un FileStream:

stream = new FileStream(
      tmpFilePath, 
      FileMode.Open, 
      FileAccess.Read, 
      FileShare.Read); 

Credo di aver provato tutte le possibili combinazioni di bandiere ma ottengo sempre "il processo impossibile accedere al file "XXX" perché è utilizzato da un altro processo ... "

Sto facendo qualcosa di sbagliato? C'è un modo per aggirare?

Answer 1

Sembra che si desideri utilizzare un file mappato in memoria come metodo per condividere un singolo file con più processi.

http://msdn.microsoft.com/en-us/library/system.io.memorymappedfiles.memorymappedfile.aspx

Answer 2

Il problema è che avete ancora il primo flusso si è creato aperto. È necessario creare il file, quindi rilasciarlo (chiudere lo stream), quindi fare in modo che l'API di terze parti funzioni, quindi eliminare il file. Racchiudere tutto questo in una classe che è IDSoable potrebbe essere una buona soluzione; crea e rilascia il file nel contructor, avvolgi il metodo del lavoro di terze parti, elimina nel metodo dispose.

Answer 3

Secondo la documentazione, sì.

http://msdn.microsoft.com/en-us/library/system.io.fileshare.aspx

Estratto:

Leggi: consente la successiva apertura del file per la lettura. Se questo flag non viene specificato, qualsiasi richiesta di apertura del file per la lettura (tramite questo processo o un altro processo) avrà esito negativo fino alla chiusura del file. Tuttavia, anche se questo flag è specificato, potrebbero essere necessarie ulteriori autorizzazioni per accedere al file.

Answer 4

È possibile passare flusso esistente per Api partito 3-rd, o se volete solo leggere solo modo per la 3-rd Api partito passare StreamReader esempio

using (var stream = new FileStream("trace.txt", FileMode.OpenOrCreate,FileAccess.ReadWrite)) 
    { 
     using (var anotherStream = new StreamReader(stream)) 
     { 
      //magic here 
     } 
    } 

Answer 5

Ho esattamente lo stesso caso d'uso e incontrare il stesso problema. Quello che provo è usare (FileShare.ReadWrite | FileShare.Delete) per entrambi i flussi e funziona.

Answer 6

Questa sequenza di chiamate funziona solo se l'API di terze parti utilizza FileShare.ReadWrite o gli usi aperti FileAccess.Read.

Si sta aprendo in lettura/scrittura, consentendo agli altri di aprirlo anche in lettura/scrittura. Il codice di terze parti sta tentando di aprirlo in sola lettura, consentendo agli altri di aprirlo, ma solo in sola lettura. Dal momento che hai ancora aperto read-write, questo fallisce.

Supponendo che non è possibile modificare il codice di terze parti, è necessario adottare il seguente schema, invece:

1. Aprire il file come ci si trova, ma senza la bandiera DeleteOnClose.
2. Scrivi qualsiasi contenuto di cui hai bisogno l'altro codice da leggere.
3. Chiudere il file.
4. Opzionalmente riaprirlo con FileAccess.Read (ed eventualmente DeleteOnClose).
5. Chiama il codice di terze parti.
6. Esegui qualsiasi altra lettura (ma non la scrittura) che desideri.

Answer 7

Nella mia esperienza, un FileStream aperta con FileOptions.DeleteOnClose non può essere aperto facendo passare il percorso del file ad un altro FileStream indipendentemente dal valore FileShare.

Quando si possiede tutto il codice (chiaramente non è il tuo caso, mi dispiace) DuplicateHandle può essere utilizzato per aprire un file DeleteOnClose più volte, anche da processi diversi.

Ecco alcuni esempi di codice per .NET 4.5.1.

using System; 
using System.Diagnostics; 
using System.IO; 
using System.Runtime.InteropServices; 
using System.Text; 
using System.Windows.Forms; 
using Microsoft.Win32.SafeHandles; 

namespace Example 
{ 
    public static class DuplicatedHandleExample 
    { 
    [DllImport("kernel32.dll")] 
    private static extern bool DuplicateHandle(
     SafeFileHandle hSourceProcessHandle, 
     IntPtr hSourceHandle, 
     SafeFileHandle hTargetProcessHandle, 
     out SafeFileHandle lpTargetHandle, 
     UInt32 dwDesiredAccess, 
     bool bInheritHandle, 
     UInt32 dwOptions); 

    [DllImport("kernel32.dll")] 
    private static extern SafeFileHandle OpenProcess(
     UInt32 dwDesiredAccess, 
     bool bInheritHandle, 
     int dwProcessId); 

    private const UInt32 PROCESS_DUP_HANDLE = 0x0040; 

    private const UInt32 DUPLICATE_SAME_ACCESS = 0x0002; 

    public static void CreateFileInProcessA() 
    { 
     try 
     { 
     // open new temp file with FileOptions.DeleteOnClose 
     string tempFilePath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString("D")); 
     using (FileStream fs = new FileStream(tempFilePath, FileMode.CreateNew, 
      FileAccess.ReadWrite, FileShare.Read | FileShare.Write | FileShare.Delete, 
      4096, FileOptions.DeleteOnClose)) 
     { 
      // put a message in the temp file 
      fs.Write(new[] { (byte)'h', (byte)'i', (byte)'!' }, 0, 3); 
      fs.Flush(); 

      // put our process ID and file handle on clipboard 
      string data = string.Join(",", 
      Process.GetCurrentProcess().Id.ToString(), 
      fs.SafeFileHandle.DangerousGetHandle().ToString()); 

      Clipboard.SetData(DataFormats.UnicodeText, data); 

      // show messagebox (while holding file open!) and wait for user to click OK 
      MessageBox.Show("Temp File opened. Process ID and File Handle copied to clipboard. Click OK to close temp file."); 
     } 
     } 
     catch (Exception ex) 
     { 
     MessageBox.Show(ex.ToString()); 
     } 
    } 

    public static void OpenFileInProcessB() 
    { 
     try 
     { 
     // get process ID and file handle from clipboard 
     string data = (string)Clipboard.GetData(DataFormats.UnicodeText); 
     string[] dataParts = data.Split(','); 
     int sourceProcessId = int.Parse(dataParts[0]); 
     IntPtr sourceFileHandle = new IntPtr(Int64.Parse(dataParts[1])); 

     // get handle to target process 
     using (SafeFileHandle sourceProcessHandle = 
      OpenProcess(PROCESS_DUP_HANDLE, false, sourceProcessId)) 
     { 
      // get handle to our process 
      using (SafeFileHandle destinationProcessHandle = 
      OpenProcess(PROCESS_DUP_HANDLE, false, Process.GetCurrentProcess().Id)) 
      { 
      // duplicate handle into our process 
      SafeFileHandle destinationFileHandle; 
      DuplicateHandle(sourceProcessHandle, sourceFileHandle, 
       destinationProcessHandle, out destinationFileHandle, 
       0, false, DUPLICATE_SAME_ACCESS); 

      // get a FileStream wrapper around it 
      using (FileStream fs = new FileStream(destinationFileHandle, FileAccess.ReadWrite, 4096)) 
      { 
       // read file contents 
       fs.Position = 0; 
       byte[] buffer = new byte[100]; 
       int numBytes = fs.Read(buffer, 0, 100); 
       string message = Encoding.ASCII.GetString(buffer, 0, numBytes); 

       // show messagebox (while holding file open!) and wait for user to click OK 
       MessageBox.Show("Found this message in file: " + message + Environment.NewLine + 
       "Click OK to close temp file"); 
      } 
      } 
     } 
     } 
     catch (Exception ex) 
     { 
     MessageBox.Show(ex.ToString()); 
     } 
    } 
    } 
}