private void MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
// Dispatch the event to the UI thread so we can update UI.
var ignore = Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
string partialOrCompleted = "Partial";
if (args.IsMessageComplete)
{
partialOrCompleted = "Complete";
}
AppendOutputLine(partialOrCompleted + " message received; Type: " + args.MessageType);
using (DataReader reader = args.GetDataReader())
{
reader.UnicodeEncoding = UnicodeEncoding.Utf8;
try
{
// Note that it may be possible for partial UTF8 messages to be split between a character if it
// extends multiple bytes. We avoid this by using only ASCII characters in this example.
// Should your application use multi-byte characters, you will need to do checks for broken characters.
string read = reader.ReadString(reader.UnconsumedBufferLength);
AppendOutputLine(read);
}
catch (Exception ex)
{
AppendOutputLine(MainPage.BuildWebSocketError(ex));
AppendOutputLine(ex.Message);
}
}
});
}
async Task SendAsync()
{
string message = InputField.Text;
if (String.IsNullOrEmpty(message))
{
rootPage.NotifyUser("Please specify text to send", NotifyType.ErrorMessage);
return;
}
AppendOutputLine("Sending Message: " + message);
// Buffer any data we want to send.
messageWriter.WriteString(message);
try
{
// Send the data as one complete message.
await messageWriter.StoreAsync();
}
catch (Exception ex)
{
AppendOutputLine(MainPage.BuildWebSocketError(ex));
AppendOutputLine(ex.Message);
return;
}
rootPage.NotifyUser("Send Complete", NotifyType.StatusMessage);
}
private void CloseSocket()
{
if (messageWriter != null)
{
// In order to reuse the socket with another DataWriter, the socket's output stream needs to be detached.
// Otherwise, the DataWriter's destructor will automatically close the stream and all subsequent I/O operations
// invoked on the socket's output stream will fail with ObjectDisposedException.
//
// This is only added for completeness, as this sample closes the socket in the very next code block.
messageWriter.DetachStream();
messageWriter.Dispose();
messageWriter = null;
}
if (messageWebSocket != null)
{
try
{
messageWebSocket.Close(1000, "Closed due to user request.");
}
catch (Exception ex)
{
AppendOutputLine(MainPage.BuildWebSocketError(ex));
AppendOutputLine(ex.Message);
}
messageWebSocket = null;
}
}
private async Task ConnectWebSocketAsync()
{
// Validating the URI is required since it was received from an untrusted source (user input).
// The URI is validated by calling TryGetUri() that will return 'false' for strings that are not
// valid WebSocket URIs.
// Note that when enabling the text box users may provide URIs to machines on the intrAnet
// or intErnet. In these cases the app requires the "Home or Work Networking" or
// "Internet (Client)" capability respectively.
Uri server = rootPage.TryGetUri(ServerAddressField.Text);
if (server == null)
{
return;
}
// Certificate validation is meaningful only for secure connections.
if (server.Scheme != "wss")
{
AppendOutputLine("Note: Certificate validation is performed only for the wss: scheme.");
}
streamWebSocket = new StreamWebSocket();
streamWebSocket.Closed += OnClosed;
// It is okay to set the ClientCertificate property even if GetClientCertificateAsync returns null.
streamWebSocket.Control.ClientCertificate = await GetClientCertificateAsync();
// When connecting to wss:// endpoint, the OS by default performs validation of
// the server certificate based on well-known trusted CAs. For testing purposes, we are ignoring
// SSL errors.
// WARNING: Only test applications should ignore SSL errors.
// In real applications, ignoring server certificate errors can lead to Man-In-The-Middle
// attacks. (Although the connection is secure, the server is not authenticated.)
// Note that not all certificate validation errors can be ignored.
// In this case, we are ignoring these errors since the certificate assigned to the localhost
// URI is self-signed and has subject name = fabrikam.com
streamWebSocket.Control.IgnorableServerCertificateErrors.Add(ChainValidationResult.Untrusted);
streamWebSocket.Control.IgnorableServerCertificateErrors.Add(ChainValidationResult.InvalidName);
AppendOutputLine($"Connecting to {server}...");
try
{
await streamWebSocket.ConnectAsync(server);
}
catch (Exception ex) // For debugging
{
streamWebSocket.Dispose();
streamWebSocket = null;
AppendOutputLine(MainPage.BuildWebSocketError(ex));
AppendOutputLine(ex.Message);
return;
}
rootPage.NotifyUser("Connected", NotifyType.StatusMessage);
AppendOutputLine("Connected to WebSocket Server.");
}
private void CloseSocket()
{
if (messageWebSocket != null)
{
try
{
messageWebSocket.Close(1000, "Closed due to user request.");
}
catch (Exception ex)
{
AppendOutputLine(MainPage.BuildWebSocketError(ex));
AppendOutputLine(ex.Message);
}
messageWebSocket = null;
}
}
private async Task ConnectAsync()
{
if (String.IsNullOrEmpty(InputField.Text))
{
rootPage.NotifyUser("Please specify text to send", NotifyType.ErrorMessage);
return;
}
// Validating the URI is required since it was received from an untrusted source (user input).
// The URI is validated by calling TryGetUri() that will return 'false' for strings that are not
// valid WebSocket URIs.
// Note that when enabling the text box users may provide URIs to machines on the intrAnet
// or intErnet. In these cases the app requires the "Home or Work Networking" or
// "Internet (Client)" capability respectively.
Uri server = rootPage.TryGetUri(ServerAddressField.Text);
if (server == null)
{
return;
}
messageWebSocket = new MessageWebSocket();
messageWebSocket.Control.MessageType = SocketMessageType.Utf8;
messageWebSocket.MessageReceived += MessageReceived;
messageWebSocket.Closed += OnClosed;
AppendOutputLine($"Connecting to {server}...");
try
{
await messageWebSocket.ConnectAsync(server);
}
catch (Exception ex) // For debugging
{
// Error happened during connect operation.
messageWebSocket.Dispose();
messageWebSocket = null;
AppendOutputLine(MainPage.BuildWebSocketError(ex));
AppendOutputLine(ex.Message);
return;
}
// The default DataWriter encoding is Utf8.
messageWriter = new DataWriter(messageWebSocket.OutputStream);
rootPage.NotifyUser("Connected", NotifyType.StatusMessage);
}
private async Task StartAsync()
{
// Validating the URI is required since it was received from an untrusted source (user input).
// The URI is validated by calling TryGetUri() that will return 'false' for strings that are not
// valid WebSocket URIs.
// Note that when enabling the text box users may provide URIs to machines on the intrAnet
// or intErnet. In these cases the app requires the "Home or Work Networking" or
// "Internet (Client)" capability respectively.
Uri server = rootPage.TryGetUri(ServerAddressField.Text);
if (server == null)
{
return;
}
streamWebSocket = new StreamWebSocket();
streamWebSocket.Closed += OnClosed;
AppendOutputLine($"Connecting to {server}...");
try
{
await streamWebSocket.ConnectAsync(server);
}
catch (Exception ex) // For debugging
{
streamWebSocket.Dispose();
streamWebSocket = null;
AppendOutputLine(MainPage.BuildWebSocketError(ex));
AppendOutputLine(ex.Message);
return;
}
rootPage.NotifyUser("Connected", NotifyType.StatusMessage);
// Start a task to continuously read for incoming data
Task receiving = ReceiveDataAsync(streamWebSocket);
// Start a task to continuously write outgoing data
Task sending = SendDataAsync(streamWebSocket);
}
private void MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
// Dispatch the event to the UI thread so we can update UI.
var ignore = Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
AppendOutputLine("Message Received; Type: " + args.MessageType);
using (DataReader reader = args.GetDataReader())
{
reader.UnicodeEncoding = UnicodeEncoding.Utf8;
try
{
string read = reader.ReadString(reader.UnconsumedBufferLength);
AppendOutputLine(read);
}
catch (Exception ex)
{
AppendOutputLine(MainPage.BuildWebSocketError(ex));
AppendOutputLine(ex.Message);
}
}
});
}
async Task SendAsync()
{
string message = InputField.Text;
if (String.IsNullOrEmpty(message))
{
rootPage.NotifyUser("Please specify text to send", NotifyType.ErrorMessage);
return;
}
try
{
DataWriter messageWriter = new DataWriter();
messageWriter.WriteString(message);
IBuffer buffer = messageWriter.DetachBuffer();
if (EndOfMessageCheckBox.IsChecked == true)
{
AppendOutputLine("Sending end of message: " + message);
await messageWebSocket.SendFinalFrameAsync(buffer);
}
else
{
AppendOutputLine("Sending partial message: " + message);
await messageWebSocket.SendNonfinalFrameAsync(buffer);
}
}
catch (Exception ex)
{
AppendOutputLine(MainPage.BuildWebSocketError(ex));
AppendOutputLine(ex.Message);
return;
}
rootPage.NotifyUser("Send Complete", NotifyType.StatusMessage);
}
private async Task ConnectAsync()
{
if (String.IsNullOrEmpty(ServerAddressField.Text))
{
rootPage.NotifyUser("Please specify a URI to connect to", NotifyType.ErrorMessage);
return;
}
// Validating the URI is required since it was received from an untrusted source (user input).
// The URI is validated by calling TryGetUri() that will return 'false' for strings that are not
// valid WebSocket URIs.
// Note that when enabling the text box users may provide URIs to machines on the intrAnet
// or intErnet. In these cases the app requires the "Private Networks (Client and Server)" or
// "Internet (Client)" capability respectively.
Uri server = rootPage.TryGetUri(ServerAddressField.Text);
if (server == null)
{
return;
}
messageWebSocket = new MessageWebSocket();
messageWebSocket.Control.MessageType = SocketMessageType.Utf8;
// To support receiving event notifications for partial messages, you must set this receive mode.
// If you do not set this mode, you will only receive notifications for complete messages; which is
// the default behavior. Setting to Partial allows us to process partial data as soon as it arrives,
// as opposed to waiting until the EndOfMessage to process the entire data.
messageWebSocket.Control.ReceiveMode = MessageWebSocketReceiveMode.PartialMessage;
messageWebSocket.MessageReceived += MessageReceived;
messageWebSocket.Closed += OnClosed;
if (server.Scheme == "wss")
{
// WARNING: Only test applications should ignore SSL errors.
// In real applications, ignoring server certificate errors can lead to Man-In-The-Middle
// attacks. (Although the connection is secure, the server is not authenticated.)
// Note that not all certificate validation errors can be ignored.
// In this case, we are ignoring these errors since the certificate assigned to the localhost
// URI is self-signed and has subject name = fabrikam.com
messageWebSocket.Control.IgnorableServerCertificateErrors.Add(ChainValidationResult.Untrusted);
messageWebSocket.Control.IgnorableServerCertificateErrors.Add(ChainValidationResult.InvalidName);
}
AppendOutputLine($"Connecting to {server}...");
try
{
await messageWebSocket.ConnectAsync(server);
}
catch (Exception ex) // For debugging
{
// Error happened during connect operation.
messageWebSocket.Dispose();
messageWebSocket = null;
AppendOutputLine(MainPage.BuildWebSocketError(ex));
AppendOutputLine(ex.Message);
return;
}
rootPage.NotifyUser("Connected", NotifyType.StatusMessage);
}
private async Task StartAsync()
{
// Validating the URI is required since it was received from an untrusted source (user input).
// The URI is validated by calling TryGetUri() that will return 'false' for strings that are not
// valid WebSocket URIs.
// Note that when enabling the text box users may provide URIs to machines on the intrAnet
// or intErnet. In these cases the app requires the "Home or Work Networking" or
// "Internet (Client)" capability respectively.
Uri server = rootPage.TryGetUri(ServerAddressField.Text);
if (server == null)
{
return;
}
streamWebSocket = new StreamWebSocket();
streamWebSocket.Closed += OnClosed;
// If we are connecting to wss:// endpoint, by default, the OS performs validation of
// the server certificate based on well-known trusted CAs. We can perform additional custom
// validation if needed.
if (SecureWebSocketCheckBox.IsChecked == true)
{
// WARNING: Only test applications should ignore SSL errors.
// In real applications, ignoring server certificate errors can lead to Man-In-The-Middle
// attacks. (Although the connection is secure, the server is not authenticated.)
// Note that not all certificate validation errors can be ignored.
// In this case, we are ignoring these errors since the certificate assigned to the localhost
// URI is self-signed and has subject name = fabrikam.com
streamWebSocket.Control.IgnorableServerCertificateErrors.Add(ChainValidationResult.Untrusted);
streamWebSocket.Control.IgnorableServerCertificateErrors.Add(ChainValidationResult.InvalidName);
// Add event handler to listen to the ServerCustomValidationRequested event. This enables performing
// custom validation of the server certificate. The event handler must implement the desired
// custom certificate validation logic.
streamWebSocket.ServerCustomValidationRequested += OnServerCustomValidationRequested;
// Certificate validation is meaningful only for secure connections.
if (server.Scheme != "wss")
{
AppendOutputLine("Note: Certificate validation is performed only for the wss: scheme.");
}
}
AppendOutputLine($"Connecting to {server}...");
try
{
await streamWebSocket.ConnectAsync(server);
}
catch (Exception ex) // For debugging
{
streamWebSocket.Dispose();
streamWebSocket = null;
AppendOutputLine(MainPage.BuildWebSocketError(ex));
AppendOutputLine(ex.Message);
return;
}
rootPage.NotifyUser("Connected", NotifyType.StatusMessage);
// Start a task to continuously read for incoming data
Task receiving = ReceiveDataAsync(streamWebSocket);
// Start a task to continuously write outgoing data
Task sending = SendDataAsync(streamWebSocket);
}
private async Task ConnectAsync()
{
if (String.IsNullOrEmpty(InputField.Text))
{
rootPage.NotifyUser("Please specify text to send", NotifyType.ErrorMessage);
return;
}
// Validating the URI is required since it was received from an untrusted source (user input).
// The URI is validated by calling TryGetUri() that will return null for strings that are not
// valid WebSocket URIs.
// Note that when enabling the text box users may provide URIs to machines on the intrAnet
// or intErnet. In these cases the app requires the "Private Networks (Client and Server)" or
// "Internet (Client)" capability respectively.
Uri server = rootPage.TryGetUri(ServerAddressField.Text);
if (server == null)
{
return;
}
messageWebSocket = new MessageWebSocket();
messageWebSocket.Control.MessageType = SocketMessageType.Utf8;
messageWebSocket.MessageReceived += MessageReceived;
messageWebSocket.Closed += OnClosed;
// If we are connecting to wss:// endpoint, by default, the OS performs validation of
// the server certificate based on well-known trusted CAs. We can perform additional custom
// validation if needed.
if (SecureWebSocketCheckBox.IsChecked == true)
{
// WARNING: Only test applications should ignore SSL errors.
// In real applications, ignoring server certificate errors can lead to Man-In-The-Middle
// attacks. (Although the connection is secure, the server is not authenticated.)
// Note that not all certificate validation errors can be ignored.
// In this case, we are ignoring these errors since the certificate assigned to the localhost
// URI is self-signed and has subject name = fabrikam.com
messageWebSocket.Control.IgnorableServerCertificateErrors.Add(ChainValidationResult.Untrusted);
messageWebSocket.Control.IgnorableServerCertificateErrors.Add(ChainValidationResult.InvalidName);
// Add event handler to listen to the ServerCustomValidationRequested event. This enables performing
// custom validation of the server certificate. The event handler must implement the desired
// custom certificate validation logic.
messageWebSocket.ServerCustomValidationRequested += OnServerCustomValidationRequested;
// Certificate validation occurs only for secure connections.
if (server.Scheme != "wss")
{
AppendOutputLine("Note: Certificate validation is performed only for the wss: scheme.");
}
}
AppendOutputLine($"Connecting to {server}...");
try
{
await messageWebSocket.ConnectAsync(server);
}
catch (Exception ex) // For debugging
{
// Error happened during connect operation.
messageWebSocket.Dispose();
messageWebSocket = null;
AppendOutputLine(MainPage.BuildWebSocketError(ex));
AppendOutputLine(ex.Message);
return;
}
// The default DataWriter encoding is Utf8.
messageWriter = new DataWriter(messageWebSocket.OutputStream);
rootPage.NotifyUser("Connected", NotifyType.StatusMessage);
}