C# Connection.Start方法代码示例

        public RemoteDeploymentManager(string serviceUrl)
        {
            serviceUrl = UrlUtility.EnsureTrailingSlash(serviceUrl);
            _client = HttpClientHelper.Create(serviceUrl);

            // Raise the event when data comes in
            _connection = new Connection(serviceUrl + "status");
            _connection.Received += data => {
                if (StatusChanged != null) {
                    var result = JsonConvert.DeserializeObject<DeployResult>(data);
                    StatusChanged(result);
                }
            };

            _connection.Error += exception => {
                // If we get a 404 back stop listening for changes
                WebException webException = exception as WebException;
                if (webException != null) {
                    var webResponse = (HttpWebResponse)webException.Response;
                    if (webResponse != null &&
                        webResponse.StatusCode == HttpStatusCode.NotFound) {
                        _connection.Stop();
                    }
                }
            };

            _connection.Closed += () => {
                Debug.WriteLine("SignalR connection to {0} was closed.", serviceUrl);
            };

            _connection.Start().Wait();
        }

        private static Task ConnectBatch(string url, int batchSize, ConcurrentBag<Connection> connections)
        {
            var options = new ParallelOptions
            {
                MaxDegreeOfParallelism = batchSize
            };

            var tcs = new TaskCompletionSource<object>();
            long remaining = batchSize;
            Parallel.For(0, batchSize, options, i =>
            {
                var connection = new Connection(url);

                connection.Start().ContinueWith(task =>
                {
                    remaining = Interlocked.Decrement(ref remaining);

                    if (task.IsFaulted)
                    {
                        Console.WriteLine("Failed to start client. {0}", task.Exception.GetBaseException());
                    }
                    else
                    {
                        connections.Add(connection);

                        var clientId = connection.ConnectionId;

                        //connection.Received += data =>
                        //{
                        //    Console.WriteLine("Client {0} RECEIVED: {1}", clientId, data);
                        //};

                        connection.Error += e =>
                        {
                            Debug.WriteLine(String.Format("SIGNALR: Client {0} ERROR: {1}", clientId, e));
                        };

                        connection.Closed += () =>
                        {
                            Debug.WriteLine(String.Format("SIGNALR: Client {0} CLOSED", clientId));
                        };

                    }

                    if (Interlocked.Read(ref remaining) == 0)
                    {
                        // When all connections are connected, mark the task as complete
                        tcs.TrySetResult(null);
                    }
                });
            });

            return tcs.Task;
        }

            public void FailedNegotiateShouldNotBeActive()
            {
                var connection = new Connection("http://test");
                var transport = new Mock<IClientTransport>();
                transport.Setup(m => m.Negotiate(connection))
                         .Returns(TaskAsyncHelper.FromError<NegotiationResponse>(new InvalidOperationException("Something failed.")));

                var aggEx = Assert.Throws<AggregateException>(() => connection.Start(transport.Object).Wait());
                var ex = aggEx.Unwrap();
                Assert.IsType(typeof(InvalidOperationException), ex);
                Assert.Equal("Something failed.", ex.Message);
                Assert.Equal(ConnectionState.Disconnected, connection.State);
            }

            public void FailsIfProtocolVersionIsNull()
            {
                var connection = new Connection("http://test");
                var transport = new Mock<IClientTransport>();
                transport.Setup(m => m.Negotiate(connection)).Returns(TaskAsyncHelper.FromResult(new NegotiationResponse
                {
                    ProtocolVersion = null
                }));

                var aggEx = Assert.Throws<AggregateException>(() => connection.Start(transport.Object).Wait());
                var ex = aggEx.Unwrap();
                Assert.IsType(typeof(InvalidOperationException), ex);
                Assert.Equal("Incompatible protocol version.", ex.Message);
            }

        protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);
            var connection = new Connection("http://mxm-signalr.azurewebsites.net/raw-connection");

            connection.Received += data => Report(data);

            connection.Reconnected += () => Report("[{0}]: Connection restablished", DateTime.Now);

            connection.StateChanged += change => Report(change.OldState + " => " + change.NewState);

            connection.Error += ex =>
            {
                Report("========ERROR==========" + ex.Message + "=======================");
            };

            connection.Start();
        }

        // Constructor
        public MainPage()
        {
            InitializeComponent();

            // Set the data context of the listbox control to the sample data
            DataContext = App.ViewModel;
            this.Loaded += new RoutedEventHandler(MainPage_Loaded);

            var connection = new Connection("http://signalr-sample.azurewebsites.net/raw-connection/");
            connection.Received += data =>
            {
                Dispatcher.BeginInvoke(() =>
                {
                    App.ViewModel.Items.Add(new ItemViewModel { LineOne = data });
                });
            };

            connection.Error += ex =>
            {
                Dispatcher.BeginInvoke(() =>
                {
                    var aggEx = (AggregateException)ex;
                    App.ViewModel.Items.Add(new ItemViewModel { LineOne = aggEx.InnerExceptions[0].Message });
                });
            };

            connection.Reconnected += () =>
            {
                Dispatcher.BeginInvoke(() =>
                {
                    App.ViewModel.Items.Add(new ItemViewModel { LineOne = "Connection restored" });
                });
            };

            var scheduler = TaskScheduler.FromCurrentSynchronizationContext();
            connection.Start().ContinueWith(task =>
            {
                var ex = task.Exception.InnerExceptions[0];
                App.ViewModel.Items.Add(new ItemViewModel { LineOne = ex.Message });
            },
            CancellationToken.None,
            TaskContinuationOptions.OnlyOnFaulted,
            scheduler);
        }

            public void FailedStartShouldNotBeActive()
            {
                var connection = new Connection("http://test");
                var transport = new Mock<IClientTransport>();
                transport.Setup(m => m.Negotiate(connection))
                         .Returns(TaskAsyncHelper.FromResult(new NegotiationResponse
                         {
                             ProtocolVersion = "1.1",
                             ConnectionId = "Something"
                         }));

                transport.Setup(m => m.Start(connection, null, It.IsAny<CancellationToken>()))
                         .Returns(TaskAsyncHelper.FromError(new InvalidOperationException("Something failed.")));

                var aggEx = Assert.Throws<AggregateException>(() => connection.Start(transport.Object).Wait());
                var ex = aggEx.Unwrap();
                Assert.IsType(typeof(InvalidOperationException), ex);
                Assert.Equal("Something failed.", ex.Message);
                Assert.Equal(ConnectionState.Disconnected, connection.State);
            }

        private async Task RunStreaming(string serverUrl)
        {
            string url = serverUrl + "streaming-connection";

            var connection = new Connection(url);
            connection.TraceWriter = _traceWriter;

            await connection.Start();
            connection.TraceWriter.WriteLine("transport.Name={0}", connection.Transport.Name);
        }

        private async Task RunRawConnection(string serverUrl)
        {
            string url = serverUrl + "raw-connection";

            var connection = new Connection(url);
            connection.TraceWriter = _traceWriter;

            await connection.Start();
            connection.TraceWriter.WriteLine("transport.Name={0}", connection.Transport.Name);

            await connection.Send(new { type = 1, value = "first message" });
            await connection.Send(new { type = 1, value = "second message" });
        }

        private async Task RunAuth(string serverUrl)
        {
            string url = serverUrl + "cookieauth";

            var handler = new HttpClientHandler();
            handler.CookieContainer = new CookieContainer();
            using (var httpClient = new HttpClient(handler))
            {
                var content = string.Format("UserName={0}&Password={1}", "user", "password");
                var response = httpClient.PostAsync(url + "/Account/Login", new StringContent(content, Encoding.UTF8, "application/x-www-form-urlencoded")).Result;
            }

            var connection = new Connection(url + "/echo");
            connection.TraceWriter = _traceWriter;
            connection.Received += (data) => connection.TraceWriter.WriteLine(data);
#if !ANDROID && !iOS
            connection.CookieContainer = handler.CookieContainer;
#endif
            await connection.Start();
            await connection.Send("sending to AuthenticatedEchoConnection");

            var hubConnection = new HubConnection(url);
            hubConnection.TraceWriter = _traceWriter;
#if !ANDROID && !iOS
            hubConnection.CookieContainer = handler.CookieContainer;
#endif
            var hubProxy = hubConnection.CreateHubProxy("AuthHub");
            hubProxy.On<string, string>("invoked", (connectionId, date) => hubConnection.TraceWriter.WriteLine("connectionId={0}, date={1}", connectionId, date));

            await hubConnection.Start();
            hubConnection.TraceWriter.WriteLine("transport.Name={0}", hubConnection.Transport.Name);

            await hubProxy.Invoke("InvokedFromClient");
        }

        static void Main(string[] args)
        {
            Console.WriteLine("Crank v{0}", typeof(Program).Assembly.GetName().Version);
            if (args.Length < 2)
            {
                Console.WriteLine("Usage: crank [url] [numclients]");
                return;
            }

            ServicePointManager.DefaultConnectionLimit = Int32.MaxValue;

            string url = args[0];
            int clients = Int32.Parse(args[1]);

            TaskScheduler.UnobservedTaskException += OnUnobservedTaskException;

            var connections = new ConcurrentBag<Connection>();

            var sw = Stopwatch.StartNew();

            Task.Factory.StartNew(() =>
            {
                Parallel.For(0, clients, i =>
                {
                    try
                    {
                        var connection = new Connection(url);
                        connection.Received += data =>
                        {
                            Console.WriteLine(data);
                        };

                        connection.Error += e =>
                        {
                            Console.WriteLine("ERROR: Client {0}, {1}", i, e.GetBaseException());
                        };

                        connection.Closed += () =>
                        {
                            Console.WriteLine("CLOSED: {0}", i);
                        };

                        connection.Start().Wait();
                        connections.Add(connection);
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine("Failed to start client {0}. {1}", i, e);
                    }
                });
                Console.WriteLine("Started {0} connection(s).", connections.Count);
            });

            Console.WriteLine("Press any key to stop running...");
            Console.Read();
            sw.Stop();

            Console.WriteLine("Total Running time: {0}s", sw.Elapsed);
            Console.WriteLine("End point: {0}", url);
            Console.WriteLine("Total connections: {0}", clients);
            Console.WriteLine("Active connections: {0}", connections.Count(c => c.IsActive));
            Console.WriteLine("Stopped connections: {0}", connections.Count(c => !c.IsActive));
        }

 private void button1_Click(object sender, EventArgs e)
 {
     if (!int.TryParse(textPort.Text, out port))
     {
         MessageBox.Show("Please enter a number in the port section.");
         DialogResult = DialogResult.None;
         return;
     }
     Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
     try
     {
         socket.Connect(Hostname, port);
     }
     catch
     {
         MessageBox.Show("Unable to connect to chosen server on specified port.");
         DialogResult = DialogResult.None;
         return;
     }
     try
     {
         Connection con = new Connection(socket, ParentShard);
         player.Name = textUsername.Text;
         SHA256 hasher = SHA256.Create();
         player.PasswordHash = hasher.ComputeHash(Encoding.Unicode.GetBytes(textPassword.Text));
         player.Connection = con;
         con.Player = player;
         con.Start();
         HelloResponse res = (HelloResponse)con.SendMessage(new HelloMessage());
         if (!res.Success)
         {
             MessageBox.Show("Client version incompatible with selected server.");
             DialogResult = DialogResult.None;
             return;
         }
         byte[] publicKeyData = res.PublicKeyData;
         byte[] nonce = res.Nonce;
         Message response = con.SendMessage(new LoginPlayerMessage(player.Name, player.PasswordHash, publicKeyData, nonce));
         LoginPlayerResponseMessage realResponse = response as LoginPlayerResponseMessage;
         if (realResponse != null)
         {
             if (!realResponse.Success)
             {
                 if (MessageBox.Show("Username does not exist or password wrong, should I attempt to create a new player?", "Login failure.", MessageBoxButtons.YesNo) == DialogResult.Yes)
                 {
                     // TODO - confirm password.
                     response = con.SendMessage(new CreatePlayerMessage(player.Name, player.PasswordHash, publicKeyData, nonce));
                     CreatePlayerResponseMessage realResponse2 = response as CreatePlayerResponseMessage;
                     if (realResponse2 != null)
                     {
                         if (realResponse2.Success)
                         {
                             MessageBox.Show("Player successfully created.");
                             return;
                         }
                         else
                         {
                             MessageBox.Show("Name already exists, choose another.");
                             DialogResult = DialogResult.None;
                             return;
                         }
                     }
                     else
                         throw new NotSupportedException("Unexpected response type from server.");
                 }
                 else
                 {
                     DialogResult = DialogResult.None;
                     return;
                 }
             }
         }
         else
             throw new NotSupportedException("Unexpected response received from server.");
     }
     catch
     {
         MessageBox.Show("Unexpected error occured while logging in.");
         DialogResult = DialogResult.None;
         return;
     }
 }

        private async Task RunBasicAuth(string serverUrl)
        {
            string url = serverUrl + "basicauth";

            var connection = new Connection(url + "/echo");
            connection.TraceWriter = _traceWriter;
            connection.Received += (data) => connection.TraceWriter.WriteLine(data);
            connection.Credentials = new NetworkCredential("user", "password");
            await connection.Start();
            await connection.Send("sending to AuthenticatedEchoConnection");

            var hubConnection = new HubConnection(url);
            hubConnection.TraceWriter = _traceWriter;
            hubConnection.Credentials = new NetworkCredential("user", "password");

            var hubProxy = hubConnection.CreateHubProxy("AuthHub");
            hubProxy.On<string, string>("invoked", (connectionId, date) => hubConnection.TraceWriter.WriteLine("connectionId={0}, date={1}", connectionId, date));

            await hubConnection.Start();            
            hubConnection.TraceWriter.WriteLine("transport.Name={0}", hubConnection.Transport.Name);

            await hubProxy.Invoke("InvokedFromClient");            
        }