public static async Task<bool> ConnectAsync() { if (imageComparisonServer != null) return true; try { imageComparisonServer = new StreamSocket(); await imageComparisonServer.ConnectAsync(new HostName(ParadoxImageServerHost), ParadoxImageServerPort.ToString()); // Send initial parameters using (var memoryStream = new MemoryStream()) { var binaryWriter = new BinaryWriter(memoryStream); ImageTestResultConnection.Write(binaryWriter); var dataWriter = new DataWriter(imageComparisonServer.OutputStream); dataWriter.WriteBytes(memoryStream.ToArray()); await dataWriter.StoreAsync(); await dataWriter.FlushAsync(); dataWriter.DetachStream(); } return true; } catch (Exception) { imageComparisonServer = null; return false; } }
public static async Task <Windows.UI.Xaml.Media.Imaging.BitmapImage> GetBitmapAsync(byte[] data) { if (data is null) { return(null); } var bitmapImage = new Windows.UI.Xaml.Media.Imaging.BitmapImage(); using (var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream()) { using (var writer = new Windows.Storage.Streams.DataWriter(stream)) { writer.WriteBytes(data); await writer.StoreAsync(); await writer.FlushAsync(); writer.DetachStream(); } stream.Seek(0); await bitmapImage.SetSourceAsync(stream); } return(bitmapImage); }
private async Task WriteToOutputStreamAsync(byte[] bytes) { if (_socket == null) return; _writer = new DataWriter(_socket.OutputStream); _writer.WriteBytes(bytes); var debugString = UTF8Encoding.UTF8.GetString(bytes, 0, bytes.Length); try { await _writer.StoreAsync(); await _socket.OutputStream.FlushAsync(); _writer.DetachStream(); _writer.Dispose(); } catch (Exception exception) { // If this is an unknown status it means that the error if fatal and retry will likely fail. if (global::Windows.Networking.Sockets.SocketError.GetStatus(exception.HResult) == global::Windows.Networking.Sockets.SocketErrorStatus.Unknown) { // TODO abort any retry attempts on Unity side throw; } } }
public async void WriteToSerialPort(string message) { var writer = new DataWriter(_realDevice.OutputStream); writer.WriteString(AddNewLine(message)); await writer.StoreAsync().AsTask(); writer.DetachStream(); }
public static async void init(TiSettings settings) { if (!settings.ContainsKey("logToken") || settings["logToken"].Length == 0) { return; } logToken = settings["logToken"]; multicastSocket = new DatagramSocket(); multicastSocket.MessageReceived += multicastSocket_MessageReceived; HostName hostname = new HostName("239.6.6.6"); try { await multicastSocket.BindServiceNameAsync("8666"); multicastSocket.JoinMulticastGroup(hostname); IOutputStream stream = await multicastSocket.GetOutputStreamAsync(hostname, "8666"); DataWriter writer = new DataWriter(stream); writer.WriteString("TI_WP8_LOGGER"); await writer.StoreAsync(); writer.DetachStream(); stream.Dispose(); } catch (Exception ex) { if (SocketError.GetStatus(ex.HResult) == SocketErrorStatus.Unknown) { throw; } Debug.WriteLine(ex.ToString()); } }
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()); }
//</SnippetVertices> /// <summary> /// Fixes issue in API where textures are not saved correctly /// </summary> /// <param name="modelStream">3dmodel.model data</param> /// <returns></returns> private async Task <IRandomAccessStream> FixTextureContentType(IRandomAccessStream modelStream) { XDocument xmldoc = XDocument.Load(modelStream.AsStreamForRead()); var outputStream = new Windows.Storage.Streams.InMemoryRandomAccessStream(); var writer = new Windows.Storage.Streams.DataWriter(outputStream); writer.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; writer.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian; writer.WriteString("<?xml version=\"1.0\" encoding=\"UTF-8\"?>"); var text = xmldoc.ToString(); // ensure that content type is set correctly // texture content can be either png or jpg var replacedText = text.Replace("contenttype=\"\"", "contenttype=\"image/png\""); writer.WriteString(replacedText); await writer.StoreAsync(); await writer.FlushAsync(); writer.DetachStream(); return(outputStream); }
public static async Task WriteFileAsync(string fileName, byte[] content) { try { var file = await ApplicationData.Current.LocalFolder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting); using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite)) { using (var outputStream = fileStream.GetOutputStreamAt(0)) { using (var dataWriter = new DataWriter(outputStream)) { dataWriter.WriteBytes(content); await dataWriter.StoreAsync(); dataWriter.DetachStream(); } await outputStream.FlushAsync(); } } } catch (Exception exception) { SnazzyDebug.WriteLine(exception); } }
//private uint sizeOfPixel = 4; private async void createTile(IRandomAccessStream tileStream, Color color) { // Create the data writer object backed by the in-memory stream. using (var dataWriter = new Windows.Storage.Streams.DataWriter(tileStream)) { for (uint y = 0; y < sizeOfMapTile; y++) { for (uint x = 0; x < sizeOfMapTile; x++) { // RGBA dataWriter.WriteByte(color.R); dataWriter.WriteByte(color.G); dataWriter.WriteByte(color.B); dataWriter.WriteByte(color.A); } } // Send the contents of the writer to the backing stream. await dataWriter.StoreAsync(); // For the in-memory stream implementation we are using, the flushAsync call // is superfluous,but other types of streams may require it. await dataWriter.FlushAsync(); // In order to prolong the lifetime of the stream, detach it from the // DataWriter so that it will not be closed when Dispose() is called on // dataWriter. Were we to fail to detach the stream, the call to // dataWriter.Dispose() would close the underlying stream, preventing // its subsequent use by the DataReader below. dataWriter.DetachStream(); } }
/// <summary> /// Writes a string to a text file. /// </summary> /// <param name="text">The text to write.</param> /// <param name="fileName">Name of the file.</param> /// <param name="folder">The folder.</param> /// <param name="options"> /// The enum value that determines how responds if the fileName is the same /// as the name of an existing file in the current folder. Defaults to ReplaceExisting. /// </param> /// <returns></returns> public static async Task SaveAsync( this string text, string fileName, StorageFolder folder = null, CreationCollisionOption options = CreationCollisionOption.ReplaceExisting) { folder = folder ?? ApplicationData.Current.LocalFolder; var file = await folder.CreateFileAsync( fileName, options); using (var fs = await file.OpenAsync(FileAccessMode.ReadWrite)) { using (var outStream = fs.GetOutputStreamAt(0)) { using (var dataWriter = new DataWriter(outStream)) { if (text != null) dataWriter.WriteString(text); await dataWriter.StoreAsync(); dataWriter.DetachStream(); } await outStream.FlushAsync(); } } }
private async void OnWrite(Object sender, RoutedEventArgs e) { // 获取本地目录的引用 StorageFolder local = ApplicationData.Current.LocalFolder; // 创建新文件 StorageFile newFIle = await local.CreateFileAsync("demo.dat", CreationCollisionOption.ReplaceExisting); // 打开文件流 using(IRandomAccessStream stream = await newFIle.OpenAsync(FileAccessMode.ReadWrite)) { // 实例化 DataWriter DataWriter dw = new DataWriter(stream); // 设置默认编码格式 dw.UnicodeEncoding = UnicodeEncoding.Utf8; // 写入 bool 值 dw.WriteBoolean(true); // 写入日期值 DateTime dt = new DateTime(2010, 8, 21); dw.WriteDateTime(dt); // 写入字符串 string str = "测试文本"; // 计算字符串长度 uint len = dw.MeasureString(str); // 先写入字符串的长的 dw.WriteUInt32(len); // 再写入字符串 dw.WriteString(str); // 以下方法必须调用 await dw.StoreAsync(); // 解除 DataWriter 与流的关联 dw.DetachStream(); dw.Dispose(); } MessageDialog msgDlg = new MessageDialog("保存成功。"); await msgDlg.ShowAsync(); }
public async Task SendAsync(string text) { var dataWriteObject = new DataWriter(_serialPort.OutputStream); dataWriteObject.WriteString(text); var task = dataWriteObject.StoreAsync().AsTask(_cancellation.Token); await task; dataWriteObject.DetachStream(); }
public static async Task WriteLine(this IOutputStream outputStream, string line) { using (var dataWriter = new DataWriter(outputStream)) { dataWriter.WriteString(line); await dataWriter.StoreAsync(); dataWriter.DetachStream(); } }
async void InitStreamInfo() { _stream = new InMemoryRandomAccessStream(); DataWriter writer = new DataWriter(_stream); writer.WriteString(_jsonValue); var data = await writer.StoreAsync(); writer.DetachStream(); }
private async Task SendMessageUsingMessageWebSocketAsync(string message) { using (var dataWriter = new Windows.Storage.Streams.DataWriter(m_Socket.OutputStream)) { dataWriter.WriteString(message); await dataWriter.StoreAsync(); dataWriter.DetachStream(); } FlowNetworkManager.log("Sending message using MessageWebSocket: " + message); }
private async Task <int> SendAsync(byte[] inbuffer) { using (var writer = new Windows.Storage.Streams.DataWriter(socket.OutputStream)) { writer.WriteBytes(inbuffer); await writer.StoreAsync(); writer.DetachStream(); } // hopefully true... return(inbuffer.Length); }
private async Task<bool> SendAsync(string data, string ok = "", string err = "") { if (serialPort == null) { if (!await Open()) return false; } try { using (var writer = new DataWriter(serialPort.OutputStream)) { writer.WriteString(data); await writer.StoreAsync(); writer.DetachStream(); } } catch (OperationCanceledException ex) { return false; } catch (Exception ex) { return false; } try { var buffer = string.Empty; using (var reader = new DataReader(serialPort.InputStream)) { reader.InputStreamOptions = InputStreamOptions.ReadAhead; if (await reader.LoadAsync(1024) > 0) buffer = reader.ReadString(reader.UnconsumedBufferLength); reader.DetachStream(); } if (!string.IsNullOrEmpty(ok) && buffer.Contains(ok)) { return true; } else if (!string.IsNullOrEmpty(err) && buffer.Contains(err)) { return false; } } catch (OperationCanceledException ex) { return false; } catch (Exception ex) { return false; } return false; }
async Task Send(FayeObject o) { if (o is FayeRequest) (o as FayeRequest).ClientID = ClientID; using (var writer = new DataWriter(_socket.OutputStream)) { writer.UnicodeEncoding = UnicodeEncoding.Utf8; var stringd = await Helpers.SerializeAsync(o); writer.WriteString(stringd); await writer.StoreAsync(); await writer.FlushAsync(); writer.DetachStream(); } }
private async void cutTile(IRandomAccessStream stream, int pixeloffsetX, int pixeloffsetY, int levelOfDetail) { // Create the data writer object backed by the in-memory stream. using (var dataWriter = new Windows.Storage.Streams.DataWriter(stream)) { //dataWriter.dataWriter.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian; for (int y = 0; y < sizeOfMapTile; y++) { for (int x = 0; x < sizeOfMapTile; x++) { double lat, lon = 0.0; Microsoft.MapPoint.TileSystem.PixelXYToLatLong(pixeloffsetX + x, pixeloffsetY + y, levelOfDetail, out lat, out lon); BasicGeoposition point = new BasicGeoposition { Latitude = lat, Longitude = lon }; if (PathCache.pointInPolygon(point.Longitude, point.Latitude)) { // RGBA dataWriter.WriteByte(ColorIn.R); dataWriter.WriteByte(ColorIn.G); dataWriter.WriteByte(ColorIn.B); dataWriter.WriteByte(ColorIn.A); } else { // RGBA dataWriter.WriteByte(ColorOut.R); dataWriter.WriteByte(ColorOut.G); dataWriter.WriteByte(ColorOut.B); dataWriter.WriteByte(ColorOut.A); } } } // Send the contents of the writer to the backing stream. await dataWriter.StoreAsync(); // For the in-memory stream implementation we are using, the flushAsync call // is superfluous,but other types of streams may require it. await dataWriter.FlushAsync(); // In order to prolong the lifetime of the stream, detach it from the // DataWriter so that it will not be closed when Dispose() is called on // dataWriter. Were we to fail to detach the stream, the call to // dataWriter.Dispose() would close the underlying stream, preventing // its subsequent use by the DataReader below. dataWriter.DetachStream(); } }
/// <summary> /// Send a message to the server. /// This message is specified in the JsonObject message. /// The byteorder of the send message is LittleEndian and the encoding is Utf8. /// </summary> /// <param name="message">The message to be send.</param> /// <returns>A boolean that indicates that the message was succesfully send.</returns> public async Task <bool> SendMessage(JsonObject message) { //Check if the connector is connected. If not, call the Connect() function. if (!isConnected) { await Connect(); } //Write the message to the server. //Code used from https://docs.microsoft.com/en-us/uwp/api/windows.storage.streams.datawriter try { using (var dataWriter = new Windows.Storage.Streams.DataWriter(socket.OutputStream)) { dataWriter.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; dataWriter.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian; // Parse the input stream and write each element separately. //Get the string version of the json object. var stringToSend = message.ToString(); //Get the length of the stream, so the server knows how much data was send. uint inputElementSize = dataWriter.MeasureString(stringToSend); dataWriter.WriteUInt32(inputElementSize); dataWriter.WriteString(stringToSend); Debug.WriteLine("Wrote" + stringToSend); Debug.WriteLine("Lenght:" + inputElementSize); // Send the contents of the writer to the backing stream. await dataWriter.StoreAsync(); // For the in-memory stream implementation we are using, the flushAsync call // is superfluous,but other types of streams may require it. await dataWriter.FlushAsync(); // In order to prolong the lifetime of the stream, detach it from the // DataWriter so that it will not be closed when Dispose() is called on // dataWriter. Were we to fail to detach the stream, the call to // dataWriter.Dispose() would close the underlying stream, preventing // its subsequent use by the DataReader below. dataWriter.DetachStream(); return(true); } } catch { //TODO on error? throw; } }
public async void WriteToSocketUsingReader(IBuffer buffer) { using (var dataWriter = new Windows.Storage.Streams.DataWriter(socket.OutputStream)) { dataWriter.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian; dataWriter.WriteUInt32(buffer.Length); dataWriter.WriteBuffer(buffer); await dataWriter.StoreAsync(); await dataWriter.FlushAsync(); dataWriter.DetachStream(); } }
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(); } }
private async Task<IRandomAccessStream> ConvertToRandomAccessStream(byte[] bytes) { var randomAccessStream = new InMemoryRandomAccessStream(); using (var writer = new DataWriter(randomAccessStream)) { writer.WriteBytes(bytes); await writer.StoreAsync(); await writer.FlushAsync(); writer.DetachStream(); writer.Dispose(); } randomAccessStream.Seek(0); return randomAccessStream; }
protected override async void OnResponse(object sender, XmlRpcResponseEventArgs e) { string fname = string.Format("{0}/{1}-{2:0000}-response-{3}.xml", _directory, DateTime.Now.Ticks, e.RequestNum, e.ProxyID); var file = await Directory.CreateFileAsync(fname, CreationCollisionOption.ReplaceExisting); using (var str = await file.OpenAsync(FileAccessMode.ReadWrite)) { using (var dw = new DataWriter(str)) { await e.ResponseStream.CopyToAsync(str.AsStreamForWrite()); await dw.FlushAsync(); dw.DetachStream(); } } }
private async void SendButton_Click(object sender, RoutedEventArgs e) { try { DataWriter writer = new DataWriter(connectedSocket.OutputStream); writer.WriteBytes(Encoding.UTF8.GetBytes(SendMessageTextBox.Text)); await writer.StoreAsync(); writer.DetachStream(); writer.Dispose(); } catch(Exception exception) { rootPage.NotifyUser(exception.Message, NotifyType.ErrorMessage); } }
public async Task Send(byte[] command) { using (var socket = new DatagramSocket()) { using (var stream = await socket.GetOutputStreamAsync(this.hostName, this.port)) { using (var dataWriter = new DataWriter(stream)) { dataWriter.WriteBytes(command); await dataWriter.StoreAsync(); dataWriter.DetachStream(); } } } }
private async void send_data(string dataToSend) { Debug.Log("sending message: " + dataToSend); using (var dataWriter = new Windows.Storage.Streams.DataWriter(streamSocket.OutputStream)){ dataWriter.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; dataWriter.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian; dataWriter.WriteString(dataToSend); await dataWriter.StoreAsync(); await dataWriter.FlushAsync(); dataWriter.DetachStream(); } Debug.Log("message sent"); }
/// <summary> /// Sets source of the BitmapImage to specified byte array. /// </summary> public static async Task SetSourceAsync(this BitmapImage image, byte[] data) { using (var stream = new InMemoryRandomAccessStream()) { using (var writer = new DataWriter(stream)) { writer.WriteBytes(data); await writer.StoreAsync(); await writer.FlushAsync(); writer.DetachStream(); } stream.Seek(0); await image.SetSourceAsync(stream); } }
public static async Task Write(this IStorageFile file, byte[] content) { using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite)) { using (var outputStream = fileStream.GetOutputStreamAt(0)) { using (var dataWriter = new DataWriter(outputStream)) { dataWriter.WriteBytes(content); await dataWriter.StoreAsync(); dataWriter.DetachStream(); } await outputStream.FlushAsync(); } } }
public static async Task SaveToFileAsync(this byte[] byteArray, StorageFile file) { ThrowIf.Null(byteArray, "byteArray"); ThrowIf.Null(file, "file"); using (var filestream = await file.OpenAsync(FileAccessMode.ReadWrite)) { using (var writer = new DataWriter(filestream.GetOutputStreamAt(0))) { writer.WriteBytes(byteArray); await writer.StoreAsync(); writer.DetachStream(); } await filestream.FlushAsync(); } }
public static async void SaveToStorage() { StorageFolder roamingFolder = ApplicationData.Current.RoamingFolder; StorageFile roamingFile = await roamingFolder.CreateFileAsync("apis.json", CreationCollisionOption.ReplaceExisting); using (IRandomAccessStream textStream = await roamingFile.OpenAsync(FileAccessMode.ReadWrite)) { using (DataWriter textWriter = new DataWriter(textStream)) { foreach (ApiEntry api in APIs) { textWriter.WriteString(api.ToJSON().ToString()); textWriter.WriteString("\n"); await textWriter.StoreAsync(); } textWriter.DetachStream(); } } }
// http://www.chrispeerman.info/loading-images-from-byte-arrays-in-windows-8-store-apps-winrt/ /// <summary> /// Creates new BitmapImage from specified byte array. /// </summary> public static async Task<BitmapImage> FromByteArrayAsync(byte[] data) { using (var stream = new InMemoryRandomAccessStream()) { using (var writer = new DataWriter(stream)) { writer.WriteBytes(data); await writer.StoreAsync(); await writer.FlushAsync(); writer.DetachStream(); } stream.Seek(0); var bitmap = new BitmapImage(); await bitmap.SetSourceAsync(stream); return bitmap; } }
public static async Task WriteFile(string filename, string contents) { var localFolder = Windows.Storage.ApplicationData.Current.LocalFolder; var folder = await localFolder.CreateFolderAsync("DataCache", Windows.Storage.CreationCollisionOption.OpenIfExists); var file = await folder.CreateFileAsync(filename, Windows.Storage.CreationCollisionOption.ReplaceExisting); var fs = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite); fs.Seek(fs.Size); var outStream = fs.GetOutputStreamAt(0); var dataWriter = new Windows.Storage.Streams.DataWriter(outStream); dataWriter.WriteString(contents); await dataWriter.StoreAsync(); dataWriter.DetachStream(); await outStream.FlushAsync(); }
public async void SaveASync(T Obj, string FileName) { FileName = FileName + ".xml"; try { if (Obj != null) { StorageFile file = null; StorageFolder folder = GetFolder(storageType); file = await folder.CreateFileAsync(FileName, CreationCollisionOption.ReplaceExisting); DataContractJsonSerializer ser = new DataContractJsonSerializer(Obj.GetType()); MemoryStream ms = new MemoryStream(); ser.WriteObject(ms, Obj); var bytes = ms.ToArray(); var contents = UTF8Encoding.UTF8.GetString(bytes, 0, bytes.Length); using (var writeStream = await file.OpenAsync(FileAccessMode.ReadWrite)) { //Stream outStream = Task.Run(() => writeStream.AsStreamForWrite()).Result; //serializer.Serialize(outStream, Obj); using (var outStream = writeStream.GetOutputStreamAt(0)) { using (var dataWriter = new Windows.Storage.Streams.DataWriter(outStream)) { dataWriter.WriteString(contents); await dataWriter.StoreAsync(); dataWriter.DetachStream(); await outStream.FlushAsync(); } } } } } catch (Exception) { throw; } }
public static async Task<BitmapImage> ConvertToBitmapImageAsync(this byte[] byteArray) { ThrowIf.Null(byteArray, "byteArray"); using (var stream = new InMemoryRandomAccessStream()) { using (var writer = new DataWriter(stream.GetOutputStreamAt(0))) { writer.WriteBytes(byteArray); await writer.StoreAsync(); writer.DetachStream(); } BitmapImage image = null; // NOTE: ~HUGE HACK~ BitmapImage can only be created/manipulated on UI thread :( await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync( CoreDispatcherPriority.Normal, () => { image = new BitmapImage(); image.SetSource(stream); }); return image; /*Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.Invoke(Windows.UI.Core.CoreDispatcherPriority.Normal, (s, a) => { if (_image == null) { IRandomAccessStream imageStream = await _imageFile.OpenAsync(FileAccessMode.Read); _image = new BitmapImage(); _image.DecodePixelHeight = _decodeHeight; _image.SetSource(imageStream); } }, null, null); return _image;*/ /* var image = new BitmapImage(); await image.SetSourceAsync(stream); return image;*/ } }
/// <summary> /// Writes text to the specified file. /// </summary> /// <param name="file">The file that the text is written to.</param> /// <param name="contents">The text to write.</param> public static async Task WriteTextAsync(IStorageFile file, string contents) { using (var fs = await file.OpenAsync(FileAccessMode.ReadWrite)) { using (var outStream = fs.GetOutputStreamAt(0)) { using (var dataWriter = new DataWriter(outStream)) { if (contents != null) { dataWriter.WriteString(contents); } await dataWriter.StoreAsync(); dataWriter.DetachStream(); } await outStream.FlushAsync(); } } }
public async void WriteString(string HostName, string Message) { HostName remoteHostName = new HostName(HostName); using (StreamSocket socket = new StreamSocket()) { socket.Control.KeepAlive = false; await socket.ConnectAsync(remoteHostName, "6"); using (DataWriter writer = new DataWriter(socket.OutputStream)) { // set payload length writer.ByteOrder = ByteOrder.LittleEndian; writer.WriteUInt32(writer.MeasureString(Message)); // set payload type writer.WriteByte((byte)PayloadType.String); // set payload writer.WriteString(Message); // transmit await writer.StoreAsync(); writer.DetachStream(); } using (DataReader reader = new DataReader(socket.InputStream)) { int length; string response; // receive payload length reader.ByteOrder = ByteOrder.LittleEndian; await reader.LoadAsync(4); length = reader.ReadInt32(); // receive payload await reader.LoadAsync((uint)length); response = reader.ReadString((uint)length); Debug.WriteLine(string.Format("response: {0}", response)); reader.DetachStream(); } } }
public async Task SaveFlickrPhotoToPictureLibraryAsync(FlickrPhoto photo) { using (var client = new HttpClient()) { var image = await client.GetByteArrayAsync(photo.LargeImageUrl); var localFile = await KnownFolders.PicturesLibrary.CreateFileAsync(GetFilenameFromUrl(photo.LargeImageUrl), CreationCollisionOption.GenerateUniqueName); using (var fileStream = await localFile.OpenAsync(FileAccessMode.ReadWrite)) { using (var writeStream = fileStream.GetOutputStreamAt(0)) { using (var writer = new DataWriter(writeStream)) { writer.WriteBytes(image); await writer.StoreAsync(); writer.DetachStream(); } await writeStream.FlushAsync(); } } } }
public async void sendMail(string strSendTo,string strContent , Boolean hasPicture) { HostName hostName = new HostName(hostIP); StreamSocket socket = new StreamSocket(); List<string[]> storeList = new List<string[]>(); try { await socket.ConnectAsync(hostName, port); } catch (Exception exception) { if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown) { throw; } } StorageFolder folder = await ApplicationData.Current.LocalFolder.GetFolderAsync("Temp"); StorageFile pic = await folder.GetFileAsync("MyPainter.png"); IBuffer buffer = await FileIO.ReadBufferAsync(pic); DataWriter writer = new DataWriter(socket.OutputStream); writer.WriteUInt32(writer.MeasureString(strSendTo)); writer.WriteString(strSendTo); writer.WriteUInt32(writer.MeasureString(strContent)); writer.WriteString(strContent); if (hasPicture) { writer.WriteUInt32((uint)buffer.Length); writer.WriteBuffer(buffer); } else { writer.WriteUInt32(0); writer.WriteString(""); } await writer.StoreAsync(); writer.DetachStream(); writer.Dispose(); socket.Dispose(); }
public async Task SendAsync(string msg) { if (IsConnected && !string.IsNullOrEmpty(msg)) { try { using (DataWriter writer = new DataWriter(socket.OutputStream)) { writer.WriteString(msg); await writer.StoreAsync(); writer.DetachStream(); } } catch (Exception ex) { //if (SocketError.GetStatus(ex.HResult) == SocketErrorStatus.Unknown) // throw; Disconnect(); } } }
public async Task Write(string key, Stream value) { var cacheFolder = await GetWorkingFolder(); var file = await cacheFolder.CreateFileAsync(key, CreationCollisionOption.ReplaceExisting); using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite)) { using (var outputStream = fileStream.GetOutputStreamAt(0)) { using (var dataWriter = new DataWriter(outputStream)) { var bytes = new byte[value.Length]; await value.ReadAsync(bytes, 0, (int)value.Length); dataWriter.WriteBytes(bytes); await dataWriter.StoreAsync(); dataWriter.DetachStream(); } await outputStream.FlushAsync(); } } }
private async Task <IRandomAccessStream> FixTextureContentType(IRandomAccessStream modelStream) { XDocument xmldoc = XDocument.Load(modelStream.AsStreamForRead()); var outputStream = new Windows.Storage.Streams.InMemoryRandomAccessStream(); var writer = new Windows.Storage.Streams.DataWriter(outputStream); writer.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; writer.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian; var text = xmldoc.ToString(); var replacedText = text.Replace("contenttype=\"\"", "contenttype=\"image/png\""); writer.WriteString(replacedText); await writer.StoreAsync(); await writer.FlushAsync(); writer.DetachStream(); return(outputStream); }