C# HubConnection.CreateHubProxy方法代码示例

        public async Task SendToGroupFromOutsideOfHub()
        {
            using (var host = new MemoryHost())
            {
                IHubContext<IBasicClient> hubContext = null;
                host.Configure(app =>
                {
                    var configuration = new HubConfiguration
                    {
                        Resolver = new DefaultDependencyResolver()
                    };

                    app.MapSignalR(configuration);
                    hubContext = configuration.Resolver.Resolve<IConnectionManager>().GetHubContext<SendToSome, IBasicClient>();
                });

                var connection1 = new HubConnection("http://foo/");

                using (connection1)
                {
                    var wh1 = new AsyncManualResetEvent(initialState: false);

                    var hub1 = connection1.CreateHubProxy("SendToSome");

                    await connection1.Start(host);

                    hub1.On("send", wh1.Set);

                    hubContext.Groups.Add(connection1.ConnectionId, "Foo").Wait();
                    hubContext.Clients.Group("Foo").send();

                    Assert.True(await wh1.WaitAsync(TimeSpan.FromSeconds(10)));
                }
            }
        }

 public async static Task<IHubProxy> GetProxy(String hubName)
 {
     var hubConnection = new HubConnection(ConfigurationManager.AppSettings.Get("ServerAddressAndPort"));
     IHubProxy proxy = null;
     switch (hubName)
     {
         case "UserHub":
         {
             proxy = hubConnection.CreateHubProxy("UserHub");
             break;
         }
         case "MessageHub":
         {
             proxy = hubConnection.CreateHubProxy("MessageHub");
             break;
         }
         case "ConversationHub":
         {
             proxy = hubConnection.CreateHubProxy("ConversationHub");
             break;
         }
     }
     ServicePointManager.DefaultConnectionLimit = 20;
     await hubConnection.Start();
     return proxy;
 }

 public void OpenConnection()
 {
     _connection = new HubConnection(_hubUrl);
     _alertHubProxy = _connection.CreateHubProxy("alertHub");
     _resourceHubProxy = _connection.CreateHubProxy("resourceHub");
     _connection.Start().Wait();
 }

        private async Task btnCon_Click(object sender, EventArgs e)
        {
            this.btnInvok.Enabled = false;

            hubConnection = new HubConnection(txtUrl.Text);
            stockTickerHubProxy = hubConnection.CreateHubProxy("TickerHub");
            strongHubProxy = hubConnection.CreateHubProxy("StrongHub");

            this.btnCon.Enabled = false;
            try
            {
                await hubConnection.Start(new WebSocketTransport());

                this.btnInvok.Enabled = true;
            }
            catch (Exception ex)
            {
                Exception temp = ex;
                string msg = temp.Message;
                while (temp.InnerException != null)
                {
                    temp = temp.InnerException;
                    msg += "\r\n" + temp.Message;
                }
                MessageBox.Show(msg);
            }
            this.btnCon.Enabled = true;

        }

		public Client ()
		{
			_connection = new HubConnection ("http://signalx.azurewebsites.net");
//			_connection.ConnectionSlow += () => {
//				var connectionSlow = true;
////				MessagingCenter.Send<ConnectionStatus> (new ConnectionStatus () { 
////					Status = "Connection Slow"
////				} , "ConnectionChanged");
//			};
//			_connection.Received += (obj) => {
//				var rec = true;
////				MessagingCenter.Send<ConnectionStatus> (new ConnectionStatus () { 
////					Status = "Received"
////				} , "ConnectionChanged");
//			};
//			_connection.Reconnecting += () => {
//				var recon = true;
////				MessagingCenter.Send<ConnectionStatus> (new ConnectionStatus () { 
////					Status = "Reconnecting"
////				} , "ConnectionChanged");
//
//			};
//			_connection.Reconnected += () => {
//				var recon = true;
////				MessagingCenter.Send<ConnectionStatus> (new ConnectionStatus () { 
////					Status = "Reconnected" 
////				} , "ConnectionChanged");
//			};
			_connection.StateChanged += (obj) => {
				MessagingCenter.Send<ConnectionStatus> (new ConnectionStatus () { 
					Status = obj.NewState.ToString() 
				} , "ConnectionChanged");
			};
//			_connection.Closed += () => {
//				var closed = true;
////				MessagingCenter.Send<ConnectionStatus> (new ConnectionStatus () { 
////					Status = "Closed"
////				} , "ConnectionChanged");
//			};
			_connection.TransportConnectTimeout = new TimeSpan (0, 0, 10);

			_connection.Error += ex => {
				MessagingCenter.Send<ConnectionStatus> (new ConnectionStatus () { 
					Status = "Error" + ex.Message
				} , "ConnectionChanged");
			};

			_chatHub = _connection.CreateHubProxy ("chathub");
			_conflictHub = _connection.CreateHubProxy ("conflicthub");
			_newsHub = _connection.CreateHubProxy ("newshub");
			_alertHub = _connection.CreateHubProxy ("alerthub");

		}

        static void Main(string[] args)
        {
            Task.Run(async () =>
            {
                var conHub = new HubConnection("http://localhost:8080/");
                conHub.CreateHubProxy("Shell").On<ShellCommandParams>("cmd", (data) =>
                {
                });

                using (var con = new Connection("http://localhost:8080/api/cmd"))
                {
                    con.Received += (data) =>
                    {
                        Console.WriteLine($"ola, recebi! {data}");
                    };
                    con.StateChanged += (state) =>
                    {
                        if (state.NewState != state.OldState)
                        {
                            Console.WriteLine($"De {state.OldState} para {state.NewState}");
                        }
                    };
                    await con.Start();

                    await con.Send("Hello Mello");
                }
            }).Wait();

        }

        //Data should be brought down from the SERVER, more specifically from the PLAYERLIST. Four slots, one for each of the four players.
        //If no data available, say N/A (Not Applicable)
        //If possible, display in order of score/health, so that pausing the game shows who's 'winning' or 'losing' at that time.

        public DisplayMenu(Texture2D bttnContinueSprite)
        {
            bttnContinue = new MenuButton(bttnContinueSprite, new Point(700, 570));
            HubConnection connection = new HubConnection("http://localhost:56859");
            proxy = connection.CreateHubProxy("UserInputHub");
            connection.Start().Wait();
        }

        private async Task OpenConnection()
        {
            var url = $"http://{await _serverFinder.GetServerAddressAsync()}/";

            try
            {
                _hubConnection = new HubConnection(url);

                _hubProxy = _hubConnection.CreateHubProxy("device");
                _hubProxy.On<string>("hello", message => Hello(message));
                _hubProxy.On("helloMsg", () => Hello("EMPTY"));
                _hubProxy.On<long, bool, bool>("binaryDeviceUpdated", (deviceId, success, binarySetting) => InvokeDeviceUpdated(deviceId, success, binarySetting: binarySetting));
                _hubProxy.On<long, bool, double>("continousDeviceUpdated", (deviceId, success, continousSetting) => InvokeDeviceUpdated(deviceId, success, continousSetting));

                await _hubConnection.Start();

                await _hubProxy.Invoke("helloMsg", "mobile device here");

                Debug.WriteLine($"{nameof(RealTimeService)}.{nameof(OpenConnection)} SignalR connection opened");
            }
            catch (Exception e)
            {
                Debug.WriteLine($"{nameof(RealTimeService)}.{nameof(OpenConnection)} ex: {e.GetType()}, msg: {e.Message}");
            }
        }

 private void StartSignalRHubConnection()
 {
     //TODO: Specify your SignalR website settings in SCPHost.exe.config
     this.hubConnection = new HubConnection(ConfigurationManager.AppSettings["SignalRWebsiteUrl"]);
     this.twitterHubProxy = hubConnection.CreateHubProxy(ConfigurationManager.AppSettings["SignalRHub"]);
     hubConnection.Start().Wait();
 }

        public void Start()
        {
            var siteUrl = Settings.Default.SiteUrl;
            var portNumber = Settings.Default.PortNumber;

            var uri = string.Format("http://*:{0}{1}", portNumber, siteUrl);

            const string url = "http://localhost:10000";
            StartOptions options = new StartOptions();
            options.Urls.Add(string.Format("http://{0}:10000", Environment.MachineName));
            options.Urls.Add("http://localhost:10000/");
            options.Urls.Add(uri);

            host = WebApp.Start<Startup>(options);

            var hubConnection = new HubConnection(url);
            var hubProxy = hubConnection.CreateHubProxy("MyHub");

            hubConnection.Start().ContinueWith(task =>
            {

            }).Wait();

            var timer = new Timer(x =>
            {
                if (ConnectionMapping.Count <= 1) return;

                hubProxy.Invoke("Send").Wait();
            }, null, 0, 2000);
        }

        public MainWindow()
        {
            InitializeComponent();
            var hubConnection = new HubConnection("http://divewakeweb.azurewebsites.net/");
            stockTickerHubProxy = hubConnection.CreateHubProxy("WakeHub");
            hubConnection.Start().Wait();
            _sensor = KinectSensor.GetDefault();

            if (_sensor != null)
            {
                _sensor.Open();

                _bodies = new Body[_sensor.BodyFrameSource.BodyCount];

                _colorReader = _sensor.ColorFrameSource.OpenReader();
                _colorReader.FrameArrived += ColorReader_FrameArrived;
                _bodyReader = _sensor.BodyFrameSource.OpenReader();
                _bodyReader.FrameArrived += BodyReader_FrameArrived;

                // 2) Initialize the face source with the desired features
                _faceSource = new FaceFrameSource(_sensor, 0, FaceFrameFeatures.BoundingBoxInColorSpace |
                                                              FaceFrameFeatures.FaceEngagement |
                                                              FaceFrameFeatures.Glasses |
                                                              FaceFrameFeatures.LeftEyeClosed |
                                                              FaceFrameFeatures.PointsInColorSpace |
                                                              FaceFrameFeatures.RightEyeClosed);
                _faceReader = _faceSource.OpenReader();
                _faceReader.FrameArrived += FaceReader_FrameArrived;
            }
        }

        public void ConnectToServer()
        {

            hubConnection = new HubConnection(serverAddress);
            hubProxy = hubConnection.CreateHubProxy("SoftNodesHub");
            bool isConnected = false;
            while (!isConnected)
            {
                try
                {
                    hubConnection.Start().Wait();
                    hubConnection.Closed += OnHubConnectionClosed;
                    //hubProxy.On<Message>("ReceiveMessage", ReceiveMessage);

                    isConnected = true;
                    LogInfo("Connected to server");
                    OnConnected?.Invoke();
                }
                catch (Exception e)
                {
                    LogError("Connection to server failed: " + e.Message);
                    OnConnectionFailed?.Invoke(e.Message);
                }
            }
        }

        public Client(string platform)
        {
            _platform = platform;

            _connection = new HubConnection("http://meetupsignalrxamarin.azurewebsites.net/");
            _proxy = _connection.CreateHubProxy("ChatHub");
        }

        public ListenerService()
        {
            InitializeComponent();
            
            // ReSharper disable once DoNotCallOverridableMethodsInConstructor
            EventLog.Log = "HubCollectorLog";
            StatsdClient = new Statsd(Config.Hostname, Config.Port);
            KlondikeConnections = new List<HubConnection>();

            Config.Hubs.ForEach(hub =>
            {
                var connection = new HubConnection(hub);

                IHubProxy statusHubProxy = connection.CreateHubProxy("status");
                statusHubProxy.On("updateStatus", status =>
                {
                    string name = Config.NameFromUrl(connection.Url);
                    var message = String.Format("From {2}: Status: {0}, Total: {1}", status.synchronizationState,
                        status.totalPackages, name);
                    EventLog.WriteEntry(message);
                    //Console.WriteLine(message);

                    StatsdClient.LogGauge("nuget."+ name +".packageCount", (int) status.totalPackages);
                });

                KlondikeConnections.Add(connection);
            });
        }

        //[STAThread]
        static void Main(string[] args)
        {
            HubConnection hub = new HubConnection("http://localhost:57365/");

            var prxy=hub.CreateHubProxy("RemoteHub");
            prxy.On<string, string>("commandReceived", (command, parameters) => {
                Console.WriteLine(string.Format("Command : {0}, Parameters : {1} ", command, parameters));
                if ("executecommand".Equals(command, StringComparison.OrdinalIgnoreCase))
                {
                    System.Diagnostics.Process.Start("CMD.exe", "/C " + parameters);
                }
            });
            hub.Start().Wait();

            //var config = new HttpSelfHostConfiguration("http://localhost:4521");
            //System.Threading.Thread.Sleep(5000);
            //config.Routes.MapHttpRoute(
            //    "API Default", "api/{controller}/{id}",
            //    new { id = RouteParameter.Optional });

            //using (HttpSelfHostServer server = new HttpSelfHostServer(config))
            //{
            //    server.OpenAsync().Wait();
            //    Console.WriteLine("Press Enter to quit.");
            //    Console.ReadLine();
            //}
            Console.ReadLine();
        }