C# IoSession.GetAttribute方法代码示例

 /// <inheritdoc/>
 public override void SessionClosed(IoSession session)
 {
     IoSessionStream input = session.GetAttribute<IoSessionStream>(KEY_IN);
     IoSessionStream output = session.GetAttribute<IoSessionStream>(KEY_OUT);
     try
     {
         input.Close();
     }
     finally
     {
         output.Close();
     }
 }

 public override void ExceptionCaught(INextFilter nextFilter, IoSession session, Exception cause)
 {
     Log.Error(ErrorCode.UnhandledExceptionCaught, cause);
     var counter = session.GetAttribute<int>(KeyName.SESSION_ERROR_COUNTER);
     if (counter >= MAX_UNCAUGHT_SESSION_ERROR_COUNT) session.Close(true);
     else
     {
         session.SetAttribute(KeyName.SESSION_ERROR_COUNTER, ++counter);
         base.ExceptionCaught(nextFilter, session, cause);
     }
 }

        private SessionTasksQueue GetSessionTasksQueue(IoSession session)
        {
            SessionTasksQueue queue = session.GetAttribute<SessionTasksQueue>(TASKS_QUEUE);

            if (queue == null)
            {
                queue = new SessionTasksQueue();
                SessionTasksQueue oldQueue = (SessionTasksQueue)session.SetAttributeIfAbsent(TASKS_QUEUE, queue);
                if (oldQueue != null)
                    queue = oldQueue;
            }

            return queue;
        }

 public override void ExceptionCaught(IoSession session, Exception cause)
 {
     IOException ioe = cause as IOException;
     if (ioe != null)
     {
         IoSessionStream input = session.GetAttribute<IoSessionStream>(KEY_IN);
         if (input != null)
         {
             input.Exception = ioe;
             return;
         }
     }
     Debug.WriteLine("Unexpected exception. {0}", cause);
     session.Close(true);
 }

        /// <inheritdoc/>
        public override void ExceptionCaught(IoSession session, Exception cause)
        {
            IOException ioe = cause as IOException;
            if (ioe != null)
            {
                IoSessionStream input = session.GetAttribute<IoSessionStream>(KEY_IN);
                if (input != null)
                {
                    input.Exception = ioe;
                    return;
                }
            }

            if (log.IsWarnEnabled)
                log.Warn("Unexpected exception.", cause);
            session.Close(true);
        }

        public override void MessageReceived(INextFilter nextFilter, IoSession session, object message)
        {
            List<String> phrases = session.GetAttribute<List<String>>("phrases");

            if (null == phrases)
            {
                phrases = new List<String>();
                session.SetAttribute("phrases", phrases);
            }

            phrases.Add((String)message);

            if (phrases.Count == 3)
            {
                session.RemoveAttribute("phrases");

                base.MessageReceived(nextFilter, session, new Haiku(phrases
                        .ToArray()));
            }
        }

 private Context GetContext(IoSession session)
 {
     Context ctx = session.GetAttribute<Context>(CONTEXT);
     if (ctx == null)
     {
         ctx = new Context(this);
         session.SetAttribute(CONTEXT, ctx);
     }
     return ctx;
 }

        public override void FilterClose(INextFilter nextFilter, IoSession session)
        {
            SslHandler handler = session.GetAttribute<SslHandler>(SSL_HANDLER);
            if (handler == null)
            {
                // The connection might already have closed, or
                // SSL might have not started yet.
                base.FilterClose(nextFilter, session);
                return;
            }

            IWriteFuture future = null;
            try
            {
                future = InitiateClosure(handler, nextFilter, session);
                future.Complete += (s, e) => base.FilterClose(nextFilter, session);
            }
            finally
            { 
                if (future == null)
                    base.FilterClose(nextFilter, session);
            }
        }

 public override void MessageSent(IoSession session, Object message)
 {
     IoBuffer buffer = (IoBuffer)message;
     buffer.Rewind();
     Byte[] data = new Byte[buffer.Remaining];
     buffer.Get(data, 0, data.Length);
     StringBuilder sb = session.GetAttribute<StringBuilder>("sent");
     sb.Append(Encoding.ASCII.GetString(data));
 }

        /// <inheritdoc/>
        public override void Decode(IoSession session, IoBuffer input, IProtocolDecoderOutput output)
        {
            if (!session.TransportMetadata.HasFragmentation)
            {
                while (input.HasRemaining)
                {
                    if (!DoDecode(session, input, output))
                        break;
                }

                return;
            }

            Boolean usingSessionBuffer = true;
            IoBuffer buf = session.GetAttribute<IoBuffer>(BUFFER);

            // If we have a session buffer, append data to that; otherwise
            // use the buffer read from the network directly.
            if (buf == null)
            {
                buf = input;
                usingSessionBuffer = false;
            }
            else
            {
                Boolean appended = false;
                // Make sure that the buffer is auto-expanded.
                if (buf.AutoExpand)
                {
                    try
                    {
                        buf.Put(input);
                        appended = true;
                    }
                    catch (InvalidOperationException)
                    {
                        // A user called derivation method (e.g. slice()),
                        // which disables auto-expansion of the parent buffer.
                    }
                    catch (OverflowException)
                    {
                        // A user disabled auto-expansion.
                    }
                }

                if (appended)
                {
                    buf.Flip();
                }
                else
                {
                    // Reallocate the buffer if append operation failed due to
                    // derivation or disabled auto-expansion.
                    buf.Flip();

                    IoBuffer newBuf = IoBuffer.Allocate(buf.Remaining + input.Remaining);
                    newBuf.AutoExpand = true;
                    newBuf.Order = buf.Order;
                    newBuf.Put(buf);
                    newBuf.Put(input);
                    newBuf.Flip();
                    buf = newBuf;

                    // Update the session attribute.
                    session.SetAttribute(BUFFER, buf);
                }
            }

            while (true)
            {
                Int32 oldPos = buf.Position;
                Boolean decoded = DoDecode(session, buf, output);
                if (decoded)
                {
                    if (buf.Position == oldPos)
                        throw new InvalidOperationException("DoDecode() can't return true when buffer is not consumed.");
                    if (!buf.HasRemaining)
                        break;
                }
                else
                {
                    break;
                }
            }

            // if there is any data left that cannot be decoded, we store
            // it in a buffer in the session and next time this decoder is
            // invoked the session buffer gets appended to
            if (buf.HasRemaining)
            {
                if (usingSessionBuffer && buf.AutoExpand)
                {
                    buf.Compact();
                }
                else
                {
                    StoreRemainingInSession(buf, session);
                }
            }
//.........这里部分代码省略.........

 private Boolean CanRead(IoSession session)
 {
     Int32 pos = session.GetAttribute<Int32>("pos");
     Object sync = session.GetAttribute("lock");
     lock (sync)
     {
         Monitor.Wait(sync, 250);
     }
     String received = GetReceived(session);
     return pos < received.Length;
 }

 public override void MessageReceived(IoSession session, Object message)
 {
     IoBuffer buffer = (IoBuffer)message;
     Byte[] data = new Byte[buffer.Remaining];
     buffer.Get(data, 0, data.Length);
     Object sync = session.GetAttribute("lock");
     lock (sync)
     {
         StringBuilder sb = session.GetAttribute<StringBuilder>("received");
         sb.Append(Encoding.ASCII.GetString(data));
         Monitor.PulseAll(sync);
     }
 }

 private String GetReceived(IoSession session)
 {
     return session.GetAttribute("received").ToString();
 }

        private IProtocolDecoderOutput GetDecoderOut(IoSession session, INextFilter nextFilter)
        {
            IProtocolDecoderOutput output = session.GetAttribute<IProtocolDecoderOutput>(DECODER_OUT);

            if (output == null)
            {
                // Create a new instance, and stores it into the session
                output = new ProtocolDecoderOutputImpl();
                session.SetAttribute(DECODER_OUT, output);
            }

            return output;
        }

 public override void MessageReceived(INextFilter nextFilter, IoSession session, object message)
 {
     using (var scope = ObjectHost.Host.BeginLifetimeScope())
     {
         var commandMessage = message as DuplexMessage;
         if (commandMessage != null)
         {
             if (commandMessage.Header.CommandCode == CommandCode.Authentication)
             {
                 var school = metaRepository
                     .GetAllSchools()
                     .ByIdentifier(commandMessage.Header.Identifier);
                 if (school != null && school.UniqueToken.Equals(
                     commandMessage.GetContent<AuthInfo>().Mac, StringComparison.OrdinalIgnoreCase))
                 {
                     session.SetAttributeIfAbsent(KeyName.SESSION_IDENTIFIER, commandMessage.Header.Identifier);
                     identifierManager.SetSessonIdentifier(commandMessage.Header.Identifier, session);
                     nextFilter.FilterWrite(session,
                         new DefaultWriteRequest(
                             DuplexMessage.CreateCallbackMessage(commandMessage)));
                 }
                 else
                 {
                     nextFilter.FilterWrite(session, 
                         new DefaultWriteRequest(
                             DuplexMessage.CreateAckMessage(commandMessage, ErrorCode.AuthenticationFailed)));
                 }
             }
             else if (
                 commandMessage.Header.CommandCode == CommandCode.Register ||
                 commandMessage.Header.CommandCode == CommandCode.Heartbeat)
             {
                 nextFilter.MessageReceived(session, message);
             }
             else
             {
                 if (!session.ContainsAttribute(KeyName.SESSION_IDENTIFIER))
                 {
                     nextFilter.FilterWrite(session, new DefaultWriteRequest(
                         DuplexMessage.CreateAckMessage(commandMessage, ErrorCode.UnauthorizedCommand)));
                 }
                 else
                 {
                     var identifier = session.GetAttribute<string>(KeyName.SESSION_IDENTIFIER);
                     if (identifier.Equals(commandMessage.Header.Identifier))
                         nextFilter.MessageReceived(session, message);
                     else
                     {
                         nextFilter.FilterWrite(session, new DefaultWriteRequest(
                             DuplexMessage.CreateAckMessage(commandMessage, ErrorCode.UnauthorizedCommand)));
                     }
                 }
                 
             }
         }
         else
         {
             nextFilter.FilterWrite(session, new DefaultWriteRequest(
                 DuplexMessage.CreateAckMessage(
                     Guid.NewGuid().ToByteArray().ToBase64(), 
                     MessageVersion.V1, 
                     CommandCode.UnAssigned, 
                     ErrorCode.IllegalCommandRequest)));
         }
     }
 }