Come posso generare uno stream da una stringa?

Question

Ho bisogno di scrivere un test unitario per un metodo che prende uno stream che proviene da un file di testo. Vorrei fare fare qualcosa di simile:

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; 
} 

Non dimenticare di utilizzare Usando:

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

---

Chi l'StreamWriter non in via di dismissione. StreamWriter è solo un wrapper attorno al flusso di base e non utilizza alcuna risorsa che deve essere smaltita. Il metodo Dispose chiuderà il sottostante Stream a cui sta scrivendo StreamWriter. In questo caso è lo MemoryStream che vogliamo restituire.

In .NET 4.5 c'è ora un sovraccarico per StreamWriter che mantiene aperto il flusso sottostante dopo che il writer è stato eliminato, ma questo codice fa la stessa cosa e funziona anche con altre versioni di .NET.

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

Answer 2

utilizzare la classe MemoryStream, chiamando Encoding.GetBytes per trasformare il tuo stringa in un array di byte prima.

Successivamente è necessario un TextReader nello stream? In tal caso, è possibile fornire direttamente un StringReader e ignorare i passaggi MemoryStream e Encoding.

Answer 3

Penso che si possa beneficiare dell'uso di MemoryStream. È possibile riempirlo con i byte di stringa ottenuti utilizzando il metodo GetBytes di Encoding class.

Answer 4

Qui si va:

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

Answer 5

Un'altra soluzione:

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

Answer 6

aggiungerlo a una classe di utilità stringa statica:

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; 
} 

Questo aggiunge una funzione di estensione in modo da poter semplicemente:

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 buona combinazione di estensioni String:

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

ho usato un mix di risposte in questo modo:

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

E poi usare in questo modo:

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

Answer 11

Utilizziamo i metodi di estensione elencati di seguito. Penso che dovresti fare in modo che lo sviluppatore prenda una decisione sulla codifica, quindi c'è meno magia coinvolta.

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

Versione leggermente modificata dei metodi di estensione suggeriti in un commento della risposta di @ JoelNet e della risposta di @Shaun Bowe. Perché sono d'accordo con il commento di @ 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));