MeasureString() public méthode

public MeasureString ( string value ) : uint
value string
Résultat uint
Exemple #1
0
        /// <summary>
        /// Send the message to the server
        /// </summary>
        /// <param name="type">KB or M</param>
        /// <param name="message">Single character or x,y</param>
        /// <param name="hold">0=default, 1=press, 2=release</param>
        public void send(string type, string message, int hold = 0)
        {
            try
            {
                //NetworkStream clientStream = client.GetStream();
                DataWriter writer = new DataWriter(client.OutputStream);

                
                //ASCIIEncoding encoder = new ASCIIEncoding();

                string buffer = type + ';' + message + ';' + hold + "\n";
                writer.WriteUInt32(writer.MeasureString(buffer));
                writer.WriteString(buffer);
                /*
                clientStream.Write(buffer, 0, buffer.Length);
                clientStream.Flush();
                 * */
                writer.WriteString(buffer);
            }
            catch
            {
                //Console.WriteLine("Connection Lost");
                startClient();
            }
        }
Exemple #2
0
 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();
 }
Exemple #3
0
 /// <summary>
 /// 连接并发送信息给对方
 /// </summary>
 /// <param name="peerInformation"></param>
 private async void ConnectToPeer(PeerInformation peer)
 {
     dataReader = new DataReader(socket.InputStream);
     dataWriter = new DataWriter(socket.OutputStream);
     string message = "测试消息";
     uint strLength = dataWriter.MeasureString(message);
     dataWriter.WriteUInt32(strLength);
     dataWriter.WriteString(message);
     uint numBytesWritten = await dataWriter.StoreAsync();
 }
Exemple #4
0
 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();
 }
Exemple #5
0
        /// <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;
            }
        }
 private async void Button_Click(object sender, RoutedEventArgs e)
 {
     string message = txtSend.Text;
     DataWriter writer = new DataWriter(socket.OutputStream);
     var length = writer.MeasureString(message);
     writer.WriteUInt32(length);
     //将字符串写入流中
     writer.WriteString(message);
     //向服务器发送数据
     await writer.StoreAsync();
     await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => {
         textList.Items.Add(message);
     });
 }
        async void streamSocketListener_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
        {
            int i = 0;
            DataReader dataReader = new DataReader(args.Socket.InputStream);
            DataWriter serverWriter = new DataWriter(args.Socket.OutputStream);
            try
            {
                while (true)
                {
                    uint sizeCount = await dataReader.LoadAsync(4);
                    uint length = dataReader.ReadUInt32();
                    uint contentLength = await dataReader.LoadAsync(length);
                    string msg = dataReader.ReadString(contentLength);
                    i++;
                    Deployment.Current.Dispatcher.BeginInvoke(() => msgList.Children.Add(
                        new TextBlock { Text = "服务器接收到的消息:" + msg }));
                    string serverStr = msg + "|" + i;
                    serverWriter.WriteUInt32(serverWriter.MeasureString(serverStr));
                    serverWriter.WriteString(serverStr);
                    try
                    {
                        await serverWriter.StoreAsync();
                    }
                    catch (Exception err)
                    {
                        if (SocketError.GetStatus(err.HResult) == SocketErrorStatus.AddressAlreadyInUse)
                        {

                        }
                    }
                }
            }
            catch (Exception err)
            {
                if (SocketError.GetStatus(err.HResult) == SocketErrorStatus.AddressAlreadyInUse)
                {

                }
            }
        }
Exemple #8
0
        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();
                }
            }
        }
Exemple #9
0
		public static async void SaveTo ( ObservableCollection<RecentData> datas )
		{
			StorageFile sf = await ApplicationData.Current.LocalFolder.CreateFileAsync ( "data.dat",
				Windows.Storage.CreationCollisionOption.ReplaceExisting );
			FileRandomAccessStream stream = await sf.OpenAsync ( FileAccessMode.ReadWrite ) as FileRandomAccessStream;
			DataWriter dw = new DataWriter ( stream );

			dw.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
			dw.ByteOrder = ByteOrder.LittleEndian;

			dw.WriteInt32 ( datas.Count );
			foreach ( RecentData data in datas )
			{
				dw.WriteUInt32 ( ( uint ) dw.MeasureString ( data.Source ) );
				dw.WriteString ( data.Source );
				dw.WriteInt32 ( data.SourceIndex );
				dw.WriteInt32 ( data.TargetIndex );
			}

			await dw.StoreAsync ();
			await dw.FlushAsync ();
			stream.Dispose ();
		}
        public async void Send(string s)
        {
            if (deviceService != null)
            {
                //send data
                string sendData = s;
                if (string.IsNullOrEmpty(sendData))
                {
                    //errorStatus.Visibility = Visibility.Visible;
                    errorStatusText = "Please specify the string you are going to send";
                    Debug.WriteLine("CommunicationChannelBT: " + errorStatusText);
                }
                else
                {
                    DataWriter dwriter = new DataWriter(streamSocket.OutputStream);
                    UInt32 len = dwriter.MeasureString(sendData);
                    dwriter.WriteUInt32(len);
                    dwriter.WriteString(sendData);
                    await dwriter.StoreAsync();
                    await dwriter.FlushAsync();
                }

            }
            else
            {
                //errorStatus.Visibility = Visibility.Visible;
                errorStatusText = "Bluetooth is not connected correctly!";
                Debug.WriteLine("CommunicationChannelBT: " + errorStatusText);
            }
        }
        private void btnAddIe_Click(object sender, RoutedEventArgs e)
        {
            if (_publisher == null)
            {
                _publisher = new WiFiDirectAdvertisementPublisher();
            }

            if (txtInformationElement.Text == "")
            {
                rootPage.NotifyUser("Please specifiy an IE", NotifyType.ErrorMessage);
                return;
            }

            WiFiDirectInformationElement IE = new WiFiDirectInformationElement();

            // IE blob
            DataWriter dataWriter = new DataWriter();
            dataWriter.UnicodeEncoding = UnicodeEncoding.Utf8;
            dataWriter.ByteOrder = ByteOrder.LittleEndian;
            dataWriter.WriteUInt32(dataWriter.MeasureString(txtInformationElement.Text));
            dataWriter.WriteString(txtInformationElement.Text);
            IE.Value = dataWriter.DetachBuffer();

            // OUI
            DataWriter dataWriterOUI = new DataWriter();
            dataWriterOUI.WriteBytes(Globals.CustomOui);
            IE.Oui = dataWriterOUI.DetachBuffer();

            // OUI Type
            IE.OuiType = Globals.CustomOuiType;

            _publisher.Advertisement.InformationElements.Add(IE);
            txtInformationElement.Text = "";

            rootPage.NotifyUser("IE added successfully", NotifyType.StatusMessage);
        }
        private async Task sendMessage(string message)
        {
            if (_streamsocket == null)
            {
                this.textboxDebug.Text += "No connection found\n";
                return;
            }
            DataWriter datawritter = new DataWriter(_streamsocket.OutputStream);

            // cấu trúc dữ liệu gởi đi gồm 
            // [độ dài chuỗi]_[chuỗi]
            // có độ dài chuỗi đễ dễ đọc.   

            // Ghi độ dài chuỗi
            datawritter.WriteUInt32(datawritter.MeasureString(message));

            // Ghi chuỗi
            datawritter.WriteString(message);
            try
            {
                // Gửi Socket đi 
                await datawritter.StoreAsync();

                // Xuất thông tin ra màn hình bằng textbox
                this.textboxDebug.Text += "Send from " + _streamsocket.Information.LocalAddress + ": " + message + "\n";
            }
            catch (Exception ex)
            {
                this.textboxDebug.Text += ex.Message + "\n";
            }
        }
        private async void send_Click(object sender, RoutedEventArgs e)
        {
            j++;
            serverWriter = new DataWriter(socket.OutputStream);
            string serverStr = "cilent test "+j ;
            serverWriter.WriteUInt32(serverWriter.MeasureString(serverStr));
            serverWriter.WriteString(serverStr);
            try
            {
                await serverWriter.StoreAsync();
                msgList.Children.Add(
                    new TextBlock { Text = "客户端发送的消息:" + serverStr });
            }
            catch (Exception err)
            {
                if (SocketError.GetStatus(err.HResult) == SocketErrorStatus.AddressAlreadyInUse)
                {

                }
            }
        }
        private async Task sendMessage(string message)
        {
            if (datagramSocket == null)
            {
                this.OutputTextblock.Text += "No connection found\n";
                return;
            }
            var outputstream = await datagramSocket.GetOutputStreamAsync(datagramSocket.Information.RemoteAddress, datagramSocket.Information.RemotePort);

            DataWriter datawritter = new DataWriter(outputstream);

            datawritter.WriteUInt32(datawritter.MeasureString(message));

            // Ghi chuỗi
            datawritter.WriteString(message);
            try
            {
                // Gửi Socket đi 
                await datawritter.StoreAsync();
                
                // Xuất thông tin ra màn hình bằng textbox
                this.OutputTextblock.Text += "Send from " + datagramSocket.Information.LocalAddress + ": " + message + "\n";
            }
            catch (Exception ex)
            {
                this.OutputTextblock.Text += ex.Message + "\n";
            }

        }
Exemple #15
0
 // Отправка сообщения
 async private void SendMessage(StreamSocket socket, string message)
 {
     var writer = new DataWriter(socket.OutputStream);
     var len = writer.MeasureString(message); // Gets the UTF-8 string length.
     writer.WriteInt32((int)len);
     writer.WriteString(message);
     var ret = await writer.StoreAsync();
     writer.DetachStream();
 }
Exemple #16
0
        private async Task Send(IOutputStream outputStream, string message)
        {
            DataWriter writer = new DataWriter(outputStream);

            // This is useless in this sample. Just a friendly remainder.
            uint messageLength = writer.MeasureString(message);

            writer.WriteString(message);
            uint bytesWritten = await writer.StoreAsync();

            Debug.Assert(bytesWritten == messageLength);

            // Do not use Dispose(). If used, streams cannot be used anymore.
            //writer.Dispose();

            // Without this, the DataReader destructor will close the stream, and closing the
            // stream might set the FIN control bit.
            writer.DetachStream();
        }
Exemple #17
0
        private async Task InternalSendMessage(Command cmd, DataWriter writer)
        {
            if(cmd == null)
            {
                return;
            }

            if(cmd.Program == GlowPrograms.None)
            {
                throw new Exception("The program can't be none!");
            }

            // Serialize the cmd
            string cmdJson = Newtonsoft.Json.JsonConvert.SerializeObject(cmd);
            UInt32 stringSize = writer.MeasureString(cmdJson);
            writer.WriteUInt32(stringSize);
            writer.WriteString(cmdJson);
            await writer.StoreAsync();
        }
        private void btnAddIe_Click(object sender, RoutedEventArgs e)
        {
            WiFiDirectInformationElement informationElement = new WiFiDirectInformationElement();

            // Information element blob
            DataWriter dataWriter = new DataWriter();
            dataWriter.UnicodeEncoding = UnicodeEncoding.Utf8;
            dataWriter.ByteOrder = ByteOrder.LittleEndian;
            dataWriter.WriteUInt32(dataWriter.MeasureString(txtInformationElement.Text));
            dataWriter.WriteString(txtInformationElement.Text);
            informationElement.Value = dataWriter.DetachBuffer();

            // Organizational unit identifier (OUI)
            informationElement.Oui = CryptographicBuffer.CreateFromByteArray(Globals.CustomOui);

            // OUI Type
            informationElement.OuiType = Globals.CustomOuiType;

            // Save this information element so we can add it when we advertise.
            _informationElements.Add(informationElement);

            txtInformationElement.Text = "";
            rootPage.NotifyUser("IE added successfully", NotifyType.StatusMessage);
        }
Exemple #19
0
        public async void ConnectAsync(string host, string name)
        {
            HostName hostName;
            try
            {
                hostName = new HostName(host);
            }
            catch (ArgumentException)
            {
                Debug.WriteLine("Error: Invalid host name {0}.", host);
                return;
            }

            _socket = new StreamSocket();
            _socket.Control.KeepAlive = true;
            _socket.Control.QualityOfService = SocketQualityOfService.LowLatency;

            //hard coded port - can be user-specified but to keep this sample simple it is 21121
            await _socket.ConnectAsync(hostName, "21121");
            Debug.WriteLine("Connected");

            //first message to send is the name of this virtual speaker
            _writer = new DataWriter(_socket.OutputStream);
            _writer.WriteUInt32(_writer.MeasureString(name));
            _writer.WriteString(name);

            try
            {
                await _writer.StoreAsync();
                Debug.WriteLine("{0} registered successfully.", name);
            }
            catch (Exception exception)
            {
                Debug.WriteLine("Send failed with error: " + exception.Message);
                // If this is an unknown status it means that the error if fatal and retry will likely fail.
                if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown)
                {
                    throw;
                }
            }

            //set no current message type
            MessageType currentMessageType = MessageType.Unknown;
            // then wait for the audio to be sent to us 
            DataReader reader = new DataReader(_socket.InputStream);

            while (true)
            {
                uint x = await reader.LoadAsync(sizeof(short));
                short t = reader.ReadInt16();
                currentMessageType = (MessageType)t;

                switch (currentMessageType)
                {
                    case MessageType.Media:
                        await ReadMediaFileAsync(reader);
                        break;
                    case MessageType.Play:
                        {
                            MediaPlayer mediaPlayer = BackgroundMediaPlayer.Current;
                            if (mediaPlayer != null)
                            {
                                if (mediaPlayer.CurrentState != MediaPlayerState.Playing)
                                {
                                    mediaPlayer.SetStreamSource(_playingStream);
                                    mediaPlayer.Play();
                                    Debug.WriteLine("Player playing. TotalDuration = " +
                                        mediaPlayer.NaturalDuration.Minutes + ':' + mediaPlayer.NaturalDuration.Seconds);
                                }
                            }
                        }
                        break;
                    case MessageType.Stop:
                        {
                            MediaPlayer mediaPlayer = BackgroundMediaPlayer.Current;
                            if (mediaPlayer != null)
                            {
                                if (mediaPlayer.CurrentState == MediaPlayerState.Playing)
                                {
                                    mediaPlayer.Pause();
                                    Debug.WriteLine("Player paused");
                                }
                            }
                        }
                        break;
                    default:
                        break;
                }
                currentMessageType = MessageType.Unknown;
            }
        }
 private async Task Send(IOutputStream outputStream, string message)
 {
     DataWriter writer = new DataWriter(outputStream);
     uint messageLength = writer.MeasureString(message);
     writer.WriteString(message);
     uint bytesWritten = await writer.StoreAsync();
     writer.DetachStream();
 }
 public async void SendData(string message)
 {
     if (_streamSocket == null || string.IsNullOrEmpty(message))
     {
         return;
     }
     try
     {
         DataWriter dwriter = new DataWriter(_streamSocket.OutputStream);
         UInt32 len = dwriter.MeasureString(message);
         dwriter.WriteUInt32(len);
         dwriter.WriteString(message);
         await dwriter.StoreAsync();
         await dwriter.FlushAsync();
     }
     catch (Exception ex)
     {
         if (ObexErrorCallback != null)
         {
             ObexErrorCallback("Sending data from Bluetooth encountered error!" + ex.Message);
         }
     }
 }
Exemple #22
0
        //
        // UDP send.
        //

        private async void UdpSend_Click_1(object sender, RoutedEventArgs e)
        {
            DatagramSocket sendSocket = new DatagramSocket();

            // Even when we do not except any response, this handler is called if any error occurrs.
            sendSocket.MessageReceived += OnMessageReceived;

            try
            {
                await sendSocket.ConnectAsync(new HostName("foohost"), "2704");
                // DatagramSocket.ConnectAsync() vs DatagramSocket.GetOutputStreamAsync()?
                // Use DatagramSocket.GetOutputStreamAsync() if datagrams are sent to multiple
                // GetOutputStreamAsync() does DNS resolution first.
                // If remote host does not exist, "No such host is known. (Exception from HRESULT: 0x80072AF9)"
                // exception is thrown.
                // If remote host is not listening on the specified host, "An existing connection was forcibly
                // closed by the remote host. (Exception from HRESULT: 0x80072746)" exception is thrown.

                string message = "¡Hello, I am the new guy in the network!";
                DataWriter writer = new DataWriter(sendSocket.OutputStream);

                // This is useless in this sample. Just a friendly remainder.
                uint messageLength = writer.MeasureString(message);

                writer.WriteString(message);

                uint bytesWritten = await writer.StoreAsync();

                Debug.Assert(bytesWritten == messageLength);

                DisplayOutput(UdpSendOutput, "Message sent: " + message);
            }
            catch (Exception ex)
            {
                DisplayOutput(UdpSendOutput, ex.ToString());
            }
        }
        private async void Button_Click(object sender, RoutedEventArgs e)
        {
            if (!connected)
            {
                StatusText.Text = "Must be connected to send!";
                return;
            }

           // Int32 len = 0; // Gets the UTF-8 string length.

            try
            {
                OutputView.Text = "";
                StatusText.Text = "Trying to send data ...";

                // add a newline to the text to send
                string sendData = SendText.Text + Environment.NewLine;
                DataWriter writer = new DataWriter(_clientSocket.OutputStream);
               UInt32 len = writer.MeasureString(sendData); // Gets the UTF-8 string length.
               writer.WriteString("123");
               //byte[] buffer = Encoding.ASCII.GetBytes(textBox.Text);
               //_clientSocket.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(SendCallback), null);

                // Call StoreAsync method to store the data to a backing stream
                await writer.StoreAsync();

                StatusText.Text = "Data was sent" + Environment.NewLine;

                // detach the stream and close it
                writer.DetachStream();
                writer.Dispose();

            }
            catch (Exception exception)
            {
                // If this is an unknown status, 
                // it means that the error is fatal and retry will likely fail.
                if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown)
                {
                    throw;
                }

                StatusText.Text = "Send data or receive failed with error: " + exception.Message;
                // Could retry the connection, but for this simple example
                // just close the socket.

                closing = true;
                _clientSocket.Dispose();
                _clientSocket = null;
                connected = false;

            }

            // Now try to receive data from server
            try
            {
                OutputView.Text = "";
                StatusText.Text = "Trying to receive data ...";

                DataReader reader = new DataReader(_clientSocket.InputStream);
                // Set inputstream options so that we don't have to know the data size
                reader.InputStreamOptions = Partial;
                await reader.LoadAsync(reader.UnconsumedBufferLength);

            }
            catch (Exception exception)
            {
                // If this is an unknown status, 
                // it means that the error is fatal and retry will likely fail.
                if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown)
                {
                    throw;
                }

                StatusText.Text = "Receive failed with error: " + exception.Message;
                // Could retry, but for this simple example
                // just close the socket.

                closing = true;
                _clientSocket.Dispose();
                _clientSocket = null;
                connected = false;

            }    
        }
        private static async Task Send(StreamSocket socket, object data)
        {
            if (socket != null)
            {
                using (var writer = new DataWriter(socket.OutputStream))
                {
                    var str = Transport.Serialize(data);
                    writer.WriteUInt32(writer.MeasureString(str));
                    writer.WriteString(str);

                    try
                    {
                        await writer.StoreAsync();
                        //await writer.FlushAsync();
                    }
                    catch (Exception exception)
                    {
                        // If this is an unknown status it means that the error if fatal and retry will likely fail.
                        if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown)
                        {
                            throw;
                        }
                    }

                    writer.DetachStream();
                }

                await socket.CancelIOAsync();
                socket.Dispose();
            }
        }
        //Envoi de la commande socket
        public async Task Send(string message)
        {
            DataWriter writer;

            // Create the data writer object backed by the in-memory stream. 
            using (writer = new DataWriter(socket.OutputStream))
            {
                // Set the Unicode character encoding for the output stream
                writer.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
                // Specify the byte order of a stream.
                writer.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian;

                // Gets the size of UTF-8 string.
                writer.MeasureString(message);
                // Write a string value to the output stream.
                writer.WriteString(message);

                // Send the contents of the writer to the backing stream.
                try
                {
                    await writer.StoreAsync();
                }
                catch (Exception exception)
                {
                    switch (SocketError.GetStatus(exception.HResult))
                    {
                        case SocketErrorStatus.HostNotFound:
                            // Handle HostNotFound Error
                            throw;
                        default:
                            // If this is an unknown status it means that the error is fatal and retry will likely fail.
                            throw;
                    }
                }

                await writer.FlushAsync();
                // In order to prolong the lifetime of the stream, detach it from the DataWriter
                writer.DetachStream();
            }

        }
Exemple #26
0
      private async void ChangeLedState(int ledNum, State state)
      {
         using (StreamSocket socket = new StreamSocket())
         {
            HostName host = new HostName("192.168.1.196");
            try
            {
               await socket.ConnectAsync(host, "5656");

               using (DataWriter writer = new DataWriter(socket.OutputStream))
               {
                  string stringToSend = String.Format("{0}, {1}", ledNum, state);
                  writer.WriteUInt32(writer.MeasureString(stringToSend));
                  writer.WriteString(stringToSend);
                  await writer.StoreAsync();
               }
            }
            catch (Exception exception)
            {
               // If this is an unknown status it means that the error if fatal and retry will likely fail.
               if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown)
               {
                  throw;
               }
            }
         }
      }
        private async void SendData_Click(object sender, RoutedEventArgs e)
        {
            if (deviceService != null)
            {   
                //send data
                string sendData = messagesent.Text;
                if (string.IsNullOrEmpty(sendData))
                {
                    errorStatus.Visibility = Visibility.Visible;
                    errorStatus.Text = "Please specify the string you are going to send";
                }
                else
                {
                    DataWriter dwriter = new DataWriter(streamSocket.OutputStream);
                    UInt32 len = dwriter.MeasureString(sendData);
                    dwriter.WriteUInt32(len);
                    dwriter.WriteString(sendData);
                    await dwriter.StoreAsync();
                    await dwriter.FlushAsync();
                }

            }
            else
            {
                errorStatus.Visibility = Visibility.Visible;
                errorStatus.Text = "Bluetooth is not connected correctly!";
            }
       
        }