Wie erhalten Sie eine Zeichenfolge von einem MemoryStream?

Wenn ich einen MemoryStream , von dem ich weiß, dass er mit einem String , wie bekomme ich dann einen String zurück?

   

Dieses Beispiel zeigt, wie eine Zeichenfolge in einem MemoryStream gelesen und geschrieben wird.


 Imports System.IO Module Module1 Sub Main() ' We don't need to dispose any of the MemoryStream ' because it is a managed object. However, just for ' good practice, we'll close the MemoryStream. Using ms As New MemoryStream Dim sw As New StreamWriter(ms) sw.WriteLine("Hello World") ' The string is currently stored in the ' StreamWriters buffer. Flushing the stream will ' force the string into the MemoryStream. sw.Flush() ' If we dispose the StreamWriter now, it will close ' the BaseStream (which is our MemoryStream) which ' will prevent us from reading from our MemoryStream 'sw.Dispose() ' The StreamReader will read from the current ' position of the MemoryStream which is currently ' set at the end of the string we just wrote to it. ' We need to set the position to 0 in order to read ' from the beginning. ms.Position = 0 Dim sr As New StreamReader(ms) Dim myStr = sr.ReadToEnd() Console.WriteLine(myStr) ' We can dispose our StreamWriter and StreamReader ' now, though this isn't necessary (they don't hold ' any resources open on their own). sw.Dispose() sr.Dispose() End Using Console.WriteLine("Press any key to continue.") Console.ReadKey() End Sub End Module 

Sie können auch verwenden

 Encoding.ASCII.GetString(ms.ToArray()); 

Ich glaube nicht, dass dies weniger effizient ist, aber ich konnte nicht darauf schwören. Sie können auch eine andere Codierung wählen, während Sie einen StreamReader als Parameter angeben müssen.

Verwenden Sie einen StreamReader, um den MemoryStream in einen String zu konvertieren.

  _ Public Function ReadAll(ByVal memStream As MemoryStream) As String ' Reset the stream otherwise you will just get an empty string. ' Remember the position so we can restore it later. Dim pos = memStream.Position memStream.Position = 0 Dim reader As New StreamReader(memStream) Dim str = reader.ReadToEnd() ' Reset the position so that subsequent writes are correct. memStream.Position = pos Return str End Function 

Verwenden Sie einen StreamReader , dann können Sie die ReadToEnd- Methode verwenden, die eine Zeichenfolge zurückgibt.

Frühere Lösungen würden in Fällen nicht funktionieren, in denen eine Codierung involviert ist. Hier ist – eine Art “echtes Leben” – Beispiel, wie man das richtig macht …

 using(var stream = new System.IO.MemoryStream()) { var serializer = new DataContractJsonSerializer(typeof(IEnumerable), new[]{typeof(ExportData)}, Int32.MaxValue, true, null, false); serializer.WriteObject(stream, model); var jsonString = Encoding.Default.GetString((stream.ToArray())); } 

Wenn Sie in diesem Fall die ReadToEnd Methode in MemoryStream auf einfache Weise verwenden ReadToEnd , können Sie diese Erweiterungsmethode verwenden, um ReadToEnd zu erreichen:

 public static class SetExtensions { public static string ReadToEnd(this MemoryStream BASE) { BASE.Position = 0; StreamReader R = new StreamReader(BASE); return R.ReadToEnd(); } } 

Und Sie können diese Methode auf diese Weise verwenden:

 using (MemoryStream m = new MemoryStream()) { //for example i want to serialize an object into MemoryStream //I want to use XmlSeralizer XmlSerializer xs = new XmlSerializer(_yourVariable.GetType()); xs.Serialize(m, _yourVariable); //the easy way to use ReadToEnd method in MemoryStream MessageBox.Show(m.ReadToEnd()); } 

Dieses Beispiel zeigt, wie eine Zeichenfolge aus einem MemoryStream gelesen wird, in der ich eine Serialisierung verwendet habe (mit DataContractJsonSerializer), die Zeichenfolge von einem Server an den Client übergebe und dann den MemoryStream aus der als Parameter übergebenen Zeichenfolge wiederherstellen soll , deserialisieren Sie den MemoryStream.

Ich habe Teile verschiedener Beiträge verwendet, um dieses Beispiel durchzuführen.

Ich hoffe, dass das hilft.

 using System; using System.Collections.Generic; using System.IO; using System.Runtime.Serialization; using System.Runtime.Serialization.Json; using System.Threading; namespace JsonSample { class Program { static void Main(string[] args) { var phones = new List { new Phone { Type = PhoneTypes.Home, Number = "28736127" }, new Phone { Type = PhoneTypes.Movil, Number = "842736487" } }; var p = new Person { Id = 1, Name = "Person 1", BirthDate = DateTime.Now, Phones = phones }; Console.WriteLine("New object 'Person' in the server side:"); Console.WriteLine(string.Format("Id: {0}, Name: {1}, Birthday: {2}.", p.Id, p.Name, p.BirthDate.ToShortDateString())); Console.WriteLine(string.Format("Phone: {0} {1}", p.Phones[0].Type.ToString(), p.Phones[0].Number)); Console.WriteLine(string.Format("Phone: {0} {1}", p.Phones[1].Type.ToString(), p.Phones[1].Number)); Console.Write(Environment.NewLine); Thread.Sleep(2000); var stream1 = new MemoryStream(); var ser = new DataContractJsonSerializer(typeof(Person)); ser.WriteObject(stream1, p); stream1.Position = 0; StreamReader sr = new StreamReader(stream1); Console.Write("JSON form of Person object: "); Console.WriteLine(sr.ReadToEnd()); Console.Write(Environment.NewLine); Thread.Sleep(2000); var f = GetStringFromMemoryStream(stream1); Console.Write(Environment.NewLine); Thread.Sleep(2000); Console.WriteLine("Passing string parameter from server to client..."); Console.Write(Environment.NewLine); Thread.Sleep(2000); var g = GetMemoryStreamFromString(f); g.Position = 0; var ser2 = new DataContractJsonSerializer(typeof(Person)); var p2 = (Person)ser2.ReadObject(g); Console.Write(Environment.NewLine); Thread.Sleep(2000); Console.WriteLine("New object 'Person' arrived to the client:"); Console.WriteLine(string.Format("Id: {0}, Name: {1}, Birthday: {2}.", p2.Id, p2.Name, p2.BirthDate.ToShortDateString())); Console.WriteLine(string.Format("Phone: {0} {1}", p2.Phones[0].Type.ToString(), p2.Phones[0].Number)); Console.WriteLine(string.Format("Phone: {0} {1}", p2.Phones[1].Type.ToString(), p2.Phones[1].Number)); Console.Read(); } private static MemoryStream GetMemoryStreamFromString(string s) { var stream = new MemoryStream(); var sw = new StreamWriter(stream); sw.Write(s); sw.Flush(); stream.Position = 0; return stream; } private static string GetStringFromMemoryStream(MemoryStream ms) { ms.Position = 0; using (StreamReader sr = new StreamReader(ms)) { return sr.ReadToEnd(); } } } [DataContract] internal class Person { [DataMember] public int Id { get; set; } [DataMember] public string Name { get; set; } [DataMember] public DateTime BirthDate { get; set; } [DataMember] public List Phones { get; set; } } [DataContract] internal class Phone { [DataMember] public PhoneTypes Type { get; set; } [DataMember] public string Number { get; set; } } internal enum PhoneTypes { Home = 1, Movil = 2 } } 
 byte[] array = Encoding.ASCII.GetBytes("MyTest1 - MyTest2"); MemoryStream streamItem = new MemoryStream(array); // convert to string StreamReader reader = new StreamReader(streamItem); string text = reader.ReadToEnd(); 

Eine leicht modifizierte Version von Brians Antwort ermöglicht die optionale Verwaltung von Lesebeginn. Dies scheint die einfachste Methode zu sein. wahrscheinlich nicht die effizienteste, aber leicht zu verstehen und zu verwenden.

 Public Function ReadAll(ByVal memStream As MemoryStream, Optional ByVal startPos As Integer = 0) As String ' reset the stream or we'll get an empty string returned ' remember the position so we can restore it later Dim Pos = memStream.Position memStream.Position = startPos Dim reader As New StreamReader(memStream) Dim str = reader.ReadToEnd() ' reset the position so that subsequent writes are correct memStream.Position = Pos Return str End Function 

Warum nicht eine schöne Erweiterungsmethode für den MemoryStream-Typ?

 public static class MemoryStreamExtensions { static object streamLock = new object(); public static void WriteLine(this MemoryStream stream, string text, bool flush) { byte[] bytes = Encoding.UTF8.GetBytes(text + Environment.NewLine); lock (streamLock) { stream.Write(bytes, 0, bytes.Length); if (flush) { stream.Flush(); } } } public static void WriteLine(this MemoryStream stream, string formatString, bool flush, params string[] strings) { byte[] bytes = Encoding.UTF8.GetBytes(String.Format(formatString, strings) + Environment.NewLine); lock (streamLock) { stream.Write(bytes, 0, bytes.Length); if (flush) { stream.Flush(); } } } public static void WriteToConsole(this MemoryStream stream) { lock (streamLock) { long temporary = stream.Position; stream.Position = 0; using (StreamReader reader = new StreamReader(stream, Encoding.UTF8, false, 0x1000, true)) { string text = reader.ReadToEnd(); if (!String.IsNullOrEmpty(text)) { Console.WriteLine(text); } } stream.Position = temporary; } } } 

Seien Sie vorsichtig, wenn Sie diese Methoden in Verbindung mit den Standardmethoden verwenden. 🙂 … Sie müssen diese handliche StreamLock verwenden, wenn Sie dies tun, für den Parallelbetrieb.