C# ByteBuffer.Put方法代码示例

 public void WritePayload(ByteBuffer buffer)
 {
     buffer.Put(ClassId);
     buffer.Put(Weight);
     buffer.Put(BodySize);
     buffer.Put(Properties.PropertyFlags);
     Properties.WritePropertyListPayload(buffer);
 }

 public void WritePayload(ByteBuffer buffer)
 {
     foreach (char c in Header)
     {
         buffer.Put((byte) c);
     }
     buffer.Put(ProtocolClass);
     buffer.Put(ProtocolInstance);
     buffer.Put(ProtocolMajor);
     buffer.Put(ProtocolMinor);
 }

        //Reads bytes from the Filestream into the bytebuffer
        public static int Read(this FileStream file, ByteBuffer dst, long position)
        {
            lock (_fsReadLock)
            {
                // TODO: check this logic, could probably optimize
                if (position >= file.Length)
                    return 0;

                var original = file.Position;

                file.Seek(position, SeekOrigin.Begin);

                int count = 0;

                for (int i = dst.Position; i < dst.Limit; i++)
                {
                    int v = file.ReadByte();
                    if (v == -1)
                        break;
                    dst.Put((byte) v);
                    count++;
                }

                file.Seek(original, SeekOrigin.Begin);

                return count;
            }
        }

 public void Setup()
 {
    const int size = 50;
    _baseBuffer = ByteBuffer.Allocate(size);
    for ( byte b = 0; b < 10; b++ )
    {
       _baseBuffer.Put(b);
    }
    _baseBuffer.Flip();
 }

      public static void WriteShortStringBytes(ByteBuffer buffer, string s)
      {
         if ( s != null )
         {
            //try
            //{
            //final byte[] encodedString = s.getBytes(STRING_ENCODING);
            byte[] encodedString;
            lock ( DEFAULT_ENCODER )
            {
               encodedString = DEFAULT_ENCODER.GetBytes(s);
            }
            // TODO: check length fits in an unsigned byte
            buffer.Put((byte)encodedString.Length);
            buffer.Put(encodedString);

         } else
         {
            // really writing out unsigned byte
            buffer.Put((byte)0);
         }
      }

        //Reads bytes from the Filestream into the bytebuffer
        public static int Read(this FileStream file, ByteBuffer dst, long position)
        {
            // TODO: check this logic, could probably optimize
            if (position >= file.Length)
                return 0;

            var original = file.Position;

            var count = dst.Limit - dst.Position;
            // TODO: (.net port) consider move to async all the way.
            var bytes = ReadBytesAsync(file, (int) position, count).Result;
            dst.Put(bytes);

            file.Seek(original, SeekOrigin.Begin);
            return count;
        }

 public static void WriteShort(ByteBuffer buffer, short value)
 {
    buffer.Put(value);
 }

 public static void WriteSByte(ByteBuffer buffer, sbyte value)
 {
    buffer.Put(value);
 }

 public static void WriteChar(ByteBuffer buffer, char value)
 {
    buffer.Put((byte)value);
 }

 public static void WriteBoolean(ByteBuffer buffer, bool value)
 {
    buffer.Put((byte)(value ? 1 : 0));
 }

		/// <summary>
		/// Puts an in buffer stream onto an out buffer stream and returns the bytes written.
		/// </summary>
		/// <param name="output"></param>
		/// <param name="input"></param>
		/// <param name="numBytesMax"></param>
		/// <returns></returns>
		public static int Put(ByteBuffer output, ByteBuffer input, int numBytesMax) 
		{
			int limit = input.Limit;
			int numBytesRead = (numBytesMax > input.Remaining) ? input.Remaining : numBytesMax;
			/*
			input.Limit = (int)input.Position + numBytesRead;
			output.Put(input);
			input.Limit = limit;
			*/
			output.Put(input, numBytesRead);
			return numBytesRead;
		}

 public static void WriteLong(ByteBuffer buffer, long value)
 {
    buffer.Put(value);
 }

 public static void WriteUnsignedInteger(ByteBuffer buffer, uint value)
 {
    buffer.Put(value);
 }

 public static void WriteLongStringBytes(ByteBuffer buffer, string s, Encoding encoding)
 {
    if ( !(s == null || s.Length <= 0xFFFE) )
    {
       throw new ArgumentException("String too long");
    }
    if ( s != null )
    {
       lock ( encoding )
       {
          byte[] encodedString = encoding.GetBytes(s);
          buffer.Put((uint)encodedString.Length);
          buffer.Put(encodedString);
       }
    } else
    {
       buffer.Put((uint)0);
    }
 }

        /// <summary>
        /// Writes MLArrays into <c>OutputStream</c>
        /// </summary>
        /// <remarks>
        /// Writes MAT-file header and compressed data (<c>miCompressed</c>).
        /// </remarks>
        /// <param name="stream"><c>Stream</c></param>
        /// <param name="data"><c>Collection</c> of <c>MLArray</c> elements.</param>
        /// <param name="compress">Use data compression?</param>
        public MatFileWriter( BinaryWriter stream, ICollection data, bool compress )
        {
            // Write header
            WriteHeader( stream );

            foreach( MLArray matrix in data )
            {
                if (compress)
                {
                    // Prepare buffer for MATRIX data
                    MemoryStream memstrm = new MemoryStream();
                    BinaryWriter bw = new BinaryWriter(memstrm);
                    // Write MATRIX bytes into buffer
                    WriteMatrix(bw, matrix);

                    // Compress data to save storage
                    memstrm.Position = 0; // Rewind the stream

                    MemoryStream compressed = new MemoryStream();
                    zlib.ZOutputStream zos = new zlib.ZOutputStream(compressed, zlib.zlibConst.Z_DEFAULT_COMPRESSION);

                    byte[] input = new byte[128];
                    int len = 0;
                    while ((len = memstrm.Read(input, 0, input.Length)) > 0)
                        zos.Write(input, 0, len);
                    zos.Flush();
                    zos.Close();  // important to note that the zlib.ZOutputStream needs to close before writting out the data to the Base.stream

                    //write COMPRESSED tag and compressed data into output channel
                    byte[] compressedBytes = compressed.ToArray();
                    ByteBuffer buf = new ByteBuffer(2 * 4 + compressedBytes.Length);
                    buf.PutInt(MatDataTypes.miCOMPRESSED);
                    buf.PutInt(compressedBytes.Length);
                    buf.Put(compressedBytes, 0, compressedBytes.Length);

                    stream.Write(buf.Array());

                    compressed.Close();
                }
                else
                {
                    // Write MATRIX bytes into buffer
                    WriteMatrix(stream, matrix);
                }

            }

            stream.Close();
        }