Wie generiere ich einen Stream aus einer Zeichenfolge?

Ich muss einen Komponententest für eine Methode schreiben, die einen Stream verwendet, der aus einer Textdatei stammt. Ich würde gerne so etwas machen:

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

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

Vergessen Sie nicht, Using zu verwenden:

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

Über das StreamWriternicht entsorgt werden. StreamWriterist nur ein Wrapper um den Basis-Stream und verwendet keine Ressourcen, die entsorgt werden müssen. Die DisposeMethode schließt den Basiswert Stream, in den geschrieben StreamWriterwird. In diesem Fall MemoryStreammöchten wir das zurückgeben.

In .NET 4.5 gibt es jetzt eine Überlastung StreamWriter, die den zugrunde liegenden Stream offen hält, nachdem der Writer entsorgt wurde. Dieser Code macht jedoch dasselbe und funktioniert auch mit anderen .NET-Versionen.

Siehe Gibt es eine Möglichkeit, einen StreamWriter zu schließen, ohne seinen BaseStream zu schließen?

Eine andere Lösung:

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

Fügen Sie dies einer Dienstprogrammklasse für statische Zeichenfolgen hinzu:

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

Dies fügt eine Erweiterungsfunktion hinzu, so dass Sie einfach:

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

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

Verwenden Sie die MemoryStreamKlasse und rufen Sie Encoding.GetBytesauf, um Ihre Zeichenfolge zuerst in ein Array von Bytes umzuwandeln.

Benötigen Sie anschließend eine TextReaderim Stream? In diesem Fall können Sie eine StringReaderdirekt angeben MemoryStreamund die EncodingSchritte und umgehen .

Ich habe eine Mischung aus Antworten wie diesen verwendet:

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

Und dann benutze ich es so:

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

Wir verwenden die unten aufgeführten Erweiterungsmethoden. Ich denke, Sie sollten den Entwickler dazu bringen, eine Entscheidung über die Codierung zu treffen, damit weniger Magie involviert ist.

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 ?? ""));
    }
}

Bitte schön:

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

Modernisierte und leicht modifizierte Version der Erweiterungsmethoden für ToStream:

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

Änderung wie in @ Palecs Kommentar zur Antwort von @Shaun Bowe vorgeschlagen.

Ich denke, Sie können von der Verwendung eines MemoryStream profitieren . Sie können es mit den Zeichenfolgenbytes füllen, die Sie mithilfe der GetBytes- Methode der Encoding-Klasse erhalten .

Wenn Sie die Codierung ändern müssen, stimme ich für die Lösung von @ShaunBowe . Aber jede Antwort hier kopiert die gesamte Zeichenfolge mindestens einmal im Speicher. Die Antworten mit ToCharArray+ BlockCopyCombo machen es zweimal.

Wenn das wichtig ist, gibt es hier einen einfachen StreamWrapper für den rohen UTF-16-String. Bei Verwendung mit einer StreamReaderAuswahl Encoding.Unicodedafür:

public class StringStream : Stream
{
    private readonly string str;

    public override bool CanRead => true;
    public override bool CanSeek => true;
    public override bool CanWrite => false;
    public override long Length => str.Length * 2;
    public override long Position { get; set; } // TODO: bounds check

    public StringStream(string s) => str = s ?? throw new ArgumentNullException(nameof(s));

    public override long Seek(long offset, SeekOrigin origin)
    {
        switch (origin)
        {
            case SeekOrigin.Begin:
                Position = offset;
                break;
            case SeekOrigin.Current:
                Position += offset;
                break;
            case SeekOrigin.End:
                Position = Length - offset;
                break;
        }

        return Position;
    }

    private byte this[int i] => (i & 1) == 0 ? (byte)(str[i / 2] & 0xFF) : (byte)(str[i / 2] >> 8);

    public override int Read(byte[] buffer, int offset, int count)
    {
        // TODO: bounds check
        var len = Math.Min(count, Length - Position);
        for (int i = 0; i < len; i++)
            buffer[offset++] = this[(int)(Position++)];
        return (int)len;
    }

    public override int ReadByte() => Position >= Length ? -1 : this[(int)Position++];
    public override void Flush() { }
    public override void SetLength(long value) => throw new NotSupportedException();
    public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException();
    public override string ToString() => str; // ;)     
}

Und hier ist eine vollständigere Lösung mit den erforderlichen gebundenen Prüfungen (abgeleitet von MemoryStreamdiesen ToArrayund WriteToMethoden).

Eine gute Kombination von String-Erweiterungen:

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