public void can_read_after_select_on_queued_Channels()
 {
     var ch1 = new Channel<int>(1);
     var ch2 = new Channel<bool>(1);
     ThreadPool.QueueUserWorkItem(state => {
         ch1.Send(123);
         ch2.Send(true);
         ch2.Close();
         ch1.Send(124);
         ch1.Close();
     });
     using (var select = new Channels(Op.Recv(ch1), Op.Recv(ch2))) {
         var got = select.Select();
         Debug.Print("got.Index = " + got.Index);
         if (got.Index == 0) {
             Assert.AreEqual(123, got.Value, "got.Value");
             Assert.AreEqual(Maybe<bool>.Some(true), ch2.Recv());
         }
         else {
             Assert.AreEqual(1, got.Index, "got.Index");
             Assert.AreEqual(true, got.Value, "got.Value");
             Assert.AreEqual(Maybe<int>.Some(123), ch1.Recv());
         }
         select.ClearAt(1);
         got = select.Select();
         Assert.AreEqual(0, got.Index, "got.Index, value =" + got.Value);
         Assert.AreEqual(124, got.Value, "got.Value");
     }
 }

        static void Main(string[] args)
        {
            Channel channel = new Channel();
            HelloService service = new HelloService();
            channel.AddMethod<HelloRequest, HelloSerializer>("maid.example.HelloService.HelloNotify", service.HelloNotify);
            channel.AddMethod<HelloRequest, HelloSerializer, HelloResponse, HelloSerializer>("maid.example.HelloService.HelloRpc", service.HelloRpc);
            channel.ConnectedCallback.Add(() =>
            {
                Console.WriteLine("连接上了");
            });

            channel.Connect("192.168.0.99", 8888);

            while (true)
            {
                channel.Update();

                HelloRequest request = new HelloRequest();
                request.message = "this message from protobuf-net";
                try
                {
                    channel.CallMethod("maid.example.HelloService.HelloNotify", request);
                    channel.CallMethod("maid.example.HelloService.HelloRpc", request);
                }
                catch (Exception ){ }
                if (channel.Connecting)
                {
                    Console.WriteLine("连接中");
                }
            }
        }

 public void can_recv_one_item_before_closing()
 {
     var ch = new Channel<int>(1);
     ThreadPool.QueueUserWorkItem(state => { ch.Send(123); ch.Close(); });
     Assert.AreEqual(Maybe<int>.Some(123), ch.Recv());
     Assert.AreEqual(Maybe<int>.None(), ch.TryRecv());
 }

        public void BatchingWithKey()
        {
            using (var fiber = new ThreadFiber())
            {
                fiber.Start();
                var counter = new Channel<int>();
                var reset = new ManualResetEvent(false);
                Action<IDictionary<String, int>> cb = delegate(IDictionary<String, int> batch)
                {
                    if (batch.ContainsKey("9"))
                    {
                        reset.Set();
                    }
                };

                Converter<int, String> keyResolver = x => x.ToString();
                counter.SubscribeToKeyedBatch<int, String>(fiber, cb, keyResolver, 0);

                for (var i = 0; i < 10; i++)
                {
                    counter.Publish(i);
                }

                Assert.IsTrue(reset.WaitOne(10000, false));
            }
        }

        public CommandContext(Client irc, UserCollection users, User from, Channel channel, string message)
        {
            this._irc = irc;
            this._users = users;

            this.From = from;
            this._channel = channel;

            if (message[0] == '!' || message[0] == '.')
            {
                this._replyNotice = true;
            }
            else
            {
                this._replyNotice = false;
            }

            if (message[0] == '!' || message[0] == '.' || message[0] == '@')
            {
                this.Message = message.Substring(1);
            }
            else
            {
                this.Message = message;
            }
        }

 public ChatServerMessage(Channel chan, string message, Global.Character actor)
     : base(PacketType.ChatServerMessage)
 {
     Channel = chan;
     Message = message;
     Actor = actor;
 }

 public override void Init(Channel ch, ProtocolHeader hdr)
 {
     if (hdr.Major != 0 && hdr.Minor != 10)
     {
         throw new ProtocolVersionException((sbyte) hdr.Major, (sbyte) hdr.Minor);
     }
 }

        public double GetMillivolts(Channel channel, Gain gain = Gain.Volt5, SamplesPerSecond sps = SamplesPerSecond.SPS1600) {
            lock (deviceLock) {

                byte[] result = new byte[2];

                // Set disable comparator and set "single shot" mode	
                config = 0x0003 | 0x8000; // | 0x100;
                config |= (ushort)SamplePerSecondMap[(int)sps];
                config |= (ushort)channel;
                config |= (ushort)programmableGainMap[(int)gain];

                data[0] = REG_CFG;
                data[1] = (byte)((config >> 8) & 0xFF);
                data[2] = (byte)(config & 0xFF);


                I2CDevice.Write(data);
                // delay in milliseconds
                //int delay = (1000.0 / SamplesPerSecondRate[(int)sps] + .1;
            //    int delay = 1;
                Task.Delay(TimeSpan.FromMilliseconds(.5)).Wait();

                I2CDevice.WriteRead(new byte[] { (byte)REG_CONV, 0x00 }, result);

                //var r = (((result[0] << 8) | result[1]) >> 4);

                //Debug.WriteLine(r.ToString());

                return (ushort)(((result[0] << 8) | result[1]) >> 4) * programmableGain_Scaler[(int)gain] / 2048;
            }
        }

 private void _AddChannel(Channel channel)
 {
     ChannelColorStateControl control = new ChannelColorStateControl(channel.Name);
     _channelControls[channel.Id] = control;
     control.Dock = DockStyle.Top;
     Controls.Add(control);
 }

        public void Start(Channel channel, int numWorkerThreads)
        {
            channelReceiver = channelFactory.GetReceiver(channel.Type);

            channelReceiver.DataReceived += DataReceivedOnChannel;
            channelReceiver.Start(channel.Address,numWorkerThreads);
        }

        public YPitchBendCube(Point3D center, double radius, 
                Pitch pitch, Instrument instrument, OutputDevice device, Channel channel)
            : base(center, radius, new InstrumentNoteAction(device, channel, pitch)) {

                outputDevice = device;
                this.channel = channel;
        }

		/// <summary>
		/// Initializes a new instance of the <see cref="ProtocolFaultResponseException"/> class
		/// such that it can be sent as a protocol message response to a remote caller.
		/// </summary>
		/// <param name="channel">The channel to use when encoding the response message.</param>
		/// <param name="errorResponse">The message to send back to the HTTP client.</param>
		/// <param name="faultedMessage">The message that was the cause of the exception.  May be null.</param>
		/// <param name="innerException">The inner exception.</param>
		/// <param name="message">The message for the exception.</param>
		protected internal ProtocolFaultResponseException(Channel channel, IDirectResponseProtocolMessage errorResponse, IProtocolMessage faultedMessage = null, Exception innerException = null, string message = null)
			: base(message ?? (innerException != null ? innerException.Message : null), faultedMessage, innerException) {
			Requires.NotNull(channel, "channel");
			Requires.NotNull(errorResponse, "errorResponse");
			this.channel = channel;
			this.ErrorResponseMessage = errorResponse;
		}

 protected void AttemptToCloseChannel(Channel channel)
 {
     if (channel.UserCount == 0
         && channel != Channel_Main
         && channel != Channel_Void)
         Channels.Remove(channel);
 }

        public void Start(Channel channel)
        {
            channelReceiver = (IChannelReceiver)builder.Build(channel.Receiver);

            channelReceiver.DataReceived += DataReceivedOnChannel;
            channelReceiver.Start(channel.ReceiveAddress, channel.NumWorkerThreads);
        }

 public override void Hook_PRIV(Channel channel, libirc.UserInfo invoker, string message)
 {
     if (message.StartsWith(Configuration.System.CommandPrefix + "translate "))
     {
         message = message.Substring(11);
         List<string> parts = new List<string>(message.Split(' '));
         if (parts.Count < 3)
         {
             IRC.DeliverMessage("Invalid number of parameters", channel);
             return;
         }
         string target = null;
         string source_language = parts[0];
         string target_language = parts[1];
         if (!IsValid(source_language) || !IsValid(target_language))
         {
             IRC.DeliverMessage(invoker.Nick + ": invalid language!", channel);
             return;
         }
         string text = message.Substring(message.IndexOf(parts[1]) + parts[1].Length + 1);
         if (text.Contains("|"))
         {
             target = text.Substring(text.IndexOf("|") + 1).Trim();
             text = text.Substring(0, text.IndexOf("|"));
         }
         // schedule a message
         Ring.Add(new Buffer.Item(channel, source_language, target_language, target, text));
     }
 }

 public override string Extension_DumpHtml(Channel channel)
 {
     string HTML = "";
     DebugLog("Getting html for " + channel.Name);
     try
     {
         if (GetConfig(channel, "RC.Enabled", false))
         {
             RecentChanges rc = (RecentChanges)channel.RetrieveObject("RC");
             if (rc != null)
             {
                 HTML = rc.ToTable();
             }
             else
             {
                 Syslog.ErrorLog("NULL rc for " + channel.Name);
             }
         }
         else
         {
             DebugLog("RC is disabled for " + channel.Name, 2);
         }
     }
     catch (Exception fail)
     {
         HandleException(fail);
     }
     return HTML;
 }

        internal static void RegisterExtension(Channel channel, StandardOpenIdExtensionFactory.CreateDelegate extensionFactory)
        {
            ErrorUtilities.VerifyArgumentNotNull(channel, "channel");

            var factory = (OpenIdExtensionFactoryAggregator)channel.BindingElements.OfType<ExtensionsBindingElement>().Single().ExtensionFactory;
            factory.Factories.OfType<StandardOpenIdExtensionFactory>().Single().RegisterExtension(extensionFactory);
        }

			public void Ping(Channel<Ping> channel)
			{
				channel.Send(new Ping
					{
						ResponseChannel = PongChannel
					});
			}

 public void DefaultCtor()
 {
     var channel = new Channel();
     Assert.Null(channel.CloudBlobStorage);
     Assert.NotNull(channel.CryptoServices);
     Assert.Null(channel.Endpoint);
 }

        static void Main()
        {
            DateTime time1 = DateTime.Now;

            s_channel = new Channel<int>();

            MicroThread t2 = new MicroThread(run2);
            t2.Start();

            MicroThread t3 = new MicroThread(run2);
            t3.Start();

            MicroThread t1 = new MicroThread(run1);
            t1.Start();

            Console.WriteLine("Starting producer/consumer test, loops {0}", s_loops);

            Scheduler.Run();

            DateTime time2 = DateTime.Now;

            Console.WriteLine("total {0}", res);
            Console.WriteLine("time {0}ms", (time2 - time1).TotalMilliseconds);
            Console.WriteLine("END");
        }