Comment obtenez-vous une corde de MemoryStream?

Dans cet exemple, il est montré comment lire et écrire une chaîne dans MemoryStream.

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

Vous pouvez aussi utiliser

Encoding.ASCII.GetString/ms.ToArray///;

je ne

je pense

, C'est moins efficace, mais je ne peux pas jurer dans cela. Il vous permet également de choisir un autre codage, tout en utilisant StreamReader Vous devrez le spécifier comme paramètre.

Utilisant StreamReader Pour la conversion MemoryStream dans la chaîne.

<extension></extension> _

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

Utilisation
http://msdn.microsoft.com/en-u ... .aspx
, et puis vous pouvez utiliser la méthode ReadToEnd, qui retourne la chaîne.

byte[] array = Encoding.ASCII.GetBytes/"MyTest1 - MyTest2"/;

MemoryStream streamItem = new MemoryStream/array/;



// convert to string

StreamReader reader = new StreamReader/streamItem/;

string text = reader.ReadToEnd//;

Les solutions précédentes ne fonctionnaient pas dans les cas où il s'agit de coder. Comme une sorte "real life"- Par exemple, comment le faire correctement ...

using/var stream = new System.IO.MemoryStream///

{

 var serializer = new DataContractJsonSerializer/typeof/IEnumerable<exportdata>/, new[]{typeof/ExportData/}, Int32.MaxValue, true, null, false/; 

 serializer.WriteObject/stream, model/; 





 var jsonString = Encoding.Default.GetString//stream.ToArray////;

}

</exportdata>

Dans ce cas, si vous voulez vraiment utiliser la méthode

ReadToEnd

dans

MemoryStream

De manière simple, vous pouvez utiliser cette méthode d'expansion pour atteindre cet objectif:

public static class SetExtensions

{

 public static string ReadToEnd/this MemoryStream BASE/

 {

 BASE.Position = 0;

 StreamReader R = new StreamReader/BASE/;

 return R.ReadToEnd//;

 }

}

Et vous pouvez utiliser cette méthode de cette manière:

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

}

Dans cet exemple, il est montré comment lire la chaîne de MemoryStream, dans lequel j'ai utilisé la sérialisation /Utilisant DataContractJsonSerializer/, Passez la chaîne de certains serveurs au client, puis comment restaurer MemoryStream à partir de la chaîne transmise comme un paramètre puis désérialiser MemoryStream.

J'ai utilisé des parties de divers messages pour effectuer cet exemple.

J'espère que cela aidera.

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<phone>

 {

 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<phone> 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

 }

}

</phone></phone>

Une version légèrement modifiée de la réponse de Brian vous permet de gérer éventuellement la lecture, il semble que la méthode la plus simple. Probablement pas le plus efficace mais facile à comprendre et à utiliser.

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

Pourquoi ne pas faire une bonne méthode d'expansion pour le type MemoryStream?

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;

 }

 }

}

Bien sûr, soyez prudent lorsque vous utilisez ces méthodes combinées à la norme. :/... vous devrez utiliser ce pratique streamLock, Si vous le faites, pour le parallélisme.

J'ai besoin d'intégrer à une classe qui a besoin d'un flux pour enregistrer dessus:

XmlSchema schema;

// ... Use "schema" ...



var ret = "";



using /var ms = new MemoryStream///

{

 schema.Write/ms/;

 ret = Encoding.ASCII.GetString/ms.ToArray///;

}

//here you can use "ret"

// 6 Lines of code

Je crée une classe simple qui peut aider à réduire les chaînes de code pour une utilisation répétée:

public static class MemoryStreamStringWrapper

{

 public static string Write/Action<memorystream> action/

 {

 var ret = "";

 using /var ms = new MemoryStream///

 {

 action/ms/;

 ret = Encoding.ASCII.GetString/ms.ToArray///;

 }



 return ret;

 }

}

Ensuite, vous pouvez remplacer l'échantillon d'une ligne de code

var ret = MemoryStreamStringWrapper.Write/schema.Write/;

</memorystream>