Detailed explanation of C# MemoryStream Case

static void Main(string[] args)
        {
            //Properties test            MemoryStream ms = new MemoryStream();
            ();      //True Memory stream is readable            ();      //True Memory flow supports search, pointers are moved around and searched.            ();   //False memory stream does not support timeout            ();     //True Memory stream is writable 
            ();     //0 Number of bytes assigned to the stream            byte[] bytes = Encoding.("abcdedcba");
            (bytes, 0, );   //A piece of text has been written to memory            ();     //256 Read again the number of bytes allocated for the text stream has become 256. It seems that the memory stream is allocated according to the amount needed.            ();       //9 This is the stream length, usually the same as the number of characters in English, the number of bytes it really takes. 
            ();     //9 The current location of the stream, this property is readable and set 
            //(); Since the stream does not support timeout, this property will report an error if read or set            //(); Since the stream does not support timeout, this property will report an error if read or set 
            //Method test            byte[] byte1 = ();          //Return to an unsigned byte array. I was almost fooled. The unsigned byte array is actually byte(0~255), and the signed byte sbyte(-128~127)            string str1 = Encoding.(byte1);
            (str1);    //Output abcdedcba 
            (2, );    //Set the position where the current stream is reading. It is the starting position that starts from 0.            //Read a byte from memory            int i = ();
            (i);                   //Output 99            byte[] bytes3 = ();
            foreach (byte b in bytes3)
            {
                (b + "-");//For comparison output 97-98-99-100-101-100-99-98-97- You can see that the second digit 0,1,2 happens to be 99            }
 
            MemoryStream ms2 = new MemoryStream();
            byte[] bytes6 = Encoding.("abcde");
            (bytes6, 0, );
            ();    //Output 5 After writing, the stream position reaches the end, so if you want to read it with read, you must add the following line of code. 
            //(0, ); //If you want to use the Read method to read the complete stream, you must set the current position. Read starts reading from the Position position.             = 0;                   //Read starts reading from the current position, and this line of code means the same as the above line.            byte[] byteArray = new byte[5] { 110, 110, 110, 110, 110 }; //99 is after YTF8 decoding, n            (byteArray, 2, 1);   //Read a byte, in the first element of byteArray, (note that it starts from 0)            (Encoding.(byteArray)); //nnann
            //(byteArray, 2, 2);
            //(Encoding.(byteArray)); //nnabn // When the total length of the received array is exceeded, the subsequent elements will be removed. 
 
            //Set the length of the current stream            ();   //Output 9 The current stream length is 9            (20);
            ();   //Output 20            foreach (byte b in ())    //Convert the content of the stream, that is, the content in memory, to convert the byte array            {
                (b + "-");     //Output 97-98-99-100-101-100-99-98-97-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0-0 Since the length is set, the empty automatically fills 0            }
            (Encoding.(()));   //Output abcdedcba Although the length has become longer, it does not affect the reading of data. 
            MemoryStream ms1 = new MemoryStream();
            byte[] bytes4 = ();
            ("This memory stream does not write data(Write)" + Encoding.(bytes4));//Output This memory stream does not write data (Write) because the memory is empty 
 
            // Let's write a specified location below            MemoryStream ms3 = new MemoryStream();
            byte[] bytesArr = ("abcdefg");
            (bytesArr, 0, );
             = 2;
            (97);  //97 represents a. This code means that the original second c is replaced by a.            string str = (());
            (str); //Output abacdefg            
            byte[] byteArr1 = ("kk");
             = 4;
            (byteArr1, 0, );
            (Encoding.(()));  //abadkkg //Replace two bytes from bit 4 to KK 
            ();
        }

using ;
using ;
using ;
 
public class DataSwitch
{
 
    /// <summary>
    /// Convert data class objects into byte streams    /// </summary>
    /// <param name="obj"></param>
    /// <returns></returns>
    /// //MemoryStream: Creates a stream whose supported storage area is memory.        //IFormatter: Provides the function of formatting serialized objects.    public static byte[] ObjectToBytes(object obj)
    {
        using (MemoryStream ms = new MemoryStream())
        {
            // //Serialize and deserialize objects or entire connection objects in binary format.            IFormatter formatter = new BinaryFormatter();
            //Put the string into memStream in binary            (ms, obj);
            //Returns the unsigned byte array from which this stream is created.  It will return all allocated bytes, and it will not work.            Return an unsigned byte array ，Unsigned byte array Actually it'sbyte(0~255),Signed bytessbyte(-128~127)
            return ();
        }
    }
 
    /// <summary>
    /// Bytes are transferred to data-class objects    /// </summary>
    /// <param name="bytes"></param>
    /// <returns></returns>
    public static object BytesToObject(byte[] bytes)
    {
        using (MemoryStream ms = new MemoryStream(bytes))
        { 
            // //Serialize and deserialize objects or entire connection objects in binary format.            IFormatter formatter = new BinaryFormatter();
            //Put the string into memStream in binary            return (ms);
        }
    }
}