Usando El Patrón de Diseño Observer Manual de Laboratori2

Usando el Patrón de Diseño

Observer Manual de

Laboratorio (Hands-On Lab) Personas que lo han encontrado útil: 3 de 11 - Valorar este tema

Por Joel Francia H.

Descargar Ejemplo de este artículo.

Contenido

1. Introducción - Utilizando el patrón Observer con Microsoft Visual Studio 2005

2. Definición 3. Ejercicio 1 – Creación de una aplicación simple utilizando los conceptos básicos del patrón

Observer

4. Creando la aplicación

5. Creando la interfaz

1. Introducción - Utilizando el patrón Observer con Microsoft Visual Studio

2005 Este laboratorio incluye los siguientes ejercicios y objetivos:

Al finalizar este laboratorio estarás en capacidad de:

o Aplicar los conceptos utilizados para la aplicación del patrón de diseño Observer e

identificar sus beneficios y funcionalidades.

Principio de la página

2. Definición

Define una depedencia del tipo uno a muchos entre objetos, de tal forma que cuando un objeto

cambia su estado, todos los objetos dependientes son notificados y actualizados automáticamente

(Ver Figura 1):

http://msdn.microsoft.com/es-es/library/bb972192.aspx#feedback

http://msdn.microsoft.com/es-es/library/bb972192.aspx#authorbrief

http://download.microsoft.com/download/6/b/b/6bbd93e3-15e9-42fc-b34c-961b2c79263c/MTJ_0007.zip

http://msdn.microsoft.com/es-es/library/bb972192.aspx#EEAA

http://msdn.microsoft.com/es-es/library/bb972192.aspx#EDAA

http://msdn.microsoft.com/es-es/library/bb972192.aspx#ECAA

http://msdn.microsoft.com/es-es/library/bb972192.aspx#ECAA

http://msdn.microsoft.com/es-es/library/bb972192.aspx#EBAA

http://msdn.microsoft.com/es-es/library/bb972192.aspx#EAAA

http://msdn.microsoft.com/es-es/library/bb972192.aspx#mainSection

http://msdn.microsoft.com/es-es/library/bb972192.aspx#figura01

Figura 1. Volver al texto.


3. Ejercicio 1 – Creación de una aplicación simple utilizando los conceptos

básicos del patrón Observer En este ejercicio se crearán 3 formularios, 2 de los cuales actuarán como observadores y

responderán a cambios realizados al tercero (sujeto).


4. Creando la aplicación 1. Ejecuta Microsoft Visual Studio 2005 y luego elige crear un nuevo proyecto. Para ello, ve al

menú File | New | Project. Luego escoge el tipo de proyecto Visual C# y la

plantilla Windows Application. Nómbralo PatronObserver, y acepta (Ver a Figura 2):

http://msdn.microsoft.com/es-es/library/bb972192.aspx#figura01back





2. Añade una nueva clase al proyecto. Para hacerlo, ve al Solution Explorer, ubicado en la

parte derecha de la pantalla, y haz clic derecho sobre el nombre del proyecto; luego, en el

menú, elige Add | Add New Item. Posteriormente, elige añadir una clase y

nómbrala Interfaces.cs o Interfaces.vb, según el lenguaje (Ver Figura 3):





5. Creando la interfaz 1. En la clase creada, especificaremos los dos tipos de interfaces a utilizar para la creación del

patrón Observer:

2. Luego, añadiremos dos formularios más al proyecto. Ve a la ventana Add New Item antes

mencionada y elige la plantilla Windows Form. Nombra los dos

formularios ListaObservador y ColorObservador (Ver Figura 4):





3. Ve al código del Form1 (doble clic sobre el respectivo formulario) y sitúate en la declaración

de la clase Form1. Para que este formulario actúe como un Sujeto que posteriormente dé

información a sus Observadores, es necesario que implementes la interfaz Sujeto antes

creada. Algo parecido se aplica a los otros dos forms (observadores). Para ello, modifica las

siguiente líneas de código:

4. Ve al diseño del form principal (Form1). Este contendrá un comboBox (cbxColor) que

permitirá elegir al usuario un conjunto de colores que luego serán reflejados en los otros

formularios. Inserta el control y ve a su Propiedad Items, luego añade la siguiente lista de

colores (Ver la Figura 5):




5. Dentro del código del formulario principal, introduce lo siguiente:

6. Vayamos ahora al diseño del formulario ListObserver. Este contendrá un listBox

(listaColores) el cual almacenará el nombre de los colores según se elijan en el formulario

principal (Ver Figura 6):


7. Programamos el siguiente código dentro del ListaObservador:

8. Por último, modificaremos el código del formulario ColorObservador, el cual modificará su

color de fondo cada vez que se elija un valor dentro del comboBox del form principal:

9. Crearemos la clase ColorDelegate que permitirá llamar al método del formulario principal

mediante un delegado:

10. Programa el evento SelectedValueChanged del comboBox cbColores en el formulario

principal de la siguiente manera:




11. Finalmente, ejecuta el programa. Notarás que los formularios ListaObservador y

ColorObservador cambiarán de acuerdo a lo ocurrido en el comboBox del formulario

principal.(Ver Figura 7):

Figura 7 . Volver al texto.

12. Visual C# .net

13. public interface Sujeto

14. {

15. void registrarInteres(Observador obs);

16. }

17.

18. public interface Observador

19. {

20. void enviarNotificacion(string mensaje);

}

Visual Basic .net

Public Interface Sujeto

Sub registrarInteres(ByVal obs As Observador)

End Interface

Public Interface Observador

Sub enviarNotificacion(ByVal mensaje As String)

End Interface

21. Luego, añadiremos dos formularios más al proyecto. Ve a la ventana Add New Item antes

mencionada y elige la plantilla Windows Form. Nombra los dos

formularios ListaObservador y ColorObservador (Ver Figura 4):



















40. Visual C# .net





41. public partial class Form1 : Form, Sujeto

42. public partial class ListaObservador : Form, Observador

public partial class ColorObservador : Form, Observador

Visual Basic .net

Public Class Form1

Implements Sujeto

Public Class ListaObservador

Implements Observador

Public Class ColorObservador

Implements Observador

























58. Visual C# .net

59. // coleccion de observadores

60. public List<Observador> observadores = new

61. List<Observador>();

62.




63. public Form1()

64. {

65. //hacemos que se muestren los formularios observadores

66. InitializeComponent();

67. ListObserver observadorLista = new ListObserver(this);

68. observadorLista.Show();

69. ColorObserver observadorColor = new ColorObserver(this);

70. observadorColor.Show();

71. }

72.

73. // implementación de la interfaz

74. public void registrarInteres(Observador obs)

75. {

76. // Agrega un objeto Observador a la colección

77. observadores.Add(obs);

78. }

79.

80. // Método que recorre la colección Observadores

81. //llamando a los enviarNotificacion() de cada observer

82.

83.

84. private void elegirColor(object sender, EventArgs e)

85. {

86. for (int i = 0; i < observadores.Count; i++)

87. {

88. Observador obs = (Observador)observadores[i];

89. obs.enviarNotificacion(cbxColor.Text);

90. }

}

Visual Basic .net

'coleccion de observadores

Public observadores As List<Observador>

'hacemos que se muestren los formularios observadores

Public Sub New()

Me.observadores = New List<Observador>

Me.components = Nothing

Me.InitializeComponent()

Dim observadorLista As New ListObserver(Me)

observadorLista.Show()

Dim observadorColor As New ColorObserver(Me)

observadorColor.Show()

End Sub

'Implementacion de la interface, añade un observador a la

'colección

Public Sub registrarInteres(ByVal obs As Observador) Implements

Sujeto.registrarInteres

Me.observadores.Add(obs)

End Sub

'Método que recorre la colección Observadores

'llamando a los enviarNotificacion() de cada observer

Private Sub elegirColor(ByVal sender As Object, ByVal e As

EventArgs)

Dim num As Integer

For num = 0 To Me.observadores.Count - 1

Dim obs As Observador =

CType(Me.observadores.Item(num), Observador)

obs.enviarNotificacion(cbxColor.Text)

Next num

End Sub
























100. Programa el evento SelectedValueChanged del comboBox cbColores en el

formulario principal de la siguiente manera:





102. Visual C# .net

103. // Se inscribe al formulario para que sea observador del sujeto

//al cual hemos pasado como argumento

104. public void registrar(Sujeto sujeto)

105. {

106. sujeto.registrarInteres(this);

107. }




108.

109. //Añade al listBox el color enviado por el sujeto y satisface a la

interfaz Observervador

110. public void enviarNotificacion(string mensaje)

111. {

112. listaColores.Items.Add(mensaje);

113. }

114.

115. public ListaObservervador(Sujeto subj)

116. {


118. registrar(subj);

}

Visual Basic .net

Public Sub New(ByVal subj As Sujeto)

InitializeComponent()

registrar(subj)

End Sub

'Se inscribe al formulario para que sea observador del sujeto al

'cual hemos pasado como

argumento

Public Sub registrar(ByVal sujeto As Sujeto)

sujeto.registrarInteres(Me)

End Sub

'Añade al listBox el color enviado por el sujeto y satisface a 'la

interfaz Observervador

Public Sub enviarNotificacion(ByVal mensaje As String) Implements

Observador.enviarNotificacion

Me.listaColores.Items.Add(mensaje)

End Sub

119. Por último, modificaremos el código del formulario ColorObservador, el cual

modificará su color de fondo cada vez que se elija un valor dentro del comboBox del form

principal:

120. Crearemos la clase ColorDelegate que permitirá llamar al método del formulario

principal mediante un delegado:








123. Visual C# .net

124. //Agregamos atributos a la clase

125. private Container componentes = null;

126. private System.Collections.Generic.Dictionary<string,Color>

127. colorFondo;

128. private string colNombre;

129.

130. public ColorObserver(Sujeto subj)

131. {


133. registrar(subj);

134. }

135.

136. //Se subscribe al sujeto e inicializa el Dictionary de colores

137. private void registrar(Sujeto sujeto)

138. {

139. sujeto.registrarInteres (this);

140. //crea el Dictionary conteniendo los colores

141. colorFondo = new Dictionary<string,Color>

142. colorFondo.Add("rojo", Color.Red );

143. colorFondo.Add ("azul", Color.Blue );

144. colorFondo.Add ("verde", Color.Green );

145. colorFondo.Add("amarillo", Color.Yellow);

146. colorFondo.Add("blanco", Color.White);

147. colNombre = "";

148. }

149.

150. //Modifica el color de fondo del formulario al recibir la

//notificación del sujeto y satisface la

151. interfaz Observervador

152. public void enviarNotificacion(string mensaje)

153. {

154. colNombre = mensaje;


155. mensaje = mensaje.ToLower ();

156. //Convierte el string de color a un objeto Color

157. Color col = (Color)colorFondo[mensaje];

158.

159. this.BackColor=col;

160.

161. //Cambia el título del form

162. this.Text=mensaje;

}

Visual Basic .net

Private colorFondo As New Dictionary(Of String, Color)

Private colNombre As String

Public Sub New(ByVal sujeto As Sujeto)

Me.InitializeComponent()

Me.registrar(sujeto)

End Sub

Private Sub init(ByVal sujeto As Sujeto)

sujeto.registrarInteres(Me)

Me.colorFondo = New Dictionary(Of String, Color)

Me.colorFondo.Add("rojo", Color.Red)

Me.colorFondo.Add("azul", Color.Blue)

Me.colorFondo.Add("verde", Color.Green)

Me.colorFondo.Add("amarillo", Color.Yellow)

Me.colorFondo.Add("blanco", Color.White)

Me.colNombre = ""

End Sub

Public Sub enviarNotificacion(ByVal mensaje As

String) Implements Observador.enviarNotificacion

Me.colNombre = mensaje

mensaje = mensaje.ToLower

Dim color1 As Color =

CType(Me.colorFondo.Item(mensaje), Color)

Me.BackColor = color1

Me.Text = mensaje

End Sub

163. Crearemos la clase ColorDelegate que permitirá llamar al método del formulario

principal mediante un delegado:








166. Visual C# .net

167. using System;

168. using System.Collections.Generic;

169. using System.Text;

170.

171. namespace PatronObserver

172. {

173. public class ColorDelegate

174. {

175.

176. public delegate void ColorDelegado();

177. public event ColorDelegado eleccionColor;

178.

179. public object elegirCambioColor

180. {

181. set

182. {

183. eleccionColor();

184. }

185. }

186. }

}

Visual Basic .net

Public Class ColorDelegate

Public Delegate Sub ColorDelegado()

Public Event eleccionColor()

Public Property elegirCambioColor() As Object

Set(ByVal value As Object)

RaiseEvent eleccionColor()

End Set


Get

Return Nothing

End Get

End Property

End Class







189. Visual C# .net

190. private void cbxColor_SelectedValueChanged(object

sender, EventArgs e)

191. {

192. //ejecutamos el método creado anteriormente mediante

el

193. delegado para notificar a todos los observadores del cambio

194. //sucedido en el comboBox

195.

196. ColorDelegate oEleccionColor = new ColorDelegate();

197. ColorDelegate.ColorDelegado oColorDelegado = new

198. ColorDelegate.ColorDelegado(elegirColor);

199. oEleccionColor.eleccionColor += oColorDelegado;

200. oEleccionColor.elegirCambioColor = sender;

201. oEleccionColor.eleccionColor -= oColorDelegado;

}

Visual Basic .net

Private Sub ComboBox1_SelectedValueChanged(ByVal sender As

System.Object, ByVal e As

System.EventArgs) Handles ComboBox1.SelectedValueChanged

//falta corregir el cambio en vb



End Sub





En la elaboración del material me apoyaron dos personas que tengo que mencionar: Jorge Enrique

Polo Martinez, (un alumno de la Universidad Ricardo Palma) y Aldo Gutierrez Tanabe (un alumno de

la Universidad San Ignacio de Loyola) ambos de Perú. Aldo ha llevado un curso de patrones que

dicto en la Universidad y también ha colaborado en la elaboración de otros cursos de patrones que

he dictado para empresas.

Joel Francia H. es Docente Universitario. Trabaja como Instructor, Consultor y Desarrollador de

aplicaciones .net. Cuenta con las certificaciones MCAD, MCSD, MCT, y es además MVP en C# .net y

expone regularmente en eventos técnicos y conferencias a nivel nacional. Su trabajo se centra

actualmente en el desarrollo de aplicaciones distribuidas, implementaciones de Servicios Web, .net

Remoting, XML y la implementación y el uso de patrones UML para el desarrollo de aplicaciones

.net usando Building Blocks, UML y RUP.



mailto:%[email protected]

Usando El Patrón de Diseño Observer Manual de Laboratori2

Documents

Transcript of Usando El Patrón de Diseño Observer Manual de Laboratori2