c# - obtener - No se puede acceder a una secuencia cerrada de un memoryStream, ¿cómo volver a abrir?

no se puede obtener acceso a system io memorystream

Question

Tengo una instancia de memoryStream y está cerrada.

Ya lo he intentado:

memoryStream.Flush();
memoryStream.Position=0;

Para volver a abrir la secuencia de memoria, pero no funciona. ¿Cómo puedo volver a abrir una secuencia de memoria cerrada?

Answer 1

¿Cómo puedo volver a abrir una secuencia de memoria cerrada?

No puedes reabrir la corriente. Si necesita "restablecer" el flujo, solo asígnele una nueva instancia:

memoryStream = new MemoryStream();

Answer 2

Esta es una pregunta antigua, pero estoy reaccionando al hecho de que la respuesta aceptada no es realmente útil y la respuesta más votada dice que usar .ToArray () es mejor que .GetBuffer (). Creo que en muchas, quizás la mayoría de las situaciones, usar .GetBuffer () es significativamente mejor que usar .ToArray ().

Este es un ejemplo del problema de un flujo de memoria que se cierra a pesar de su deseo de continuar usándolo:

  /// <summary>
  /// Method that gets called by ManagedResource.WriteData() in project CodeAnalysis during code 
  /// emitting to get the data for an embedded resource file.
  /// </summary>
  /// <param name="resourceFullFilename">full path and filename for resource file to embed</param>
  /// <returns>MemoryStream containing .resource file data - caller will dispose it</returns>
  private static MemoryStream ProvideResourceData(string resourceFullFilename)
  {
     MemoryStream shortLivedBackingStream = new MemoryStream();
     using (ResourceWriter resourceWriter = new ResourceWriter(shortLivedBackingStream))
     {
        using (ResXResourceReader resourceReader = new ResXResourceReader(resourceFullFilename))
        {
           IDictionaryEnumerator dictionaryEnumerator = resourceReader.GetEnumerator();
           while (dictionaryEnumerator.MoveNext())
           {
              string resourceKey = dictionaryEnumerator.Key as string;
              if (resourceKey != null)  // Should not be possible
                 resourceWriter.AddResource(resourceKey, dictionaryEnumerator.Value);
           }
        }
     }

     return new MemoryStream(shortLivedBackingStream.GetBuffer());
  }

La clase ResourceWriter necesita un flujo de respaldo, así que le doy un flujo de memoria recién creado. Pero cuando ResourceWriter ya no es necesario, cierra la secuencia de respaldo. Luego creo un nuevo MemoryStream basado en el búfer del flujo de respaldo, que funciona bien, aunque está cerrado.

En esta situación, sé que el programa que llama utilizará la secuencia de memoria proporcionada para copiar los datos en otro búfer y luego cerrar la secuencia de memoria inmediatamente. Por lo tanto, no es necesario crear una nueva matriz de bytes, y existe una ventaja de rendimiento al no crear una nueva matriz de bytes.

Gracias a @JoshVarty por mostrar cómo evitar que el problema de MemoryStream se cierre aquí: https://github.com/dotnet/roslyn/issues/7791

Answer 3

Puede clonar el original y luego usar el clon, incluso cuando el original se haya cerrado. Aunque el original se crea con una capacidad de 1000, ToArray () devuelve una matriz de 2 elementos. ToBuffer (), por otro lado, te ofrece el búfer completo, que es lo que no quieres.

MemoryStream original = new MemoryStream(1000);
original.WriteByte(4);
original.WriteByte(5);

MemoryStream dolly = new MemoryStream(original.ToArray());
dolly.Seek(0, SeekOrigin.Begin);

Answer 4

prueba esto:

memoryStream = new MemoryStream(memoryStream.ToArray());