C# Stream.ReadInt方法代码示例

        /// <summary>
        /// Reconstructs remote data, given a delta stream and a random access / seekable input stream,
        /// all written to outputStream.
        /// </summary>
        /// <param name="deltaStream">sequential stream of deltas</param>
        /// <param name="inputStream">seekable and efficiently random access stream</param>
        /// <param name="outputStream">sequential stream for output</param>
        public void Receive(Stream deltaStream, Stream inputStream, Stream outputStream)
        {
            if (deltaStream == null) throw new ArgumentNullException("deltaStream");
            if (inputStream == null) throw new ArgumentNullException("inputStream");
            if (outputStream == null) throw new ArgumentNullException("outputStream");
            if (inputStream.CanSeek == false) throw new InvalidOperationException("inputStream must be seekable");

            int commandByte;
            while ((commandByte = deltaStream.ReadByte()) != -1)
            {
                if (commandByte == DeltaStreamConstants.NEW_BLOCK_START_MARKER)
                {
                    int length = deltaStream.ReadInt();
                    var buffer = new byte[length];
                    deltaStream.Read(buffer, 0, length);
                    outputStream.Write(buffer, 0, length);
                }
                else if (commandByte == DeltaStreamConstants.COPY_BLOCK_START_MARKER)
                {
                    long sourceOffset = deltaStream.ReadLong();
                    int length = deltaStream.ReadInt();
                    var buffer = new byte[length];
                    inputStream.Seek(sourceOffset, SeekOrigin.Begin);
                    inputStream.Read(buffer, 0, length);
                    outputStream.Write(buffer, 0, length);
                }
                else throw new IOException("Invalid data found in deltaStream");
            }
        }

        public override object Deserialize(Stream stream)
        {
            if (encryptionEnabled)
            {
                string descriptorName = stream.ReadUTF();
                int length = stream.ReadInt();
                byte[] buffer = stream.Read(length);

                string privateKey = serverAuthority.GenerateAgreementValue(remotePublicKey).ToString(16);
                RijndaelCrypto crypto = new RijndaelCrypto();

                Type t = registry.GetTypeForDescriptor(crypto.Decrypt(descriptorName, privateKey));
                if (t != null)
                {
                    return ReflectionHelper.InvokeStaticMethodOnType(t, "ParseFrom", crypto.Decrypt(buffer, privateKey));
                }

            }
            else
            {
                string descriptorName = stream.ReadUTF();

                int length = stream.ReadInt();
                byte[] buffer = stream.Read(length);

                Type t = registry.GetTypeForDescriptor(descriptorName);
                if (t != null)
                {
                    return ReflectionHelper.InvokeStaticMethodOnType(t, "ParseFrom", buffer);
                }
            }

            return null;
        }

 public override void ReadFromStream(Stream aStream)
 {
     EntityID = aStream.ReadInt ();
     Type = aStream.ReadObjType ();
     X = aStream.ReadInt ();
     Y = aStream.ReadInt ();
     Z = aStream.ReadInt ();
 }

        /* Unpack a GMP into a Bitmap */
        public override Bitmap Unpack(ref Stream data)
        {
            try
            {
                /* Get and set image variables */
                int width      = data.ReadInt(0xC); // Width
                int height     = data.ReadInt(0x8); // Height
                short bitDepth = data.ReadShort(0x1E); // Bit Depth
                short colors   = data.ReadShort(0x1C); // Pallete Entries

                /* Throw an exception if this is not an 8-bit gmp (for now) */
                if (bitDepth != 8)
                    throw new Exception();

                /* Set up the image */
                Bitmap image = new Bitmap(width, height, PixelFormat.Format8bppIndexed);
                BitmapData imageData = image.LockBits(
                    new Rectangle(0, 0, width, height),
                    ImageLockMode.WriteOnly, image.PixelFormat);

                /* Read the data from the GMP */
                unsafe
                {
                    /* Write the palette */
                    ColorPalette palette = image.Palette;
                    for (int i = 0; i < colors; i++)
                        palette.Entries[i] = Color.FromArgb(data.ReadByte(0x20 + (i * 0x4) + 0x2), data.ReadByte(0x20 + (i * 0x4) + 0x1), data.ReadByte(0x20 + (i * 0x4)));

                    image.Palette = palette;

                    /* Start getting the pixels from the source image */
                    for (int y = 0; y < height; y++)
                    {
                        for (int x = 0; x < width; x++)
                        {
                            byte* rowData = (byte*)imageData.Scan0 + (y * imageData.Stride);
                            rowData[x] = data.ReadByte(0x20 + (colors * 0x4) + (width * height) - ((y + 1) * width) + x);
                        }
                    }
                }

                /* Unlock the bits now. */
                image.UnlockBits(imageData);

                return image;
            }
            catch
            {
                return null;
            }
        }

        private FrameReader(Stream stream, bool streaming)
        {
            try
            {
                MessageOpcode = (MessageOpcodes)stream.ReadByte();
                int bodyLen = stream.ReadInt();
                if (streaming)
                {
                    _ms = new WindowedReadStream(stream, bodyLen);
                }
                else
                {
                    byte[] buffer = new byte[bodyLen];
                    if (0 < bodyLen)
                    {
                        stream.Read(buffer, 0, bodyLen);
                        _ms = new MemoryStream(buffer);
                    }
                }

                if (MessageOpcodes.Error == MessageOpcode)
                {
                    ThrowError();
                }
            }
            catch
            {
                Dispose();
                throw;
            }
        }

 /// <summary>
 /// RSYNC file transfer with exchange of delta representatives (receiving end)
 /// </summary>
 /// <param name="stream">Connection stream</param>
 /// <param name="path">Path of file to transfer, must exist</param>
 public static void Receive(Stream stream, string path)
 {
     // Receive new file size
     int fileSizeNew = stream.ReadInt();
     int prevReadTimeout = stream.ReadTimeout;
     int prevWriteTimeout = stream.WriteTimeout;
     string tempPath = Shared.TempFile();
     var fileSizeOld = (int)new FileInfo(path).Length;
     var buffer = new byte[BufferSize];
     try
     {
         using (var fileStreamOld = new FileStream(path, FileMode.Open, FileAccess.Read))
         {
             Dictionary<int, List<Chunk>> remoteChunks = ReceiveChunkInformation(stream, fileSizeNew);
             stream.ReadTimeout = stream.WriteTimeout = fileSizeNew;
             List<Chunk> chunks = DiscoverChunksInLocalFile(remoteChunks, new C3C4TaylorsRollingChecksum(fileStreamOld, BlockSize), fileStreamOld,
                                                             fileSizeOld, buffer);
             stream.ReadTimeout = prevReadTimeout;
             stream.WriteTimeout = prevWriteTimeout;
             UniteCloseChunks(chunks);
             int chunksToRequest = AddChunksNotFoundInfo(chunks);
             chunksToRequest += AddChunkNotFoundTail(chunks, fileSizeNew);
             using (var fileStreamNew = new FileStream(tempPath, FileMode.CreateNew, FileAccess.Write))
             {
                 SendAndReceiveChunksAndRebuildFile(stream, chunks, fileStreamNew, fileStreamOld, chunksToRequest, buffer);
             }
         }
     }
     catch
     {
         if (File.Exists(tempPath))
             File.Delete(tempPath);
         stream.ReadTimeout = prevReadTimeout;
         stream.WriteTimeout = prevWriteTimeout;
     }
     // Verify file hash is as expected
     byte[] fileReceivedHash;
     using (var fs = File.OpenRead(tempPath))
     {
         fileReceivedHash = Md5.ComputeHash(fs);
     }
     // Receive hash of whole file
     var fileHash = new byte[16];
     stream.ForceRead(fileHash, 0, 16);
     if (!fileReceivedHash.AreEqual(fileHash))
     {
         File.Delete(tempPath);
         throw new Exception("File transfer error: file hash test failure");
     }
     // File transfer okay
     File.Delete(path);
     File.Move(tempPath, path);
 }

        public override void ReadFrom(Stream stream, bool readName)
        {
            base.ReadFrom(stream, readName);

            Length = stream.ReadInt();

            Items = new byte[Length];

            for (int i = 0; i < Length; ++i)
            {
                Items[i] = (byte)stream.ReadByte();
            }
        }

 public static HashBlock[] Destream(Stream inputStream)
 {
     uint count = inputStream.ReadUInt();
     var hashBlocks = new HashBlock[count];
     for (int i = 0; i < count; ++i)
     {
         hashBlocks[i] = new HashBlock {Hash = new byte[16]};
         inputStream.Read(hashBlocks[i].Hash, 0, 16);
         hashBlocks[i].Length = inputStream.ReadInt();
         hashBlocks[i].Offset = inputStream.ReadLong();
         hashBlocks[i].Checksum = inputStream.ReadUInt();
     }
     return hashBlocks;
 }

        public override void ReadFrom(Stream stream, bool readName)
        {
            base.ReadFrom(stream, readName);

            ItemType = (byte)stream.ReadByte();
            Length = stream.ReadInt();
            Items = new Tag[Length];

            for (int i = 0; i < Length; ++i)
            {
                var tag = TagType.CreateTag(ItemType);
                tag.ReadFrom(stream, false);
                Items[i] = tag;
            }
        }

        public override void Deserialize(Stream stream, Type type, ref object value)
        {
            var elementType = GetElementType(type);
            var add = GetAddMethod(type, elementType).DelegateForCall();
            var clear = GetClearMethod(type);
            clear.Invoke(value);

            int count = stream.ReadInt();
            for (int i = 0; i < count; i++)
            {
                object item = null;
                ctx.Serializer.Deserialize_Main(stream, elementType, ref item);
                addArgs[0] = item;
                add.Invoke(value, addArgs);
            }
        }

        public override void Deserialize(Stream stream, Type type, ref object instance)
        {
            int count = stream.ReadInt();
            if (instance == null || ((Array)instance).Length != count)
            {
                instance = Array.CreateInstance(type.GetElementType(), count);
                ctx.Serializer.ReMark(instance);
            }

            var array = instance as IList;
            var elementType = type.GetElementType();
            for (int i = 0; i < count; i++)
            {
                object element = null;
                ctx.Serializer.Deserialize_Main(stream, elementType, ref element);
                array[i] = element;
            }
        }

        public override object Deserialize(Stream stream)
        {
            string typeName = stream.ReadLine(MessageEncoding);

            int length = stream.ReadInt();
            byte[] messageBuffer = stream.Read(length);
            Type type = ReflectionHelper.FindType(typeName);

            if (type != null)
            {
                MemoryStream messageStream = new MemoryStream(messageBuffer);
                return Serializer.NonGeneric.Deserialize(type, messageStream);
            }
            else
            {
                throw new Exception("Invalid message type");
            }
        }

        private FrameReader(Stream stream, bool streaming, bool tracing)
        {
            try
            {
                MessageOpcode = (MessageOpcodes)stream.ReadByte();
                int bodyLen = stream.ReadInt();
                if (streaming)
                {
                    _ms = new WindowedReadStream(stream, bodyLen);
                }
                else
                {
                    byte[] buffer = new byte[bodyLen];
                    if (0 < bodyLen)
                    {
                        // read whole frame in memory
                        int read = stream.Read(buffer, 0, bodyLen);
                        while (read != bodyLen)
                        {
                            read += stream.Read(buffer, read, bodyLen - read);
                        }
                        _ms = new MemoryStream(buffer);
                    }
                }

                if (tracing)
                {
                    // skip traceId
                    byte[] traceId = new byte[16];
                    int count = traceId.Length;
                    _ms.Read(traceId, 0, count);
                }

                if (MessageOpcodes.Error == MessageOpcode)
                {
                    ThrowError();
                }
            }
            catch
            {
                Dispose();
                throw;
            }
        }

        private static Exception CreateExceptionFromError(Stream stream)
        {
            ErrorCodes code = (ErrorCodes) stream.ReadInt();
            string msg = stream.ReadString();

            switch (code)
            {
                case ErrorCodes.Unavailable:
                    {
                        ConsistencyLevel cl = (ConsistencyLevel) stream.ReadUShort();
                        int required = stream.ReadInt();
                        int alive = stream.ReadInt();
                        return new UnavailableException(msg, cl, required, alive);
                    }

                case ErrorCodes.WriteTimeout:
                    {
                        ConsistencyLevel cl = (ConsistencyLevel) stream.ReadUShort();
                        int received = stream.ReadInt();
                        int blockFor = stream.ReadInt();
                        string writeType = stream.ReadString();
                        return new WriteTimeOutException(msg, cl, received, blockFor, writeType);
                    }

                case ErrorCodes.ReadTimeout:
                    {
                        ConsistencyLevel cl = (ConsistencyLevel) stream.ReadUShort();
                        int received = stream.ReadInt();
                        int blockFor = stream.ReadInt();
                        bool dataPresent = 0 != stream.ReadByte();
                        return new ReadTimeOutException(msg, cl, received, blockFor, dataPresent);
                    }

                case ErrorCodes.Syntax:
                    return new SyntaxException(msg);

                case ErrorCodes.Unauthorized:
                    return new UnauthorizedException(msg);

                case ErrorCodes.Invalid:
                    return new InvalidException(msg);

                case ErrorCodes.AlreadyExists:
                    {
                        string keyspace = stream.ReadString();
                        string table = stream.ReadString();
                        return new AlreadyExistsException(msg, keyspace, table);
                    }

                case ErrorCodes.Unprepared:
                    {
                        byte[] unknownId = stream.ReadShortBytes();
                        return new UnpreparedException(msg, unknownId);
                    }

                default:
                    return new CassandraException(code, msg);
            }
        }