1 using System;
   2 using System.Windows.Input;
   3 
   4 namespace ChatClient
   5 {
   6     class DelegateCommand : ICommand
   7     {
   8         private readonly Predicate<object> _canExecute;
   9         private readonly Action<object> _execute;
  10 
  11         public event EventHandler CanExecuteChanged;
  12 
  13         public DelegateCommand(Action<object> execute, Predicate<object> canExecute)
  14         {
  15             _execute = execute;
  16             _canExecute = canExecute;
  17         }
  18 
  19         public bool CanExecute(object parameter)
  20         {
  21             return _canExecute == null || _canExecute(parameter);
  22         }
  23 
  24         public void Execute(object parameter)
  25         {
  26             _execute(parameter);
  27         }
  28 
  29         public void RaiseCanExecuteChanged()
  30         {
  31             if (CanExecuteChanged != null)
  32             {
  33                 CanExecuteChanged(this, EventArgs.Empty);
  34             }
  35         }
  36     }
  37 }

   1 using System.ComponentModel;
   2 using ChatClient.Models;
   3 
   4 namespace ChatClient.ViewModels
   5 {
   6     /// <summary>
   7     /// Adaptive code only. You should only see things here that adapt
   8     /// the Model to the view. This is an abstraction of the Model for 
   9     /// the express use by the View.
  10     /// </summary>
  11     class ClientViewModel : INotifyPropertyChanged
  12     {
  13         #region Properties
  14         //Elements bound to by the view
  15         public string Message {
  16             get { return _clientModel.CurrentMessage; }
  17             set
  18             {
  19                 _clientModel.CurrentMessage = value;
  20                 NotifyPropertyChanged("Message");
  21             }
  22         }
  23 
  24         public string MessageBoard 
  25         {
  26             get { return _clientModel.MessageBoard; }
  27             set
  28             {
  29                 _clientModel.MessageBoard = value;
  30                 NotifyPropertyChanged("MessageBoard");
  31             }
  32         }
  33     
  34         public DelegateCommand ConnectCommand { get; set; }
  35         public DelegateCommand SendCommand { get; set; }
  36         #endregion 
  37 
  38         #region Private and Internal Vars/Props
  39         private readonly ClientModel _clientModel;
  40         #endregion 
  41 
  42         /// <summary>
  43         /// Constructor creates the Model!
  44         /// </summary>
  45         public ClientViewModel()
  46         {
  47             //Create ourselves a model
  48             _clientModel = new ClientModel();
  49             //Subscribe to the Model's PropertyChanged event
  50             _clientModel.PropertyChanged += ClientModelChanged;
  51             //Create our two Command objects
  52             ConnectCommand = new DelegateCommand(
  53                 a => _clientModel.Connect(), 
  54                 b => !_clientModel.Connected
  55             );
  56             SendCommand = new DelegateCommand(
  57                 a => _clientModel.Send(),
  58                 b => _clientModel.Connected
  59             );
  60         }
  61 
  62         #region Event Listeners
  63         private void ClientModelChanged(object sender, PropertyChangedEventArgs e)
  64         {
  65             if (e.PropertyName.Equals("Connected"))
  66             {
  67                 NotifyPropertyChanged("Connected");
  68                 ConnectCommand.RaiseCanExecuteChanged();
  69                 SendCommand.RaiseCanExecuteChanged();
  70             }
  71             else if (e.PropertyName.Equals("MessageBoard"))
  72             {
  73                 NotifyPropertyChanged("MessageBoard");
  74             }
  75         }
  76         #endregion
  77 
  78         #region NPC Implementation
  79         public event PropertyChangedEventHandler PropertyChanged;
  80 
  81         private void NotifyPropertyChanged(string prop)
  82         {
  83             if (PropertyChanged != null)
  84             {
  85                 PropertyChanged(this, new PropertyChangedEventArgs(prop));
  86             }
  87         }
  88         #endregion NPC Implementation
  89     }
  90 }

   1 using System.ComponentModel;
   2 using System.Net.Sockets;
   3 using System.Text;
   4 using System.Threading;
   5 
   6 namespace ChatClient.Models
   7 {
   8     class ClientModel : INotifyPropertyChanged
   9     {
  10         private TcpClient _socket;
  11         private NetworkStream _stream;
  12 
  13         private string _messageBoard;
  14         public string MessageBoard {
  15             get { return _messageBoard; }
  16             set 
  17             {
  18                 _messageBoard = value;
  19                 NotifyPropertyChanged("MessageBoard");
  20             }
  21         }
  22         private string _currentMessage;
  23         public string CurrentMessage 
  24         {
  25             get {return _currentMessage;}
  26             set 
  27             {
  28                 _currentMessage = value;
  29                 NotifyPropertyChanged("CurrentMessage");
  30             }
  31         }
  32         private bool _connected;
  33 
  34         public ClientModel()
  35         {
  36             _connected = false;
  37         }
  38 
  39         public bool Connected { 
  40             get {return _connected; }
  41             set {
  42                 _connected = value;
  43                 NotifyPropertyChanged("Connected");
  44             }
  45         }
  46 
  47         public void Connect()
  48         {
  49             _socket = new TcpClient();
  50             _socket.Connect("127.0.0.1", 8888);
  51             _stream = _socket.GetStream();
  52             Connected = true;
  53             Send();
  54             _messageBoard = "Welcome: " + _currentMessage;
  55             var thread = new Thread(GetMessage);
  56             thread.Start();
  57         }
  58 
  59         public void Send()
  60         {
  61             WriteString(_currentMessage + "$");
  62         }
  63 
  64         private void GetMessage()
  65         {
  66             while (true)
  67             {
  68                 string msg = ReadString();
  69                 MessageBoard += "\r\n" + msg;
  70             }
  71         }
  72 
  73         private string ReadString()
  74         {
  75             var bytes = new byte[16384];
  76             _stream.Read(bytes, 0, _socket.ReceiveBufferSize);
  77             string msg = Encoding.ASCII.GetString(bytes);
  78             int index = msg.IndexOf("$") > 0 ? msg.IndexOf("$")
  79                 : msg.IndexOf('\0');
  80             return msg.Substring(0, index);
  81 
  82         }
  83 
  84         private void WriteString(string msg)
  85         {
  86             byte[] bytes = Encoding.ASCII.GetBytes(msg);
  87             _stream.Write(bytes, 0, bytes.Length);
  88             _stream.Flush();
  89         }
  90 
  91 
  92         #region NPC
  93         public event PropertyChangedEventHandler PropertyChanged;
  94 
  95         private void NotifyPropertyChanged(string prop)
  96         {
  97             if (PropertyChanged != null)
  98             {
  99                 PropertyChanged(this, new PropertyChangedEventArgs(prop));
 100             }
 101         }
 102         #endregion
 103     }
 104 }