Fil Safe Streamwriter C # Comment le faire? 2

• Le code a l'écrivain comme une intestation var mais à l'aide d'un casier statique. Si vous avez eu plusieurs instances écrivant à différents fichiers, il n'y a aucune raison pour laquelle il aurait besoin de partager le même verrou li>
• sur une note connexe, puisque vous avez déjà l'écrivain (comme une instance privée Var), vous pouvez utiliser cela pour le verrouillage au lieu d'utiliser un objet de casier séparé dans ce cas - qui rend les choses un peu plus simples. li>

  La «bonne réponse» dépend vraiment de ce que vous recherchez en termes de comportement de verrouillage / blocage. Par exemple, la chose la plus simple serait de sauter la structure de données intermédiaire, il suffit de disposer d'une méthode ErreurSvalues ​​de manière à ce que chaque thread "signalant" ses résultats soit avancé et les écrit au fichier. Quelque chose comme: p> xxx pré>

  Bien sûr, cela signifie que les threads de travailleurs se serifisent pendant leurs phases "Résultats de rapport" - en fonction des caractéristiques de performance, cela peut être tout simplement bien (5 minutes à Générez, 500ms à écrire, par exemple). P>

  sur l'autre extrémité du spectre, vous auriez que les threads de travailleur écrivent à une structure de données. Si vous êtes à .NET 4, je recommanderais simplement d'utiliser un Concurrentquue plutôt que de faire cela se verrouillant vous-même. p>

  En outre, vous pouvez faire le fichier E / S dans des lots plus gros que ceux rapportés par les threads de travailleur, vous pouvez donc choisir de simplement écrire dans un fil de fond sur une fréquence. Cette fin du spectre ressemble à quelque chose comme ci-dessous (vous supprimez les appels de console.writeline en code réel, ce sont juste là pour que vous puissiez le voir travailler en action) P>

  public class ThreadSafeFileBuffer<T> : IDisposable
  {
      private readonly StreamWriter m_writer;
      private readonly ConcurrentQueue<T> m_buffer = new ConcurrentQueue<T>();
      private readonly Timer m_timer;
  
      public ThreadSafeFileBuffer(string filePath, int flushPeriodInSeconds = 5)
      {
          m_writer = new StreamWriter(filePath);
          var flushPeriod = TimeSpan.FromSeconds(flushPeriodInSeconds);
          m_timer = new Timer(FlushBuffer, null, flushPeriod, flushPeriod);
      }
  
      public void AddResult(T result)
      {
          m_buffer.Enqueue(result);
          Console.WriteLine("Buffer is up to {0} elements", m_buffer.Count);
      }
  
      public void Dispose()
      {
          Console.WriteLine("Turning off timer");
          m_timer.Dispose();
          Console.WriteLine("Flushing final buffer output");
          FlushBuffer(); // flush anything left over in the buffer
          Console.WriteLine("Closing file");
          m_writer.Dispose();
      }
  
      /// <summary>
      /// Since this is only done by one thread at a time (almost always the background flush thread, but one time via Dispose), no need to lock
      /// </summary>
      /// <param name="unused"></param>
      private void FlushBuffer(object unused = null)
      {
          T current;
          while (m_buffer.TryDequeue(out current))
          {
              Console.WriteLine("Buffer is down to {0} elements", m_buffer.Count);
              m_writer.WriteLine(current);
          }
          m_writer.Flush();
      }
  }
  
  class Program
  {
      static void Main(string[] args)
      {
          var tempFile = Path.GetTempFileName();
          using (var resultsBuffer = new ThreadSafeFileBuffer<double>(tempFile))
          {
              Parallel.For(0, 100, i =>
              {
                  // simulate some 'real work' by waiting for awhile
                  var sleepTime = new Random().Next(10000);
                  Console.WriteLine("Thread {0} doing work for {1} ms", Thread.CurrentThread.ManagedThreadId, sleepTime);
                  Thread.Sleep(sleepTime);
                  resultsBuffer.AddResult(Math.PI*i);
              });
          }
          foreach (var resultLine in File.ReadAllLines(tempFile))
          {
              Console.WriteLine("Line from result: {0}", resultLine);
          }
      }
  }
  

Vous dites donc que vous voulez que vous souhaitiez un tas de threads d'écrire des données sur un seul fichier à l'aide d'un streamwriter? Facile. Il suffit de verrouiller l'objet StreamWriter.

Le code ici créera 5 threads. Chaque thread effectuera 5 "actions" et à la fin de chaque action, il écrira 5 lignes sur un fichier nommé "fichier". xxx

Le résultat doit être un fichier. "Fichier" avec 125 lignes dedans avec toutes les "actions" effectuées simultanément et le résultat de chaque action écrite de manière synchrone au fichier.