public override bool ConnectAsync(TimeSpan timeout, TransportAsyncCallbackArgs callbackArgs)
{
var streamSocket = new Windows.Networking.Sockets.StreamSocket();
var addr = this.transportSettings.Host;
this.callbackArgs = callbackArgs;
var connectTask = streamSocket.ConnectAsync(new Windows.Networking.HostName(addr), this.transportSettings.Port.ToString(), Windows.Networking.Sockets.SocketProtectionLevel.PlainSocket).AsTask();
connectTask.ContinueWith(_ =>
{
TransportBase transport = null;
Exception exception = null;
try
{
transport = new TcpTransport(streamSocket, this.transportSettings);
transport.Open();
}
catch (Exception exp)
{
if (Fx.IsFatal(exp))
{
throw;
}
exception = exp;
if (transport != null)
{
transport.SafeClose();
}
transport = null;
}
var completeSynchronously = false;
this.callbackArgs.CompletedSynchronously = completeSynchronously;
this.callbackArgs.Exception = exception;
this.callbackArgs.Transport = transport;
if (!completeSynchronously)
{
this.callbackArgs.CompletedCallback(this.callbackArgs);
}
});
return true;
}
public async void init()
{
try
{
Windows.Networking.Sockets.StreamSocket socket = new Windows.Networking.Sockets.StreamSocket();
Windows.Networking.HostName serverHost = new Windows.Networking.HostName("localhost");
string serverPort = "1337";
await socket.ConnectAsync(serverHost, serverPort);
streamIn = socket.InputStream.AsStreamForRead();
streamOut = socket.OutputStream.AsStreamForWrite();
Debug.WriteLine("Connected successfully");
}
catch (Exception e)
{
Debug.WriteLine("Failed to connect: " + e.Message);
}
}
public async Task <bool> ConnectAsync()
{
try
{
sock = new Windows.Networking.Sockets.StreamSocket();
Windows.Networking.HostName hostname = new Windows.Networking.HostName(ServerName);
await sock.ConnectAsync(hostname, ServiceName);
writer = new Windows.Storage.Streams.DataWriter(sock.OutputStream);
reader = new Windows.Storage.Streams.DataReader(sock.InputStream);
StartReceiveDataAsync();
return(true);
}
catch
{
return(false);
}
}
async private void ConnectToPeer(Windows.Networking.Proximity.PeerInformation peerInfo)
{
WriteMessageText("Peer found. Connecting to " + peerInfo.DisplayName + "\n");
try
{
Windows.Networking.Sockets.StreamSocket socket =
await Windows.Networking.Proximity.PeerFinder.ConnectAsync(peerInfo);
WriteMessageText("Connection successful. You may now send messages.\n");
SendMessage(socket);
}
catch (Exception err)
{
WriteMessageText("Connection failed: " + err.Message + "\n");
}
requestingPeer = null;
}
private async void UpdateDataSave(string name)
{
try
{
// Create the StreamSocket and establish a connection to the echo server.
using (var streamSocket = new Windows.Networking.Sockets.StreamSocket())
{
// The server hostname that we will be establishing a connection to. In this example, the server and client are in the same process.
var hostName = new Windows.Networking.HostName("localhost");
await streamSocket.ConnectAsync(hostName, MainPage.outPortNumber);
// Send a request to the server and update list.
string request = name;
using (Stream outputStream = streamSocket.OutputStream.AsStreamForWrite())
{
using (var streamWriter = new StreamWriter(outputStream))
{
await streamWriter.WriteLineAsync(request);
await streamWriter.FlushAsync();
}
}
string response;
using (Stream inputStream = streamSocket.InputStream.AsStreamForRead())
{
using (StreamReader streamReader = new StreamReader(inputStream))
{
response = await streamReader.ReadLineAsync();
string[] responses = response.Split(',');
this.name.Text = "Task name : " + responses[0];
this.source.Text = "Source folder : " + responses[1];
this.target.Text = "Target folder : " + responses[2];
this.progressBar.Value = Convert.ToDouble(responses[3]);
}
}
}
}
catch (Exception ex)
{
}
}
private async void ReadThread(object host)
{
reading = true;
Windows.Networking.Sockets.StreamSocket socket = new Windows.Networking.Sockets.StreamSocket();
await socket.ConnectAsync((Windows.Networking.HostName) host, InTheHand.Devices.Bluetooth.Rfcomm.RfcommServiceId.SerialPort.AsString());
byte[] buffer = new byte[32];
System.Text.StringBuilder sb = new StringBuilder();
while (reading)
{
IBuffer returnedBuffer = await socket.InputStream.ReadAsync(buffer.AsBuffer(), (uint)buffer.Length, Windows.Storage.Streams.InputStreamOptions.Partial);
// break loop if response is empty (connection fail etc)
if (returnedBuffer.Length == 0)
{
break;
}
string s = System.Text.Encoding.UTF8.GetString(buffer, 0, (int)returnedBuffer.Length);
if (!string.IsNullOrEmpty(s))
{
if (s.IndexOf('\0') > -1)
{
s = s.Substring(0, s.IndexOf('\0'));
}
sb.Append(s);
// Only process when we have a complete line
if (sb.ToString().EndsWith("\r"))
{
Dispatcher.BeginInvoke(new Action <string>(this.InsertMessage), sb.ToString());
sb.Clear();
}
}
}
socket.Dispose();
}
// Reference socket streams for writing and reading messages.
private void SendMessage(Windows.Networking.Sockets.StreamSocket socket)
{
// PeerFinder has not been started.
if (!_started)
{
CloseSocket();
return;
}
// Get the network socket from the proximity connection.
proximitySocket = socket;
// Create DataWriter for writing messages to peers.
dataWriter = new Windows.Storage.Streams.DataWriter(proximitySocket.OutputStream);
// Listen for messages from peers.
Windows.Storage.Streams.DataReader dataReader =
new Windows.Storage.Streams.DataReader(proximitySocket.InputStream);
StartReader(proximitySocket, dataReader);
}
/// <summary>
/// Just sends a single message to another device
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public async Task Send(string message)
{
try
{
// Create the StreamSocket and establish a connection to the echo server.
streamSocket = new Windows.Networking.Sockets.StreamSocket();
// The server hostname that we will be establishing a connection to. In this example, the server and client are in the same process.
await streamSocket.ConnectAsync(hostName, this.portNumber);
// send the message
await SendInternal(message);
this.Close();
}
catch (Exception ex)
{
Windows.Networking.Sockets.SocketErrorStatus webErrorStatus = Windows.Networking.Sockets.SocketError.GetStatus(ex.GetBaseException().HResult);
this.Output(MessageHelper.MessageType.Exception, webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : ex.Message);
}
}
public async Task <bool> ConnectAsync()
{
//Monitor.Enter(nstreamlock);
try
{
sock = new Windows.Networking.Sockets.StreamSocket();
Windows.Networking.HostName hostname = new Windows.Networking.HostName(ServerName);
await sock.ConnectAsync(hostname, ServiceName);
writer = new Windows.Storage.Streams.DataWriter(sock.OutputStream);
reader = new Windows.Storage.Streams.DataReader(sock.InputStream);
//Monitor.Exit(nstreamlock);
return(true);
}
catch
{
Disconnect();
// Monitor.Exit(nstreamlock);
return(false);
}
}
// A C#-only technique for batched sends.
private async void BatchedSendsCSharpOnly(Windows.Networking.Sockets.StreamSocket streamSocket, string message)
{
var packetsToSend = new List <IBuffer>();
for (int count = 0; count < 5; ++count)
{
packetsToSend.Add(Windows.Security.Cryptography.CryptographicBuffer.ConvertStringToBinary(message, Windows.Security.Cryptography.BinaryStringEncoding.Utf8));
}
var pendingTasks = new System.Threading.Tasks.Task[packetsToSend.Count];
for (int index = 0; index < packetsToSend.Count; ++index)
{
// track all pending writes as tasks, but don't wait on one before beginning the next.
pendingTasks[index] = streamSocket.OutputStream.WriteAsync(packetsToSend[index]).AsTask();
// Don't modify any buffer's contents until the pending writes are complete.
}
// Wait for all of the pending writes to complete.
System.Threading.Tasks.Task.WaitAll(pendingTasks);
}
public async void StartClient()
{
try
{
// Create the StreamSocket and establish a connection to the echo server.
using (var streamSocket = new Windows.Networking.Sockets.StreamSocket())
{
// The server hostname that we will be establishing a connection to. In this example, the server and client are in the same process.
var hostName = new Windows.Networking.HostName("localhost");
await streamSocket.ConnectAsync(hostName, PortNumber);
// Send a request to the echo server.
string request = "Hello, World!";
using (Stream outputStream = streamSocket.OutputStream.AsStreamForWrite())
{
using (var streamWriter = new StreamWriter(outputStream))
{
await streamWriter.WriteLineAsync(request);
await streamWriter.FlushAsync();
}
}
// Read data from the echo server.
string response;
using (Stream inputStream = streamSocket.InputStream.AsStreamForRead())
{
using (StreamReader streamReader = new StreamReader(inputStream))
{
response = await streamReader.ReadLineAsync();
}
}
}
}
catch (Exception ex)
{
Windows.Networking.Sockets.SocketErrorStatus webErrorStatus = Windows.Networking.Sockets.SocketError.GetStatus(ex.GetBaseException().HResult);
}
}
/// <summary>
/// This is the click handler for the 'ConnectSocket' button.
/// </summary>
/// <param name="sender">Object for which the event was generated.</param>
/// <param name="e">Event's parameters.</param>
private async void ConnectSocket_Click(object sender, RoutedEventArgs e)
{
// By default 'HostNameForConnect' is disabled and host name validation is not required. When enabling the
// text box validating the host name is required since it was received from an untrusted source
// (user input). The host name is validated by catching ArgumentExceptions thrown by the HostName
// constructor for invalid input.
Windows.Networking.HostName hostName;
try
{
hostName = new Windows.Networking.HostName(HostNameForConnect.Text);
}
catch (ArgumentException)
{
return;
}
var pvCameraSocket = new Windows.Networking.Sockets.StreamSocket();
pvCameraSocket.Control.KeepAlive = true;
// Save the socket, so subsequent steps can use it.
try
{
// Connect to the server (by default, the listener we created in the previous step).
await pvCameraSocket.ConnectAsync(hostName, _pvServiceName.Text);
}
catch (Exception exception)
{
// If this is an unknown status it means that the error is fatal and retry will likely fail.
if (Windows.Networking.Sockets.SocketError.GetStatus(exception.HResult) ==
Windows.Networking.Sockets.SocketErrorStatus.Unknown)
{
throw;
}
}
OnServerConnectionEstablished(
pvCameraSocket);
}
//Create a socket and attempt connection to remote server
//In future, an entry from a 2D UWP application can provide inputs into the hard coded values
#if UNITY_UWP
async void ConnectToRemote()
{
try
{
//if (dataExchange != null)
// StopExchange();
//Socket setup
socket = new Windows.Networking.Sockets.StreamSocket();
Windows.Networking.HostName serverHost = new Windows.Networking.HostName("40.76.194.87");
await socket.ConnectAsync(serverHost, "62520");
Debug.LogError("connection successful");
Stream outStream = socket.OutputStream.AsStreamForWrite();
writer = new StreamWriter(outStream);
Stream inStream = socket.InputStream.AsStreamForRead();
reader = new StreamReader(inStream);
}
catch (System.Exception except)
{
Debug.LogError(except.ToString());
}
}
// Read out and print the message received from the socket.
private async void StartReader(Windows.Networking.Sockets.StreamSocket socket,
Windows.Storage.Streams.DataReader reader)
{
try
{
uint bytesRead = await reader.LoadAsync(sizeof(uint));
if (bytesRead > 0)
{
uint strLength = (uint)reader.ReadUInt32();
bytesRead = await reader.LoadAsync(strLength);
if (bytesRead > 0)
{
String message = reader.ReadString(strLength);
WriteMessageText("Received message: " + message + "\n");
StartReader(socket, reader); // Start another reader
}
else
{
WriteMessageText("The peer app closed the socket\n");
reader.Dispose();
CloseSocket();
}
}
else
{
WriteMessageText("The peer app closed the socket\n");
reader.Dispose();
CloseSocket();
}
}
catch
{
WriteMessageText("The peer app closed the socket\n");
reader.Dispose();
CloseSocket();
}
}
private async Task ConnectUWP(string host, string port)
{
Debug.Log("ConnectUWP");
if (exchangeTask != null)
{
StopExchange();
}
socket = new Windows.Networking.Sockets.StreamSocket();
Windows.Networking.HostName serverHost = new Windows.Networking.HostName(host);
try {
await socket.ConnectAsync(serverHost, port);
byteWriter = socket.OutputStream.AsStreamForWrite();
writer = new StreamWriter(byteWriter)
{
AutoFlush = true
};
} catch (Exception e) {
errorStatus = e.ToString();
Debug.Log("connection error:" + errorStatus);
}
}
private async void LocalIpAsync()
{
try
{
var settings = ApplicationData.Current.LocalSettings;
object value = settings.Values["IP"];
string IPValue = value.ToString();
IP.Text = IPValue;
mTimer2.Start();
Windows.Networking.HostName serverHost = new Windows.Networking.HostName(IPValue);
string serverPort = "1337";
socket = new Windows.Networking.Sockets.StreamSocket();
await socket.ConnectAsync(serverHost, serverPort);
Stream streamOut = socket.OutputStream.AsStreamForWrite();
Writer = new StreamWriter(streamOut);
//create timer
mTimer.Tick += MTimer_Tick;
mTimer.Interval = TimeSpan.FromSeconds(5);
mTimer.Start();
//read data from server
Stream streamIn = socket.InputStream.AsStreamForRead();
StreamReader reader = new StreamReader(streamIn);
if (reader != null)
{
connectFalse.Visibility = Visibility.Visible;
connectFalse.Content = reader;
}
}
catch (Exception e)
{
connectbutton.Visibility = Visibility.Visible;
stackPanel.Visibility = Visibility.Visible;
serverIP.Visibility = Visibility.Visible;
VerticalPage verticalpage = frame.Content as VerticalPage;
verticalpage.hideImg();
}
}
/// <summary>
/// Creates a TCP connection and writes the report to the socket at the provided hostname and port
/// </summary>
/// <param name="hostName">hostname</param>
/// <param name="port">port</param>
/// <returns>TrxResultChannel</returns>
public static Task <TrxResultChannel> CreateTcpTrxResultChannel(string hostName, int port)
{
if ((port < 0) || (port > ushort.MaxValue))
{
throw new ArgumentException("port");
}
var HostName = hostName ?? throw new ArgumentNullException(nameof(hostName));
var Port = port;
#if __IOS__ || MAC
UIKit.UIApplication.SharedApplication.NetworkActivityIndicatorVisible = true;
#endif
try
{
#if __IOS__ || MAC || __ANDROID__
var client = new System.Net.Sockets.TcpClient(hostName, port);
var channel = new TrxResultChannel(client.GetStream(), true);
#if __IOS__ || MAC
channel.showNetworkIndicator = true;
#endif
return(Task.FromResult(channel));
#elif WINDOWS_PHONE || NETFX_CORE
var socket = new Windows.Networking.Sockets.StreamSocket();
return(socket.ConnectAsync(new Windows.Networking.HostName(hostName), port.ToString(CultureInfo.InvariantCulture))
.AsTask()
.ContinueWith(_ => new TrxResultChannel(socket.OutputStream.AsStreamForWrite(), true)));
#endif
}
catch
{
#if __IOS__ || MAC
UIKit.UIApplication.SharedApplication.NetworkActivityIndicatorVisible = false;
#endif
throw;
}
}
private async void Item_ClickAsync(object sender, EventArgs e)
{
SceneSelectEventArgs args = e as SceneSelectEventArgs;
var index = args.Index;
IEnumerable <SceneItem> items = scenePanel.Children.OfType <SceneItem>();
foreach (var item in items)
{
item.Select(index);
Windows.Networking.Sockets.StreamSocket socket = new Windows.Networking.Sockets.StreamSocket();
Stream streamOut = socket.OutputStream.AsStreamForWrite();
var writer = MainPage.Writer;
try
{
await writer.WriteLineAsync($"scene,{mSceneId},{index}");
await writer.FlushAsync();
}
catch (Exception ex)
{
Log.Error("Send command error", ex);
}
}
}
private async void OnServerConnectionEstablished(
Windows.Networking.Sockets.StreamSocket socket)
{
#if DBG_ENABLE_VERBOSE_LOGGING
System.Diagnostics.Debug.WriteLine(
"OnServerConnectionEstablished: server connection established");
#endif
var receiver = new HoloLensForCV.SensorFrameReceiver(
socket);
try
{
while (true)
{
HoloLensForCV.SensorFrame sensorFrame =
await receiver.ReceiveAsync();
#if DBG_ENABLE_VERBOSE_LOGGING
System.Diagnostics.Debug.WriteLine(
"OnServerConnectionEstablished: seeing a {0}x{1} image of type {2} with timestamp {3}",
sensorFrame.SoftwareBitmap.PixelWidth,
sensorFrame.SoftwareBitmap.PixelHeight,
sensorFrame.FrameType,
sensorFrame.Timestamp);
#endif
switch (sensorFrame.FrameType)
{
case HoloLensForCV.SensorType.VisibleLightLeftLeft:
_vlcLeftLeftContext.RawImage =
sensorFrame.SoftwareBitmap;
_vlcLeftLeftContext.ImageSourceNeedsUpdate = true;
break;
case HoloLensForCV.SensorType.VisibleLightLeftFront:
_vlcLeftFrontContext.RawImage =
sensorFrame.SoftwareBitmap;
_vlcLeftFrontContext.ImageSourceNeedsUpdate = true;
break;
case HoloLensForCV.SensorType.VisibleLightRightFront:
_vlcRightFrontContext.RawImage =
sensorFrame.SoftwareBitmap;
_vlcRightFrontContext.ImageSourceNeedsUpdate = true;
break;
case HoloLensForCV.SensorType.VisibleLightRightRight:
_vlcRightRightContext.RawImage =
sensorFrame.SoftwareBitmap;
_vlcRightRightContext.ImageSourceNeedsUpdate = true;
break;
default:
throw new Exception("invalid sensor frame type");
}
UpdateImages();
}
}
catch (Exception exception)
{
// If this is an unknown status it means that the error is fatal and retry will likely fail.
if (Windows.Networking.Sockets.SocketError.GetStatus(exception.HResult) ==
Windows.Networking.Sockets.SocketErrorStatus.Unknown)
{
throw;
}
System.Diagnostics.Debug.WriteLine(
"Read stream failed with error: " + exception.Message);
}
}
private void SocketListener_startStreaming(object sender, Windows.Networking.Sockets.StreamSocket args)
{
StationLib.StationSocketListener SocketListener = sender as StationLib.StationSocketListener;
ActivateDisplay(SocketListener);
}
public void Run()
{
try
{
socket = new Windows.Networking.Sockets.StreamSocket();
UpgradeRequest request = null;
try
{
// connect to the eftlServer
if (String.Compare("ws", uri.Scheme, StringComparison.CurrentCultureIgnoreCase) == 0)
{
socket.ConnectAsync(remoteHostName, getPort().ToString(), Windows.Networking.Sockets.SocketProtectionLevel.PlainSocket).AsTask().Wait(5000);
}
else if (String.Compare("wss", uri.Scheme, StringComparison.CurrentCultureIgnoreCase) == 0)
{
socket.ConnectAsync(remoteHostName, getPort().ToString(), Windows.Networking.Sockets.SocketProtectionLevel.Ssl).AsTask().Wait(5000);
}
Windows.Networking.Sockets.SocketProtectionLevel l = socket.Information.ProtectionLevel;
Console.WriteLine("ProtectionLevel = " + l);
// send HTTP upgrade request
request = new UpgradeRequest(uri, protocols);
DataWriter writer = new DataWriter(socket.OutputStream);
String s = request.toString();
writer.WriteString(s);
// Call StoreAsync method to store the data to a backing stream
try
{
writer.StoreAsync().AsTask().Wait();
writer.FlushAsync().AsTask().Wait();
}
catch (Exception e) {
Console.WriteLine(e.StackTrace);
}
writer.DetachStream();
}
catch (Exception e)
{
Exception exp = new Exception("failed to connect" + ((e.InnerException != null) ? e.InnerException.Message : ""));
notifyError(exp);
}
byte[] buffer = new byte[32768];
IInputStream inputStream = socket.InputStream;
try {
inputStream.ReadAsync(buffer.AsBuffer(), (uint)buffer.Length, InputStreamOptions.Partial).AsTask().Wait();
System.IO.Stream stream = new System.IO.MemoryStream(buffer);
// read HTTP upgrade response
UpgradeResponse response = UpgradeResponse.read(stream);
response.validate(request);
// get the agreed upon protocol
protocol = response.getProtocol();
}
catch (Exception e)
{
notifyError(e);
}
// notify listener
notifyOpen();
// dispatch frames
dispatch();
}
catch (Exception e)
{
notifyError(e);
}
finally
{
socket.Dispose();
}
}
public void Connect()
{
TvDirectSocket = new Windows.Networking.Sockets.StreamSocket();
TvDirectSocket.ConnectAsync(ConnectedHostName, ConnectedPort.ToString()).Completed += newConnected;
ConnectionState = TvConnectionState.Connecting;
if (Connecting != null)
{
Connecting();
}
}
public void Cleanup()
{
try
{
Writer.DetachStream();
Reader.DetachStream();
Writer.Dispose();
Reader.Dispose();
TvDirectSocket.Dispose();
TvDirectSocket = null;
}
catch { }
}
//netcode functions
private async void StartClient(string data)
{
var hostName = new Windows.Networking.HostName("localhost"); // local machine
// IPAddress ipAddress = IPAddress.Parse("192.168.0.122"); //rpi
// Create a TCP/IP socket.
// Connect to a remote device.
try
{
// Establish the remote endpoint for the socket.
// The name of the
// Connect to the remote endpoint.
using (var streamSocket = new Windows.Networking.Sockets.StreamSocket())
{
if (lb1.Items.Count > 10)
{
lb1.Items.Clear();
}
lb1.Items.Add("connecting");
//new Windows.Networking.HostName("Legion-Surface")
//new Windows.Networking.HostName("raspberrypi")
await streamSocket.ConnectAsync(new Windows.Networking.HostName("192.168.0.122"), port.ToString());
// Send test data to the remote device.
if (lb1.Items.Count > 10)
{
lb1.Items.Clear();
}
lb1.Items.Add("connected. Sending Data");
string request = data + "<EOF>";
using (Stream outputStream = streamSocket.OutputStream.AsStreamForWrite())
{
using (var streamWriter = new StreamWriter(outputStream))
{
await streamWriter.WriteLineAsync(request);
await streamWriter.FlushAsync();
}
}
// Receive the response from the remote device.
// Receive(streamSocket);
//lb1.Items.Add("received the response: " + serverResponse);
streamSocket.Dispose();
}
}
catch (Exception e)
{
Windows.Networking.Sockets.SocketErrorStatus webErrorStatus = Windows.Networking.Sockets.SocketError.GetStatus(e.GetBaseException().HResult);
this.lb1.Items.Add(webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : e.Message);
}
}
public Client(
#if NETFX_CORE
Windows.Networking.Sockets.StreamSocket tcpClient
private async Task StartClientBD(string zapros, string ip)
{
try
{
// Create the StreamSocket and establish a connection to the echo server.
using (var streamSocket = new Windows.Networking.Sockets.StreamSocket())
{
// The server hostname that we will be establishing a connection to. In this example, the server and client are in the same process.
var hostName = new Windows.Networking.HostName(ip);
// this.clientListBox.Items.Add("client is trying to connect...");
// MessageDialog messageDialog1 = new MessageDialog("client is trying to connect...");
// await messageDialog1.ShowAsync();
await streamSocket.ConnectAsync(hostName, "8888");
// this.clientListBox.Items.Add("client connected");
// messageDialog1 = new MessageDialog("client connected");
// await messageDialog1.ShowAsync();
// Send a request to the echo server.
string request = "BDB!" + "\t" + zapros;
using (Stream outputStream = streamSocket.OutputStream.AsStreamForWrite())
{
using (var streamWriter = new StreamWriter(outputStream))
{
await streamWriter.WriteLineAsync(request);
await streamWriter.FlushAsync();
}
}
// this.clientListBox.Items.Add(string.Format("client sent the request: \"{0}\"", request));
// messageDialog1 = new MessageDialog("client sent the request: \"{0}\"", request);
// await messageDialog1.ShowAsync();
// Read data from the echo server.
string response = null;
List <byte> list = new List <byte>();
byte[] Buffer1 = new byte[1024];
Windows.Storage.StorageFolder storageFolder =
Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile sampleFile =
await storageFolder.CreateFileAsync("sample.xml",
Windows.Storage.CreationCollisionOption.ReplaceExisting);
using (Stream inputStream = streamSocket.InputStream.AsStreamForRead())
{
int Count;
while ((Count = inputStream.Read(Buffer1, 0, Buffer1.Length)) > 0)
{
// Преобразуем эти данные в строку и добавим ее к переменной Request
for (int i = 0; i < Count; i++)
{
list.Add(Buffer1[i]);
}
// Запрос должен обрываться последовательностью \r\n\r\n
// Либо обрываем прием данных сами, если длина строки Request превышает 4 килобайта
// Нам не нужно получать данные из POST-запроса (и т. п.), а обычный запрос
// по идее не должен быть больше 4 килобайт
}
if (list.Count != 0)
{
MessageDialog messageDialog12 = new MessageDialog(list.Count.ToString());
await messageDialog12.ShowAsync();
// IBuffer buffer = Buffer1.AsBuffer();
await Windows.Storage.FileIO.WriteBytesAsync(sampleFile, list.ToArray());
MessageDialog messageDialog112 = new MessageDialog("файл создан");
await messageDialog112.ShowAsync();
}
}
if (list.Count != 0)
{
DataSet ds = new DataSet();
// XDocument d= System.Xml.Linq.XDocument.Load(sampleFile.Path);
ds.ReadXml(sampleFile.Path);
// выбираем первую таблицу
DataTable dt = ds.Tables[0];
await ParserTabSobData(dt);
// ViewModel.SostoYs = vs[0];
// if (vs.Length > 1)
// {
// }
}
else
{
MessageDialog messageDialog12 = new MessageDialog("Данные по запросу не обнаружены");
await messageDialog12.ShowAsync();
}
MessageDialog messageDialog122 = new MessageDialog("Конец");
await messageDialog122.ShowAsync();
}
// this.clientListBox.Items.Add("client closed its socket");
// MessageDialog messageDialog = new MessageDialog("client closed its socket");
// await messageDialog.ShowAsync();
}
catch (Exception ex)
{
MessageDialog messageDialog = new MessageDialog("Error" + ex.ToString());
messageDialog.ShowAsync();
}
}
