Windows 10 和 Windows IOT 核心之间的 TCP 通信
TCP communication between Windows 10 and Windows IOT core
我不知道是什么阻止了 Windows 10 IOT Core 和 Windows 10 机器之间的通信。
我的设置如下，
1) NXP imx6 安装 Windows 10 IOT
2) 我的开发沙箱安装了 windows 10
3) 两台机器都在同一个子网
在 Windows 10 IOT 核心上安装了一个 TCP 端口转发 UWP 应用程序（按原样复制代码并自定义使其成为 UWP 应用程序，参考来自下面提供的 Git 集线器）。
https://gist.github.com/bongbongco/588abf3928cbd297443dd9da8171eb9a
应用 运行 在 Windows 10 IOT 上成功，它无法接受来自我的 Windows 10 机器的客户端连接请求。
该应用程序在以下代码行一直等待客户端连接
来源=_mainSocket.Accept();
从我的客户端机器（Windows 10 开发机器）当我尝试连接到 Windows 10 IOT 核心时，我收到连接超时异常。
我正在尝试通过 telnet 8081 连接到安装了 windows 10 IOT Core 的 iMX6 板，但出现错误 "Could not open connection to the host, on port 8081: connect failed"
当我 ping 到 iMX6 机器时得到回复，我的问题是，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) Windows 10 和 Windows 10 IOT 之间是否可以使用 TCP 协议进行通信
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!");
}
}
谢谢
是的，可以使用 TCP 协议在 Windows 10 和 Windows 10 IoT Core 之间进行通信。您需要执行以下两个步骤：
通过此命令在服务器设备上的防火墙设置中指定端口。
netsh advfirewall firewall add rule name="Web Access" dir=in protocol=TCP localport=8081 action=Allow
在您的 UWP 应用程序中添加 privateNetworkClientServer 功能。你可以参考这篇文档(https://docs.microsoft.com/en-us/windows/uwp/networking/sockets#build-a-basic-tcp-socket-client-and-server).
我不知道是什么阻止了 Windows 10 IOT Core 和 Windows 10 机器之间的通信。 我的设置如下， 1) NXP imx6 安装 Windows 10 IOT 2) 我的开发沙箱安装了 windows 10 3) 两台机器都在同一个子网
在 Windows 10 IOT 核心上安装了一个 TCP 端口转发 UWP 应用程序（按原样复制代码并自定义使其成为 UWP 应用程序，参考来自下面提供的 Git 集线器）。
https://gist.github.com/bongbongco/588abf3928cbd297443dd9da8171eb9a
应用 运行 在 Windows 10 IOT 上成功，它无法接受来自我的 Windows 10 机器的客户端连接请求。 该应用程序在以下代码行一直等待客户端连接
来源=_mainSocket.Accept();
从我的客户端机器（Windows 10 开发机器）当我尝试连接到 Windows 10 IOT 核心时，我收到连接超时异常。
我正在尝试通过 telnet 8081 连接到安装了 windows 10 IOT Core 的 iMX6 板，但出现错误 "Could not open connection to the host, on port 8081: connect failed"
当我 ping 到 iMX6 机器时得到回复，我的问题是，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) Windows 10 和 Windows 10 IOT 之间是否可以使用 TCP 协议进行通信 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!");
}
}
谢谢
是的，可以使用 TCP 协议在 Windows 10 和 Windows 10 IoT Core 之间进行通信。您需要执行以下两个步骤：
通过此命令在服务器设备上的防火墙设置中指定端口。
netsh advfirewall firewall add rule name="Web Access" dir=in protocol=TCP localport=8081 action=Allow在您的 UWP 应用程序中添加 privateNetworkClientServer 功能。你可以参考这篇文档(https://docs.microsoft.com/en-us/windows/uwp/networking/sockets#build-a-basic-tcp-socket-client-and-server).