|
Size: 4174
Comment:
|
Size: 4170
Comment:
|
| Deletions are marked like this. | Additions are marked like this. |
| Line 7: | Line 7: |
| {{{ #!csharp |
{{{#!java |
Chat Server and WPF Client
Client
For the client code I used WPF and the MVVM pattern. From the bottom up the first thing I used is a DelegateCommand for the ICommands needed for buttons and what not. This makes the ICommand thing almost easy.
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 }
You can see this in the ViewModel used below:
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 }