C# Buffer类代码示例

        public int InverseTransform(Buffer buffer, int length)
        {
            Log.Trace("Cipher.InverseTransform: input length {0}", length);

            int result;
            using (var ms = new MemoryStream(length))
            {
                var decryptor = algorithm.CreateDecryptor(key, iv);
                using (var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Write))
                {
                    var buffers = new List<ArraySegment<byte>>();
                    buffer.ListStartingSegments(buffers, length);

                    for (var i = 0; i < buffers.Count; ++i)
                    {
                        var segment = buffers[i];

                        Log.Trace("Cipher.InverseTransform: input block {0}",
                            BitConverter.ToString(segment.Array, segment.Offset, segment.Count));

                        cs.Write(segment.Array, segment.Offset, segment.Count);
                    }
                    cs.FlushFinalBlock();

                    result = (int)ms.Length;
                }

                buffer.Rewind();
                buffer.CopyFrom(ms.GetBuffer(), 0, result);

                Log.Trace("Cipher.InverseTransform: output {0} {1}",
                    result, BitConverter.ToString(ms.GetBuffer(), 0, result));
            }
            return result;
        }

 /////////////////////////////////////////////有效時間性Buffer////////////////////////////////////////////////////////
 /// <summary>
 /// 腳色取得Buffer，傳入Buffer
 /// </summary>
 public virtual void ReceiveBuffer(Buffer _buffer)
 {
     if (BufferDic == null)
     {
         Debug.LogWarning("BufferDic為null");
         return;
     }
     //尚未擁有此BufferID
     if (!BufferDic.ContainsKey(_buffer.ID))
     {
         Go_BufferEntity = Instantiate(Prefab_BufferEntity, Vector2.zero, Quaternion.identity) as GameObject;
         Go_BufferEntity.transform.parent = Trans_BufferList;
         Com_BufferEntity = Go_BufferEntity.GetComponent<BufferEntity>();
         Com_BufferEntity.IniBuffer(_buffer, this);
         List<BufferEntity> TmpBufferEntityList = new List<BufferEntity>();
         TmpBufferEntityList.Add(Com_BufferEntity);
         BufferDic.Add(_buffer.ID, TmpBufferEntityList);//加入BufferDIc字典
     }
     else//已經擁有此BufferID
     {
         //如果此狀態是可疊加的
         if (_buffer.Stackable)
         {
             Go_BufferEntity = Instantiate(Prefab_BufferEntity, Vector2.zero, Quaternion.identity) as GameObject;
             Go_BufferEntity.transform.parent = Trans_BufferList;
             Com_BufferEntity = Go_BufferEntity.GetComponent<BufferEntity>();
             Com_BufferEntity.IniBuffer(_buffer, this);
             BufferDic[_buffer.ID].Add(Com_BufferEntity);
         }
         else//如果此狀態不可疊加
         {
             BufferDic[_buffer.ID][0].IniBuffer(_buffer, this);
         }
     }
 }

        public void request(Session session, Channel channel)
        {
            Buffer buf = new Buffer();
            Packet packet = new Packet(buf);

            bool reply = waitForReply();
            if (reply)
            {
                channel.Replay = -1;
            }

            packet.reset();
            buf.putByte((byte)Session.SSH_MSG_CHANNEL_REQUEST);
            buf.putInt(channel.Recipient);
            buf.putString(Util.getBytes("subsystem"));
            buf.putByte((byte)(waitForReply() ? 1 : 0));
            buf.putString(Util.getBytes("sftp"));
            session.write(packet);

            if (reply)
            {
                while (channel.Replay == -1)
                {
                    try { System.Threading.Thread.Sleep(10); }
                    catch//(Exception ee)
                    {
                    }
                }
                if (channel.Replay == 0)
                {
                    throw new JSchException("failed to send sftp request");
                }
            }
        }

 public void Blit(Buffer src, int srcX, int srcY, int width, int height, int dstX, int dstY)
 {
     var attribs = new int[] {
         (int)BlitAttribute.SCREEN_BLIT_SOURCE_X,
         srcX,
         (int)BlitAttribute.SCREEN_BLIT_SOURCE_Y,
         srcY,
         (int)BlitAttribute.SCREEN_BLIT_SOURCE_WIDTH,
         width,
         (int)BlitAttribute.SCREEN_BLIT_SOURCE_HEIGHT,
         height,
         (int)BlitAttribute.SCREEN_BLIT_DESTINATION_X,
         dstX,
         (int)BlitAttribute.SCREEN_BLIT_DESTINATION_Y,
         dstY,
         (int)BlitAttribute.SCREEN_BLIT_DESTINATION_WIDTH,
         width,
         (int)BlitAttribute.SCREEN_BLIT_DESTINATION_HEIGHT,
         height,
         (int)BlitAttribute.SCREEN_BLIT_END
     };
     if (screen_blit (context.Handle, buffer, src.buffer, attribs) != 0) {
         throw new Exception ("Error blitting.");
     }
 }

        internal void Clear()
        {
            m_deviceContext.ClearState();

            m_inputLayout = null;
            m_primitiveTopology = PrimitiveTopology.Undefined;
            m_indexBufferRef = null;
            m_indexBufferFormat = 0;
            m_indexBufferOffset = 0;
            for (int i = 0; i < m_vertexBuffers.Length; i++)
                m_vertexBuffers[i] = null;
            for (int i = 0; i < m_vertexBuffersStrides.Length; i++)
                m_vertexBuffersStrides[i] = 0;

            m_blendState = null;
            m_stencilRef = 0;
            m_depthStencilState = null;
            m_rtvsCount = 0;
            for (int i = 0; i < m_rtvs.Length; i++)
                m_rtvs[i] = null;
            m_dsv = null;

            m_rasterizerState = null;
            m_scissorLeftTop = new Vector2I(-1, -1);
            m_scissorRightBottom = new Vector2I(-1, -1);
            m_viewport = default(RawViewportF);

            m_targetBuffer = null;
            m_targetOffsets = 0;

            m_statistics.ClearStates++;
        }

        public MeshContainer(Engine.Serialize.Mesh M)
        {
            if (M != null)
            {
                LocalAABBMax = M.AABBMax;
                LocalAABBMin = M.AABBMin;

                VertexsCount = M.VertexCount;
                FaceCount = M.FaceCount;
                BytesPerVertex = M.VertexData.Length / VertexsCount;

                using (var vertices = new DataStream(BytesPerVertex * VertexsCount, true, true))
                {
                    vertices.WriteRange<byte>(M.VertexData, 0, M.VertexData.Length);
                    vertices.Position = 0;
                    Vertexs = new Buffer(ModelViewer.Program.device, vertices, BytesPerVertex * VertexsCount, ResourceUsage.Default, BindFlags.VertexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
                    binding = new VertexBufferBinding(Vertexs, BytesPerVertex, 0);
                }

                using (var indices = new DataStream(4 * FaceCount * 3, true, true))
                {
                    indices.WriteRange<byte>(M.IndexData, 0, M.IndexData.Length);
                    indices.Position = 0;
                    Indices = new Buffer(ModelViewer.Program.device, indices, 4 * FaceCount * 3, ResourceUsage.Default, BindFlags.IndexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
                }
            }
        }

        internal UnloadedBlock(Buffer raw, DirectivesBlock directives)
            : base(BlockCode.Unloaded)
        {
            kind = raw.ReadByte ();
            start_counter = raw.ReadUlong ();
            end_counter = raw.ReadUlong ();
            thread_id = raw.ReadUlong ();
            if (directives.LoadedElementsCarryId)
                id = raw.ReadUint ();
            item_name = raw.ReadString ();

            switch ((LoadedItemInfo) kind) {
            case LoadedItemInfo.APPDOMAIN:
                is_appdomain = true;
                break;
            case LoadedItemInfo.MODULE:
                is_module = true;
                break;
            case LoadedItemInfo.ASSEMBLY:
                is_assembly = true;
                break;
            default:
                throw new Exception (String.Format ("unknown load event kind {0}", kind));
            }
            if (!raw.IsEmpty)
                throw new Exception ("Unexpected data remaining in block");
        }

 public WaitPanelThread(Point origin, int delay, bool positiveAxis, bool horizontal, Panel panel, Plane plane, Semaphore semaphoreThis, Semaphore semaphoreNext, Semaphore semaphoreTerminal, Buffer bufferPrevious, Buffer bufferNext, Buffer bufferTerminal, int length, int terminalID)
 {
     this.origin = origin;
     this.delay = delay;
     this.positiveAxis = positiveAxis;
     this.panel = panel;
     this.plane = plane;
     this.panel.Paint += new PaintEventHandler(this.panel_Paint);
     if (horizontal)
     {
         this.xDelta = positiveAxis ? +10 : -10;
         this.yDelta = 0;
     }
     else
     {
         this.xDelta = 0;
         this.yDelta = positiveAxis ? +10 : -10;
     }
     this.semaphoreThis = semaphoreThis;
     this.semaphoreNext = semaphoreNext;
     this.semaphoreTerminal = semaphoreTerminal;
     this.bufferPrevious = bufferPrevious;
     this.bufferNext = bufferNext;
     this.bufferTerminal = bufferTerminal;
     this.length = length;
     this.terminalID = terminalID;
 }

 public BufferNode(Dictionary<string, TreeNode> actors, Dictionary<string, TreeNode> quests, string clientHash)
 {
     this.Buffer = new Buffer(new byte[0]);
     this.actors = actors;
     this.quests = quests;
     this.clientHash = clientHash;
 }

 public IOProcessor(KeyProcessor kpr)
 {
     SetKPR(kpr);
     bf = new Buffer();
     log = new Log();
     cfg = new Config("MyInput\\");
 }

 public void run()
 {
     Buffer buf=new Buffer(300); // ??
     Packet packet=new Packet(buf);
     thread=this;
     try
     {
         ss.Start();
         while(thread!=null)
         {
             Socket socket=ss.AcceptSocket();
             socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.NoDelay, 1);
             NetworkStream ns = new NetworkStream(socket);
             Stream ins= ns;
             Stream outs=ns;
             ChannelDirectTCPIP channel=new ChannelDirectTCPIP();
             channel.init();
             channel.setInputStream(ins);
             channel.setOutputStream(outs);
                 session.addChannel(channel);
             ((ChannelDirectTCPIP)channel).setHost(host);
             ((ChannelDirectTCPIP)channel).setPort(rport);
             ((ChannelDirectTCPIP)channel).setOrgIPAddress( ((IPEndPoint)socket.RemoteEndPoint).Address.ToString() );
             ((ChannelDirectTCPIP)channel).setOrgPort(((IPEndPoint)socket.RemoteEndPoint).Port);
             channel.connect();
             if(channel.exitstatus!=-1)
             {
             }
         }
     }
     catch
     {
         //System.out.println("! "+e);
     }
 }

 public Buffer Next()
 {
     lock (obj)
     {
         if (next == null) return null;
         int size = next.Size();
         if (size < 13) return null;
         if (next.GetInt(0) != 0x42424344)
         {
             System.Console.WriteLine("Not reading a dirac stream");
             next = null;
             return null;
         }
         int offset = next.GetInt(5);
         if (offset == 0)
             offset = 13;
         if (offset > size) return null;
         if (prev != next.GetInt(9))
             throw new Exception();
         prev = offset;
         if (size == offset)
         {
             Buffer tmp = next;
             next = null;
             return tmp;
         }
         else
         {
             Buffer tmp = next.Sub(0, offset);
             next = next.Sub(offset);
             return tmp;
         }
     }
 }

 public void Add(Buffer buf)
 {
     lock(obj)
     {
         next = (next == null ? buf : next.Cat(buf));
     }
 }

        public void TestTransform()
        {
            BlockCipher cipher1 = new BlockCipher();
            BlockCipher cipher2 = new BlockCipher();

            byte[] bytes1 = cipher1.InitializeHandshake();
            byte[] bytes2 = cipher2.InitializeHandshake();
            bytes1 = cipher2.Handshake(bytes1);
            bytes2 = cipher1.Handshake(bytes2);
            cipher1.FinalizeHandshake(bytes1);
            cipher2.FinalizeHandshake(bytes2);

            Buffer buffer = new Buffer();

            string text = new String('x', 5300);
            Assert.AreEqual(5300, text.Length);
            /*
            buffer.Write(1);
            buffer.Write(text);
            buffer.Shrink(1);
            */

            cipher1.Transform(buffer, (int)buffer.Length);
            cipher2.InverseTransform(buffer, (int)buffer.Length);

            buffer.Rewind();

            /*
            string result;
            buffer.Read(out result);

            Assert.AreEqual(text, result);
            */
        }

    void OnEnable()
    {
        if (mRequest == null)
        {
            mRequest = Buffer.Create();
            mRequest.BeginPacket(Packet.RequestServerList).Write(GameServer.gameID);
            mRequest.EndPacket();
        }

        if (mRemoteAddress == null)
        {
            if (string.IsNullOrEmpty(remoteAddress))
            {
                mRemoteAddress = new IPEndPoint(IPAddress.Broadcast, remotePort);
            }
            else
            {
                mRemoteAddress = Tools.ResolveEndPoint(remoteAddress, remotePort);
            }

            if (mRemoteAddress == null)
            {
                mUdp.Error(new IPEndPoint(IPAddress.Loopback, mUdp.listeningPort), "Invalid address: " + remoteAddress + ":" + remotePort);
            }
        }

        // Twice just in case the first try falls on a taken port
        if (!mUdp.Start(Tools.randomPort)) mUdp.Start(Tools.randomPort);
    }