async void OnFileOpenButtonClick(object sender, RoutedEventArgs args) { FileOpenPicker picker = new FileOpenPicker(); picker.FileTypeFilter.Add(".txt"); StorageFile storageFile = await picker.PickSingleFileAsync(); // If user presses Cancel, result is null if (storageFile == null) return; Exception exception = null; try { using (IRandomAccessStream stream = await storageFile.OpenReadAsync()) { using (DataReader dataReader = new DataReader(stream)) { uint length = (uint)stream.Size; await dataReader.LoadAsync(length); txtbox.Text = dataReader.ReadString(length); } } } catch (Exception exc) { exception = exc; } if (exception != null) { MessageDialog msgdlg = new MessageDialog(exception.Message, "File Read Error"); await msgdlg.ShowAsync(); } }
private async void ReadFromStreamButton_Click(object sender, RoutedEventArgs e) { StorageFile file = rootPage.sampleFile; if (file != null) { try { using (IRandomAccessStream readStream = await file.OpenAsync(FileAccessMode.Read)) { using (DataReader dataReader = new DataReader(readStream)) { UInt64 size = readStream.Size; if (size <= UInt32.MaxValue) { UInt32 numBytesLoaded = await dataReader.LoadAsync((UInt32)size); string fileContent = dataReader.ReadString(numBytesLoaded); rootPage.NotifyUser(String.Format("The following text was read from '{0}' using a stream:{1}{2}", file.Name, Environment.NewLine, fileContent), NotifyType.StatusMessage); } else { rootPage.NotifyUser(String.Format("File {0} is too big for LoadAsync to load in a single chunk. Files larger than 4GB need to be broken into multiple chunks to be loaded by LoadAsync.", file.Name), NotifyType.ErrorMessage); } } } } catch (FileNotFoundException) { rootPage.NotifyUserFileNotExist(); } } else { rootPage.NotifyUserFileNotExist(); } }
public async Task<IEnumerable<Event>> Read() { List<Event> events = null; StorageFolder localFolder = ApplicationData.Current.LocalFolder; try { StorageFile textFile = await localFolder.GetFileAsync("SavedContent"); events = new List<Event>(); using (IRandomAccessStream textStream = await textFile.OpenReadAsync()) { using (DataReader textReader = new DataReader(textStream)) { uint textLength = (uint)textStream.Size; await textReader.LoadAsync(textLength); string jsonContents = textReader.ReadString(textLength); events = JsonConvert.DeserializeObject<IList<Event>>(jsonContents) as List<Event>; } return events; } } catch (Exception ex) { return null; } }
private async Task<string> readHTTPMessage(DataReader dr) { // Make sure we are allowed to return early dr.InputStreamOptions = InputStreamOptions.Partial; // This is the value we will return string ret = ""; // This is the amount of data ready to be read in uint readyLen; while (true) { // Wait until we've got a kilobyte, or the stream closed readyLen = await dr.LoadAsync(1024 * 1024); // Check to see if we actually have any data if (readyLen > 0) { // Read in that string, append it to ret ret += dr.ReadString(readyLen); // Check for the "\r\n\r\n" at the end of messages if (ret.Substring(ret.Length - 4, 4) == "\r\n\r\n") break; } else { // If not, the connection is closed! return ret; } } // Finally, return that string return ret; }
public async void OnOpen() { try { var picker = new FileOpenPicker() { SuggestedStartLocation = PickerLocationId.DocumentsLibrary }; picker.FileTypeFilter.Add(".txt"); StorageFile file = await picker.PickSingleFileAsync(); if (file != null) { IRandomAccessStreamWithContentType stream = await file.OpenReadAsync(); using (var reader = new DataReader(stream)) { await reader.LoadAsync((uint)stream.Size); text1.Text = reader.ReadString((uint)stream.Size); } } } catch (Exception ex) { var dlg = new MessageDialog(ex.Message, "Error"); await dlg.ShowAsync(); } }
private async void ReadFromStreamButton_Click(object sender, RoutedEventArgs e) { try { rootPage.ResetScenarioOutput(OutputTextBlock); StorageFile file = rootPage.sampleFile; if (file != null) { using (IRandomAccessStream readStream = await file.OpenAsync(FileAccessMode.Read)) { using (DataReader dataReader = new DataReader(readStream)) { UInt64 size = readStream.Size; if (size <= UInt32.MaxValue) { UInt32 numBytesLoaded = await dataReader.LoadAsync((UInt32)size); string fileContent = dataReader.ReadString(numBytesLoaded); OutputTextBlock.Text = "The following text was read from '" + file.Name + "' using a stream:" + Environment.NewLine + Environment.NewLine + fileContent; } else { OutputTextBlock.Text = "File " + file.Name + " is too big for LoadAsync to load in a single chunk. Files larger than 4GB need to be broken into multiple chunks to be loaded by LoadAsync."; } } } } } catch (FileNotFoundException) { rootPage.NotifyUserFileNotExist(); } }
private async Task<string> DoCommand(string command) { StringBuilder strBuilder = new StringBuilder(); using (StreamSocket clientSocket = new StreamSocket()) { await clientSocket.ConnectAsync(new HostName("192.168.9.108"), "9001"); using (DataWriter writer = new DataWriter(clientSocket.OutputStream)) { writer.WriteString(command); await writer.StoreAsync(); writer.DetachStream(); } using (DataReader reader = new DataReader(clientSocket.InputStream)) { reader.InputStreamOptions = InputStreamOptions.Partial; await reader.LoadAsync(8192); while (reader.UnconsumedBufferLength > 0) { strBuilder.Append(reader.ReadString(reader.UnconsumedBufferLength)); await reader.LoadAsync(8192); } reader.DetachStream(); } } return (strBuilder.ToString()); }
private async void ReadBlock_Click(object sender, RoutedEventArgs e) { var fx2Device = DeviceList.Current.GetSelectedDevice(); if (fx2Device == null) { rootPage.NotifyUser("Fx2 device not connected or accessible", NotifyType.ErrorMessage); return; } var button = (Button)sender; button.IsEnabled = false; var dataReader = new DataReader(fx2Device.InputStream); // load the data reader from the stream. For purposes of this // sample, assume all messages read are < 64 bytes int counter = readCounter++; LogMessage("Read {0} begin", counter); await dataReader.LoadAsync(64); // Get the message string out of the buffer var message = dataReader.ReadString(dataReader.UnconsumedBufferLength); LogMessage("Read {0} end: {1}", counter, message); button.IsEnabled = true; }
public void ReadAllText(string filename, Action<string> completed) { StorageFolder localFolder = ApplicationData.Current.LocalFolder; IAsyncOperation<StorageFile> createOp = localFolder.GetFileAsync(filename); createOp.Completed = (asyncInfo1, asyncStatus1) => { IStorageFile storageFile = asyncInfo1.GetResults(); IAsyncOperation<IRandomAccessStreamWithContentType> openOp = storageFile.OpenReadAsync(); openOp.Completed = (asyncInfo2, asyncStatus2) => { IRandomAccessStream stream = asyncInfo2.GetResults(); DataReader dataReader = new DataReader(stream); uint length = (uint)stream.Size; DataReaderLoadOperation loadOp = dataReader.LoadAsync(length); loadOp.Completed = (asyncInfo3, asyncStatus3) => { string text = dataReader.ReadString(length); dataReader.Dispose(); completed(text); }; }; }; }
public static async Task<AppModel> DeserializeAppData() { StorageFolder localFolder = ApplicationData.Current.LocalFolder; AppModel appModel = null; try { // Getting JSON from file if it exists, or file not found exception if it does not StorageFile textFile = await localFolder.GetFileAsync("app.json"); using (IRandomAccessStream textStream = await textFile.OpenReadAsync()) { // Read text stream using (DataReader textReader = new DataReader(textStream)) { //get size uint textLength = (uint)textStream.Size; await textReader.LoadAsync(textLength); // read it string jsonContents = textReader.ReadString(textLength); // deserialize back to our product! appModel = JsonConvert.DeserializeObject<AppModel>(jsonContents); } } } catch (Exception ex) { throw; } return appModel; }
async private void OpenGraphFile_Click(object sender, RoutedEventArgs e) { var picker = new FileOpenPicker(); picker.FileTypeFilter.Add(".txt"); picker.ViewMode = PickerViewMode.Thumbnail; picker.SettingsIdentifier = "GraphPicker"; picker.CommitButtonText = "Select Files"; var selectedFile = await picker.PickSingleFileAsync(); using (IRandomAccessStream stream = await selectedFile.OpenReadAsync()) { using (DataReader reader = new DataReader(stream)) { uint length = (uint)stream.Size; await reader.LoadAsync(length); string[] s = reader.ReadString(length).Split('\r'); string[][] str = new string[s.Length][]; for (int i = 0; i < s.Length; i++) str[i] = s[i].Replace('\n', ' ').Split(' '); int n = int.Parse(s[0]); int[,] adjMatrix = new int[n, n]; for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) adjMatrix[i, j] = int.Parse(str[i + 1][j + 1]); adjMatrix[0, 0] += 0; graph = new Graph(adjMatrix, n); } } }
public static async Task<bool> LoadFrom ( ObservableCollection<RecentData> datas ) { try { StorageFile sf = await ApplicationData.Current.LocalFolder.GetFileAsync ( "data.dat" ); FileRandomAccessStream stream = await sf.OpenAsync ( FileAccessMode.Read ) as FileRandomAccessStream; DataReader dr = new DataReader ( stream ); dr.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; dr.ByteOrder = ByteOrder.LittleEndian; await dr.LoadAsync ( ( uint ) stream.Size ); int len = dr.ReadInt32 (); for ( int i = 0; i < len; i++ ) { RecentData data = new RecentData (); uint srclen = dr.ReadUInt32 (); data.Source = dr.ReadString ( srclen ); data.SourceIndex = dr.ReadInt32 (); data.TargetIndex = dr.ReadInt32 (); datas.Add ( data ); } stream.Dispose (); } catch { return false; } return true; }
public async Task <string> ReadLogFile(string fileName) { if (fileName != this.FQP) { int index = fileName.IndexOf(DIRECTORY_NAME); fileName = fileName.Substring(index); var file = await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFileAsync(fileName, CreationCollisionOption.OpenIfExists); if (file == null) { return(""); } return(await Windows.Storage.FileIO.ReadTextAsync(file)); } if (_logFile != null) { using (var inputStream = _stream.GetInputStreamAt(0)) { Windows.Storage.Streams.DataReader reader = new Windows.Storage.Streams.DataReader(inputStream); await reader.LoadAsync((uint)_stream.Size); string data = reader.ReadString((uint)_stream.Size); reader.DetachStream(); return(data); } } return(""); }
public async void LoadSettings() { try { string contents; StorageFolder localFolder = ApplicationData.Current.LocalFolder; StorageFile textFile = await localFolder.GetFileAsync("settingV2"); using (IRandomAccessStream textStream = await textFile.OpenReadAsync()) { using (DataReader textReader = new DataReader(textStream)) { uint textLength = (uint)textStream.Size; await textReader.LoadAsync(textLength); contents = textReader.ReadString(textLength); } } string[] lines = contents.Split('\n'); bool.TryParse(lines[0], out AutoJoinChat); bool.TryParse(lines[1], out LockLandscape); bool.TryParse(lines[2], out LiveTilesEnabled); } catch { } }
/// <summary> /// Read string content from file. /// </summary> /// <param name="path">Location of file, separate by //.</param> /// <param name="rootFolder"> </param> /// <returns>Content of file.</returns> public async Task<string> ReadFromFileAsync(string path, StorageFolder rootFolder = null) { if (path == null) { return null; } try { var file = await GetFileToReadAsync(path, rootFolder); if (file == null) { return null; } var readStream = await file.OpenAsync(FileAccessMode.Read); var inputStream = readStream.GetInputStreamAt(0); var dataReader = new DataReader(inputStream); var numBytesLoaded = await dataReader.LoadAsync((uint)readStream.Size); var content = dataReader.ReadString(numBytesLoaded); dataReader.DetachStream(); dataReader.Dispose(); inputStream.Dispose(); readStream.Dispose(); return content; } catch { return null; } }
private async void OnForegroundSocketClicked(object sender, RoutedEventArgs e) { socket = new StreamSocket(); HostName host = new HostName("localhost"); try { await socket.ConnectAsync(host, "1983"); isConnected = true; while (isConnected) { try { DataReader reader; using (reader = new DataReader(socket.InputStream)) { // Set the DataReader to only wait for available data (so that we don't have to know the data size) reader.InputStreamOptions = InputStreamOptions.Partial; // The encoding and byte order need to match the settings of the writer we previously used. reader.UnicodeEncoding = UnicodeEncoding.Utf8; reader.ByteOrder = ByteOrder.LittleEndian; // Send the contents of the writer to the backing stream. // Get the size of the buffer that has not been read. await reader.LoadAsync(256); // Keep reading until we consume the complete stream. while (reader.UnconsumedBufferLength > 0) { string readString = reader.ReadString(reader.UnconsumedBufferLength); await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { messages.Add(readString); }); Debug.WriteLine(readString); await reader.LoadAsync(256); } reader.DetachStream(); } } catch (Exception exc) { MessageDialog dialog = new MessageDialog("Error reading the data"); await dialog.ShowAsync(); } } } catch (Exception exc) { MessageDialog dialog = new MessageDialog("Error connecting to the socket"); await dialog.ShowAsync(); } }
public static async Task<string> LoadAndRemoveBOM(this StorageFile storageFile) { IRandomAccessStream readStream = await storageFile.OpenAsync(FileAccessMode.Read); IInputStream inputSteam = readStream.GetInputStreamAt(0); DataReader dataReader = new DataReader(inputSteam); uint numBytesLoaded = await dataReader.LoadAsync((uint)readStream.Size); string output = dataReader.ReadString(numBytesLoaded); return output.Trim(UTF8_BYTE_ORDER_MARK.ToCharArray()); }
async public static Task<string> ReadAllTextAsync(this StorageFile storageFile) { var inputStream = await storageFile.OpenAsync(FileAccessMode.Read); var readStream = inputStream.GetInputStreamAt(0); var reader = new DataReader(readStream); uint fileLength = await reader.LoadAsync((uint)inputStream.Size); string content = reader.ReadString(fileLength); return content; }
private void ReadDataFromDevice(DataReader reader) { reader.InputStreamOptions = InputStreamOptions.Partial; reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; var size = reader.UnconsumedBufferLength; var message = reader.ReadString(size); SendDataToDevice("Ack " + message); ProcessMessage(message).Wait(); }
private async void InitializeConnection() { await _socket.ConnectAsync(new HostName("127.0.0.1"), "41337"); var dataWriter = new DataWriter(_socket.OutputStream); var dataReader = new DataReader(_socket.InputStream); var message = CreateHandshakeMessage(); dataWriter.WriteString(message); var response = dataReader.ReadString(100); }
/// <summary> /// Gets intent and entities from a text string /// </summary> /// <returns>Unprocessed result from a server</returns> public async Task<string> GetAsync() { return await Task.Run<string>(async () => { try { var socket = new StreamSocket(); var writer = new DataWriter(socket.OutputStream); var reader = new DataReader(socket.InputStream); reader.InputStreamOptions = InputStreamOptions.Partial; StringBuilder stringBuilder = new StringBuilder(); stringBuilder.AppendLine(String.Format("GET /message?q={0} HTTP/1.1", HttpUtility.UrlEncode(message))); stringBuilder.AppendLine("Host: api.wit.ai"); stringBuilder.AppendLine(String.Format("Authorization: Bearer {0}", accessToken)); stringBuilder.AppendLine(""); string headers = stringBuilder.ToString(); byte[] headersPayload = Encoding.UTF8.GetBytes(headers); await socket.ConnectAsync(new HostName("wit.ai"), "443", SocketProtectionLevel.SslAllowNullEncryption); writer.WriteBytes(headersPayload); WitLog.Log("Sending text..."); await writer.StoreAsync(); await writer.FlushAsync(); var count = await reader.LoadAsync(UInt16.MaxValue); string response = reader.ReadString(count); int bodyStartIndex = response.IndexOf("\r\n\r\n"); if (bodyStartIndex != -1) { string body = response.Substring(bodyStartIndex + 4); WitLog.Log(body); return body; } else { return null; } } catch { return null; } }); }
public async Task <T> LoadASync(string FileName) { FileName = FileName + ".xml"; try { StorageFile file = null; StorageFolder folder = GetFolder(storageType); file = await folder.GetFileAsync(FileName); //using (var readStream = await file.OpenAsync(FileAccessMode.Read)) //{ // Windows.Storage.Streams.DataReader reader = new Windows.Storage.Streams.DataReader(readStream); // await reader.LoadAsync((uint)readStream.Size); // string data = reader.ReadString((uint)readStream.Size); // if (data == null) // { // } //} using (var readStream = await file.OpenAsync(FileAccessMode.Read)) { //Stream inStream = Task.Run(() => readStream.AsStreamForRead()).Result; //return (T)serializer.Deserialize(inStream); var inStream = readStream.GetInputStreamAt(0); Windows.Storage.Streams.DataReader reader = new Windows.Storage.Streams.DataReader(inStream); await reader.LoadAsync((uint)readStream.Size); string data = reader.ReadString((uint)readStream.Size); reader.DetachStream(); MemoryStream ms = new MemoryStream(UTF8Encoding.UTF8.GetBytes(data)); DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T)); T result = (T)ser.ReadObject(ms); return(result); } } catch (FileNotFoundException) { //file not existing is perfectly valid so simply return the default return(default(T)); //throw; } catch (Exception) { //Unable to load contents of file throw; } }
private async void Listener_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args) { Debug.WriteLine("Connection Received on Port {0}", sender.Information.LocalPort); StreamSocket streamSocket = args.Socket; if (streamSocket != null) { DataReader reader = new DataReader(streamSocket.InputStream); try { // Read first 4 bytes (length of the subsequent string). uint sizeFieldCount = await reader.LoadAsync(sizeof(uint)); if (sizeFieldCount != sizeof(uint)) { // The underlying socket was closed before we were able to read the whole data. return; } // Read the length of the 'packet'. uint length = reader.ReadUInt32(); uint actualLength = await reader.LoadAsync(length); if (length != actualLength) { // The underlying socket was closed before we were able to read the whole data. return; } string name = reader.ReadString(actualLength); Speaker speaker = new Speaker() { Name = name, Address = streamSocket.Information.RemoteAddress.DisplayName, Status = "Connected", Socket = streamSocket }; await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { Speakers.Add(speaker); }); reader.DetachStream(); Debug.WriteLine("New speaker added " + name); } catch (Exception e) { Debug.WriteLine("Error in connection received: " + e); } } }
public async Task<string> ReadAsync(string fileName) { var folder = ApplicationData.Current.LocalFolder; var file = await folder.CreateFileAsync(fileName, CreationCollisionOption.OpenIfExists); using (var stream = await file.OpenReadAsync()) using (var textReader = new DataReader(stream)) { var textLength = (uint) stream.Size; await textReader.LoadAsync(textLength); return textReader.ReadString(textLength); } }
public async void Run(IBackgroundTaskInstance taskInstance) { var deferral = taskInstance.GetDeferral(); try { var details = taskInstance.TriggerDetails as SocketActivityTriggerDetails; var socketInformation = details.SocketInformation; switch (details.Reason) { case SocketActivityTriggerReason.SocketActivity: var socket = socketInformation.StreamSocket; DataReader reader = new DataReader(socket.InputStream); reader.InputStreamOptions = InputStreamOptions.Partial; await reader.LoadAsync(250); var dataString = reader.ReadString(reader.UnconsumedBufferLength); ShowToast(dataString); socket.TransferOwnership(socketInformation.Id); break; case SocketActivityTriggerReason.KeepAliveTimerExpired: socket = socketInformation.StreamSocket; DataWriter writer = new DataWriter(socket.OutputStream); writer.WriteBytes(Encoding.UTF8.GetBytes("Keep alive")); await writer.StoreAsync(); writer.DetachStream(); writer.Dispose(); socket.TransferOwnership(socketInformation.Id); break; case SocketActivityTriggerReason.SocketClosed: socket = new StreamSocket(); socket.EnableTransferOwnership(taskInstance.Task.TaskId, SocketActivityConnectedStandbyAction.Wake); if (ApplicationData.Current.LocalSettings.Values["hostname"] == null) { break; } var hostname = (String)ApplicationData.Current.LocalSettings.Values["hostname"]; var port = (String)ApplicationData.Current.LocalSettings.Values["port"]; await socket.ConnectAsync(new HostName(hostname), port); socket.TransferOwnership(socketId); break; default: break; } deferral.Complete(); } catch (Exception exception) { ShowToast(exception.Message); deferral.Complete(); } }
public async Task<String> ReadTextAsync(string filename) { StorageFolder localFolder = ApplicationData.Current.LocalFolder; IStorageFile storageFile = await localFolder.GetFileAsync(filename); using(IRandomAccessStream stream = await storageFile.OpenReadAsync()) { using(DataReader dataReader = new DataReader(stream)) { uint length = (uint)stream.Size; await dataReader.LoadAsync(length); return dataReader.ReadString(length); } } }
private async void ReadviaStream_Click(object sender, RoutedEventArgs e) { var stream = await sampleFile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite); var size = stream.Size; using (var inputStream = stream.GetInputStreamAt(0)) { // Add code to use the stream to read your file DataReader dataReader = new DataReader(inputStream); uint numBytesLoaded = await dataReader.LoadAsync((uint)size); string text = dataReader.ReadString(numBytesLoaded); txtbox.Text = text; } }
internal static async Task<string> ReadTextAsync(this StorageFile file) { using (var fs = await file.OpenAsync(FileAccessMode.Read)) { using (var inStream = fs.GetInputStreamAt(0)) { using (var dataReader = new DataReader(inStream)) { await dataReader.LoadAsync((uint)fs.Size); var data = dataReader.ReadString((uint)fs.Size); dataReader.DetachStream(); return data; } } } }
public static async void LoadFromFile() { var loadPicker = new Windows.Storage.Pickers.FileOpenPicker(); loadPicker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail; loadPicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary; // Dropdown of file types the user can save the file as loadPicker.FileTypeFilter.Add(".json"); StorageFile file = await loadPicker.PickSingleFileAsync(); if (file != null) { var inputStream = await file.OpenAsync(FileAccessMode.Read); var readStream = inputStream.GetInputStreamAt(0); var reader = new DataReader(readStream); uint fileLength = await reader.LoadAsync((uint)inputStream.Size); dataStore.ImportFromJson(reader.ReadString(fileLength)); } }
internal static async Task<String> ReadFile(string filename) { string contents; StorageFolder localFolder = ApplicationData.Current.LocalFolder; StorageFile textFile = await localFolder.GetFileAsync(filename); using (IRandomAccessStream textStream = await textFile.OpenReadAsync()) { using (DataReader textReader = new DataReader(textStream)) { uint textLength = (uint)textStream.Size; await textReader.LoadAsync(textLength); contents = textReader.ReadString(textLength); } } return contents; }
public async Task<string> ReadFile(string file) { try { var storageFile = await ApplicationData.Current.LocalFolder.GetFileAsync(file); IRandomAccessStream readStream = await storageFile.OpenAsync(FileAccessMode.Read); // Read the file to an IInputStream stream, then get and load the DataReader. IInputStream inputStream = readStream.GetInputStreamAt(0); DataReader dataReader = new DataReader(inputStream); uint numBytesLoaded = await dataReader.LoadAsync((uint)readStream.Size); return dataReader.ReadString(numBytesLoaded); } catch (FileNotFoundException) { return null; } }
async Task<string> ReadTextAsync(StorageFile file) { #if NETFX_CORE var text = await FileIO.ReadTextAsync(file); #else var text = default(string); using (var stream = await file.OpenReadAsync()) { var size = stream.Size; using (var inputStream = stream.GetInputStreamAt(0)) { var dataReader = new DataReader(inputStream); uint numBytesLoaded = await dataReader.LoadAsync((uint)size); text = dataReader.ReadString(numBytesLoaded); } } #endif return text; }
private void WebSocket_MessageReceived(Windows.Networking.Sockets.MessageWebSocket sender, Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args) { try { using (Windows.Storage.Streams.DataReader dataReader = args.GetDataReader()) { dataReader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; string message = dataReader.ReadString(dataReader.UnconsumedBufferLength); Debug.Log("Message received from MessageWebSocket: " + message); cmds.Enqueue(message); //m_Socket.Dispose(); } } catch (Exception ex) { Windows.Web.WebErrorStatus webErrorStatus = Windows.Networking.Sockets.WebSocketError.GetStatus(ex.GetBaseException().HResult); // Add additional code here to handle exceptions. } }
public async void StartReader(ConnectedPeer connectedPeer) { try { using (var socketReader = new Windows.Storage.Streams.DataReader(connectedPeer._socket.InputStream)) { // Read the message sent by the remote peer uint bytesRead = await socketReader.LoadAsync(sizeof(uint)); if (bytesRead > 0) { uint strLength = (uint)socketReader.ReadUInt32(); bytesRead = await socketReader.LoadAsync(strLength); if (bytesRead > 0) { String message = socketReader.ReadString(strLength); OnRaiseMessageEvent(new MessageEventArgs("Got message: " + message)); StartReader(connectedPeer); // Start another reader } else { OnRaiseSocketErrorEvent(new SocketEventArgs("The remote side closed the socket")); } } else { OnRaiseSocketErrorEvent(new SocketEventArgs("The remote side closed the socket")); } socketReader.DetachStream(); } } catch (Exception e) { if (!connectedPeer._socketClosed) { OnRaiseSocketErrorEvent(new SocketEventArgs("Reading from socket failed: " + e.Message)); } } }
private async void Sck_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args) { //[email protected]("Message received " + args); if (args.MessageType == SocketMessageType.Utf8) { Windows.Storage.Streams.DataReader messageReader = args.GetDataReader(); messageReader.UnicodeEncoding = UnicodeEncoding.Utf8; string messageString = messageReader.ReadString(messageReader.UnconsumedBufferLength); com.codename1.io.websocket.WebSocket.messageReceived(id, messageString); } else { Windows.Storage.Streams.IInputStream readStream = args.GetDataStream(); byte[] readBuffer = new byte[4096]; try { while (true) { if (sender != sck) { return; } IBuffer res = await readStream.ReadAsync(readBuffer.AsBuffer(), (uint)readBuffer.Length, 0); if (res.Length == 0) { return; } byte[] resArr = new byte[res.Length]; res.CopyTo(resArr); com.codename1.io.websocket.WebSocket.messageReceived(1, resArr); } } catch (Exception ex) { com.codename1.io.websocket.WebSocket.errorReceived(id, ex.Message, ex.HResult); } } }
private async Task TryPostJsonAsync() { try { // Construct the HttpClient and Uri. This endpoint is for test purposes only. //var myFilter = new Windows.Web.Http.Filters.HttpBaseProtocolFilter(); //myFilter.AllowUI = false; //Windows.Web.Http.Filters.HttpBaseProtocolFilter filter = new Windows.Web.Http.Filters.HttpBaseProtocolFilter(); //Windows.Storage.StorageFolder storageFolder = KnownFolders.DocumentsLibrary; fileOpenPicker.FileTypeFilter.Add(".json"); /*fileOpenPicker.FileTypeFilter.Add(".txt"); * Windows.Storage.StorageFile credentialsFile = await fileOpenPicker.PickSingleFileAsync(); * string text = await Windows.Storage.FileIO.ReadTextAsync(credentialsFile); * string username = text.Split(',')[0]; * string password = text.Split(',')[1]; * string domain = text.Split(',')[2];*/ HttpClientHandler handler = new HttpClientHandler(); handler.Credentials = new NetworkCredential("", "", ""); System.Net.Http.HttpClient httpClient = new System.Net.Http.HttpClient(handler); httpClient.DefaultRequestHeaders.Clear(); httpClient.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json")); Uri uri = new Uri("https://prodigalcompany.com/npjTest/SurveyStuff/testSurveyFile.json"); // Construct the JSON to post. //fileOpenPicker.FileTypeChoices.Add("JSON", new List<string>() { ".json" }); IStorageFile jsonFile = await fileOpenPicker.PickSingleFileAsync(); IRandomAccessStream stream = await jsonFile.OpenAsync(FileAccessMode.Read); System.Net.Http.MultipartFormDataContent postContent = new MultipartFormDataContent(); if (stream != null) { using (var dataReader = new Windows.Storage.Streams.DataReader(stream)) { uint numBytesLoaded = await dataReader.LoadAsync((uint)stream.Size); string jsonText = dataReader.ReadString(numBytesLoaded); System.Net.Http.StringContent streamContent = new System.Net.Http.StringContent(jsonText); streamContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json"); postContent.Add(streamContent); System.Net.Http.HttpResponseMessage httpResponseMessage = await httpClient.PostAsync( "https://prodigalcompany.com/npjTest/SurveyStuff/testSurveyFile.json", postContent); // Make sure the post succeeded, and write out the response. httpResponseMessage.EnsureSuccessStatusCode(); var httpResponseBody = await httpResponseMessage.Content.ReadAsStringAsync(); Debug.WriteLine(httpResponseBody); } } else { Debug.WriteLine("stream is NULL."); } //HttpStringContent content = await jsonFile.OpenReadAsync(); // Post the JSON and wait for a response. } catch (Exception ex) { // Write out any exceptions. Debug.WriteLine(ex); } }
private async Task <string> ExecuteCommandLineString(string CommandString) { const string CommandLineProcesserExe = "c:\\windows\\system32\\cmd.exe"; const uint CommandStringResponseBufferSize = 8192; string currentDirectory = "C:\\"; StringBuilder textOutput = new StringBuilder((int)CommandStringResponseBufferSize); uint bytesLoaded = 0; if (string.IsNullOrWhiteSpace(CommandString)) { return(""); } var commandLineText = CommandString.Trim(); var standardOutput = new Windows.Storage.Streams.InMemoryRandomAccessStream(); var standardError = new Windows.Storage.Streams.InMemoryRandomAccessStream(); var options = new Windows.System.ProcessLauncherOptions { StandardOutput = standardOutput, StandardError = standardError }; try { var args = "/C \"cd \"" + currentDirectory + "\" & " + commandLineText + "\""; var result = await Windows.System.ProcessLauncher.RunToCompletionAsync(CommandLineProcesserExe, args, options); //First write std out using (var outStreamRedirect = standardOutput.GetInputStreamAt(0)) { using (var dataReader = new Windows.Storage.Streams.DataReader(outStreamRedirect)) { while ((bytesLoaded = await dataReader.LoadAsync(CommandStringResponseBufferSize)) > 0) { textOutput.Append(dataReader.ReadString(bytesLoaded)); } new System.Threading.ManualResetEvent(false).WaitOne(10); if ((bytesLoaded = await dataReader.LoadAsync(CommandStringResponseBufferSize)) > 0) { textOutput.Append(dataReader.ReadString(bytesLoaded)); } } } //Then write std err using (var errStreamRedirect = standardError.GetInputStreamAt(0)) { using (var dataReader = new Windows.Storage.Streams.DataReader(errStreamRedirect)) { while ((bytesLoaded = await dataReader.LoadAsync(CommandStringResponseBufferSize)) > 0) { textOutput.Append(dataReader.ReadString(bytesLoaded)); } new System.Threading.ManualResetEvent(false).WaitOne(10); if ((bytesLoaded = await dataReader.LoadAsync(CommandStringResponseBufferSize)) > 0) { textOutput.Append(dataReader.ReadString(bytesLoaded)); } } } return(textOutput.ToString()); } catch (UnauthorizedAccessException uex) { return("ERROR - " + uex.Message + "\n\nCmdNotEnabled"); } catch (Exception ex) { return("ERROR - " + ex.Message + "\n"); } }