C# MemoryStream.Read方法代码示例

    /*	The only necessary method - follows two step process outlined above
     *	Returns album art as a new texture
     */
    public Texture getAlbumArtAsTexture(GameObject audioHolder, FileInfo f)
    {
        Texture2D albumArt = new Texture2D (1, 1); //empty texture holder

        foreach (Transform file in audioHolder.transform.parent) { //loads all files from current directory - will not result in massive searches because we only pass files until an album container is created
            if (file.gameObject.name.EndsWith(".jpg") || file.gameObject.name.EndsWith(".png")) { //pull album art from images found in directory
                byte[] bytes = System.IO.File.ReadAllBytes(file.gameObject.name); //pull byte stream from image file
                albumArt.LoadImage(bytes); //load byte stream into new texture
                return albumArt;
            }
            else {
                if (file.name != "AlbumTitle") {//scrape album art from music file data
                    TagLib.File tagFile = TagLib.File.Create(file.name);
                    if (tagFile.Tag.Pictures.Length == 0) {
                        return null; //default texture
                    }
                    TagLib.IPicture albumPic = tagFile.Tag.Pictures [0];
                    MemoryStream stream = new MemoryStream (albumPic.Data.Data);
                    byte[] tagBytes;
                    byte[] buffer = new byte[16 * 1024];
                    using (MemoryStream ms = new MemoryStream()) { //read image data into new stream
                        int read;
                        while ((read = stream.Read(buffer, 0, buffer.Length)) > 0) {
                            ms.Write(buffer, 0, read);
                        }
                        tagBytes = ms.ToArray();
                    }
                    albumArt.LoadImage (tagBytes); //convert stream data into new texture
                    return albumArt;
                }
            }
        }

        return null;
    }

    public override void unserialize(MemoryStream stream)
    {
        base.unserialize(stream);
        byte[] bqwGameTime=new byte[4];
        stream.Read(bqwGameTime,0,4);
        qwGameTime = BitConverter.ToUInt32(bqwGameTime,0);

        byte[] bcurServerTime=new byte[4];
        stream.Read(bcurServerTime,0,4);
        curServerTime = BitConverter.ToUInt32(bcurServerTime,0);
    }

        public static void MemoryStream_Write_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 Write
                memoryStream.Write(bytes, 0, bytes.Length);
                long pos = memoryStream.Position;
                Assert.Equal(pos, origLength + spanPastEnd + bytes.Length);
                Assert.Equal(memoryStream.Length, origLength + spanPastEnd + bytes.Length);

                // Verify bytes were correct.
                memoryStream.Position = origLength;
                byte[] newData = new byte[bytes.Length + spanPastEnd];
                int n = memoryStream.Read(newData, 0, newData.Length);
                Assert.Equal(n, newData.Length);
                for (int i = 0; i < spanPastEnd; i++)
                    Assert.Equal(0, newData[i]);
                for (int i = 0; i < bytes.Length; i++)
                    Assert.Equal(bytes[i], newData[i + spanPastEnd]);
            }
        }

	public static void Compress(string text, string outfile)
	{
		byte[] buffer = Encoding.UTF8.GetBytes(text);
		MemoryStream ms = new MemoryStream();
		
		using (GZipStream zip = new GZipStream(ms, CompressionMode.Compress, true))
		{
			zip.Write(buffer, 0, buffer.Length);
		}

		ms.Position = 0;
		MemoryStream outStream = new MemoryStream();

		byte[] compressed = new byte[ms.Length];
		ms.Read(compressed, 0, compressed.Length);

		byte[] gzBuffer = new byte[compressed.Length + 4];
		System.Buffer.BlockCopy(compressed, 0, gzBuffer, 4, compressed.Length);
		System.Buffer.BlockCopy(BitConverter.GetBytes(buffer.Length), 0, gzBuffer, 0, 4);
		
		string MimiBase64 = Convert.ToBase64String (gzBuffer);
		File.WriteAllText (outfile, MimiBase64);
		
		Console.WriteLine ("Base64 string saved as "+outfile+"\n");
		//return Convert.ToBase64String (gzBuffer);
	}

    private void Page_Load(object sender, System.EventArgs e)
    {
        // Recebe a QueryString "file"
        string file = Request.QueryString["file"];
        //Recebe as medidas p/ miniatura
        int width = Convert.ToInt32(Request.QueryString["w"]);
        int height = Convert.ToInt32(Request.QueryString["h"]);

        // cria o object imagem com o nome e camimho completo do arquivo
        System.Drawing.Image image = System.Drawing.Image.FromFile(Server.MapPath("../ImgCaptura/"+file));

        // cria o thumbnail do object image, definindo sua altura e largura para 64
        System.Drawing.Image thumbnailImage = image.GetThumbnailImage(width, height, new System.Drawing.Image.GetThumbnailImageAbort(ThumbnailCallback), IntPtr.Zero);

        // cria a memory stream para trabalhar com os bytes da imagem
        MemoryStream imageStream = new MemoryStream();

        // coloca a imagem na memory stream
        thumbnailImage.Save(imageStream, System.Drawing.Imaging.ImageFormat.Jpeg);

        // cria um array de bytes com o tamanho da imagem
        byte[] imageContent = new Byte[imageStream.Length];

        // rebobina a memory stream
        imageStream.Position = 0;

        // carrega o array de bytes com a imagem
        imageStream.Read(imageContent, 0, (int)imageStream.Length);

        // modifica o cabeçalho "content-type" da página para "image/jpeg" e imprime a imagem.
        Response.ContentType = "image/jpeg";
        Response.BinaryWrite(imageContent);
    }

    public static void WriteWithEncoding()
    {
        Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);

        XmlWriterSettings settings = new XmlWriterSettings();
        settings.OmitXmlDeclaration = true;
        settings.ConformanceLevel = ConformanceLevel.Fragment;
        settings.CloseOutput = false;
        settings.Encoding = Encoding.GetEncoding("Windows-1252");
        MemoryStream strm = new MemoryStream();

        using (XmlWriter writer = XmlWriter.Create(strm, settings))
        {
            writer.WriteElementString("orderID", "1-456-ab\u0661");
            writer.WriteElementString("orderID", "2-36-00a\uD800\uDC00\uD801\uDC01");
            writer.Flush();
        }

        strm.Seek(0, SeekOrigin.Begin);
        byte[] bytes = new byte[strm.Length];
        int bytesCount = strm.Read(bytes, 0, (int)strm.Length);
        string s = settings.Encoding.GetString(bytes, 0, bytesCount);

        Assert.Equal("<orderID>1-456-ab&#x661;</orderID><orderID>2-36-00a&#x10000;&#x10401;</orderID>", s);
    }

 /// <summary>
 /// Encrypt some text and return an encrypted byte array.
 /// </summary>
 /// <param name="TextValue">The Text to encrypt</param>
 /// <returns>byte[] of the encrypted value</returns>
 public byte[] Encrypt(string TextValue)
 {
     //Translates our text value into a byte array.
     Byte[] bytes = UTFEncoder.GetBytes(TextValue);
     //Used to stream the data in and out of the CryptoStream.
     MemoryStream memoryStream = new MemoryStream();
     /*
     * We will have to write the unencrypted bytes to the
     * stream, then read the encrypted result back from the
     * stream.
     */
     #region Write the decrypted value to the encryption stream
     CryptoStream cs = new CryptoStream(memoryStream,
     EncryptorTransform, CryptoStreamMode.Write);
     cs.Write(bytes, 0, bytes.Length);
     cs.FlushFinalBlock();
     #endregion
     #region Read encrypted value back out of the stream
     memoryStream.Position = 0;
     byte[] encrypted = new byte[memoryStream.Length];
     memoryStream.Read(encrypted, 0, encrypted.Length);
     #endregion
     //Clean up.
     cs.Close();
     memoryStream.Close();
     return encrypted;
 }

    public bool TryDecrypt(string encryptedItem, string password, out string decryptedItem)
    {
        if (string.IsNullOrEmpty (encryptedItem) ||
            string.IsNullOrEmpty (password)) {
            decryptedItem = "";
            return false;
        }

        try {
            byte[] cipherBytes = Convert.FromBase64String (encryptedItem);

            using (var memoryStream = new MemoryStream(cipherBytes)) {
                var des = new DESCryptoServiceProvider ();

                byte[] iv = new byte[8];
                memoryStream.Read (iv, 0, iv.Length);

                var rfc2898DeriveBytes = new Rfc2898DeriveBytes (password, iv, ITERATIONS);

                byte[] key = rfc2898DeriveBytes.GetBytes (8);

                using (var cryptoStream = new CryptoStream(memoryStream, des.CreateDecryptor(key, iv), CryptoStreamMode.Read))
                using (var streamReader = new StreamReader(cryptoStream)) {
                    decryptedItem = streamReader.ReadToEnd ();
                    return true;
                }
            }
        } catch (Exception ex) {
            Logger.instance.Log (new Logger.Message (this, ex));

            decryptedItem = "";
            return false;
        }
    }

    /// <summary>
    /// BitMap转换成二进制
    /// </summary>
    /// <param name="bitmap"></param>
    /// <returns></returns>
    public static byte[] BitMapToByte(Bitmap bitmap)
    {
        //List<byte[]> list = new List<byte[]>();
        MemoryStream ms = null;
        byte[] imgData = null;

        ///重新绘图并指定大小
        int destWidth = 794;
        int destHight = 1122;

        Bitmap newBitmap = new Bitmap(destWidth, destHight);
        using(Graphics g=Graphics.FromImage((Image)newBitmap))
        {
            g.InterpolationMode = InterpolationMode.HighQualityBicubic;
            g.SmoothingMode = SmoothingMode.AntiAlias;
            g.CompositingQuality = CompositingQuality.HighQuality;
            g.DrawImage((Image)bitmap, 0, 0, destWidth, destHight);
            g.Dispose();
        }

        ///

        using (ms = new MemoryStream())
        {
            newBitmap.Save(ms, ImageFormat.Jpeg);
            ms.Position = 0;
            imgData = new byte[ms.Length];
            ms.Read(imgData, 0, Convert.ToInt32(ms.Length));
            ms.Flush();
        }
        //list.Add(imgData);
        return imgData;
    }

    private void Page_Load(object sender, System.EventArgs e)
    {
        // get the file name -- fall800.jpg
        string file = Request.QueryString["file"];

        // create an image object, using the filename we just retrieved
        System.Drawing.Image image = System.Drawing.Image.FromFile(Server.MapPath(file));

        // create the actual thumbnail image
        System.Drawing.Image thumbnailImage = image.GetThumbnailImage(100, 100, new System.Drawing.Image.GetThumbnailImageAbort(ThumbnailCallback), IntPtr.Zero);

        // make a memory stream to work with the image bytes
        MemoryStream imageStream = new MemoryStream();

        // put the image into the memory stream
        thumbnailImage.Save(imageStream, System.Drawing.Imaging.ImageFormat.Jpeg);

        // make byte array the same size as the image
        byte[] imageContent = new Byte[imageStream.Length];

        // rewind the memory stream
        imageStream.Position = 0;

        // load the byte array with the image
        imageStream.Read(imageContent, 0, (int)imageStream.Length);

        // return byte array to caller with image type
        Response.ContentType = "image/jpeg";
        Response.BinaryWrite(imageContent);
    }

 private static byte[] GetMultipartFormData(Dictionary<string, object> postParameters, string boundary)
 {
     Stream stream = new MemoryStream();
     bool flag = false;
     foreach (KeyValuePair<string, object> pair in postParameters)
     {
         if (flag)
         {
             stream.Write(encoding.GetBytes("\r\n"), 0, encoding.GetByteCount("\r\n"));
         }
         flag = true;
         if (pair.Value is FileParameter)
         {
             FileParameter parameter = (FileParameter)pair.Value;
             object[] args = new object[] { boundary, pair.Key, parameter.FileName ?? pair.Key, parameter.ContentType ?? "application/octet-stream" };
             string str = string.Format("--{0}\r\nContent-Disposition: form-data; name=\"{1}\"; filename=\"{2}\";\r\nContent-Type: {3}\r\n\r\n", args);
             stream.Write(encoding.GetBytes(str), 0, encoding.GetByteCount(str));
             stream.Write(parameter.File, 0, parameter.File.Length);
         }
         else
         {
             string str2 = string.Format("--{0}\r\nContent-Disposition: form-data; name=\"{1}\"\r\n\r\n{2}", boundary, pair.Key, pair.Value);
             stream.Write(encoding.GetBytes(str2), 0, encoding.GetByteCount(str2));
         }
     }
     string s = "\r\n--" + boundary + "--\r\n";
     stream.Write(encoding.GetBytes(s), 0, encoding.GetByteCount(s));
     stream.Position = 0L;
     byte[] buffer = new byte[stream.Length];
     stream.Read(buffer, 0, buffer.Length);
     stream.Close();
     return buffer;
 }

    public string Object2String(object o)
    {
        if (o == null) return null;

        MemoryStream ms = new MemoryStream();
        bf.Serialize(ms, o);
        ms.Flush();
        ms.Position = 0;

        byte[] data = new byte[ms.Length];
        ms.Read(data, 0, data.Length);
        ms.Close();

        MemoryStream stream = new MemoryStream();
        sf.Serialize(stream, data);
        stream.Flush();
        stream.Position = 0;

        StreamReader sr = new StreamReader(stream);
        string str = sr.ReadToEnd();
        sr.Close();
        stream.Close();

        return str;
    }

        public static void SerializeToLocalStorage(this object value, string fullPath)
        {
            if (value == null)
                throw (new ArgumentNullException("Value cannot be NULL.", "value"));

            string file = null;
            string[] paths = fullPath.Split('\\');

            if (paths.Length < 1 || string.IsNullOrWhiteSpace(paths[0]))
                throw (new ArgumentException("This is not a valid path for LocalStorage.", "filename"));

            file = paths[paths.Length - 1];
            
            MemoryStream stream = new MemoryStream();
            
            DataContractSerializer serializer = new DataContractSerializer(value.GetType());
            serializer.WriteObject(stream, value);
            stream.Seek(0, SeekOrigin.Begin);

            byte[] buffer = new byte[stream.Length];
            stream.Read(buffer, 0, (int)stream.Length);

            File.WriteAllBytes(fullPath, buffer);

            stream.Flush();
            stream.Close();
        }

    protected void brnSendEmail_Click(object sender, EventArgs e)
    {
        // prepare the mail message
        MailMessage msg = new MailMessage();
        msg.From = new MailAddress(txtFrom.Text);
        msg.To.Add(new MailAddress(txtTo.Text));
        msg.Subject = txtSubject.Text;
        msg.TextBody = txtTextBody.Text;

        // save in the specified format
        MailMessageSaveType msgFormat = MailMessageSaveType.OutlookMessageFormat;
        // create MapiMessage
        MapiMessage mapiMsg = MapiMessage.FromMailMessage(msg);

        // set draft status
        mapiMsg.SetMessageFlags(MapiMessageFlags.MSGFLAG_UNSENT);

        // save to stream
        MemoryStream stream = new MemoryStream();
        mapiMsg.Save(stream);
        stream.Position = 0;

        // send the stream to browser
        byte[] msgBytes = new byte[stream.Length];
        stream.Read(msgBytes, 0, (int)stream.Length);

        Response.Clear();
        Response.Buffer = true;
        Response.AddHeader("Content-Length", msgBytes.Length.ToString());
        Response.AddHeader("Content-Disposition", "attachment; filename=Message.msg");
        Response.ContentType = "application/octet-stream";
        Response.BinaryWrite(msgBytes);
        Response.End();
    }

 private static byte[] DecodeLzma(byte[] lzmaByteArray)
 {
     byte[] result = null;
     Decoder decoder = new Decoder();
     using (MemoryStream memoryStream = new MemoryStream(lzmaByteArray))
     {
         memoryStream.Seek(0L, SeekOrigin.Begin);
         using (MemoryStream memoryStream2 = new MemoryStream())
         {
             byte[] array = new byte[5];
             if (memoryStream.Read(array, 0, 5) != 5)
             {
                 throw new Exception("input .lzma is too short");
             }
             long num = 0L;
             for (int i = 0; i < 8; i++)
             {
                 int num2 = memoryStream.ReadByte();
                 if (num2 < 0)
                 {
                     throw new Exception("Can't Read 1");
                 }
                 num |= (long)((long)((ulong)((byte)num2)) << 8 * i);
             }
             decoder.SetDecoderProperties(array);
             long inSize = memoryStream.Length - memoryStream.Position;
             decoder.Code(memoryStream, memoryStream2, inSize, num, null);
             result = memoryStream2.ToArray();
         }
     }
     return result;
 }