C# MemoryStream.WriteByte方法代码示例

 void writeHeader(MemoryStream stream)
 {
     stream.WriteByte(byCmd);
     stream.WriteByte(byParam);
     byte[] bpara = BitConverter.GetBytes(dwTimestamp);
     stream.Write(bpara, 0, bpara.Length);
     //Debug.Log("byCmd=" + byCmd + " byParam" + byParam + " dwTimestamp" + dwTimestamp + " length" + bpara.Length + " bpara" + bpara.ToString());
 }

    public GamePacketStream(short message_id)
    {
        stream = new MemoryStream();

        stream.WriteByte(0xff);
        stream.WriteByte(0xff);

        add(message_id);
    }

 static void CompressProfile(string srcfile, string dstfile)
 {
     try
     {
         Console.WriteLine("Reading source...");
         byte[] x = File.ReadAllBytes(srcfile);
         int usize = x.Length;
         Console.WriteLine("Initializing memory stream...");
         MemoryStream ms = new MemoryStream();
         // write uncompressed size as big endian
         ms.WriteByte((byte)((usize>>24) & 0xFF));
         ms.WriteByte((byte)((usize>>16) & 0xFF));
         ms.WriteByte((byte)((usize>>8) & 0xFF));
         ms.WriteByte((byte)(usize & 0xFF));
         // then, compressed data
         // these two bytes are part of zlib standard, but aren't supported by DeflateStream
         ms.WriteByte(0x78);
         ms.WriteByte(0x9C);
         Console.WriteLine("Compressing data...");
         MemoryStream compData = new MemoryStream();
         DeflateStream ds = new DeflateStream(compData, CompressionMode.Compress);
         ds.Write(x, 0, x.Length);
         ds.Close();
         ms.Write(compData.ToArray(), 0, compData.ToArray().Length);
         // Adler32 checksum as big endian - also not supported by DeflateStream, but required by zlib standard
         int checksum = GetAdler32(x);
         ms.WriteByte((byte)((checksum>>24) & 0xFF));
         ms.WriteByte((byte)((checksum>>16) & 0xFF));
         ms.WriteByte((byte)((checksum>>8) & 0xFF));
         ms.WriteByte((byte)(checksum & 0xFF));
         // start filestream
         Console.WriteLine("Creating file stream...");
         FileStream fs = File.Create(dstfile);
         // write hash
         fs.Write(new SHA1CryptoServiceProvider().ComputeHash(ms.ToArray()), 0, 0x14);
         // write usize + compressed data
         fs.Write(ms.ToArray(), 0, ms.ToArray().Length);
         Console.WriteLine("Compression done.\n" + dstfile);
         fs.Close();
         ms.Close();
         compData.Close();
     }
     catch(Exception ex)
     {
         Console.WriteLine(ex.GetType().Name + " | " + ex.Message);
         Console.Beep();
     }
     return;
 }

	//public static string Unscramble(string text ) {
	//	byte[] clear = Encoding.UTF8.GetBytes (text);
	//	return Encoding.UTF8.GetString( Xor( clear) );
	//}

	public static byte[] Xor(byte[] clearTextBytes )
	{

		byte[] key = GenKey (clearTextBytes.Length);

		//Debug.Log ("KEY : " + Encoding.Unicode.GetString (key));

		MemoryStream ms = new MemoryStream();
	
		for (int i = 0; i < clearTextBytes.Length; i++) {

			byte b = (byte)(  (clearTextBytes [i] ^ key [i]) );

			//if (b == 0 ) {
			//	b = key [i];
				//Debug.Log ("GOt NULL BYTE FROM KEY: " + key [i] + ", BYTE: " + clearTextBytes [i]);
			//}

			ms.WriteByte ( b );
		}

		byte[] output =  ms.ToArray();
		//Debug.Log ("SCRAM OUT: " + output.Length);
		return output;

	}

    public bool NegTest2() 
    {
        bool retVal = true;
        TestLibrary.TestFramework.BeginScenario("Verify InvalidOperationException is thrown when set ReadTimeOut property...");

        try
        {
            Stream s = new MemoryStream();
            for (int i = 0; i < 100; i++)
                s.WriteByte((byte)i);
            s.Position = 0;

            s.ReadTimeout = 10;

            TestLibrary.TestFramework.LogError("001", "No exception occurs!");
            retVal = false;
        }
        catch (InvalidOperationException)
        {
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("002", "Unexpected exception occurs: " + e);
            retVal = false;
        }

        return retVal;
    }

 public static bool MemStreamClearWriteByteTest()
 {
     Console.WriteLine("Ensuring that we clear data > Length in a MemoryStream when we write past the end via WriteByte");
     const int len = 10;
     const int spanPastEnd = 5;
     MemoryStream ms = new MemoryStream(3*len);
     byte[] bytes = new byte[len];
     for(int i=0; i<bytes.Length; i++)
         bytes[i] = (byte) i;
     ms.Write(bytes, 0, bytes.Length);
     for(int i=0; i<2*len; i++)
         ms.WriteByte((byte)255);
     ms.SetLength(len);
     ms.Seek(spanPastEnd, SeekOrigin.End);
     for(int i=0; i<bytes.Length; i++)
         ms.WriteByte(bytes[i]);
     ms.Position = bytes.Length;
     byte[] newData = new byte[bytes.Length + spanPastEnd];
     int n = ms.Read(newData, 0, newData.Length);
     if (n != newData.Length) 
     {
         iCountErrors++ ;
         throw new Exception("Hmmm, maybe a bug in the stream.  Asked to read "+newData.Length+", but got back "+n+" bytes.");
     }
     for(int i=0; i<spanPastEnd; i++)
     {
         if (newData[i] != 0)
         {
             iCountErrors++ ;
             throw new Exception(String.Format("New data in the middle of the stream should have been all 0's, but at position {0} I got a wrong byte: {1} [0x{1:x}]!", i+bytes.Length, newData[i]));
         }
     }
     for(int i=0; i<bytes.Length; i++)
     {
         if (newData[i+spanPastEnd] != bytes[i])
         {
             iCountErrors++ ;
             throw new Exception(String.Format("New data at the end of the stream should have been equal to our byte[], but the {0}'th new byte was a wrong byte: {1} [0x{1:x}]!", i, newData[i+spanPastEnd]));
         }
     }
     ms.Flush();
     ms.Close();
     return true;
 }    

    // Use this for initialization
    private void Start()
    {
        int count;
        byte[] byteArray;
        char[] charArray;
        UnicodeEncoding uniEncoding = new UnicodeEncoding();

        // Create the data to write to the stream. 
        byte[] firstString = uniEncoding.GetBytes(
            "Invalid file path characters are: ");
        byte[] secondString = uniEncoding.GetBytes(
            "123456789");

        using (MemoryStream memStream = new MemoryStream(100))
        {
            // Write the first string to the stream.
            memStream.Write(firstString, 0, firstString.Length);

            // Write the second string to the stream, byte by byte.
            count = 0;
            while (count < secondString.Length)
            {
                memStream.WriteByte(secondString[count++]);
            }

            // Write the stream properties to the console.
            Debug.Log(String.Format(
                "Capacity = {0}, Length = {1}, Position = {2}\n",
                memStream.Capacity.ToString(),
                memStream.Length.ToString(),
                memStream.Position.ToString()));

            // Set the position to the beginning of the stream.
            memStream.Seek(0, SeekOrigin.Begin);

            // Read the first 20 bytes from the stream.
            byteArray = new byte[memStream.Length];
            count = memStream.Read(byteArray, 0, 20);

            // Read the remaining bytes, byte by byte. 
            while (count < memStream.Length)
            {
                byteArray[count++] =
                    Convert.ToByte(memStream.ReadByte());
            }

            // Decode the byte array into a char array 
            // and write it to the console.
            charArray = new char[uniEncoding.GetCharCount(
                byteArray, 0, count)];
            uniEncoding.GetDecoder().GetChars(
                byteArray, 0, count, charArray, 0);
            Debug.Log(charArray);
        }
    }

    public byte[] Compress(byte[] data)
    {
        using (var stream = new MemoryStream())
        {
            int len = data.Length;
            int source = 0;

            while (len > 0)
            {
                long flagdest = stream.Position;
                stream.WriteByte(0);

                byte flags = 0; /* All guess wrong initially */

                for (int bitmask = 1, i = 0; i < 8 && len > 0; i++, bitmask <<= 1)
                {
                    if (_guessTable[_hash] == data[source])
                    {
                        flags |= (byte)bitmask;  /* Guess was right - don't output */
                    }
                    else
                    {
                        _guessTable[_hash] = data[source];
                        stream.WriteByte(data[source]); /* Guess wrong, output char */
                    }

                    Hash(data[source++]);
                    len--;
                }

                long dest = stream.Position;
                stream.Position = flagdest;
                stream.WriteByte(flags);
                stream.Position = dest;
            }

            return stream.ToArray();
        }
    }

    //将Stream流转换为byte数组的方法。   
    public byte[] ConvertStreamToByteBuffer(Stream s)
    {
        if (!CheckUserRight(null, null))
        {
            throw new Exception("invalid user");
        }


        MemoryStream ms = new MemoryStream();
        int b;
        while ((b = s.ReadByte()) != -1)
        {
            ms.WriteByte((byte)b);
        }
        return ms.ToArray();
    }

        public static void MemoryStream_WriteByte_BeyondCapacity()
        {
            using (MemoryStream memoryStream = new MemoryStream())
            {
                long origLength = memoryStream.Length;
                byte[] bytes = new byte[10];
                for (int i = 0; i < bytes.Length; i++)
                    bytes[i] = (byte)i;
                int spanPastEnd = 5;
                memoryStream.Seek(spanPastEnd, SeekOrigin.End);
                Assert.Equal(memoryStream.Length + spanPastEnd, memoryStream.Position);

                // Test WriteByte
                origLength = memoryStream.Length;
                memoryStream.Position = memoryStream.Length + spanPastEnd;
                memoryStream.WriteByte(0x42);
                long expected = origLength + spanPastEnd + 1;
                Assert.Equal(expected, memoryStream.Position);
                Assert.Equal(expected, memoryStream.Length);
            }
        }

        public async Task CopyToAsyncTest_RequiresAsyncFlushingOfWrites()
        {
            byte[] data = Enumerable.Range(0, 1000).Select(i => (byte)(i % 256)).ToArray();

            var manualReleaseStream = new ManuallyReleaseAsyncOperationsStream();
            var src = new BufferedStream(manualReleaseStream);
            src.Write(data, 0, data.Length);
            src.Position = 0;

            var dst = new MemoryStream();

            data[0] = 42;
            src.WriteByte(42);
            dst.WriteByte(42);

            Task copyTask = src.CopyToAsync(dst);
            manualReleaseStream.Release();
            await copyTask;

            Assert.Equal(data, dst.ToArray());
        }

 private static void WriteHashtable(MemoryStream stream, Hashtable h, Hashtable ht, ref int hv, Encoding encoding)
 {
     int len = h.Count;
     byte[] hlen = Encoding.ASCII.GetBytes(len.ToString());
     stream.WriteByte(__a);
     stream.WriteByte(__Colon);
     stream.Write(hlen, 0, hlen.Length);
     stream.WriteByte(__Colon);
     stream.WriteByte(__LeftB);
     foreach (DictionaryEntry entry in h)
     {
         if ((entry.Key is Byte) || (entry.Key is SByte) || (entry.Key is Int16) || (entry.Key is UInt16) || (entry.Key is Int32))
         {
             WriteInteger(stream, Encoding.ASCII.GetBytes(entry.Key.ToString()));
         }
         else if (entry.Key is Boolean)
         {
             WriteInteger(stream, new byte[] { ((Boolean)entry.Key) ? __1 : __0 });
         }
         else
         {
             WriteString(stream, encoding.GetBytes(entry.Key.ToString()));
         }
         Serialize(stream, entry.Value, ht, ref hv, encoding);
     }
     stream.WriteByte(__RightB);
 }

 private static void WriteDouble(MemoryStream stream, byte[] d)
 {
     stream.WriteByte(__d);
     stream.WriteByte(__Colon);
     stream.Write(d, 0, d.Length);
     stream.WriteByte(__Semicolon);
 }

 private static void WriteBoolean(MemoryStream stream, byte b)
 {
     stream.WriteByte(__b);
     stream.WriteByte(__Colon);
     stream.WriteByte(b);
     stream.WriteByte(__Semicolon);
 }

 private static void WriteArrayList(MemoryStream stream, ArrayList a, Hashtable ht, ref int hv, Encoding encoding)
 {
     int len = a.Count;
     byte[] alen = Encoding.ASCII.GetBytes(len.ToString());
     stream.WriteByte(__a);
     stream.WriteByte(__Colon);
     stream.Write(alen, 0, alen.Length);
     stream.WriteByte(__Colon);
     stream.WriteByte(__LeftB);
     for (int i = 0; i < len; i++)
     {
         WriteInteger(stream, Encoding.ASCII.GetBytes(i.ToString()));
         Serialize(stream, a[i], ht, ref hv, encoding);
     }
     stream.WriteByte(__RightB);
 }