C# StreamSocketListener.BindEndpointAsync方法代码示例

        private async Task run(string host, int port)
        {
            var listener = new StreamSocketListener();
            listener.ConnectionReceived += listener_ConnectionReceived;

            await listener.BindEndpointAsync(new HostName(host), port.ToString());
        }

 protected override async void OnNavigatedTo(NavigationEventArgs e)
 {
     rootPage = MainPage.Current;
     rootPage.NotifyUser("Waiting for client to connect...", NotifyType.StatusMessage);
     tcpListener = new StreamSocketListener();
     tcpListener.ConnectionReceived += OnConnected;
     await tcpListener.BindEndpointAsync(null, port);
 }

 /// <summary>
 /// Opens a connection, which means, that the server will be listening for telemetry clients to connect.
 /// </summary>
 /// <param name="strHostName">Hostname of the server.</param>
 /// <param name="strConnectionPort">Port which will be used for listening.</param>
 public async void OpenConnection(string strHostName, string strConnectionPort)
 {
     m_pTelemetryReaderSemaphoreSlim = new SemaphoreSlim(0, 1);
     m_pTcpListener = new StreamSocketListener();
     m_pTcpListener.ConnectionReceived += OnConnectionReceived;
     m_pTcpListener.Control.KeepAlive = true;
     var localHostName = new HostName(strHostName);
     await m_pTcpListener.BindEndpointAsync(localHostName, strConnectionPort);
 }

 private async void StartListener()
 {
    try
    {
       StreamSocketListener listener = new StreamSocketListener();
       listener.ConnectionReceived += OnConnection;
       HostName name = new HostName("192.168.1.196");
       await listener.BindEndpointAsync(name, "5656");
    }
    catch (Exception exception)
    {
       // If this is an unknown status it means that the error is fatal and retry will likely fail.
       if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown)
       {
          throw;
       }
    }
 }

 public async void Start(int port)
 {
     lock (this)
     {
         if (m_running)
             throw new InvalidOperationException("Server is already running.");
         m_running = true;
     }
     Port = port;
     m_listeners = new List<StreamSocketListener>();
     StreamSocketListener listener;
     foreach (HostName candidate in NetworkInformation.GetHostNames())
     {
         if ((candidate.Type == HostNameType.Ipv4) || (candidate.Type == HostNameType.Ipv6))
         {
             listener = new StreamSocketListener();
             listener.ConnectionReceived += OnConnectionReceived;
             await listener.BindEndpointAsync(candidate, Port.ToString());
             m_listeners.Add(listener);
         }
     }
 }

        /// <summary>
        /// This is the click handler for the 'StartListener' button.
        /// </summary>
        /// <param name="sender">Object for which the event was generated.</param>
        /// <param name="e">Event's parameters.</param>
        private async void StartListener_Click(object sender, RoutedEventArgs e)
        {
            // Overriding the listener here is safe as it will be deleted once all references to it are gone. 
            // However, in many cases this is a dangerous pattern to override data semi-randomly (each time user 
            // clicked the button) so we block it here.
            if (CoreApplication.Properties.ContainsKey("listener"))
            {
                rootPage.NotifyUser(
                    "This step has already been executed. Please move to the next one.", 
                    NotifyType.ErrorMessage);
                return;
            }

            if (String.IsNullOrEmpty(ServiceNameForListener.Text))
            {
                rootPage.NotifyUser("Please provide a service name.", NotifyType.ErrorMessage);
                return;
            }

            CoreApplication.Properties.Remove("serverAddress");
            CoreApplication.Properties.Remove("adapter");
            
            LocalHostItem selectedLocalHost = null;
            if ((BindToAddress.IsChecked == true) || (BindToAdapter.IsChecked == true))
            {
                selectedLocalHost = (LocalHostItem)AdapterList.SelectedItem;
                if (selectedLocalHost == null)
                {
                    rootPage.NotifyUser("Please select an address / adapter.", NotifyType.ErrorMessage);
                    return;
                }

                // The user selected an address. For demo purposes, we ensure that connect will be using the same 
                // address.
                CoreApplication.Properties.Add("serverAddress", selectedLocalHost.LocalHost.CanonicalName);
            }

            StreamSocketListener listener = new StreamSocketListener();
            listener.ConnectionReceived += OnConnection;
            
            // Save the socket, so subsequent steps can use it.
            CoreApplication.Properties.Add("listener", listener);
            
            // Start listen operation.
            try
            {
                if (BindToAny.IsChecked == true)
                {
                    // Don't limit traffic to an address or an adapter.
                    await listener.BindServiceNameAsync(ServiceNameForListener.Text);
                    rootPage.NotifyUser("Listening", NotifyType.StatusMessage);
                }
                else if (BindToAddress.IsChecked == true)
                {
                    // Try to bind to a specific address.
                    await listener.BindEndpointAsync(selectedLocalHost.LocalHost, ServiceNameForListener.Text);
                    rootPage.NotifyUser(
                        "Listening on address " + selectedLocalHost.LocalHost.CanonicalName, 
                        NotifyType.StatusMessage);
                }
                else if (BindToAdapter.IsChecked == true)
                {
                    // Try to limit traffic to the selected adapter. 
                    // This option will be overriden by interfaces with weak-host or forwarding modes enabled.
                    NetworkAdapter selectedAdapter = selectedLocalHost.LocalHost.IPInformation.NetworkAdapter; 

                    // For demo purposes, ensure that use the same adapter in the client connect scenario.
                    CoreApplication.Properties.Add("adapter", selectedAdapter);

                    await listener.BindServiceNameAsync(
                        ServiceNameForListener.Text, 
                        SocketProtectionLevel.PlainSocket,
                        selectedAdapter);

                    rootPage.NotifyUser(
                        "Listening on adapter " + selectedAdapter.NetworkAdapterId,
                        NotifyType.StatusMessage);
                }
            }
            catch (Exception exception)
            {
                CoreApplication.Properties.Remove("listener");
                
                // If this is an unknown status it means that the error is fatal and retry will likely fail.
                if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown)
                {
                    throw;
                }

                rootPage.NotifyUser(
                    "Start listening failed with error: " + exception.Message, 
                    NotifyType.ErrorMessage);
            }
        }

        private async Task Initialize(Uri baseUri, SuperCacheConfig configuration)
        {
            this.baseUri = baseUri;
            this.configuration = configuration;
            activityId = Guid.NewGuid();
            Trace.TraceLevel = configuration.TraceLevel;
            Trace.Information(activityId, "Server is starting...");

            HostName hostName = null;
            string port = string.Empty;
            if (!configuration.ProxyUri.Equals(SuperCacheConfig.AutomaticProxyUriConfiguration, StringComparison.OrdinalIgnoreCase))
            {
                // use manual configuration
                Uri proxyUri;
                if (!Uri.TryCreate(configuration.ProxyUri, UriKind.Absolute, out proxyUri))
                {
                    throw new InvalidOperationException("An invalid value was specified for the ProxyUri configuration setting.");
                }

                hostName = new HostName(proxyUri.Host);
                port = proxyUri.Port.ToString();
            }

            // start socket listener 
            listener = new StreamSocketListener();
            listener.ConnectionReceived += (sender, args) => { Task.Run(async () => { await OnConnectionReceivedAsync(sender, args); }); };
            await listener.BindEndpointAsync(hostName, port);

            // build proxy URI from the actual port bound to the listener
            this.proxyUri = new Uri(
                "http://" +
                (hostName != null ? hostName.CanonicalName : LocalhostIpAddress) +
                ":" +
                listener.Information.LocalPort);

            // initialize cookie manager
            cookieManager = new CookieManager(this.proxyUri);
            await cookieManager.LoadCookiesAsync(activityId);

            // initialize list of preload scripts
            await InitializePreloadScriptsAsync();

            Trace.Information(activityId, "Server is listening on port: {0} - baseUri: {1}", listener.Information.LocalPort, this.baseUri);
        }

        public async void StartServer()
        {
            try
            {
                //get IP
                var icp = NetworkInformation.GetInternetConnectionProfile();
                if (icp != null && icp.NetworkAdapter != null)
                {
                    var hostname =
                        NetworkInformation.GetHostNames()
                            .SingleOrDefault(
                                hn =>
                                hn.IPInformation != null && hn.IPInformation.NetworkAdapter != null
                                && hn.IPInformation.NetworkAdapter.NetworkAdapterId
                                == icp.NetworkAdapter.NetworkAdapterId);

                    if (hostname != null)
                    {
                        // the ip address
                        this.ipAddress = hostname.CanonicalName;
                        this.txtBoxAddress.Text = hostname.CanonicalName;
                    }
                }
                listener = new StreamSocketListener();
                listener.ConnectionReceived += OnConnection;

                // If necessary, tweak the listener's control options before carrying out the bind operation.
                // These options will be automatically applied to the connected StreamSockets resulting from
                // incoming connections (i.e., those passed as arguments to the ConnectionReceived event handler).
                // Refer to the StreamSocketListenerControl class' MSDN documentation for the full list of control options.
                listener.Control.KeepAlive = false;

                // Try to bind to a specific address.
                await listener.BindEndpointAsync(new HostName(txtBoxAddress.Text), ServiceName);

                rootPage.ShowMessage("Listening");
            }
            catch (Exception exception)
            {
                // If this is an unknown status it means that the error is fatal and retry will likely fail.
                if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown)
                {
                    rootPage.ShowMessage(
                   "Start listening failed with error: " + exception.Message);
                }
            }
        }

 /// <summary>
 /// Start listening for data
 /// </summary>
 public void Start()
 {
     if (!mIsActive)
     {
         mIsActive = true;
         listener = new StreamSocketListener();
         listener.Control.QualityOfService = SocketQualityOfService.Normal;
         listener.ConnectionReceived += Listener_ConnectionReceived;
         listener.BindEndpointAsync(new HostName(PeerConnector.GetMyIP()), listenerPort).AsTask().Wait();
     }
 }

        private async void OnConnectionRequested(WiFiDirectConnectionListener sender, WiFiDirectConnectionRequestedEventArgs connectionEventArgs)
        {
            try
            {
                var connectionRequest = connectionEventArgs.GetConnectionRequest();

                var tcs = new TaskCompletionSource<bool>();
                var dialogTask = tcs.Task;
                var messageDialog = new MessageDialog("Connection request received from " + connectionRequest.DeviceInformation.Name, "Connection Request");

                // Add commands and set their callbacks; both buttons use the same callback function instead of inline event handlers 
                messageDialog.Commands.Add(new UICommand("Accept", null, 0));
                messageDialog.Commands.Add(new UICommand("Decline", null, 1));

                // Set the command that will be invoked by default 
                messageDialog.DefaultCommandIndex = 1;

                // Set the command to be invoked when escape is pressed 
                messageDialog.CancelCommandIndex = 1;

                await Dispatcher.RunAsync(CoreDispatcherPriority.High, async () =>
                {
                    // Show the message dialog 
                    var commandChosen = await messageDialog.ShowAsync();

                    tcs.SetResult((commandChosen.Label == "Accept") ? true : false);
                });

                var fProceed = await dialogTask;

                if (fProceed == true)
                {
                    var tcsWiFiDirectDevice = new TaskCompletionSource<WiFiDirectDevice>();
                    var wfdDeviceTask = tcsWiFiDirectDevice.Task;

                    await Dispatcher.RunAsync(CoreDispatcherPriority.High, async () =>
                    {
                        try
                        {
                            rootPage.NotifyUser("Connecting to " + connectionRequest.DeviceInformation.Name + "...", NotifyType.StatusMessage);

                            WiFiDirectConnectionParameters connectionParams = new WiFiDirectConnectionParameters();
                            connectionParams.GroupOwnerIntent = Convert.ToInt16(txtGOIntent.Text);

                            // IMPORTANT: FromIdAsync needs to be called from the UI thread
                            tcsWiFiDirectDevice.SetResult(await WiFiDirectDevice.FromIdAsync(connectionRequest.DeviceInformation.Id, connectionParams));
                        }
                        catch (Exception ex)
                        {
                            rootPage.NotifyUser("FromIdAsync task threw an exception: " + ex.ToString(), NotifyType.ErrorMessage);
                        }
                    });

                    WiFiDirectDevice wfdDevice = await wfdDeviceTask;

                    // Register for the ConnectionStatusChanged event handler
                    wfdDevice.ConnectionStatusChanged += OnConnectionStatusChanged;

                    await Dispatcher.RunAsync(CoreDispatcherPriority.High, () =>
                    {
                        ConnectedDevice connectedDevice = new ConnectedDevice("Waiting for client to connect...", wfdDevice, null);
                        _connectedDevices.Add(connectedDevice);
                    });

                    var EndpointPairs = wfdDevice.GetConnectionEndpointPairs();

                    _listenerSocket = null;
                    _listenerSocket = new StreamSocketListener();
                    _listenerSocket.ConnectionReceived += OnSocketConnectionReceived;
                    await _listenerSocket.BindEndpointAsync(EndpointPairs[0].LocalHostName, Globals.strServerPort);

                    rootPage.NotifyUserFromBackground("Devices connected on L2, listening on IP Address: " + EndpointPairs[0].LocalHostName.ToString() +
                                            " Port: " + Globals.strServerPort, NotifyType.StatusMessage);
                }
                else
                {
                    // Decline the connection request
                    rootPage.NotifyUserFromBackground("Connection request from " + connectionRequest.DeviceInformation.Name + " was declined", NotifyType.ErrorMessage);
                    connectionRequest.Dispose();
                }
            }
            catch (Exception ex)
            {
                rootPage.NotifyUserFromBackground("Connect operation threw an exception: " + ex.Message, NotifyType.ErrorMessage);
            }
        }

        private async void StartListener_Click(object sender, RoutedEventArgs e)
        {
            if (CoreApplication.Properties.ContainsKey("listener"))
            {
                rootPage.NotifyUser("此步骤完成，请下一步", NotifyType.ErrorMessage);
                return;
            }
            if (String.IsNullOrEmpty(ServiceNameForListener.Text))
            {
                rootPage.NotifyUser("请输入服务器名", NotifyType.ErrorMessage);
            }
            CoreApplication.Properties.Remove("serverAddress");
            CoreApplication.Properties.Remove("adapter");

            LocalHostItem selectedLocalHost = null;
            if((BindToAddress.IsChecked == true) || (BindToAdapter.IsChecked == true))
            {
                selectedLocalHost = (LocalHostItem)AdapterList.SelectedItem;
                if (selectedLocalHost == null)
                {
                    rootPage.NotifyUser("请选择ip", NotifyType.ErrorMessage);
                    return;
                }
                CoreApplication.Properties.Add("servereAddress", selectedLocalHost.LoacalHost.CanonicalName);
            }
            StreamSocketListener listener = new StreamSocketListener();
            listener.ConnectionReceived += OnConnection;
            listener.Control.KeepAlive = false;
            //保存socket,便于以后使用
            CoreApplication.Properties.Add("listener", listener);
            //开始监听操作
            try
            {
                if (BindToAny.IsChecked == true)
                {
                    await listener.BindServiceNameAsync(ServiceNameForListener.Text);
                    rootPage.NotifyUser("Listening", NotifyType.StatusMessage);
                }
                else if (BindToAddress.IsChecked == true)
                {
                    await listener.BindEndpointAsync(selectedLocalHost.LoacalHost, ServiceNameForListener.Text);
                    rootPage.NotifyUser("Listening on address" + selectedLocalHost.LoacalHost.CanonicalName, NotifyType.StatusMessage);
                }
                else if (BindToAdapter.IsChecked == true)
                {
                    // Try to limit traffic to the selected adapter.
                    //尝试与所选适配器有限通讯
                    // This option will be overridden by interfaces with weak-host or forwarding modes enabled.
                    NetworkAdapter selectedAdapter = selectedLocalHost.LoacalHost.IPInformation.NetworkAdapter;
                    CoreApplication.Properties.Add("adapter", selectedAdapter);
                    await listener.BindServiceNameAsync(ServiceNameForListener.Text,
                        SocketProtectionLevel.PlainSocket,
                        selectedAdapter);
                    rootPage.NotifyUser("Listening on adapter " + selectedAdapter.NetworkAdapterId,
                        NotifyType.StatusMessage);
                }
            }
            catch (Exception exception)
            {
                CoreApplication.Properties.Remove("listener");
                if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown)
                {
                    throw;
                }
                rootPage.NotifyUser("开启监听失败： " + exception.Message, NotifyType.ErrorMessage);
            }
        }

        private async Task<bool> HandleConnectionRequestAsync(WiFiDirectConnectionRequest connectionRequest)
        {
            string deviceName = connectionRequest.DeviceInformation.Name;

            bool isPaired = (connectionRequest.DeviceInformation.Pairing?.IsPaired == true) ||
                            (await IsAepPairedAsync(connectionRequest.DeviceInformation.Id));

            // Show the prompt only in case of WiFiDirect reconnection or Legacy client connection.
            if (isPaired || _publisher.Advertisement.LegacySettings.IsEnabled)
            {
                var messageDialog = new MessageDialog($"Connection request received from {deviceName}", "Connection Request");

                // Add two commands, distinguished by their tag.
                // The default command is "Decline", and if the user cancels, we treat it as "Decline".
                messageDialog.Commands.Add(new UICommand("Accept", null, true));
                messageDialog.Commands.Add(new UICommand("Decline", null, null));
                messageDialog.DefaultCommandIndex = 1;
                messageDialog.CancelCommandIndex = 1;

                // Show the message dialog
                var commandChosen = await messageDialog.ShowAsync();

                if (commandChosen.Id == null)
                {
                    return false;
                }
            }

            rootPage.NotifyUser($"Connecting to {deviceName}...", NotifyType.StatusMessage);

            // Pair device if not already paired and not using legacy settings
            if (!isPaired && !_publisher.Advertisement.LegacySettings.IsEnabled)
            {
                if (!await connectionSettingsPanel.RequestPairDeviceAsync(connectionRequest.DeviceInformation.Pairing))
                {
                    return false;
                }
            }

            WiFiDirectDevice wfdDevice = null;
            try
            {
                // IMPORTANT: FromIdAsync needs to be called from the UI thread
                wfdDevice = await WiFiDirectDevice.FromIdAsync(connectionRequest.DeviceInformation.Id);
            }
            catch (Exception ex)
            {
                rootPage.NotifyUser($"Exception in FromIdAsync: {ex}", NotifyType.ErrorMessage);
                return false;
            }

            // Register for the ConnectionStatusChanged event handler
            wfdDevice.ConnectionStatusChanged += OnConnectionStatusChanged;

            var listenerSocket = new StreamSocketListener();

            // Save this (listenerSocket, wfdDevice) pair so we can hook it up when the socket connection is made.
            _pendingConnections[listenerSocket] = wfdDevice;

            var EndpointPairs = wfdDevice.GetConnectionEndpointPairs();

            listenerSocket.ConnectionReceived += OnSocketConnectionReceived;
            try
            {
                await listenerSocket.BindEndpointAsync(EndpointPairs[0].LocalHostName, Globals.strServerPort);
            }
            catch (Exception ex)
            {
                rootPage.NotifyUser($"Connect operation threw an exception: {ex.Message}", NotifyType.ErrorMessage);
                return false;
            }

            rootPage.NotifyUser($"Devices connected on L2, listening on IP Address: {EndpointPairs[0].LocalHostName}" +
                                $" Port: {Globals.strServerPort}", NotifyType.StatusMessage);
            return true;
        }

            public async void AddStreamSocketListenerAsync(UInt16 port)
            {
                ThrowIfDisposed();

                manager.NotifyUser("Adding stream socket listener for TCP port " + port, NotifyType.StatusMessage);

                var endpointPairCollection = session.GetConnectionEndpointPairs();
                
                // Create listener for socket connection (and add to list to cleanup later)
                StreamSocketListener listenerSocket = new StreamSocketListener();
                StreamSocketListenerWrapper listenerWrapper = new StreamSocketListenerWrapper(
                    manager,
                    listenerSocket,
                    this
                    );
                streamSocketListeners.Add(listenerWrapper);

                manager.NotifyUser("BindEndpointAsync...", NotifyType.StatusMessage);
                await listenerSocket.BindEndpointAsync(endpointPairCollection[0].LocalHostName, Convert.ToString(port, CultureInfo.InvariantCulture));
                manager.NotifyUser("BindEndpointAsync Done", NotifyType.StatusMessage);

                manager.NotifyUser("AddStreamSocketListenerAsync...", NotifyType.StatusMessage);
                await session.AddStreamSocketListenerAsync(listenerSocket);
                manager.NotifyUser("AddStreamSocketListenerAsync Done", NotifyType.StatusMessage);
            }

 private async void StartButton_Click(Object sender, RoutedEventArgs e)
 {
     StreamSocketListener listener = new StreamSocketListener();
     listener.ConnectionReceived += Listener_ConnectionReceived;
     capture = new UWPVideoCaptureHelper();
     try
     {
         
         MediaCaptureInitializationSettings settings = await GetMediaCaptureSettingsAsync(Windows.Devices.Enumeration.Panel.Back, 
                                                                                          (int)Preview.Width, 
                                                                                          (int)Preview.Height, 
                                                                                          30);
         await listener.BindEndpointAsync(new HostName("127.0.0.1"), "25");
         capturing = true;
         bool result = await capture.Start(settings,(int)Preview.Width,(int)Preview.Height, 25);
         System.Diagnostics.Debug.WriteLine("Capture start returned " + result);                
     }
     catch(System.Runtime.InteropServices.COMException cex)
     {
         var error = cex.HResult;
     }
 }

 // public methods
 public async Task<Int32> bind(string address, Int32 port)
 {
     _socketListener = new StreamSocketListener();
     _socketListenerLocalAddress = address;
     _socketListener.ConnectionReceived += _socket_ConnectionReceived;
     await _socketListener.BindEndpointAsync(new HostName(address), port.ToString());
     return 0;
 }