private async Task <string> SendImage()
        {
            var options = new ChannelOptions
            {
                Logger       = NullLogger.Instance,
                ReadAsDemand = true
            };

            Microsoft.Win32.OpenFileDialog openFileDialog = new Microsoft.Win32.OpenFileDialog();
            openFileDialog.Title            = "选择文件";
            openFileDialog.Filter           = "jpg|*.jpg|jpeg|*.jpeg";
            openFileDialog.FileName         = string.Empty;
            openFileDialog.FilterIndex      = 1;
            openFileDialog.RestoreDirectory = true;
            openFileDialog.DefaultExt       = "jpg";
            bool?result = openFileDialog.ShowDialog();

            if (result != true)
            {
                return(null);
            }
            string fileName = openFileDialog.FileName;

            var buffer = ImageHelper.ImageToBytes(fileName);

            ChatArea.Children.Add(new SendControl(new TcpPackage()
            {
                LocalName  = TbUserName.Text,
                RemoteName = LbChatWith.Content.ToString()
            }, ImageHelper.BytesToBitmapImage(buffer)));
            Scr.ScrollToEnd();

            #region 发送接收确认码, 再创建UDP进行通信, 比较麻烦, 预留, 重写
            // 发送确认码, 并接收确认


            //while (packages.Length() > 0)
            //{
            //    var data = await packages.DequeueAsync();
            //    await _sendUdpImageClient.SendAsync(data, data.Length);
            //}

            //await _sendImageTcpClient.CloseAsync();
            //await _sendUdpImageClient.UdpClientCloseAsync();
            #endregion

            return(fileName);
        }
        private async Task SendMessage(string message)
        {
            var sendPackage = new TcpPackage()
            {
                OpCode      = LbChatWith.Content.Equals("All") ? OpCode.All : OpCode.Single,
                MessageType = MessageType.Text,
                LocalName   = TbUserName.Text,
                RemoteName  = LbChatWith.Content.ToString(),
                Message     = message
            };

            ChatArea.Children.Add(new SendControl(sendPackage, null));
            var msg = sendPackage.ToString();
            await _sendTcpClient.SendAsync(new ReadOnlyMemory <byte>(Encoding.UTF8.GetBytes(msg)));

            Scr.ScrollToEnd();
        }
Example #3
0
        private async Task Send(string message)
        {
            ////await _client.SendAsync(Encoding.UTF8.GetBytes(message + "\r\n"));
            //var data = new TextMessageModel
            //{
            //    LocalName = TbUserName.Text,
            //    TextMessage = message
            //};
            //// 向ChatArea中添加组件
            //WpChatArea.Children.Add(new SendControl(data));
            //CreateUdpClient();

            ////await _client.SendAsync(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(data) + "\r\n"));

            var sendPackage = new MessagePackage <TextMessageModel>()
            {
                OpCode      = LbCurrentChat.Content.Equals("All") ? OpCode.All : OpCode.Single,
                MessageType = MessageType.TextMessage,
                Message     = new TextMessageModel()
                {
                    LocalName   = TbUserName.Text,
                    RemoteName  = LbCurrentChat.Content.ToString(),
                    TextMessage = TbSendArea.Text
                }
            };

            WpChatArea.Children.Add(new SendControl(new TextMessageModel()
            {
                LocalName   = TbUserName.Text,
                RemoteName  = LbCurrentChat.Content.ToString(),
                TextMessage = TbSendArea.Text
            }));

            await _client.SendAsync(Encoding.UTF8.GetBytes(sendPackage.ToString()));

            Scr.ScrollToEnd();
        }
Example #4
0
        private async Task InitTcp()
        {
            var options = new ChannelOptions
            {
                Logger       = NullLogger.Instance,
                ReadAsDemand = true
            };

            _client = new EasyClient <TextPackageInfo>(new LinePipelineFilter(), options).AsClient();

            var connected = await _client.ConnectAsync(new IPEndPoint(IPAddress.Loopback, 8888));

            var connectPackage = new MessagePackage <TextMessageModel>()
            {
                OpCode      = OpCode.Connect,
                MessageType = MessageType.TextMessage,
                Message     = new TextMessageModel()
                {
                    LocalName  = TbUserName.Text,
                    RemoteName = "Server"
                }
            };
            await _client.SendAsync(
                new ReadOnlyMemory <byte>(Encoding.UTF8.GetBytes(connectPackage.ToString())));

            while (true)
            {
                var receivePackage =
                    JsonConvert.DeserializeObject <MessagePackage <TextMessageModel> >((await _client.ReceiveAsync()).Text);

                if (receivePackage.Message == null)
                {
                    continue;
                }
                switch (receivePackage.OpCode)
                {
                case OpCode.DisConnect:
                    MessageBox.Show(receivePackage.Message.TextMessage, receivePackage.Message.LocalName);
                    TbUserName.IsEnabled = true;
                    break;

                case OpCode.Connect:
                    LvOnlineList.Children.Clear();
                    var allItem = new UserItemsControl("All");
                    allItem.setRoteName = SetRoteName;
                    LvOnlineList.Children.Add(allItem);
                    foreach (var userClient in receivePackage.Clients)
                    {
                        var childItem = new UserItemsControl(userClient.Username);
                        childItem.setRoteName = SetRoteName;
                        LvOnlineList.Children.Add(childItem);
                    }

                    TbUserName.IsEnabled = false;
                    break;

                case OpCode.All:
                    this.LbCurrentChat.Content = receivePackage.Message.LocalName;
                    WpChatArea.Children.Add(new MessageControl(new TextMessageModel()
                    {
                        LocalName   = receivePackage.Message.LocalName,
                        TextMessage = receivePackage.Message.TextMessage
                    }));
                    break;

                case OpCode.Single:
                    LbCurrentChat.Content = receivePackage.Message.LocalName;
                    WpChatArea.Children.Add(new MessageControl(new TextMessageModel()
                    {
                        LocalName   = receivePackage.Message.LocalName,
                        TextMessage = receivePackage.Message.TextMessage
                    }));
                    break;
                }
                Scr.ScrollToEnd();

                if (connected)
                {
                    BdConnectState.Background = new SolidColorBrush(Colors.LimeGreen);
                    TbUserName.IsEnabled      = false;
                }
                else
                {
                    BdConnectState.Background = new SolidColorBrush(Colors.OrangeRed);
                    TbUserName.IsEnabled      = true;
                    break;
                }

                await Task.Delay(500);
            }

            //while (true)
            //{
            //    var package = await _client.ReceiveAsync();
            //    //if(package != null) SpChatArea.Text += "Receive:" + package.Text + Environment.NewLine;
            //    var data = JsonConvert.DeserializeObject<TextMessageModel>(package.Text);
            //    if (package != null)
            //    {
            //        WpChatArea.Children.Add(new MessageControl(new TextMessageModel()
            //        {
            //            LocalName = data.LocalName,
            //            TextMessage = data.TextMessage
            //        }));
            //    }
            //    await Task.Delay(500);
            //}
        }
        private async void InitTcpConnectAndReceive()
        {
            var options = new ChannelOptions
            {
                Logger       = NullLogger.Instance,
                ReadAsDemand = true
            };

            _sendTcpClient = new EasyClient <TextPackageInfo>(new LinePipelineFilter(), options).AsClient();

            _connected = await _sendTcpClient.ConnectAsync(new IPEndPoint(IPAddress.Loopback, 8888));

            var connectPackage = new TcpPackage()
            {
                OpCode      = OpCode.Connect,
                LocalName   = TbUserName.Text,
                RemoteName  = "Server",
                MessageType = MessageType.Text
            };

            await _sendTcpClient.SendAsync(
                new ReadOnlyMemory <byte>(Encoding.UTF8.GetBytes(connectPackage.ToString())));


            while (true)
            {
                var receivePackage = TcpPackage.JsonToPackage((await _sendTcpClient.ReceiveAsync()).Text);
                if (string.IsNullOrEmpty(receivePackage.Message))
                {
                    continue;
                }

                switch (receivePackage.OpCode)
                {
                case OpCode.Connect:
                    SpOnlineList.Children.Clear();
                    var allItem = new UserItemsControl("All");
                    allItem.setRoteName = SetRoteName;
                    SpOnlineList.Children.Add(allItem);
                    foreach (var onlineClient in receivePackage.Clients)
                    {
                        var childItem = new UserItemsControl(onlineClient.Username);
                        childItem.setRoteName = SetRoteName;
                        SpOnlineList.Children.Add(childItem);
                    }
                    TbUserName.IsEnabled       = false;
                    BtnConnectServer.IsEnabled = false;
                    break;

                case OpCode.DisConnect:
                    MessageBox.Show(receivePackage.Message, receivePackage.LocalName);
                    TbUserName.IsEnabled = true;
                    break;

                case OpCode.All:
                case OpCode.Single:
                    LbChatWith.Content = receivePackage.OpCode == OpCode.All
                            ? receivePackage.RemoteName : receivePackage.LocalName;
                    switch (receivePackage.MessageType)
                    {
                    case MessageType.Text:
                        ChatArea.Children.Add(new ReceiveControl(receivePackage, null));
                        break;

                    case MessageType.Image:
                        // 建立UDP客户端 直接接收消息
                        ReceiveImage(receivePackage: receivePackage);
                        break;

                    case MessageType.File:
                        var res = MessageBox.Show("是否接收文件?", "提示", MessageBoxButton.YesNo,
                                                  MessageBoxImage.Information);
                        if (res == MessageBoxResult.Yes)
                        {
                            // 发送TCP确认连接消息
                            // 创建UDP客户端
                        }
                        break;
                    }
                    break;

                case OpCode.Confirm:
                    switch (receivePackage.MessageType)
                    {
                    case MessageType.Image:
                        var fileName = await SendImage();

                        await Task.Delay(1000);
                        await SendImage(fileName, receivePackage);

                        break;

                    case MessageType.File:
                        break;
                    }
                    break;
                }

                Scr.ScrollToEnd();

                if (_connected)
                {
                    BdConnectState.Background = new SolidColorBrush(Colors.LimeGreen);
                    TbUserName.IsEnabled      = false;
                }
                else
                {
                    BdConnectState.Background = new SolidColorBrush(Colors.OrangeRed);
                    TbUserName.IsEnabled      = true;
                    break;
                }

                //await Task.Delay(1000);
            }
        }