Windows 10和Windows IOT核心之间的TCP通信

我不知道是什么原因阻止了Windows 10 IOT Core与Windows 10计算机之间的通信。我的设置如下，1）Windows 10 IOT上安装了NXP imx6 2）Windows 10 10上安装了我的开发沙箱3）两台计算机都在同一子网中

在Windows 10 IOT核心上安装了TCP端口转发UWP应用（按原样复制代码并定制为UWP应用，请从下面提供的Git集线器中进行引用）。

https://gist.github.com/bongbongco/588abf3928cbd297443dd9da8171eb9a

该应用程序已在Windows 10 IOT上成功运行，无法接受来自我的Windows 10计算机的客户端连接请求。应用程序在下面的代码行中继续等待客户端连接

源= _mainSocket.Accept（）;

当我尝试连接到Windows 10 IOT核心时，从我的客户端计算机（Windows 10开发人员计算机）收到连接超时异常。

我正在尝试将telnet 8081连接到安装了Windows 10 IOT Core的iMX6板上，但是出现错误“无法打开主机到端口8081的连接：连接失败”

当我对iMX6机器执行ping操作时，我的问题是，IOT核心是否已打开特定端口？

或我们需要启用的某些防火墙设置？如果是这样，如何启用。

我已经从NXP安装了以下图像“ W1860_1_0_1_EVK_iMX6ULL_512MB_TestOEMInput-xml-Release.ffu”

让我知道您的想法可能是个问题。
是否有人在UWP中开发了有效的端口转发应用程序？

我的一些观察1）我可以ping我的Windows 10 IOT核心2）我可以在Windows 10 IOT核心上安装，管理应用程序3）通过Visual Studio远程调试应用程序时，会安装所有依赖的框架库

几个问题困扰着我1）是否可以使用TCP协议在Windows 10和Windows 10 IOT之间进行通信2）我是否缺少Windows 10 IOT上的任何库

我的服务器程序如下

/// <summary>
/// TCP server is used to connect, disconnect and manage TCP sessions
/// </summary>
/// <remarks>Thread-safe</remarks>
public class TcpServer : IDisposable
{
    /// <summary>
    /// Initialize TCP server with a given IP address and port number
    /// </summary>
    /// <param name="address">IP address</param>
    /// <param name="port">Port number</param>
    public TcpServer(IPAddress address, int port) : this(new IPEndPoint(address, port)) {}
    /// <summary>
    /// Initialize TCP server with a given IP address and port number
    /// </summary>
    /// <param name="address">IP address</param>
    /// <param name="port">Port number</param>
    public TcpServer(string address, int port) : this(new IPEndPoint(IPAddress.Parse(address), port)) {}
    /// <summary>
    /// Initialize TCP server with a given IP endpoint
    /// </summary>
    /// <param name="endpoint">IP endpoint</param>
    public TcpServer(IPEndPoint endpoint)
    {
        Id = Guid.NewGuid();
        Endpoint = endpoint;
    }

    /// <summary>
    /// Server Id
    /// </summary>
    public Guid Id { get; }

    /// <summary>
    /// IP endpoint
    /// </summary>
    public IPEndPoint Endpoint { get; private set; }

    /// <summary>
    /// Number of sessions connected to the server
    /// </summary>
    public long ConnectedSessions { get { return Sessions.Count; } }
    /// <summary>
    /// Number of bytes pending sent by the server
    /// </summary>
    public long BytesPending { get { return _bytesPending; } }
    /// <summary>
    /// Number of bytes sent by the server
    /// </summary>
    public long BytesSent { get { return _bytesSent; } }
    /// <summary>
    /// Number of bytes received by the server
    /// </summary>
    public long BytesReceived { get { return _bytesReceived; } }

    /// <summary>
    /// Option: acceptor backlog size
    /// </summary>
    /// <remarks>
    /// This option will set the listening socket's backlog size
    /// </remarks>
    public int OptionAcceptorBacklog { get; set; } = 1024;
    /// <summary>
    /// Option: keep alive
    /// </summary>
    /// <remarks>
    /// This option will setup SO_KEEPALIVE if the OS support this feature
    /// </remarks>
    public bool OptionKeepAlive { get; set; }
    /// <summary>
    /// Option: no delay
    /// </summary>
    /// <remarks>
    /// This option will enable/disable Nagle's algorithm for TCP protocol
    /// </remarks>
    public bool OptionNoDelay { get; set; }
    /// <summary>
    /// Option: reuse address
    /// </summary>
    /// <remarks>
    /// This option will enable/disable SO_REUSEADDR if the OS support this feature
    /// </remarks>
    public bool OptionReuseAddress { get; set; }
    /// <summary>
    /// Option: enables a socket to be bound for exclusive access
    /// </summary>
    /// <remarks>
    /// This option will enable/disable SO_EXCLUSIVEADDRUSE if the OS support this feature
    /// </remarks>
    public bool OptionExclusiveAddressUse { get; set; }

    #region Start/Stop server

    // Server acceptor
    private Socket _acceptorSocket;
    private SocketAsyncEventArgs _acceptorEventArg;

    // Server statistic
    internal long _bytesPending;
    internal long _bytesSent;
    internal long _bytesReceived;

    /// <summary>
    /// Is the server started?
    /// </summary>
    public bool IsStarted { get; private set; }
    /// <summary>
    /// Is the server accepting new clients?
    /// </summary>
    public bool IsAccepting { get; private set; }

    /// <summary>
    /// Start the server
    /// </summary>
    /// <returns>'true' if the server was successfully started, 'false' if the server failed to start</returns>
    public virtual bool Start()
    {
        Debug.Assert(!IsStarted, "TCP server is already started!");
        if (IsStarted)
            return false;

        // Setup acceptor event arg
        _acceptorEventArg = new SocketAsyncEventArgs();
        _acceptorEventArg.Completed += OnAsyncCompleted;

        // Create a new acceptor socket
        _acceptorSocket = new Socket(Endpoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);

        // Apply the option: reuse address
        _acceptorSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, OptionReuseAddress);
        // Apply the option: exclusive address use
        _acceptorSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ExclusiveAddressUse, OptionExclusiveAddressUse);

        // Bind the acceptor socket to the IP endpoint
        _acceptorSocket.Bind(Endpoint);
        // Refresh the endpoint property based on the actual endpoint created
        Endpoint = (IPEndPoint)_acceptorSocket.LocalEndPoint;
        // Start listen to the acceptor socket with the given accepting backlog size
        _acceptorSocket.Listen(OptionAcceptorBacklog);

        // Reset statistic
        _bytesPending = 0;
        _bytesSent = 0;
        _bytesReceived = 0;

        // Update the started flag
        IsStarted = true;

        // Call the server started handler
        OnStarted();

        // Perform the first server accept
        IsAccepting = true;
        StartAccept(_acceptorEventArg);

        return true;
    }

    /// <summary>
    /// Stop the server
    /// </summary>
    /// <returns>'true' if the server was successfully stopped, 'false' if the server is already stopped</returns>
    public virtual bool Stop()
    {
        Debug.Assert(IsStarted, "TCP server is not started!");
        if (!IsStarted)
            return false;

        // Stop accepting new clients
        IsAccepting = false;

        // Reset acceptor event arg
        _acceptorEventArg.Completed -= OnAsyncCompleted;

        // Close the acceptor socket
        _acceptorSocket.Close();

        // Dispose the acceptor socket
        _acceptorSocket.Dispose();

        // Disconnect all sessions
        DisconnectAll();

        // Update the started flag
        IsStarted = false;

        // Call the server stopped handler
        OnStopped();

        return true;
    }

    /// <summary>
    /// Restart the server
    /// </summary>
    /// <returns>'true' if the server was successfully restarted, 'false' if the server failed to restart</returns>
    public virtual bool Restart()
    {
        if (!Stop())
            return false;

        while (IsStarted)
            Thread.Yield();

        return Start();
    }

    #endregion

    #region Accepting clients

    /// <summary>
    /// Start accept a new client connection
    /// </summary>
    private void StartAccept(SocketAsyncEventArgs e)
    {
        // Socket must be cleared since the context object is being reused
        e.AcceptSocket = null;

        // Async accept a new client connection
        if (!_acceptorSocket.AcceptAsync(e))
            ProcessAccept(e);
    }

    /// <summary>
    /// Process accepted client connection
    /// </summary>
    private void ProcessAccept(SocketAsyncEventArgs e)
    {
        if (e.SocketError == SocketError.Success)
        {
            // Create a new session to register
            var session = CreateSession();

            // Register the session
            RegisterSession(session);

            // Connect new session
            session.Connect(e.AcceptSocket);
        }
        else
            SendError(e.SocketError);

        // Accept the next client connection
        if (IsAccepting)
            StartAccept(e);
    }

    /// <summary>
    /// This method is the callback method associated with Socket.AcceptAsync()
    /// operations and is invoked when an accept operation is complete
    /// </summary>
    private void OnAsyncCompleted(object sender, SocketAsyncEventArgs e)
    {
        ProcessAccept(e);
    }

    #endregion

    #region Session factory

    /// <summary>
    /// Create TCP session factory method
    /// </summary>
    /// <returns>TCP session</returns>
    protected virtual TcpSession CreateSession() { return new TcpSession(this); }

    #endregion

    #region Session management

    // Server sessions
    protected readonly ConcurrentDictionary<Guid, TcpSession> Sessions = new ConcurrentDictionary<Guid, TcpSession>();

    /// <summary>
    /// Disconnect all connected sessions
    /// </summary>
    /// <returns>'true' if all sessions were successfully disconnected, 'false' if the server is not started</returns>
    public virtual bool DisconnectAll()
    {
        if (!IsStarted)
            return false;

        // Disconnect all sessions
        foreach (var session in Sessions.Values)
            session.Disconnect();

        return true;
    }

    /// <summary>
    /// Find a session with a given Id
    /// </summary>
    /// <param name="id">Session Id</param>
    /// <returns>Session with a given Id or null if the session it not connected</returns>
    public TcpSession FindSession(Guid id)
    {
        // Try to find the required session
        return Sessions.TryGetValue(id, out TcpSession result) ? result : null;
    }

    /// <summary>
    /// Register a new session
    /// </summary>
    /// <param name="session">Session to register</param>
    internal void RegisterSession(TcpSession session)
    {
        // Register a new session
        Sessions.TryAdd(session.Id, session);
    }

    /// <summary>
    /// Unregister session by Id
    /// </summary>
    /// <param name="id">Session Id</param>
    internal void UnregisterSession(Guid id)
    {
        // Unregister session by Id
        Sessions.TryRemove(id, out TcpSession temp);
    }

    #endregion

    #region Multicasting

    /// <summary>
    /// Multicast data to all connected sessions
    /// </summary>
    /// <param name="buffer">Buffer to multicast</param>
    /// <returns>'true' if the data was successfully multicasted, 'false' if the data was not multicasted</returns>
    public virtual bool Multicast(byte[] buffer) { return Multicast(buffer, 0, buffer.Length); }

    /// <summary>
    /// Multicast data to all connected clients
    /// </summary>
    /// <param name="buffer">Buffer to multicast</param>
    /// <param name="offset">Buffer offset</param>
    /// <param name="size">Buffer size</param>
    /// <returns>'true' if the data was successfully multicasted, 'false' if the data was not multicasted</returns>
    public virtual bool Multicast(byte[] buffer, long offset, long size)
    {
        if (!IsStarted)
            return false;

        if (size == 0)
            return true;

        // Multicast data to all sessions
        foreach (var session in Sessions.Values)
            session.SendAsync(buffer, offset, size);

        return true;
    }

    /// <summary>
    /// Multicast text to all connected clients
    /// </summary>
    /// <param name="text">Text string to multicast</param>
    /// <returns>'true' if the text was successfully multicasted, 'false' if the text was not multicasted</returns>
    public virtual bool Multicast(string text) { return Multicast(Encoding.UTF8.GetBytes(text)); }

    #endregion

    #region Server handlers

    /// <summary>
    /// Handle server started notification
    /// </summary>
    protected virtual void OnStarted() {}
    /// <summary>
    /// Handle server stopped notification
    /// </summary>
    protected virtual void OnStopped() {}

    /// <summary>
    /// Handle session connected notification
    /// </summary>
    /// <param name="session">Connected session</param>
    protected virtual void OnConnected(TcpSession session) {}
    /// <summary>
    /// Handle session disconnected notification
    /// </summary>
    /// <param name="session">Disconnected session</param>
    protected virtual void OnDisconnected(TcpSession session) {}

    /// <summary>
    /// Handle error notification
    /// </summary>
    /// <param name="error">Socket error code</param>
    protected virtual void OnError(SocketError error) {}

    internal void OnConnectedInternal(TcpSession session) { OnConnected(session); }
    internal void OnDisconnectedInternal(TcpSession session) { OnDisconnected(session); }

    #endregion

    #region Error handling

    /// <summary>
    /// Send error notification
    /// </summary>
    /// <param name="error">Socket error code</param>
    private void SendError(SocketError error)
    {
        // Skip disconnect errors
        if ((error == SocketError.ConnectionAborted) ||
            (error == SocketError.ConnectionRefused) ||
            (error == SocketError.ConnectionReset) ||
            (error == SocketError.OperationAborted) ||
            (error == SocketError.Shutdown))
            return;

        OnError(error);
    }

    #endregion

    #region IDisposable implementation

    // Disposed flag.
    private bool _disposed;

    // Implement IDisposable.
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposingManagedResources)
    {
        // The idea here is that Dispose(Boolean) knows whether it is
        // being called to do explicit cleanup (the Boolean is true)
        // versus being called due to a garbage collection (the Boolean
        // is false). This distinction is useful because, when being
        // disposed explicitly, the Dispose(Boolean) method can safely
        // execute code using reference type fields that refer to other
        // objects knowing for sure that these other objects have not been
        // finalized or disposed of yet. When the Boolean is false,
        // the Dispose(Boolean) method should not execute code that
        // refer to reference type fields because those objects may
        // have already been finalized."

        if (!_disposed)
        {
            if (disposingManagedResources)
            {
                // Dispose managed resources here...
                Stop();
            }

            // Dispose unmanaged resources here...

            // Set large fields to null here...

            // Mark as disposed.
            _disposed = true;
        }
    }

    // Use C# destructor syntax for finalization code.
    ~TcpServer()
    {
        // Simply call Dispose(false).
        Dispose(false);
    }

    #endregion
}

我的主程序：

public class Program
{

    static void Main(string[] args)
    {
        // TCP server port
        int port = 1111;
        if (args.Length > 0)
            port = int.Parse(args[0]);

        Console.WriteLine($"TCP server port: {port}");

        Console.WriteLine();

        // Create a new TCP chat server
        var server = new TcpServer(IPAddress.Any, port);

        // Start the server
        Console.Write("Server starting...");
        server.Start();
        Console.WriteLine("Done!");

        Console.WriteLine("Press Enter to stop the server or '!' to restart the server...");

        // Perform text input
        for (; ; )
        {
            string line = Console.ReadLine();
            if (string.IsNullOrEmpty(line))
                break;

            // Restart the server
            if (line == "!")
            {
                Console.Write("Server restarting...");
                server.Restart();
                Console.WriteLine("Done!");
                continue;
            }

            // Multicast admin message to all sessions
            line = "(admin) " + line;
            server.Multicast(line);
        }

        // Stop the server
        Console.Write("Server stopping...");
        server.Stop();
        Console.WriteLine("Done!");
    }
}

谢谢