C# Stream.Write方法代码示例

        protected override void InternalWrite(Stream Target)
        {
            Target.Seek(0, SeekOrigin.Begin);
            Target.Write(ByteHelper.StringToByte("ID3"));
            //                Version 3.0   Flags  dummy size
            Target.Write(new byte[] { 3,0,  0,     0, 0, 0, 0  }, 0, 7);

            long totalFrameSize = 0;
            Stream frameStream = null;
            foreach(Frame f in Frames)
            {
                frameStream = FrameObjectToByteArray(f);
                totalFrameSize += frameStream.Length;
                frameStream.CopyTo(Target);
                frameStream.Flush();
            }
            Target.Seek(6, SeekOrigin.Begin);
            Target.Write(ByteHelper.GetByteArrayWith7SignificantBitsPerByteForInt((int)totalFrameSize));

            // frame fertig geschrieben jetzt müssen die daten rein =>
            // sourcestream an die stelle spulen und lesen bis endpos
            Target.Seek(DataStart, SeekOrigin.Begin);

            // Target.Copy(SourceStream, DataStart, DataEnd);

            Target.Flush();
            Target.Close();
        }

 public SignatureStream( string signature, Stream baseStream )
 {
     Signature = signature;
     this.baseStream = baseStream;
     if ( CanRead )
     {
         byte [] sig = new byte [ signature.Length ];
         try { baseStream.Read ( sig, 0, sig.Length ); }
         catch { throw new ArgumentException (); }
         if ( Encoding.UTF8.GetString ( sig, 0, sig.Length ) != Signature )
             throw new ArgumentException ();
     }
     else if ( CanWrite && CanSeek )
     {
         long pos = baseStream.Position;
         baseStream.Position = 0;
         byte [] sig = Encoding.UTF8.GetBytes ( signature );
         baseStream.Write ( sig, 0, sig.Length );
         baseStream.Position = pos + signature.Length;
     }
     else if ( CanWrite && !CanSeek && baseStream.Position == 0 )
     {
         byte [] sig = Encoding.UTF8.GetBytes ( signature );
         baseStream.Write ( sig, 0, sig.Length );
     }
 }

 public void Save(Stream stream)
 {
     stream.Write((byte)1);
     stream.Write((byte)m_mode);
     stream.Write(m_first);
     stream.Write(m_second);
 }

        public static int Compress(Stream input, Stream output)
        {
            var length = (int)(input.Length - input.Position);

            var varInt = new VarInt32(length).GetEncodedValue();
            output.Write(varInt, 0, varInt.Length);

            int bytesWritten = varInt.Length;

            int bytesToRead = Math.Min(length, CompressorConstants.BlockSize);

            var fragment = MemoryPool.Instance.Take(bytesToRead);

            int maxOutput = MaxCompressedOutput(bytesToRead);

            var block = MemoryPool.Instance.Take(maxOutput);

            while(length > 0)
            {
                var fragmentSize = input.Read(fragment, 0, bytesToRead);
                var hashTable = new HashTable(fragmentSize);

                int blockSize = CompressFragment(fragment, fragmentSize, hashTable, block);
                output.Write(block, 0, blockSize);
                bytesWritten += blockSize;

                length -= bytesToRead;
            }

            MemoryPool.Instance.Return(fragment);
            MemoryPool.Instance.Return(block);

            return bytesWritten;
        }

 /// <summary>
 /// Saves the token to a stream
 /// </summary>
 /// <param name="stream">the stream to save to</param>
 public void Save(Stream stream)
 {
     stream.WriteByte(1);
     stream.Write(CanWrite);
     stream.Write(CanRead);
     stream.Write(IsAdmin);
 }

        public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content,
                                                TransportContext transportContext)
        {
            var callback = GetCallbackName();

            if (!String.IsNullOrEmpty(callback))
            {
                // select the correct encoding to use.
                Encoding encoding = SelectCharacterEncoding(content.Headers);

                // write the callback and opening paren.
                return Task.Factory.StartNew(() =>
                {
                    var bytes = encoding.GetBytes(callback + "(");
                    writeStream.Write(bytes, 0, bytes.Length);
                })
                    // then we do the actual JSON serialization...
                .ContinueWith(t => base.WriteToStreamAsync(type, value, writeStream, content, transportContext))

                // finally, we close the parens.
                .ContinueWith(t =>
                {
                    var bytes = encoding.GetBytes(")");
                    writeStream.Write(bytes, 0, bytes.Length);
                });
            }
            return base.WriteToStreamAsync(type, value, writeStream, content, transportContext);
        }

        public async Task Encrypt(Stream input, Stream output)
        {
            _aes.GenerateIV();

            if (_cancelEvent.IsSet())
                return;

            byte[] vector = _aes.IV;
            byte[] vectorLength = BitConverter.GetBytes(vector.Length);
            output.Write(vectorLength, 0, 4);
            output.Write(vector, 0, vector.Length);

            if (_cancelEvent.IsSet())
                return;

            using (ICryptoTransform encryptor = _aes.CreateEncryptor())
            using (CryptoStream encryptionStream = new CryptoStream(output, encryptor, CryptoStreamMode.Write))
            {
                if (_cancelEvent.IsSet())
                    return;

                await PatcherService.CopyAsync(input, encryptionStream, _cancelEvent, Progress);
                encryptionStream.FlushFinalBlock();
            }
        }

        public void SerializeTraceData(TraceData data, Stream stream)
        {
            /* write the magic to the raw stream */
            stream.Write(BitConverter.GetBytes(MAGIC), 0, sizeof(uint));
            stream.Write(BitConverter.GetBytes(VERSION), 0, sizeof(uint));

            /* Write the magic */
            WriteUint(MAGIC);

            /* Write the version */
            WriteUint(VERSION);

            SerializeStatistics(data.Statistics);

            SerializeStackTraces(data.StackTraces);

            SerializeSQLStatements(data.SQLStatements);

            SerializeExecutionCalls(data.AllExecutionCalls);

            WriteLong(data.MaxCallDepth);

            ms.Seek(0, SeekOrigin.Begin);

            using (DeflateStream def = new DeflateStream(stream, CompressionLevel.Optimal))
            {
                ms.CopyTo(def);
            }
        }

 public static void Uint32ToByteStreamLe(uint val, Stream stream)
 {
     stream.Write((byte)(val >> 0));
     stream.Write((byte)(val >> 8));
     stream.Write((byte)(val >> 16));
     stream.Write((byte)(val >> 24));
 }

        public override void Save(Image i, Stream dest)
        {
            dest.WriteByte(0); // Write No Image ID
            dest.WriteByte(0); // Write No Color-Map
            dest.WriteByte(2); // Write Image Type (Uncompressed- True Color)
            byte[] dat = new byte[5];
            dest.Write(dat, 0, 5); // Write Color-Map Spec

            dest.WriteByte(0);
            dest.WriteByte(0); // Write X-Origin
            dest.WriteByte(0);
            dest.WriteByte(0); // Write Y-Origin
            dat = BitConverter.GetBytes((UInt16)i.Width);
            dest.Write(dat, 0, 2); // Write the Width
            dat = BitConverter.GetBytes((UInt16)i.Height);
            dest.Write(dat, 0, 2); // Write the Height
            dest.WriteByte(32); // Write the Color-Depth

            byte ImageDescriptor = 0;
            ImageDescriptor |= 8; // Set 8-Bit Alpha data.
            ImageDescriptor |= (byte)(1 << 5); // Set Top-Left Image origin
            dest.WriteByte(ImageDescriptor); // Write Image Descriptor Byte

            UInt32 len = (uint)(i.Width * i.Height);
            Pixel p;
            for (int loc = 0; loc < len; loc++) // Write the Image Data.
            {
                p = i.Data[loc];
                dest.WriteByte(p.B);
                dest.WriteByte(p.G);
                dest.WriteByte(p.R);
                dest.WriteByte(p.A);
            }
        }

 protected virtual void SendRequest(Stream outputStream)
 {
     byte[] headerBuffer = this._header.ToByte();
     outputStream.Write(headerBuffer, 0, headerBuffer.Length);
     if (_body != null)
         outputStream.Write(this._body, 0, this._body.Length);
 }

		public void Write(Tag tag, Stream apeStream, Stream tempStream) {
			ByteBuffer tagBuffer = tc.Create(tag);

			if (!TagExists(apeStream)) {
				apeStream.Seek(0, SeekOrigin.End);
				apeStream.Write(tagBuffer.Data, 0, tagBuffer.Capacity);
			} else {
				apeStream.Seek( -32 + 8 , SeekOrigin.End);
			
				//Version
				byte[] b = new byte[4];
				apeStream.Read( b , 0,  b.Length);
				int version = Utils.GetNumber(b, 0, 3);
				if(version != 2000) {
					throw new CannotWriteException("APE Tag other than version 2.0 are not supported");
				}
				
				//Size
				b = new byte[4];
				apeStream.Read( b , 0,  b.Length);
				long oldSize = Utils.GetLongNumber(b, 0, 3) + 32;
				int tagSize = tagBuffer.Capacity;
				
				apeStream.Seek(-oldSize, SeekOrigin.End);
				apeStream.Write(tagBuffer.Data, 0, tagBuffer.Capacity);
					
				if(oldSize > tagSize) {
					//Truncate the file
					apeStream.SetLength(apeStream.Length - (oldSize-tagSize));
				}
			}
		}

 public override Stream Write(Stream stream)
 {
     base.Write(stream);
     stream.Write(Topic);
     stream.Write(IsAdd);
     return stream;
 }

 public int GetCrc32AndCopy(Stream input, Stream output)
 {
     if (input == null)
     {
         throw new ZipException("bad input.", new ArgumentException("The input stream must not be null.", "input"));
     }
     byte[] buffer = new byte[0x2000];
     int readSize = 0x2000;
     this._TotalBytesRead = 0;
     int count = input.Read(buffer, 0, readSize);
     if (output != null)
     {
         output.Write(buffer, 0, count);
     }
     this._TotalBytesRead += count;
     while (count > 0)
     {
         this.SlurpBlock(buffer, 0, count);
         count = input.Read(buffer, 0, readSize);
         if (output != null)
         {
             output.Write(buffer, 0, count);
         }
         this._TotalBytesRead += count;
     }
     return (int) ~this._RunningCrc32Result;
 }

		/// <summary>
		/// Returns the CRC32 for the specified stream, and writes the input into the output stream.
		/// </summary>
		/// <param name="input">The stream over which to calculate the CRC32</param>
		/// <param name="output">The stream into which to deflate the input</param>
		/// <returns>the CRC32 calculation</returns>
		public UInt32 GetCrc32AndCopy(Stream input, Stream output)
		{
			unchecked
			{
				UInt32 crc32Result;
				crc32Result = 0xFFFFFFFF;
				byte[] buffer = new byte[BufferSize];
				int readSize = BufferSize;

				m_TotalBytesRead = 0;
				int count = input.Read(buffer, 0, readSize);
				if (output != null) output.Write(buffer, 0, count);
				m_TotalBytesRead += count;
				while (count > 0)
				{
					for (int i = 0; i < count; i++)
					{
						crc32Result = ((crc32Result) >> 8) ^ m_crc32Table[(buffer[i]) ^ ((crc32Result) & 0x000000FF)];
					}
					count = input.Read(buffer, 0, readSize);
					if (output != null) output.Write(buffer, 0, count);
					m_TotalBytesRead += count;

				}

				return ~crc32Result;
			}
		}