C# IOutputStream类代码示例

		public DataWriter (IOutputStream outputStream)
		{
			if (outputStream == null)
				throw new ArgumentNullException ("outputStream");

			throw new NotImplementedException();
		}

        private async Task WriteResponseAsync(string[] requestTokens, IOutputStream outstream)
        {
            // NOTE: If you change the respBody format, change the Content-Type (below) accordingly
            //string respBody = weatherData.HTML;
            //string respBody = weatherData.XML;
            string respBody = weatherData.JSON;

            string htmlCode = "200 OK";

            using (Stream resp = outstream.AsStreamForWrite())
            {
                byte[] bodyArray = Encoding.UTF8.GetBytes(respBody);
                MemoryStream stream = new MemoryStream(bodyArray);

                // NOTE: If you change the respBody format (above), change the Content-Type accordingly
                string header = string.Format("HTTP/1.1 {0}\r\n" +
                                              //"Content-Type: text/html\r\n" + // HTML only
                                              //"Content-Type: text/xml\r\n" +  // XML only
                                              "Content-Type: text/json\r\n" + // JSON only
                                              "Content-Length: {1}\r\n" +
                                              "Connection: close\r\n\r\n",
                                              htmlCode, stream.Length);

                byte[] headerArray = Encoding.UTF8.GetBytes(header);
                await resp.WriteAsync(headerArray, 0, headerArray.Length);
                await stream.CopyToAsync(resp);
                await resp.FlushAsync();
            }
        }

 public override void WriteTo(
     IOutputStream stream,
     Document context
     )
 {
     stream.Write(value);
 }

   internal CompressedWriter(
 files.File file,
 IOutputStream stream
 )
       : base(file, stream)
   {
   }

        public bool Initialize(IOutputStream _stream)
        {
            stream = _stream;

            Print("Controller.Initialize is success.");
            return true;
        }

        /// <summary>
        /// Register output stream.
        /// </summary>
        /// <param name="output_stream"></param>
        public static void RegisterOutputStream(
            IOutputStream output_stream)
        {
            OutputStreamHost.InitializeIfNeeded();

            _output_streams.Add(output_stream);
        }

		/// <exception cref="System.IO.IOException"></exception>
		protected virtual void Copy(Socket4Adapter sock, IOutputStream rawout, int length
			, bool update)
		{
			BufferedOutputStream @out = new BufferedOutputStream(rawout);
			byte[] buffer = new byte[BlobImpl.CopybufferLength];
			int totalread = 0;
			while (totalread < length)
			{
				int stilltoread = length - totalread;
				int readsize = (stilltoread < buffer.Length ? stilltoread : buffer.Length);
				int curread = sock.Read(buffer, 0, readsize);
				if (curread < 0)
				{
					throw new IOException();
				}
				@out.Write(buffer, 0, curread);
				totalread += curread;
				if (update)
				{
					_currentByte += curread;
				}
			}
			@out.Flush();
			@out.Close();
		}

        /// <summary>
        /// Encrypt an input stream and output to another stream
        /// </summary>
        /// <param name="inStream"></param>
        /// <param name="outStream"></param>
        /// <param name="userDescriptor"></param>
        /// <returns></returns>
        public static async Task ProtectStreamToStream(IInputStream inStream, IOutputStream outStream, string userDescriptor)
        {
            // Create a DataProtectionProvider object for the specified descriptor.
            DataProtectionProvider Provider = new DataProtectionProvider(userDescriptor);

            await Provider.ProtectStreamAsync(inStream, outStream);

        }

   protected Writer(
 File file,
 IOutputStream stream
 )
   {
       this.file = file;
         this.stream = stream;
   }

   public override void WriteTo(
 IOutputStream stream,
 Document context
 )
   {
       stream.Write(BeginChunk);
         base.WriteTo(stream, context);
         stream.Write(EndChunk);
   }

        /// <summary>
        /// Decrypt an input stream and output to another stream
        /// </summary>
        /// <param name="readStream"></param>
        /// <param name="outStream"></param>
        /// <returns></returns>
        public static async Task DecryptStream(IInputStream readStream, IOutputStream outStream, string userDescriptor)
        {
            // Create a DataProtectionProvider object for the specified descriptor.
            DataProtectionProvider Provider = new DataProtectionProvider(userDescriptor);

            await Provider.UnprotectStreamAsync(readStream, outStream);     // decrypt and output

            return;
        }

        public IAsyncAction DownloadAsync(IRecord record, IOutputStream destination)
        {
            if (record == null)
            {
                throw new ArgumentNullException("record");
            }

            return record.DownloadBlob(this, destination);
        }

        public void Open(IInputStream input, IOutputStream output)
        {
            m_DataReader = new DataReader(input);
            m_DataReader.ByteOrder = ByteOrder.LittleEndian;
            m_Reader.Reader = m_DataReader;

            m_DataWriter = new DataWriter(output);
            m_DataWriter.ByteOrder = ByteOrder.LittleEndian;
            m_Writer.Writer = m_DataWriter;
        }

        public HashedOutputStream(IOutputStream stream)
        {
            if (stream == null)
                throw new ArgumentNullException("stream");

            _stream = stream;
            _sha = HashAlgorithmProvider
                .OpenAlgorithm(HashAlgorithmNames.Sha256)
                .CreateHash();
        }

 public RemotePeer(ICommandSerializer serializer, ICommandsTransportResource transport, IOutputStream stream, HostName host, string port)
 {
     _serializer = serializer;
     _transport = transport;
     _dataWriter = new DataWriter(stream);
     HostName = host.RawName;
     Port = port;
     HandleActivity();
     _transport.Received += _transport_Received;
 }