¿Cómo puedo generar una secuencia a partir de una cadena?

Question

Necesito escribir una prueba unitaria para un método que toma una secuencia que proviene de un archivo de texto. Me gustaría hacer algo como esto:

Stream s = GenerateStreamFromString("a,b \n c,d"); 

Answer 1

public static Stream GenerateStreamFromString(string s) 
{ 
    var stream = new MemoryStream(); 
    var writer = new StreamWriter(stream); 
    writer.Write(s); 
    writer.Flush(); 
    stream.Position = 0; 
    return stream; 
} 

No se olvide de usar Usando: no estando dispuestos

using (var stream = GenerateStreamFromString("a,b \n c,d")) 
{ 
    // ... Do stuff to stream 
} 

---

Sobre el StreamWriter. StreamWriter es solo una envoltura alrededor de la transmisión base y no utiliza ningún recurso que deba desecharse. El método Dispose cerrará el Stream subyacente en el que StreamWriter está escribiendo. En este caso, ese es el MemoryStream que queremos devolver.

En .NET 4.5 ahora hay una sobrecarga para StreamWriter que mantiene la secuencia subyacente abierta después de que se elimina el escritor, pero este código hace lo mismo y funciona con otras versiones de .NET también.

Ver Is there any way to close a StreamWriter without closing its BaseStream?

Answer 2

utilizar la clase MemoryStream, llamando Encoding.GetBytes para convertir su cadena en una matriz de bytes en primer lugar.

¿Necesita posteriormente un TextReader en la secuencia? Si es así, se puede suministrar una StringReader directamente, sin pasar por el MemoryStream y Encoding pasos.

Answer 3

Creo que puede beneficiarse del uso de MemoryStream. Puede llenarlo con los bytes de cadena que obtiene utilizando el método GetBytes del Encoding class.

Answer 4

Aquí van:

private Stream GenerateStreamFromString(String p) 
{ 
    Byte[] bytes = UTF8Encoding.GetBytes(p); 
    MemoryStream strm = new MemoryStream(); 
    strm.Write(bytes, 0, bytes.Length); 
    return strm; 
} 

Answer 5

Otra solución:

public static MemoryStream GenerateStreamFromString(string value) 
{ 
    return new MemoryStream(Encoding.UTF8.GetBytes(value ?? "")); 
} 

Answer 6

añadir esto a una clase de utilidad cadena estática:

public static Stream ToStream(this string str) 
{ 
    MemoryStream stream = new MemoryStream(); 
    StreamWriter writer = new StreamWriter(stream); 
    writer.Write(str); 
    writer.Flush(); 
    stream.Position = 0; 
    return stream; 
} 

Esto añade una función de extensión para que pueda simplemente:

using (var stringStream = "My string".ToStream()) 
{ 
    // use stringStream 
} 

Answer 7

/// <summary> 
/// Get Byte[] from String 
/// </summary> 
/// <param name="str"></param> 
/// <returns></returns> 
public static byte[] GetBytes(string str) 
{ 
    byte[] bytes = new byte[str.Length * sizeof(char)]; 
    System.Buffer.BlockCopy(str.ToCharArray(), 0, bytes, 0, bytes.Length); 
    return bytes; 
} 

/// <summary> 
/// Get Stream from String 
/// </summary> 
/// <param name="str"></param> 
/// <returns></returns> 
public static Stream GetStream(string str) 
{ 
    return new MemoryStream(GetBytes(str)); 
} 

Answer 8

Una buena combinación de extensiones de Cuerda:

public static byte[] GetBytes(this string str) 
{ 
    byte[] bytes = new byte[str.Length * sizeof(char)]; 
    System.Buffer.BlockCopy(str.ToCharArray(), 0, bytes, 0, bytes.Length); 
    return bytes; 
} 

public static Stream ToStream(this string str) 
{ 
    Stream StringStream = new MemoryStream(); 
    StringStream.Read(str.GetBytes(), 0, str.Length); 
    return StringStream; 
} 

Answer 9

public Stream GenerateStreamFromString(string s) 
{ 
    return new MemoryStream(Encoding.UTF8.GetBytes(s)); 
} 

Answer 10

utilicé una mezcla de respuestas como esta:

public static Stream ToStream(this string str, Encoding enc = null) 
{ 
    enc = enc ?? Encoding.UTF8; 
    return new MemoryStream(enc.GetBytes(str ?? "")); 
} 

Y entonces utilizar de esta manera:

String someStr="This is a Test"; 
Encoding enc = getEncodingFromSomeWhere(); 
using (Stream stream = someStr.ToStream(enc)) 
{ 
    // Do something with the stream.... 
} 

Answer 11

Utilizamos los métodos de extensión que se enumeran a continuación. Creo que debes hacer que el desarrollador tome una decisión sobre la codificación, por lo que hay menos magia involucrada.

public static class StringExtensions { 

    public static Stream ToStream(this string s) { 
     return s.ToStream(Encoding.UTF8); 
    } 

    public static Stream ToStream(this string s, Encoding encoding) { 
     return new MemoryStream(encoding.GetBytes(s ?? "")); 
    } 
} 

Answer 12

ligeramente modificada versión de los métodos de extensión que se sugieren en un comentario de respuesta y respuesta @Shaun Bowe @ de JoelNet. Porque estoy de acuerdo con el comentario de @Palec.

public static Stream ToStream(this string value) => ToStream(value, Encoding.UTF8); 

public static Stream ToStream(this string value, Encoding encoding) => new MemoryStream(encoding.GetBytes(value ?? string.Empty));