Saludos banda, sólo para invitarles a la reunión PRESENCIAL de la comunidad .NET del DF. Es el próximo 27 de agosto de 2009 de 7 p.m. a 9:30 p.m., los esperamos en Alfonso Esparza Oteo # 144 Despacho 608, cerca de la estación Olivo del metrobú, a una cuadra de Insurgentes y a 2 cuadras de Plaza Inn.
Se les recuerda que hay que registrarse en la siguiente dirección:
Como saben no tiene ningún costo la asistencia y los invitamos a hacer extensiva la presente invitación a sus amiguitos.
La agenda del día es:
-Lenguajes Dinamicos en Visual Studio 2010 con Miguel Angel Moran, servidor y amigo
-Inyección de Dependencias con Raúl Guerrero
Por otro lado los invito a que asistan a este webcast, "MSDN - Conexión del código nativo y los servicios Web utilizando la API de servicios Web de Windows " que daré para MSDN.
En esta sesión vemos cómo puede utilizar la API de servicios Web de Windows para conectar una base de código nativo a los servicios Web para SOAP. Analizamos los escenarios clave donde esta API aporta valor a los desarrolladores de código nativo, y ahondamos en cómo esta API ayuda a crear aplicaciones que aprovechan por completo el software y la plataforma de servicios Microsoft. Microsoft Visual Studio 2008 SP1 y Windows SDK para Windows 7 se utilizan en todas las demos.
Fecha: 29/09/2009 (dd/mm/yyyy).
Hora: 16:00 (GMT-05:00 Colombia, Panama).
http://msevents.microsoft.com/CUI/WebCastEventDetails.aspx?EventID=1032423892&EventCategory=4&culture=es-AR&CountryCode=AR
Salu2
SharePoint.
Mi único comentario
Uso el twitter como un confidente virtual, en él generalmente pongo cosas poco relevantes de mi vida, desde mis corajes con los franeleros, hasta las canciones que canto al trabajar, poemitas lerdos y pensamientos aleatorios. En ocasiones he twitteado sobre SharePoint y las frustraciones con las que me he encontrado como desarrollador, o al enfrentarme con los requerimientos del usuario aplicados a SharePoint.
Derivado de estos twitts he recibido ya varios comentarios de mis frustraciones al desarrollar con SharePoint y creo que ante esto, lo menos que puedo hacer es justificar desde un punto de vista técnico lo que a mi NO me gusta de SharePoint y también lo que SÍ me gusta del mismo.
Creo que es necesaria una clarificación, sin duda alguna es TOTALMENTE INJUSTO decir que SharePoint apesta por el sólo hecho de decirlo. Mi contexto es que al ser una persona que durante 13 años ha dedicado su vida profesional a trabajar con la plataforma Microsoft, SharePoint, se ha convertido en el primer (y único) producto al cual le pido mucho más de lo que tiene, insisto como plataforma de desarrollo, no como producto Out of the box. No es una satanización del producto ni mucho menos.
Este post tiene como objetivo clarificar mi visión y mi propuesta sobre SharePoint. Un producto tan exitoso como controvertido, excelentemente posicionado y que sigue con una inercia impresionante implantándose en muchas organizaciones.
Debo empezar con algo:
SharePoint (tanto WSS como MOSS) es un EXCELENTE producto para usuario final, en minutos es posible crear intranets completas, colaborativas, búsquedas empresariales, calendarios, documentos, flujos de trabajo y muchas cosas más sin una sóla línea de código.
SharePoint es una plataforma habilitadora para la colaboración, creo que la competencia de Microsoft no tiene algo similar. SharePoint es un cohete para generar intranets y hasta sitios web en cuestión completamente funcionales en cuestión no de días, sino de horas. SharePoint es un HABILITADOR de automatización y del trabajo en equipo mediante el uso de la tecnología
En el lugar donde se me emplea, se usa SharePoint para el control de las horas y el presupuesto, he vendido SharePoint en muchas empresas como la base tecnológica para sus necesidades de colaboración. Cuando se trata de colaborar o de hacer intranets, mi primera opción siempre es recomendar SharePoint, estoy totalmente convencido, he hecho muchas propuestas a grandes organizaciones proponiendo SharePoint como su plataforma de colaboración. El ecosistema modular de SharePoint (MOSS, Forms, PerformancePoint, Project Server, ahora hasta Commerce Server y un largo etc.) utiliza la plataforma WSS para generar aplicaciones funcionales en cuestión de horas, crece y se ajusta a las necesidades de la empresa.
Además de esto Microsoft ha hecho otro EXCELENTE trabajo al posicionar la plataforma en muchas empresas y cada vez es más el furor por esta plataforma, que independientemente de la mercadotecnia, es un gran producto colaborativo, y así de sencillo: EL MEJOR (Notes, Domino, Community Server, Opengroupware y muchas otras plataformas se quedan totalmente cortas ante el poder habilitador de SharePoint)
SharePoint es, desde mi punto de vista, una idea maravillosa, hecha realidad en muchos aspectos. Pero ¿qué le hace falta para convertirse en una verdadera plataforma de desarrollo?
Yo opino que es HACER AMIGABLE SHAREPOINT AL DESARROLLADOR. No hablo del producto ni de la idea. Hablo exclusivamente de la experiencia del developer con la plataforma.
SharePoint es una excelente herramienta, pero cuando hay que llevar más allá un requerimiento al funcionamiento out of the box, uno tiene que convertirse en un verdadero experto y conocer las tripas tripas tripas del producto, lo cual no es malo, pero sin duda impedirá el posicionamiento de MOSS/WSS como una verdadera plataforma de desarrollo.
¿Qué peros le veo al producto como plataforma de desarrollo?
- Es necesario programar en una versión de servidor de Windows. Esto es complicado, ya que en muchos corporativos (lo digo porque ya van 3 veces que me pasa) hay políticas restrictivas respecto a las computadoras y no se pueden estar levantando ambientes a la ligera.
- Nativamente la programación nunca es visual (hay parches de terceros como smartpart por ejemplo) pero generalmente todo es "a manita"
- La instalación de un cambio, feature, workflow etc. es una experiencia complicada, desde los archivos de configuración y xml, los strong names, el stsadm y su gran número de modificadores.
- El modelo de objetos es confuso, recibir GUIDS como parámetros para casi todo es una experiencia complicadísima y poco amigable, cosas realmente triviales se convierten en complicadas. Caso de ejemplo: El comportamiento de los calendarios de Sharepoint, permite nativamente introducir muchas citas al mismo tiempo, sin embargo el requerimiento dice que sólo se puede agendar una cita simultánea. ¿Se oye complicado el requerimiento?... Bueno, la solución a algo tan trivial, en SharePoint se convierte a algo más o menos así:
using System;
002.using Microsoft.SharePoint;
003.
004.
005.namespace Webcoda.WSS.Calendar.Events
006.{
007. class PreventDoubleBooking: SPItemEventReceiver
008. {
009. /// <summary>
010. /// This event is triggered when the user adds a new item
011. /// </summary>
012. /// <param name="properties"></param>
013. public override void ItemAdding(SPItemEventProperties properties)
014. {
015. //Our query string variable
016. string strQuery = null;
017.
018. try
019. {
020. //Get the Sharepoint site instance
021. using (SPWeb oWebsite = new SPSite(properties.SiteId).OpenWeb(properties.RelativeWebUrl))
022. {
023.
024. //Get the collection of properties for the Booking item
025. SPListItemCollection collItems = oWebsite.Lists[properties.ListTitle].Items;
026.
027. //Get the Calendar List that we will be querying against
028. SPList calendar = oWebsite.Lists[properties.ListId];
029.
030. //Get the internal name of the fields we are querying.
031. //These are required for the CAML query
032. string start_internal = collItems.List.Fields["Start Time"].InternalName;
033. string end_internal = collItems.List.Fields["End Time"].InternalName;
034. string MeetingRoom_Internal = collItems.List.Fields["Meeting Room"].InternalName;
035.
036. //Get the query string parameters
037. string start_str = properties.AfterProperties[start_internal].ToString();
038. string end_str = properties.AfterProperties[end_internal].ToString();
039. string MeetingRoom_str = properties.AfterProperties[MeetingRoom_Internal].ToString();
040.
041. //Construct a CAML query
042. SPQuery query = new SPQuery();
043.
044. //Create the CAML query string that checks to see if the booking we are attemping
045. //to add will overlap any existing bookings
046. strQuery = string.Format(@"
047.
048. <Where>
049.
050. <And>
051. <Or>
052.
053. <Or>
054. <And>
055. <Leq>
056. <FieldRef Name='EventDate' />
057. <Value Type='DateTime' IncludeTimeValue='TRUE'>{0}</Value>
058. </Leq>
059.
060. <Gt>
061. <FieldRef Name='EndDate' />
062. <Value Type='DateTime' IncludeTimeValue='TRUE'>{0}</Value>
063. </Gt>
064. </And>
065.
066. <And>
067. <Lt>
068. <FieldRef Name='EventDate' />
069. <Value Type='DateTime' IncludeTimeValue='TRUE'>{1}</Value>
070. </Lt>
071.
072. <Geq>
073. <FieldRef Name='EndDate' />
074. <Value Type='DateTime' IncludeTimeValue='TRUE'>{1}</Value>
075. </Geq>
076. </And>
077. </Or>
078.
079. <Or>
080. <And>
081. <Leq>
082. <FieldRef Name='EventDate' />
083. <Value Type='DateTime' IncludeTimeValue='TRUE'>{0}</Value>
084. </Leq>
085.
086. <Geq>
087. <FieldRef Name='EndDate' />
088. <Value Type='DateTime' IncludeTimeValue='TRUE'>{1}</Value>
089. </Geq>
090. </And>
091.
092. <And>
093. <Geq>
094. <FieldRef Name='EventDate' />
095. <Value Type='DateTime' IncludeTimeValue='TRUE'>{0}</Value>
096. </Geq>
097.
098. <Leq>
099. <FieldRef Name='EndDate' />
100. <Value Type='DateTime' IncludeTimeValue='TRUE'>{1}</Value>
101. </Leq>
102. </And>
103. </Or>
104.
105. </Or>
106.
107. <Eq>
108. <FieldRef Name='Meeting_x0020_Room' />
109. <Value Type='Choice'>{2}</Value>
110. </Eq>
111.
112. </And>
113.
114. </Where>
115. <OrderBy>
116. <FieldRef Name='EventDate' />
117. </OrderBy>
118.", start_str, end_str, MeetingRoom_str);
119.
120. //Set the query string for the SPQuery object
121. query.Query = strQuery;
122.
123. //Execute the query against the Calendar List
124. SPListItemCollection existing_events = calendar.GetItems(query);
125.
126. //Check to see if the query returned any overlapping bookings
127. if (existing_events.Count > 0)
128. {
129. //Cancels the ItemAdd action and redirects to error page
130. properties.Cancel = true;
131.
132. //Edit the error message that will display on the error page
133. properties.ErrorMessage += "This booking cannot be made because of one or more bookings in conflict. <BR><BR>";
134.
135. //Here you can loop through the results of the query
136. //foreach (SPListItem oListItem in existing_events)
137. //{
138. // ....
139. //}
140.
141. properties.ErrorMessage += "Please go back and schedule a new time.";
142. }
143.
144. }
145. }
146. catch (Exception ex)
147. {
148. //Cancels the ItemAdd action and redirects to error page
149. properties.Cancel = true;
150.
151. //Edit the error message that will display on the error page
152. properties.ErrorMessage = "Error looking for booking conflicts: " + ex.Message;
153. }
154.
155. }
156.
157. /// <summary>
158. /// This event is triggered when the user edits an calendar item
159. /// </summary>
160. /// <param name="properties"></param>
161. public override void ItemUpdating(SPItemEventProperties properties) {
162.
163. string strQuery = null;
164.
165. try {
166.
167. //Get the Sharepoint site instance
168. using (SPWeb oWebsite = new SPSite(properties.SiteId).OpenWeb(properties.RelativeWebUrl)) {
169.
170. //Get the collection of properties for the Booking item
171. SPListItemCollection collItems = oWebsite.Lists[properties.ListTitle].Items;
172.
173. //Get the Calendar List that we will be querying against
174. SPList calendar = oWebsite.Lists[properties.ListId];
175.
176. //Get the internal name of the fields we are querying.
177. //These are required for the CAML query
178. string start_internal = collItems.List.Fields["Start Time"].InternalName;
179. string end_internal = collItems.List.Fields["End Time"].InternalName;
180. string MeetingRoom_Internal = collItems.List.Fields["Meeting Room"].InternalName;
181. string guid_internal = collItems.List.Fields["GUID"].InternalName;
182.
183. //Get the query string parameters
184. string start_str = properties.AfterProperties[start_internal].ToString();
185. string end_str = properties.AfterProperties[end_internal].ToString();
186. string MeetingRoom_str = properties.AfterProperties[MeetingRoom_Internal].ToString();
187. string guid_str = properties.AfterProperties[guid_internal].ToString();
188.
189. //Construct a CAML query
190. SPQuery query = new SPQuery();
191.
192. //Create the CAML query string that checks to see if the booking we are attemping
193. //to change will overlap any existing bookings, OTHER THAN ITSELF
194. strQuery = string.Format(@"
195.
196. <Where>
197. <And>
198.
199. <And>
200. <Or>
201.
202. <Or>
203. <And>
204. <Leq>
205. <FieldRef Name='EventDate' />
206. <Value Type='DateTime' IncludeTimeValue='TRUE'>{0}</Value>
207. </Leq>
208.
209. <Gt>
210. <FieldRef Name='EndDate' />
211. <Value Type='DateTime' IncludeTimeValue='TRUE'>{0}</Value>
212. </Gt>
213. </And>
214.
215. <And>
216. <Lt>
217. <FieldRef Name='EventDate' />
218. <Value Type='DateTime' IncludeTimeValue='TRUE'>{1}</Value>
219. </Lt>
220.
221. <Geq>
222. <FieldRef Name='EndDate' />
223. <Value Type='DateTime' IncludeTimeValue='TRUE'>{1}</Value>
224. </Geq>
225. </And>
226. </Or>
227.
228. <Or>
229. <And>
230. <Leq>
231. <FieldRef Name='EventDate' />
232. <Value Type='DateTime' IncludeTimeValue='TRUE'>{0}</Value>
233. </Leq>
234.
235. <Geq>
236. <FieldRef Name='EndDate' />
237. <Value Type='DateTime' IncludeTimeValue='TRUE'>{1}</Value>
238. </Geq>
239. </And>
240.
241. <And>
242. <Geq>
243. <FieldRef Name='EventDate' />
244. <Value Type='DateTime' IncludeTimeValue='TRUE'>{0}</Value>
245. </Geq>
246.
247. <Leq>
248. <FieldRef Name='EndDate' />
249. <Value Type='DateTime' IncludeTimeValue='TRUE'>{1}</Value>
250. </Leq>
251. </And>
252. </Or>
253.
254. </Or>
255.
256. <Eq>
257. <FieldRef Name='Meeting_x0020_Room' />
258. <Value Type='Choice'>{2}</Value>
259. </Eq>
260.
261. </And>
262.
263. <Neq>
264. <FieldRef Name='GUID' />
265. <Value Type='GUID'>{3}</Value>
266. </Neq>
267.
268. </And>
269.
270. </Where>
271.
272. <OrderBy>
273. <FieldRef Name='EventDate' />
274. </OrderBy>
275.", start_str, end_str, MeetingRoom_str, guid_str);
276.
277. //Set the query string for the SPQuery object
278. query.Query = strQuery;
279.
280. //Execute the query against the Calendar List
281. SPListItemCollection existing_events = calendar.GetItems(query);
282.
283. //Check to see if the query returned any overlapping bookings
284. if (existing_events.Count > 0) {
285.
286. //Cancels the ItemAdd action and redirects to error page
287. properties.Cancel = true;
288.
289. //Edit the error message that will display on the error page
290. properties.ErrorMessage += "This booking cannot be made because of one or more bookings in conflict. <BR><BR>";
291.
292. //Here you can loop through the results of the query
293. //foreach (SPListItem oListItem in existing_events)
294. //{
295. // ....
296. //}
297.
298. properties.ErrorMessage += "Please go back and schedule a new time.";
299. }
300.
301. }
302. } catch (Exception ex) {
303.
304. //Cancels the ItemAdd action and redirects to error page
305. properties.Cancel = true;
306.
307. //Edit the error message that will display on the error page
308. properties.ErrorMessage = "Error looking for booking conflicts: " + ex.Message;
309. }
310.
311. }
312.
313.
314. }
315.}
Copiado del sitio: http://blog.sharepointsydney.com.au/post/Setting-up-multiple-calendars-for-meeting-room-bookings-prevent-double-booking.aspx
Desde mi punto de vista códigos como el anterior son completamente improductivos y hablan de la complejidad del modelo de programación de SP.
- CAML ¿CAML? Para qué un lenguaje adicional para hacer Querys. (además complicado y poco natural) Commerce Server, tambien de MS, por ejemplo utiliza en su modelo de objetos una función .Where donde se pasa como parámetro algo semejante a T-SQL, lo cual reutiliza el conocimiento del programador ¿Para que OTRO lenguaje? No ya es suficientemente difícil conocer asp.net, c#, javascript, css, xaml, html, xhtml, xml, sql, xpath, xquery y muchos más para programar una página web ¿necesitamos OTRO lenguajito basado en XML?. Esto va precisamente en contra de la propuesta de LINQ: Dotar de nuevo a los lenguajes de programación la sintaxis necesaria para interactuar con objetos de la capa de datos.
- Poca o nula integración a Visual Studio, hay que bajar plugins para el poco soporte que existe
- El debuggeo es también muy complicado, estarse atacheando a procesos del server es poco natural y como quiera que sea, SÍ QUITA TIEMPO.
- Cuando truena… TRUENA, y da mensajes de error super crípticos, como una gran caja negra, hay que meterse a los logs, que tampoco dan mucha información.
- A nivel de diseño gráfico la personalización es complicada.
- Hacer algo más allá de una simple forma de captura en infopath se vuelve una experiencia tortuosa, hacer que infopath tenga fuentes de datos y muestre dinámicamente controles se vuelve un mar de clics clics y clics que se desconfiguran al hacer un deployment de la aplicación y hay que volver a hacer todo otra vez.
- Eso de usar SharePoint Designer para una cosa, Visual Studio para otra, una herramienta 3rd party para el CAML, otra 3rd party para el attacheo de eventos, y el Notepad para los .bats de deployment huele como a trabajar en Eclipse /Java donde se requiere un programita de diferente proveedor para cada cosa. Esto siempre critico. El poder de la plataforma MS es precisamente la maravillosa integración de sus productos.
Estos y muchos temas más se han discutido ya mucho en Internet, hay muchos posts debatiendo esto y estas razones han sido discutidas 50000 veces antes de esto. Este post no es investigativo, es una reflexión personal.
Yo siempre he dicho (por eso mi afición a VB y a proyectos como Astoria, entity framework, jasper etc) que a estas alturas ya no podemos permitir que los desarrolladores pasen una gran cantidad de tiempo investigando cómo hacer las cosas. Los desarrolladores cuestan dinero, y mucho. Una de las características de la plataforma Microsoft ha sido facilitar enormemente la tarea del desarrollador con tecnologías de alto desempeño e intuitivas.
Con sharepoint es posible generar de una manera rápida y efectiva intranets , el único problema se da cuando por requerimiento del usuario se necesita extender la funcionalidad ya incluida dentro de la plataforma, entonces es cuando entra al rol del desarrollador y todo el tiempo que se gana al implementar la intranet de una manera rápida puede perderse cuando el equipo de desarrollo tiene que estar batallando con códigos como el de arribal.
El objetivo de este pots insisto, es meramente propositivo, RECALCO OTRA VEZ SHAREPOINT ES UN EXCELENTE PRODUCTO. Lo único que digo es que Microsoft debería invertir más en en Sharepoint una verdadera plataforma de desarrollo amigable con las nuevas tendencias tecnológicas que aparecen dentro de la siguiente entrega de Visual studio y en general de la plataforma. Net , no sé porque tengo la impresión de que los equipos de ASP.NET y Sharepoint no se comunican.
Yo me imagino a un Sharepoint más integrado con el IDE de VS, con un modelo basado en objetos o en WSDL mucho más simple, que explotara LINQ, entity framework y los pusiera como provedores de datos, algo que se pareciera más al enterprise library, con menos complejidad en todos los aspectos.
Conclusión:
SharePoint es una plataforma efectiva y poderosa de colaboración. El retorno de inversión en Intranets pequeñas/medianas es excelente. Es un maravilloso habilitador del trabajo en equipo. Para consolidar a SharePoint como una plataforma sustentable que crezca con el negocio y sea fácilmente extendible, es necesaria más inversión desde el punto de vista del desarrollador. Desde mi HUMILDE opinión, le falta el toque que caracteriza a la tecnología Microsoft: hacer la vida más facil al desarrollador, por eso amo .NET por eso estoy convencido de que .NET es superior en casi todo a su competencia, y creo que C# 4.0 es el MEJOR lenguaje disponible en el mercado.
Espero que Sharepoint 2010, otorgue ése "algo" que le falta como una verdadera experiencia de developer, si es así, en este espacio escribiré al respecto.
Los invito cordialmente a que me acompañen a los siguientes webcasts que estaré dando para el MSDN de Microsoft.
Webcast MSDN: Base de datos de SQL Server para la Plataforma de datos – Transite del servidor a los dispositivos y a la nube
miércoles, 08 de abril de 2009
Los servicios de datos basados en la nube cambiarán la forma en que usted desarrolla e implementa aplicaciones y las tecnologías SQL Server evolucionan para ayudarle a integrar soluciones impulsadas por datos que abarcan dispositivos, escritorios, servidores y la nube. Descubra la forma de usar l Marco de servicios de datos ADO.NET (nombre de código "Astoria"), SQL Server Data Services (SSDS) y Microsoft Sync Framework.
Aquí está la liga http://tinyurl.com/c8wboq
Webcast MSDN - Programar Live Services usando tecnologías distintas a Microsoft
Los bloques de construcción de Live Services exponen un modelo de programación independiente de plataformas, neutral al lenguaje y basado en protocolos. El marco se diseñó bajo el concepto de obtener-seguir para no estar atado a ninguna tecnología (Microsoft u otra) o implementación específica de plataforma.
Fecha: 23/04/2009
Y aquí está la liga: http://tinyurl.com/d336ae
No falten, se van a poner muy buenos, los webcasts, no ustesdes… :)
Miguel A. Morán
MVP C#
Los lenguajes dinámicos, en pocas palabras, son la neta. Mi entusiasmo a este tipo de programación siempre ha sido evidente por el poder que representa para el programador. De ahí mi gusto siempre desenfrenado por Visual Basic, dada su implementación rudimentaria de dinamismo (el famoso late binding) y las cosas que podíamos hacer con COM desde épocas inmemorables, ya platicaremos en un momento más al respecto de ésto.
Pero vamos por partes.
En este artículo aprenderemos que son y para qué sirven estos lenguajes y trato de explicar muchos conceptos básicos (y quizá alguno no tan básico) sobre ella, además de ver la implementación ya posible con C# 4.0
Espero que este artículo sea del gusto de todos ustedes y que sirva como punto de inicio para prepararnos (o reencontrarnos) con las delicias de la programación dinámica.
Antecedentes:
Anders Helsberg anunció C# 4.0 en el PDC 2008, C# 4.0 representa un paso más en la evolución de C#. Los milestones, o las características principales de C# son los siguientes
· C#1.0: La primera versión de nuestro querido lenguaje de programación creado específicamente para la plataforma .NET
· C#2.0: Más funcionalidad con tipos de datos genéricos, tipos anulables, métodos anónimos y algunas otras delicias sintácticas
· C# 3.0: Inicializadores de objetos, expresiones lambda, árboles de expresiones, métodos de extensión entre otras cosas, todo esto para lograr desde luego el soporte a LINQ.
· C#4.0: Programación dinámica y quizás la posibilidad de compilador como servicio (quizás porque Microsoft no ha anunciado nada hasta el momento, quizás sea parte de C#4.0 o quizás tengamos que esperar hasta la siguiente versión)
Así que lo más destacado de la versión 4.0 de C# es la posibilidad de manejar tipos dinámicos, lo cual explicaremos a continuación
¿Qué es un lenguaje dinámico?
Un lenguaje dinámico, en pocas palabras es un lenguaje que en tiempo de ejecución realiza cosas que tradicionalmente se harían en tiempo de compilación. Entre estas cosas tenemos:
1) Parseo (Análisis) de expresiones: Es poder enviar al lenguaje generalmente una cadena y que el tiempo de ejecución lo interprete como código ejecutable en el acto. Si les viene a la mente la función Eval() de Javascript, están en lo cierto, es exactamente eso.
2) Verificación de tipos de datos. Si en C# tratamos de sumar perros, con enteros, con cadenas y con gatos, el compilador nativamente nos daría un error en tiempo de compilación la mayoría de las veces (digo la mayoría porque en tiempos de las primeras versiones de C# cuando no había tipos genéricos podíamos hacer operaciones de este tipo y recibir el tronido hasta que el programa ya estaba corriendo juar juar). Con un lenguaje dinámico podemos definir las reglas para manejar tipos de datos heterogéneos. Además es posible hacer el binding de un objeto a una variable
3) Redefinición y alteración a los tipos: En los lenguajes tradicionales (no dinámicos) una vez que hemos definido un tipo es imposible cambiarlo. Sí sí claro algunos de ustedes dirán que no es necesario toda vez que puedo definir contratos mediante interfaces y clases abstractas y meter cualquier tipo de información en estas plantillas y así ya queda, pero recordemos: Las interfaces y las clases abstractas no son en runtime, es decir, no puedo alterar el contrato una vez definido, además de que debo escribir una gran bola de código para definir estas estructuras. Lenguajes como Phyton o Ruby permiten nativamente esto, y C# 4.0 también, como lo veremos en éste artículo
4) Emisión de bloques ejecutables: Esto se refiere a código que genera código. Se implementa mediante closures y funciones de orden superior, esto es parcialmente posible en C# mediante funciones de orden superior y expresiones lambda (ver más en mi artículo publicado en la revista Software Gurú)
¿Y para qué sirve todo esto? Los lenguajes dinámicos facilitan enormemente la labor del programador haciéndolo más productivo, ayudándolo entre otras cosas con:
· Permiten la carga de tipos de datos desde estructuras externas (como por ejemplo un archivo en XML o en JSON) y usar sintaxis nativa de atributo para asignar o leer información
· Permiten usar datos sin necesidad de definir contratos (las interfaces, precisamente son el paliativo de la estaticidad de C#)
· Fomentan el bajo acoplamiento (No tengo que tener referencias a bibiliotecas de tipo, que si cambian, me hacen recompilar el código)
· Eliminan las bibliotecas de tipos y/o intefaces
· Eliminan las referencias circulares (molesto y horrible dolor de cabeza)
· Disminuyen la cantidad de código requerido
· Evalúan en tiempo real fórmulas y código (por ejemplo para los molestos cálculos de nómina, dado que las leyes fiscales cambian constantemente)
· Facilitan la creación de alfabetos finitos con significado para nuestro programa
· Modifican el comportamiento de un proceso o flujo de trabajo en tiempo real sin necesidad de recompilar
· Dan la posibilidad de generar un “polimorfismo extremo” dirigido por los datos, esto es, permiten que un tipo de datos mute (o sea que se le agregue comportamiento o estado en tiempo de ejecución) en cualquier momento
· Facilitan la metaprogramación, es decir código que genera o manipula código, por ejemplo yo podría permitirle a un usuario describir como es un tipo de dato y en tiempo de ejecucución tener un programa que manipule o lea esa información
Como podrán ver son bastantes las ventajas y puedo seguir echando choro acerca de todo lo que se puede hacer con un lenguaje dinámico, pero también hay que decirlo, también tienen sus desventajas como exponer nuestro programa a errores en tiempo de ejecución, herramientas de programación más pobres (adiós Intellisense), menor desempeño en la aplicación por la chamba adicional que le damos a la computadora de inferir y hacer casts en tiempo de ejecución. Hay que poner en la balanza si estos problemas no superan al beneficio de usar los lenguajes dinámicos.
Existen diferentes implementaciones de dinamismo en lenguajes como Ruby, Phyton y hasta el mismo Visual Basic y COM con su capacidad para hacer late binding, sin embargo aquí nos concentraremos en aprender cómo funcionarán estos conceptos en C#.
La línea de un lenguaje de programación estático y dinámico no es muy clara, los lenguajes estáticos (el CLR de .NET en general) fue creado para ser fuertemente tipado, sin embargo tiene alternativas para generar “cierto” dinamismo. La herramienta principal de .NET para esto es la reflección (Reflection) en el namespace System.Reflection. Este namespace contiene clases para conocer en tiempo de ejecución los tipos de datos, es más, es posible generar métodos dinámicos escribiendo directamente los opcodes del IL (Intermediate Language), sin embargo esto es sumamente complejo de lograr toda vez que tendríamos que aprender IL además de existir muchas limitantes, lo que trato de decir es que no creo que haya un lenguaje totalmente dinámico ni otro totalmente estático, cada lenguaje tiene su propia implementación en mayor o menor medida para realizar las tareas que enumeré en párrafos anteriores.
Un poco de historia en la plataforma Microsoft sobre los tipos dinámicos
Como escribí en los renglones superiores, esto de no ser tan estricto en la tipificación de los datos no es nuevo en la plataforma Microsoft.
Quienes programamos alguna vez con COM o con Visual Basic 6.0 recordaremos código como el siguiente:
'VB 6.0/VBScript
Dim lobjUnObjeto
Set lobjUnObjeto = CreateObject("ADODB.Connection")
Lo que sucede con el código anterior es que la función CreateObject devuelve una referencia a un objeto COM. Todo objeto COM debe tener implementada la interface IDispatch (que a su vez hereda de IUknown y que son las interfaces básicas para hacer que un objeto tenga la capacidad de utilizarse en COM) Veremos en un rato cómo se parece el modelo a lo que actualmente (o próximamente) tendremos en C#.
Una vez que utilizábamos una sintaxis semejante a la anterior podíamos fácilmente mandar a llamar a cualquier método o atributo con la sintaxis del puntito
lobjUnObjeto.Metodo1
lobjUnObjeto.Atributo1
Tener una situación similar en C# 3.0 o anteriores es imposible, toda vez que siempre es necesario agregar una referencia a y en tiempo de compilación conocer previamente el tipo de datos para poder hacer cualquier llamada a un método o atributo.
Pues que creen... En C# 4.0 YA ES POSIBLE OTRA VEZ jeje. De hecho éste artículo el artículo se iba a llamar “Y Visual Basic siempre tuvo razón”, pero seguramente iba a herir varias susceptibilidades, así que le cambié el nombre. Fuera de coto, la posibilidad de utilizar sintaxis dinámica en C#, desde mi humilde punto de vista hace a C# un lenguaje de programación multiparadigma real, con capacidad para utilizar el paradigma estructurado, orientado a objetos, funcional y dinámico. Esto es una excelente noticia para todos nosotros que día a día nos enfrentamos a pantallas llenas de código en C#.
Algo que me gustaría aclarar es que el código fuertemente tipeado debe de prevalecer, el hecho de que C# tenga estas nuevas funcionalidades no significa que debemos olvidar todo lo que hemos aprendido hasta el momento sobre las buenas prácticas de la programación orientada a objetos y componentizada (interfaces, contratos, mecanismos de publicación – suscripción etc.), yo creo que como deberíamos de ver estas alternativas exactamente como eso, simplemente como una serie de alternativas que nos darán mayor productividad y facilidad al programar, pero no debemos de perder el foco y caer en el libertinaje haciendo código dinámico y olvidar de plano la tipificación.
Todo se resume en una máxima: Usemos siempre fuerte tipificación, a menos de que sea absolutamente necesario, usemos tipos dinámicos.
Basta pues de todo esto y concentrémonos ahora en ver la implementación básica de dinamismo en C# 4.0.
El tipo de datos dynamic
C# 4.0 introduce el tipo de datos dynamic, que no es más que una manera alternativa de decirle al compilador que NO verifique el tipo de datos en tiempo de ejecución. Según los arquitectos de C# la palabra dynamic representa un objeto estáticamente tipado para ser dinámico.
El código se ve así:
1: //C# 4.0
2: dynamic variable = 1;
En pocas palabras, y sin tanto choro, lo que sucede es que estamos declarando un objeto del tipo objeto pero como mencionamos esta implementación permite dejar la verificación del tipo (el binding) hasta el tiempo de ejecución
¿Ustedes dirán y eso no es lo mismo que var? La respuesta es ¡No!, son dos cosas completamente diferentes, veamos el siguiente ejemplo
1: //C# 4.0
2: dynamic objeto = 1;
3: var objeto2 = 1;
En la línea 2, internamente lo que sucede es que se asigna el tipo de datos objeto el cual se conocerá hasta el runtime y en la línea 3 quien infiere el tipo de datos es el compilador y antes de ejecutarlo se conoce el tipo, por lo que sigue siendo un tipeado estático.
Internamente esta funcionalidad se monta sobre una pieza de software que ya tiene un ratito entre nosotros que es el DLR.
El DLR
El DLR o Dynamic Language Runtime que se monta sobre el CLR, es decir, no lo reemplaza ni mucho menos, es simplemente código adicional que sirve para facilitarnos la vida a la hora de hacer las cosas dinámicas. Físicamente vive en un ensamblado llamado Microsoft.Scripting y proporciona clases que facilitan en gran medida la utilización de lenguajes dinámicos.
El DLR tiene como funcionlidad proveer funciones básicas de dinamismo, de la misma manera que en COM y VB 6.0 lo hacía la interface IDispatch y la función CreateObject, sin embargo y a diferencia de COM, el CLR tiene funciones de optimización para hacer que el código sea mucho más eficiente, toda vez que tiene soporte para caché de objetos, además de permitir la interoperabilidad de diferentes lenguajes de programación dinámicos como IronPython o IronRuby.
Vayamos ahora a aplicaciones reales de esta tecnología
Bajo acoplamiento con C# 4.0
Como lo he mencionado creo que en la mayoría de los posts que he hecho, es básico y conocido por todos que debemos fomentar la ya veterana la programación basada en componentes, al menos en tres capas, capa de usuario, regla de negocio y capa de persistencia o acceso a base de datos. Generalmente hay una dependencia de composición o agregación entre dichas capas, o sea agregamos una referencia desde la capa de usuario para que vea a los tipos y funciones de la Regla de Negocio y a su vez esta tiene una referencia a la capa de datos.
El problema con C# es que si queremos seguir un modelo semejante en C#, además debemos definir bibliotecas de interfaces para que la capa de datos conozca las entidades porque las entidades (clases especializadas en la persistencia de datos) generalmente deben persistir en una regla de negocio, o bien en el caso de que queramos realizar inyección de dependencias sucede exactamente lo mismo.
El tipo de datos dynamic permite una manera sencilla de hacer esto aun mas simple de lo que ya es. Veamos como
Lo primero que vemos es la capa de usuario (en este caso una vil formita con dos botones), uno que acumula datos en un diccionario y el otro que invoca a la Regla de negocio con la cual tiene dependencia, éste código es perfectamente legal en C# 3.0 porque no hay nada nuevo y aun no usamos la palabra clave dynamic. Examinemos pues el código
1: ///C# 4.0///////////CAPA DE USUARIO//////////////////////////
2: using System;
3: using System.Collections.Generic;
4: using System.ComponentModel;
5: using System.Data;
6: using System.Drawing;
7: using System.Linq;
8: using System.Text;
9: using System.Windows.Forms;
10: using Rdn.Entidades;
11:
12: namespace Usr
13: { 14: public partial class Form1 : Form
15: { 16: //Aqui guardare los datos de las personas
17: List<Persona> Personas = new List<Persona>();
18:
19: //PASO 1-------------------------------------------------------------------------
20: //Este botón lo único que hace es agregar entidades persona al diccionario Personas
21: private void button1_Click(object sender, EventArgs e)
22: { 23: //Invoco a la entidad Persona de regla de negocio (Rdn) y la lleno
24: Rdn.Entidades.Persona unaPersona = new Rdn.Entidades.Persona() { 25: Id=Personas.Count+1, AMaterno="Perez", APaterno="Perez", Nombre="Lucha" };
26: //Sólo agrego la entidad al diccionario
27: Personas.Add(unaPersona);
28: }
29:
30: //PASO 2 -------------------------------------------------------------------------
31: //Aquí doy clic cuando termino de agregar personas al diccionario
32: private void button2_Click(object sender, EventArgs e)
33: { 34: //Instancio la Rdn
35: var ReglaNegocio = new Rdn.Rdn();
36: //Invoco el método de la Rdn y le paso el diccionario lleno de Personas
37: ReglaNegocio.AgregarPersonas(Personas);
38:
39: }
40:
41:
42: public Form1()
43: { 44: InitializeComponent();
45: }
46:
47: }
48: }
Posteriormente veremos lo que hay en la RDN. En este caso y para hacer menos verboso el código esta RDN realmente no hace nada (recordemos que las capas de negocio tienen como función principal la orquestacíón de los procesos), sino que le avienta el diccionario a la capa de acceso a datos (persistencia). Igual que en el código anterior, éste código NO tiene nada novedoso.
1: //C# 4.0 ////////////////////CAPA DE REGLA DE NEGOCIO
2: using System;
3: using System.Collections.Generic;
4: using System.Linq;
5: using System.Text;
6:
7: namespace Rdn
8: { 9: public class Rdn
10: { 11: public void AgregarPersonas(List<Entidades.Persona> pobjPersonas)
12: { 13: //Instancio a la capa de persistencia y le paso el mismo objeto recibido
14: var BaseDatos = new Abd.Abd();
15: BaseDatos.Persistir(pobjPersonas);
16:
17: }
18: }
19: }
Aquí tienen la definición de la clase Persona
1: namespace Rdn.Entidades
2: { 3:
4: public class Persona
5: { 6: public int Id;
7: public string APaterno;
8: public string AMaterno;
9: public string Nombre;
10: public string Telefono;
11:
12: }
13: }
Por fin llegó el momento de utilizar la palabra clave dynamic. La usaremos en este ejemplo precisamente en la capa de persistencia.
1: //C# 4.0 CAPA DE ACCESO A DATOS CON dynamic
2: using System;
3: using System.Collections.Generic;
4: using System.Linq;
5: using System.Text;
6: using System.Windows.Forms;
7: using System.Diagnostics;
8:
9: namespace Abd
10: { 11: public class Abd
12: { 13: //Recibo la entidad persona, pero como podemos ver NO CONOZCO EL TIPO!!!
14: //sólo lo declaro como dynamic y el código es completamente válido
15: public void Persistir(dynamic pdynObjeto)
16: { 17:
18: foreach (dynamic Item in pdynObjeto)
19: { 20: //Aqui se pone el código para persistir en bdd, en este
21: // ejemplo solo lo mando a la ventana de debug
22: Debug.Write(Item.APaterno + " " + Item.AMaterno+ " " +Item.Nombre);
23: Debug.Write(Item.Id.ToString());
24:
25: }
26:
27: }
28:
29: }
30: }
Como podemos ver no tuve que hacer interfaces, ni bibliotecas de tipos. El compilador permite la compilación sin ningún problema y descubre en tiempo de ejecución las propiedades (en teste caso APaterno, AMaterno etc, de los datos que le llegan.) jaja al más puro estilo de VB 6.0. Quiero señalar que en un contexto controlado esta implementación no es la óptima, sin embargo, es útil cuando queremos implementar arquitecturas dirigidas por los datos.
¿Qué más se puede hacer con C# 4.0?
Generación de atributos dinámicos en tiempo de ejecución.
Examinemos el siguiente código válido en C# 4.0, creo que habla por sí solo...
1: //C# 4.0
2: private void button3_Click(object sender, EventArgs e)
3: { 4: //Creo un diccionario de atributos que se agregarán dinámicamente
5: //en tiempo de ejecución a una clase que se llama PerroDinamico
6: Dictionary<string, object> AtributosDinamicos = new Dictionary<string, object>();
7: AtributosDinamicos.Add("Color", "Verde"); 8: AtributosDinamicos.Add("Raza", "Chihuahua"); 9: AtributosDinamicos.Add("Edad", 7); 10: //Defino tipo dinámico
11: dynamic UnPerroDinamico = new PerroDinamico(AtributosDinamicos);
12: //Invoco a los atributos con sintaxis estándar de atributo
13: //como si 'realmente' existieran, cosa que no se podía hacer antes
14: //porque este código hubiera lanzado una excepción
15: MessageBox.Show(UnPerroDinamico.Raza);
16: MessageBox.Show(UnPerroDinamico.Edad.ToString());
17:
18: }
El msgbox evidentemente muestra "Chihuahua" y 7. Esta clase llamada PerroDinamico hereda de.
Veamos su implementación:
//C# 4.0
1: public class PerroDinamico : System.Scripting.Actions.Dynamic
//Clase con la interface IDynamicObject implementada
2: { 3: Dictionary<string, object> DiccionarioAtributos= new Dictionary<string,object>();
4: //Recibo el diccionario con los atributos
5: public PerroDinamico(Dictionary<string, object> pAtributos)
6: { 7: DiccionarioAtributos = pAtributos;
8: }
9:
10: public PerroDinamico()
11: { 12: throw new NotImplementedException();
13: }
14:
15: //Estos métodos proveen la implementación de los atributos dinámicos, en este caso
16: //no se realiza implementación adicional
17: public override object GetMember(GetMemberAction action)
18: { 19:
20: return DiccionarioAtributos[action.Name];
21:
22: }
23:
24: public override void SetMember(SetMemberAction action, object value)
25: { 26:
27: DiccionarioAtributos[action.Name] = value.ToString();
28:
29: }
30:
31:
32: }
Con esto podemos comprobar que el dinamismo con el DLR de .NET es bastante poderoso, toda vez que es posible implementar cualquier tipo en forma dinámica, y compartir la implentación independientemente del lenguaje.
Como conclusión puedo decir que estoy muy emocionado con todo esto, nos permitirá hacer cosas que antes eran, si no imposibles, muy talachudas de hacer y de nuevo, los invito a que cuando esto salga no lo usemos en demasía, solamente para cuando sea estrictamente necesario.
Pues a grandes rasgos esta fue una explicación somera del funcionamiento del dinamismo en C#. Espero que les haya gustado, cualquier duda o comentario no duden en externarlo poniendo un reply.
Gracias y los invito a que vean esto, es la entrevista de Anders Helsberg sobre las motivaciones que llevaron al equipo de C# a implementar estas cosas, se las recomiendo especialmente a los que no están muy convencidos de esta nueva flexibilidad:
mms://mschnlnine.wmod.llnwd.net/a1809/d1/ch9/4/2/3/2/4/4/CSharpFourQuestionsAndReasons_s_ch9.wmv
Un abrazo a tod@s y ¡Feliz Codificación!
La Comunidad .NET de la Ciudad de México y DevelopersDotNet te invitan al evento de Lanzamiento de VS2008, SQL2008 y Windows 2008
¡Asiste!
Fecha:
13 de Mayo
Hora:
11 a.m. – 7.p.m
Lugar:
ITAM
Dirección:
Río Hondo # 1
Col. Progreso Tizapán
C.P. 01080 Del. Álvaro Obregón
México D.F.
Agenda:
11:00 a 12:30
Héctor Obregón -Interoperabilidad entre Código Nativo en C++ (con MFC), Windows Forms y WPF
12:30 a 2:00
Misael Monterroca - Silverlight 2.0 Beta 1
2:00 a 3:00
Tiempo disponible para salir a comer.
3:00 a 4:30
Miguel Ángel Moran - Nuevos elementos sintácticos con C# 3.0 y VB 9.0
4:30 a 5:45
Alfredo Ceballos – Experiencias de Usuario Enriquecidas en Web y Windows.
5:45 a 7:00
Raúl Guerrero – SQL Server 2008
Mapa:
http://www.itam.mx/es/ubicacion/riohondo1.html
http://www.itam.mx/es/ubicacion/riohondo2.html
Como les comenté en posts anteriores sigo medio obsesionado con estas cosas de la programación alterna (dinámica, declarativa, funcional etc.) Les dejo un link para que visiten el sitio de la revista Software Gurú donde salió publicado un artículo mío denominado "Más allá de los objetos, C# como lenguaje funcional", en la edición de Mayo-Julio de 2008.
¡Cómprenla!
El link es:
http://www.sg.com.mx/content/view/713
Traté de explicar con varios ejemplos de como usar C# con características funcionales, me faltó un buen pero ps el espacio era limitado, igual acá profundizamos más en algunos posts posteriores.
El código fuente es este, abran una nueva aplicación de consola con Visual Studio 2008 (.NET Framework 3.5) y denle Copy Paste al siguiente código.
Lean el artículo, espero que les guste y cualquier duda me la pueden hace llegar a través de los foros de este sitio o a mi mail starcatchingboy@gmail.com
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
using System.Threading;
using System.Linq.Expressions;
namespace Devworx.SG
{
class Program
{
//Función de orden superior
public static Func<int,int> ConvertirMoneda(string pstrMoneda) { return (int pintCantidad) =>
{ return pstrMoneda == "EURO" ? pintCantidad * 15 : pintCantidad * 10; }; }
static void Main()
{
//Expresiones lambda CUBO
Func<int, int> lintResultado = (pintNum) => { return pintNum * pintNum; }; Console.WriteLine(lintResultado(3));
//Inferencia de tipos
var lobjMsg= "Hola";
lobjMsg.GetType().ToString();
Console.WriteLine("El tipo inferido es " + lobjMsg.GetType().ToString());
//Invocación a Función de orden superior con parámetro euro
var lobjConvertidor = ConvertirMoneda("EURO"); Console.WriteLine("La FOS regresa " + lobjConvertidor(20) + " si se le invoca con euro");
//Invocación a Función de orden superior con parámetro dolar
lobjConvertidor = ConvertirMoneda("DOLAR"); Console.WriteLine("La FOS regresa " + lobjConvertidor(20) + " si se le invoca con dolar" );
//Sumatoria sin for, al modo funcional
Console.WriteLine("La sumatoria de 100 es: " + Enumerable.Range(1, 100).Sum());
Console.ReadKey();
}
}
}
Un abrazo a tod@s y
¡Feliz Codificación!
Me encuentro en el aeropuerto de Seattle esperando mi vuelo rumbo a casita, después de una semana sumamente enriquecedora (debo decir, mucho más de lo que yo esperaba) asistiendo al MVP Summit 2008. Creo que fue un evento impresionante, que me sorprendió la manera en la que habló Steve Ballmer y que es extraordinario estar en medio de los equipos de producto de Microsoft (particularmente estuve con los equipos de VB y C#) y en este post me gustaría platicar un poco respecto a mis impresiones.
Desafortunadamente (o afortunadamente) hay un contrato NDA (Non Disclosure Agreement) firmado entre Microsoft y los MVPs que impide comentar detalles y los ejemplos concretos de lo que hemos visto. Sin embargo quisiera compartir algunas reflexiones en estos tiempos de cambio en los que vivimos.
Mi área de interés en esta parte de mi carrera profesional es la teoría de lenguajes de computación, me enoja un poco tener tanto trabajo y no poder dedicarme más a este apasionante tema, sin embargo en tiempecitos he estado investigando y aprendiendo cosas muy interesantes durante los últimos meses, es un tema que me apasiona, quizás como ningún otro en la informática y en este Summit tuve la oportunidad de asistir a pláticas exactamente de estos tópicos, así que con algo de tristeza renuncié a pláticas de Silverlight, de SQL, de SharePoint y hasta de LINQ, y enfoqué todo mi track de sesiones exclusivamente en el área de los lenguajes “puros”, lo cual fue la mejor decisión que pude haber tomado. Estas sesiones me hicieron reafirmar algunas creencias que tengo y modificar otras y las enumeraré a continuación
1) Cosas que siempre he dicho que reafirmé
a) Seguiremos en el camino de la computación “multiparadigma”:
Es bueno ser teórico para programar, me gusta mucho conocer gente que le guste adherirse a una escuela o patrón de diseño, yo soy el principal defensor de la teoría al programar, sin embargo hay que decir que ni VB ni C# son lenguajes puramente orientados a objetos, y mucho menos con la introducción de Visual Studio 2008, con la cual los lenguajes adquiririeron elementos funcionales. Microsoft seguirá por ese rumbo para efectos de aumentar las opciones y la productividad del programador, de cualquier tipo y de cualquier escuela. Los lenguajes evolucionan, deben hacerse más fáciles, mejores y con muchas opciones. Java alguna vez presumía de que era un lenguaje de programación “fácil” y en sus primeras versiones se jactaba de que en el lenguaje solamente se podían hacer las cosas de 2 o 3 maneras distintas cuando en otros lenguajes como C++ lo mismo se podía hacer de 20 formas diferentes. Pues a Java se le cayó esa premisa y conforme ha ido evolucionando (es impresionante que hasta hace algún tiempo java no tenia foreach :P) ha tenido que cambiar e introducir cosas como genéricos y muchas construcciones que le han dado flexibilidad al lenguaje. Lo mismo ha pasado con .NET, sigue en constante evolución y creo que esto es el camino que tendremos en el corto y mediano plazo.
Me saca de onda un poco que a estas alturas del partido haya MVPs en C# que sigan diciendo que var es malo o que se oponen a la evolución natural de los lenguajes, no debería de ser, los lenguajes entre más opciones nos den, se vuelven más flexibles, es función del arquitecto de software elegir un paradigma, patrón y arquitectura para generar mejor software.
b) Los lenguajes open source seguirán ahí:
Microsoft no tiene interés es “competir” frontalmente o posicionar a C# o a VB como una alternativa a lenguajes como Ruby, al contrario, la idea es integrar cada vez más lenguajes de programación heterogéneos que sean compatibles con el CLR y con el DLR (Dynamic Language Runtime). Microsoft está muy comprometido con la comunidad open source y la integración de nuevos lenguajes más específicos para determinadas tareas como F#, Ruby, Phyton etc. será (es) ya un hecho dentro de Microsoft.
c) Los lenguajes dinámicos (y el late binding) NO son malos, si se usan con precaución:
Lo tengo que aceptar: Soy FANÁTICO de los lenguajes que aceptan late binding (léase Visual Basic), siempre lo he sido y seguramente lo seré. Microsoft está haciendo grandes esfuerzos por encontrar una solución que balancee la seguridad del static typing y la flexibilidad del dinamismo y/o late binding. (Por cierto, la diferencia principal del dinamismo al Late Binding es muy sutil podemos decir que un lenguaje dinámico no es más que uno con latebinding con esteroides, y los esteroides son precisamente la creación de un tipo nuevo en compile time (antes de su ejecución), cosa que no sucede con late binding, donde se conoce el tipo hasta la ejecución del mismo y este se encuentra boxeado en un tipo general (que no es lo mismo que genérico) llamado object)
Seguramente un servidor (yo) y DevWorx estaremos haciendo algo al respecto. Allá afuera pasan muchas cosas y no nos vamos a quedar sin participar. El tema de los lenguajes dinámicos es extremadamente apasionante y lo considero como la orientación a objetos real, más humana, más antropomorfizada, es decir, ¿para qué hacer casts y tener bibliotecas de interfaces? Podemos, sin duda alguna generar una real orientación a objetos mediante un polimorfismo llevado al extremo y la programación dinámica es un pilar fundamental para lograrlo. Les recomiendo mucho leer esto: http://pico.vub.ac.be/~wdmeuter/RDL04/papers/Meijer.pdf
2) Cosas que siempre he dicho y que tendré que rectificar
1) He dicho en varios posts que C# se está convirtiendo en un lenguaje funcional y VB en un lenguaje dinámico: Aunque C# 3.0 es más funcional que VB 9.0, en el futuro inmediato pareciera ser que ambos lenguajes seguirán teniendo un soporte similar a tecnologías dinámicas y funcionales respectivamente lo cual lejos de ser malo, es excelente, ambos lenguajes están adquiriendo las capacidades necesarias para seguir estando en la vanguardia y que se pueda programar en ellos cualquier software por complejo que parezca.
En fin, la semana del Summit se acabó y mis proyectos en me esperan apilados, tengo que programar teléfonos celulares, dar cursos de SharePoint (arg!), no es lo que más me gusta, pero ni modo la chamba es la chamba y hay que verla de la mejor manera posible. Espero pronto postear varios posts que tengo empezados pero no terminados.
Se invita a todas las personas interesadas a participar en la clínica para presentar el examen de certificación 70-536, la cual comenzará el próximo día 03 de marzo del 2008 y será llevada a cabo de manera online; siendo su duración aproximada de 2 meses. Se extiende esta invitación también a todas aquellas personas ya certificadas que deseen reforzar sus conocimientos acerca de los temas que toca el temario para este examen. La clínica es totalmente gratuita y será impartida por:
El temario lo pueden consultar aquí. Nos vemos en línea!
Existen muchas razones por las cuales una aplicación podría tener la capacidad de dibujar en pantalla y contenido visual como rectángulos, elipses, triángulos, círculos etc. WPF incluye una gran cantidad de funcionalidad para tener este tipo de gráficos y realmente existe una mejora significativa al dibujar con esta tecnología respecto a tecnologías previas como GDI+.
Shapes
Las Shapes (formas) son primitivas que nos permiten dibujar automáticamente algunas formas básicas y muy usadas en la definición de gráficos. La ventaja de utilizar Shapes es que incluyen todo lo necesario para definir la presentación y aspecto visual en las figuras sin necesidad de componer árboles de objetos complejos.
Las Shapes definidas por WPF se encuentran en el siguiente listado
| Shape (Forma) | |
| Ellipse | Dibuja círculos y elipses de circunferencia fija si se le especifican los atributos Width y Height o variable de acuerdo a su objeto contenedor si no se le especifican dichos atributos. |
| Line | Dibuja una línea dados dos puntos. Es posible especificar la presentación de la línea utilizando los atributos Stroke, StokeThikness entre otros. |
| Rectangle | Dibuja rectángulos y cuadrados y tiene la capacidad de modificar la presentación de las esquinas y el trazado de las líneas del rectángulo |
| Polyline | Dibuja rectas continuas |
| Polygon | Dibuja rectas continuas y añade un segmento de recta adicional para cerrar la figura. |
| Path | Dibuja líneas, curvas y en general cualquier caso siguiendo un conjunto de instrucciones especificadas mediante XAML o una notación especial |
Ellipse:
El siguiente código muestra la manera de dibujar dos elipses. La primera elipse tiene especificados los atributos Width Y Height por lo que al momento de cambiar de tamaño la ventana el dibujo de la elipse permanecerá inamovible mientras que en la elipse llamada MiElipseFija ocurrirá un redimensionamiento toda vez que hereda el tamaño especificado por su objeto contenedor
XAML
<Ellipse Margin="68,47,82,86" Width="50" Height="50" Name="MiElipseMovible" StrokeThickness="5" Stroke="Red" /> <Ellipse Margin="68,47,82,86" Name="MiElipseFija" Stroke="Blue" StrokeThickness="5"></Ellipse>
El resultado es el siguiente:
Para definir que una elipse será rellenada con determinado color es posible utilizar el atributo Fill.
Line:
Las líneas son uno de los elementos visuales más utilizados en las aplicaciones. Para definir una línea es necesario indicar los puntos origen y destino a través de los cuales se dibujará el segmento de recta. Para definir estos puntos hacemos uso de los atributos X1, Y1 para definir el primer punto y X2, Y2 para definir el segundo punto. El ejemplo siguiente muestra cómo definir dos líneas.
XAML
<Line X1="0" Y1="0" X2="300" Y2="280"
Stroke="Blue" StrokeThickness="14" />
<Line X1="0" Y1="260" X2="280" Y2="0"
StrokeThickness="14">
<Line.Stroke>
<ImageBrush ImageSource="C:\Revista USERS\2D\fondo.jpg" />
</Line.Stroke>
</Line>
La primera línea define para el atributo Stroke un color fijo mientras que la segunda línea utilizada un elemento ImageBrush para definir el trazado de dicha línea utilizada como fondo una imagen especificada en un archivo el resultado del código anterior es el siguiente.
Polyline
Este objeto representa una colección de líneas. Las líneas son definidas a través de la propiedad Points donde se definen los puntos por los cuales pasará el conjunto de líneas. De la misma manera que sucede con el objeto Line, podemos establecer el formato del trazado de la línea mediante los atributos Stroke, StrokeThikness entre otros. Además es posible utilizar el atributo Fill para llenar el área por la que pasan las líneas.
El código a continuación genera un triángulo:
XAML
<Polyline Points="100,100 200,40 300,100 104,100" Stroke="Black"
StrokeThickness="10" Margin="0,50" StrokeLineJoin="Round" Fill="Red"/>
Resultado
Polygon
La funcionalidad entre Polyline y Polygon es prácticamente la misma. La única diferencia que existe entre ambos objetos es que Polygon automáticamente añade una línea entre el primero y el último punto y de esta manera se genera una figura cerrada. A continuación mostramos el mismo ejemplo anterior utilizando ahora para ver la diferencia entre uno y otro
XAML
<Polygon Points="100,100 200,40 300,100 170,100" Stroke="Black"
StrokeThickness="10" Fill="Red" Margin="0,50" StrokeLineJoin="Round" />
Path
Con la clase Path es posible dibujar prácticamente cualquier trazo. A diferencia de las figuras vistas anteriormente, con éste objeto es posible dibujar inclusive curvas y rectas figuras abiertas y figuras cerradas, para eso, hace uso de la propiedad Data que tiene una notación que permite definir los movimientos, las curvas y las líneas mediante una notación sintaxis que se detalla a continuación.
| Shape (Forma) | |
| M | Define el punto inicial de una figura |
| L | Define una recta a partir de la posición actual y hasta el punto especificado |
| V, H | Definen una línea vertical u horizontal respectivamente |
| C, Q, S, T | Definen curvas de Bezier (cúbicas, cuadráticas, cúbicas suaves y cuadráticas suaves respectivamente) |
| A | Dibuja un arco elíptico |
| Z | Cierra la figura actual |
El siguiente ejemplo muestra como utilizar el objeto Path
XAML
<Path Stroke="Black" Fill="Blue">
<Path.Data>
<PathGeometry Figures="M 10,100 C 10,300 300,-100 300,100 " />
</Path.Data>
</Path>
El código previo genera la siguiente salida:
Cabe señalar que cuando es necesario dibujar una figura compleja no es muy práctico editar a mano el XAML; es por eso que podemos hacer uso de herramientas especializadas en diseño gráfico como Expression Blend que automáticamente genera el código requerido para representar los trazos y dibujos creados en la herramienta misma.
A continuación un ejemplo de código generado automáticamente con Expression Blend utilizando su herramienta Pencil.
XAML
<Path Stretch="Fill" Stroke="#FF000000" HorizontalAlignment="Left" Margin="154.833,0,0,121.5" VerticalAlignment="Bottom" Width="3" Height="59" Data="M155.33333,264 C155.76028,283.21278 157.33333,302.47815 157.33333,322"/>
<Path Stretch="Fill" Stroke="#FF000000" HorizontalAlignment="Left" Margin="189.5,0,0,122.167" VerticalAlignment="Bottom" Width="1.667" Height="59" Data="M190,263.33333 C190,282.62739 190.66667,301.97267 190.66667,321.33333"/>
<Path Stretch="Fill" Stroke="#FF000000" HorizontalAlignment="Left" Margin="156.833,0,0,152.167" VerticalAlignment="Bottom" Width="36.334" Height="2.503" Data="M157.33333,291.33333 C168.83269,289.12798 180.58536,290 192.66667,290"/>
<Path Stretch="Fill" Stroke="#FF000000" HorizontalAlignment="Left" Margin="198.432,0,0,127.415" VerticalAlignment="Bottom" Width="29.565" Height="27.752" Data="M214.66667,290 C204.25621,291.76448 202.49111,287.14113 200,303.33333 198.87719,310.63157 195.22353,319.6057 213.33333,314.66667 222.48637,312.17038 240.35052,303.42693 212.66667,289.33333"/>
<Path Stretch="Fill" Stroke="#FF000000" HorizontalAlignment="Left" Margin="238.167,0,0,125.5" VerticalAlignment="Bottom" Width="1.666" Height="55.667" Data="M239.33333,263.33333 C239.33333,281.67256 238.66667,299.67663 238.66667,318"/>
<Path Stretch="Fill" Stroke="#FF000000" HorizontalAlignment="Left" Margin="246.122,0,0,127.5" VerticalAlignment="Bottom" Width="33.045" Height="34.448" Data="M276,291.33333 C265.47034,284.113 258.73579,272.80992 249.33333,298.66667 245.70658,308.64023 241.38342,318.87219 268,310 270.13969,303.58094 273.33333,299.49906 273.33333,292 268.11259,304.18173 262.25661,306.1878 278.66667,316"/>
Resultado:
Animaciones
WPF incluye clases que nos permiten generar animaciones de una manera muy sencilla. Dentro de WPF básicamente las animaciones se logran mediante la variación de una o varias propiedades a través del tiempo; éstas propiedades pueden ser el tamaño del objeto, su posición, el color, su opacidad etc. Cuando las propiedades cambian durante el tiempo se percibe el efecto de animación.
Para crear una animación primero debemos de definir el objeto al cual queremos animar. Durante los siguientes pasos definiremos un círculo que variará su tamaño constantemente.
1) Antes que nada definimos un círculo con el siguiente código
XAML
<Ellipse Name="MiBalon" Height="50" Width="50" Stroke="Black" StrokeThickness="5"> </Ellipse>
2) Posteriormente utilizaremos la propiedad Ellipse.Triggers que define el suceso o condición que dará inicio a la animación. Existen varios tipos de Triggers como el DataTrigger que especifica una condición que se debe de cumplir para realizar alguna acción. También tenemos el EventTrigger que será el objeto que utilizaremos en éste ejemplo y que se usa cuando queremos definir un conjunto de acciones en respuesta a un evento. Cuando utilizamos EventTrigger debemos definir el evento que debe de suceder para disparar la animación mediante el atributo RoutedEvent, en este caso, definiremos el evento Ellipse.Loaded es decir: En el momento de que se cargue la Ellipse se iniciará inmediatamente la animación
XAML
<Ellipse Name="MiBalon" Height="50" Width="50" Stroke="Black" StrokeThickness="5"> <Ellipse.Triggers>
<EventTrigger RoutedEvent="Ellipse.Loaded"> </EventTrigger> </Ellipse.Triggers> </Ellipse>
3) Después de definir el evento utilizaremos las clases StoryBoard y BeginStoryBoard que representan una línea de tiempo y su inicio.
<Ellipse Name="MiBalon" Height="50" Width="50" Stroke="Black" StrokeThickness="5">
<Ellipse.Triggers>
<EventTrigger RoutedEvent="Ellipse.Loaded">
<BeginStoryboard>
<Storyboard>
</Storyboard>
</BeginStoryboard>
</EventTrigger>
</Ellipse.Triggers>
</Ellipse>
4) Para finalizar la creación de nuestra animación utilizaremos la clase DoubleAnimation que representa una animación que se aplica a aquellas propiedades que sean del tipo Double. De la misma manera existen diferentes tipos de animaciones como BooleanAnimation que anima propiedades del tipo Boolean, ColorAnimation que anima propiedades del tipo Color y así sucesivamente existen objetos de diferentes tipos para animar las propiedades que tienen el tipo de datos compatible con la animación. En nuestro ejemplo podemos apreciar que utilizaremos el atributo Duration que indica el tiempo en el que tiene que ser completada la animación así como los atributos From y To que representan el valor inicial y el valor final de las propiedades que serán animadas. También utilizamos el atributo RepeatBehavior que indica la cantidad de veces que será repetida la animación. El código del ejemplo completo se presenta a continuación.
XAML
<Ellipse Name="MiBalon" Height="50" Width="50" Stroke="Black" StrokeThickness="5">
<Ellipse.Triggers>
<EventTrigger RoutedEvent="Ellipse.Loaded">
<BeginStoryboard>
<Storyboard>
<DoubleAnimation Duration="0:0:01" From="50" To="250" Storyboard.TargetProperty="Width" RepeatBehavior="Forever"/>
<DoubleAnimation Duration="0:0:01" From="50" To="250" Storyboard.TargetProperty="Height" RepeatBehavior="Forever"/>
</Storyboard>
</BeginStoryboard>
</EventTrigger>
</Ellipse.Triggers>
</Ellipse>
El código anterior produce el siguiente resultado:
Además de que podemos utilizar los colores sólidos como el fondo de cualquier objeto que tenga la propiedad Background, también es posible utilizar gradientes. Estos gradientes se establecen a través de brochas (objetos que heredan del tipo Brush) y pueden ser Lineales (LinearGradientBrush) o Radiales (RadialGradientBrush).
En nuestro ejemplo añadiremos un gradiente al fondo del Grid y posteriormente lo animaremos a través de su propiedad Offset.
A continuación utilizaremos para nuestro ejemplo otro tipo de animación llamado ColorAnimation cuyo objetivo será cambiar de color el fondo (Fill) del círculo. El XAML requerido es el siguiente.
XAML
<Grid>
<Grid.Background>
<LinearGradientBrush>
<GradientStop Color="Blue" Offset=".0"></GradientStop>
<GradientStop Color="Lime" Offset=".99"></GradientStop>
</LinearGradientBrush>
</Grid.Background>
<Grid.Triggers>
<EventTrigger RoutedEvent="Grid.Loaded">
<BeginStoryboard>
<Storyboard>
<DoubleAnimation Duration="0:0:02" From="0.0" To=".99" Storyboard.TargetProperty="(Grid.Background).(LinearGradientBrush.GradientStops)[0].(GradientStop.Offset)" RepeatBehavior="Forever" />
</Storyboard>
</BeginStoryboard>
</EventTrigger>
</Grid.Triggers>
<Ellipse Name="MiBalon" Height="50" Width="50" StrokeThickness="5">
<Ellipse.Fill>
<SolidColorBrush Color="Transparent"></SolidColorBrush>
</Ellipse.Fill>
<Ellipse.Triggers>
<EventTrigger RoutedEvent="Ellipse.Loaded">
<BeginStoryboard>
<Storyboard>
<DoubleAnimation Duration="0:0:02" From="50" To="200" Storyboard.TargetProperty="Width" RepeatBehavior="Forever"/>
<DoubleAnimation Duration="0:0:02" From="50" To="200" Storyboard.TargetProperty="Height" RepeatBehavior="Forever"/>
<ColorAnimation From="Red" To="Yellow" Duration="0:0:02" Storyboard.TargetProperty="(Ellipse.Fill).(SolidColorBrush.Color)" RepeatBehavior="Forever"></ColorAnimation>
</Storyboard>
</BeginStoryboard>
</EventTrigger>
</Ellipse.Triggers>
</Ellipse>
</Grid>
Como podemos ver para poder animar el gradiente hacemos referencia a la ruta completa de la propiedad a la cual deseamos animar y nos referimos en específico a un GradientStop mediante su índice en la colección. El resultado que obtenemos es el siguiente:
Podemos notar que el color de la circunferencia ha cambiado de color rojo especificado hacia el color amarillo así como también se ha desplazado el gradiente hacia el color azul.
Eso es todo amigos cya next post!
¡Q tranx niños! Desde mi humilde opinión de los principales beneficios
que ofrece el motor de ejecución de Windows Workflow Foundation es que posee la
capacidad de proveer servicios que tienen como objetivo el simplificar las
tareas comunes a los cuales se enfrenta un desarrollador de flujos de trabajo.
El primero de los servicios que
cubriremos en nuestro estudio ese servicio denominado "Tracking Services" que puede ser utilizados para una gran cantidad
de objetivos.
Podemos definir a Tracking Services como el servicio que
proporciona automáticamente el rastreo y/o seguimiento de la ejecución de
cualquier instancia de un flujo de trabajo. Esta característica es
particularmente importante debido a que en los flujos de trabajo muchas veces
nos interesa saber qué actividades fueron ejecutadas y en general el camino que se siguió el motor
de ejecución para completar determinado
flujo de trabajo.
El panorama en el cual a nosotros
podemos hacer uso de esta característica es realmente amplio: Por ejemplo:
Cuando utilizamos a WorkFlow Foundation como un proveedor de servicios de
orquestación en un panorama de Enterprise Service Bus dentro de una
arquitectura orientada servicios es
sumamente importante conocer los
servicios que fueron invocados desde la orquestación y los usuarios que
utilizaron el sistema, en este escenario podemos utilizar los Tracking
services para monitorear la actividad que se está generando el
momento de ejecutar los flujos de trabajo involucrados en orquestación de los
servicios, en otras palabras la utilización de estos servicios será
efectivamente en los escenarios de auditoría de monitoreo de flujos de trabajo.
Para poder acceder a los
servicios que ofrece Tracking services
hacemos uso del espacio de nombres System.Workflow.Runtime.Tracking que contiene las clases que nos permitirán generar ya
sea a nuestra propia solución de monitoreo y seguimiento de los flujos de trabajo o bien podemos
utilizar soluciones que ya vienen listas para usarse como el SQL tracking
service.
Antes de continuar los
adentraremos un poco al arquitectura de Tracking
Services.
Básicamente existen tres
componentes principales dentro del arquitectura de los Tracking services y estos son:
1.
Tracking Profiles (perfiles de seguimiento)
Los perfiles de seguimiento representan
la manera con la cuál es posible identificar los orígenes y las fuentes de los eventos
que deseamos capturar dentro del monitoreo del flujo de trabajo. Estos perfiles
son indispensables al momento de generar nuestra propia solución de seguimiento.
Existen tres tipos de eventos o sucesos a los cuales nos podemos suscribir para
monitorearlos
a) Workflow Events (Eventos
del flujo de trabajo):
Estos eventos surgen a nivel de instancia y son
equivalentes a los eventos a los cuales nos suscribimos al momento de invocar
un flujo de trabajo. Como ejemplo de estos flujos tenemos los eventos: Created,
Terminated, Suspended etc.
b) Activity Events
(eventos de las actividades)
Estos eventos son generados por las actividades que están
siendo ejecutadas dentro de la instancia del flujo de trabajo.
c) User Events
(Eventos de usuario):
Existen ocasiones en las cuales es
necesario obtener información adicional sobre lo que está sucediendo en un
determinado flujo de trabajo y que no necesariamente corresponde a la situación
de la instancia del mismo flujo de trabajo o de alguna de sus actividades sino
que es necesario generar un suceso personalizado para capturar determinado
comportamiento del flujo de trabajo.
Para cada uno de los eventos
descritos previamente existe una clase específica que guarda información sobre
los mismos. Nos referimos a las clases WorkflowTrackingRecord ActivityTrackingRecord
y UserTrackingRecord
respectivamente
2. Tracking Runtime (Motor de
ejecución de los servicios de seguimiento)
El motor de ejecución de los servicios de seguimiento de
los flujos de trabajo se encarga de iniciarlo servicios de monitoreo que han
sido declarados antes de la invocación de la instancia del flujo de trabajo que
deseamos monitorear para hacer esto utiliza la información encontrada dentro de
los perfiles de seguimiento.
3. Channels
(Canales)
Los canales de
monitoreo se usan para enviar los registros asociados a la instancia del flujo
de trabajo cuando se encuentra un tracking point que es la clase genérica que
recibe información de lo que está sucediendo dentro del flujo de trabajo.
Crearemos a continuación la implementación básica de un
servicio de seguimiento personalizado.
1) Iniciaremos con
una forma a la que llamaremos FormaInicio,
en la cual colocaremos dos etiquetas, una de las cuales usaremos como el
receptor de la información que generan las actividades del flujo de trabajo, y
otra como los mensajes que genera el servicio de seguimiento (Tracking Service)
que generaremos en este ejemplo.
![]()
2) Añadiremos a continuación a la solución un flujo de
trabajo secuencial y agregaremos una actividad del tipo codeActivity
![]()
3) En el código de codeActivity1 simplemente escribiremos en
la etiqueta un mensaje con el siguiente código
C#
|
private
void codeActivity1_ExecuteCode(object sender, EventArgs
e)
{
Programa.FormaInicio.lblMensaje.Text += "MENSAJE DESDE LA CODEACTIVITY1\n";
}
}
|
|
4) Posteriormente vamos a invocar la ejecución del flujo de
trabajo en el manejador de evento del clic del botón de la forma y generaremos
la suscripción al evento WorkFlowCompleted del flujo de trabajo con el código
que aparece a continuación
C#
|
private void
button1_Click(object sender, EventArgs e)
{
WorkflowRuntime
MotorWF = new WorkflowRuntime();
Type
Tipo = typeof(Workflow1);
WorkflowInstance
InstanciaWF = MotorWF.CreateWorkflow(Tipo);
InstanciaWF.Start();
MotorWF.WorkflowCompleted +=
new
EventHandler<WorkflowCompletedEventArgs>(MotorWF_WorkflowCompleted);
}
void
MotorWF_WorkflowCompleted(object sender, WorkflowCompletedEventArgs e)
{
MessageBox.Show("¡El
flujo de trabajo fue finalizado!");
}
}
|
|
Al momento de ejecutar el código previamente mostrado en la
etiqueta que recibe la información generada desde flujo de trabajo deberá
aparecer el mensaje "MENSAJE DESDE LA
CODEACTIVITY1"
5) Hemos llegado al momento en el
cuál propiamente iniciaremos el desarrollo del servicio de tracking. Añadiremos
una nueva clase a nuestro proyecto que denominaremos ServicioSeguimiento. Esta clase deberá heredar de la
clase TrackingService que es la clase
abstracta base que provee la interfase entre un servicio de seguimiento y el motor de ejecución de los
servicios de seguimiento que mencionamos anteriormente en los conceptos de
arquitectura de este capítulo.
Para generar exitosamente una
clase que pueda ser consumida por el motor de seguimiento es necesario sobreescribir
(hacer override) los siguientes miembros de la clase base TrackingService.
-
GetProfile(Guid),
-
GetProfile(Type,
Version)
-
TryGetProfile
-
GetTrackingChannel
-
TryReloadProfile.
El motor de ejecución de los
servicios de seguimiento solicita un objeto del tipo TrackingChannel para cada una de las instancias que
tienen un TrackingProfile asignado y usa este TrackingChannel para mandar los
registros asociados a dar una instancia de flujo de trabajo. Dentro de la definición del TrackingProfile se debe de especificar
cuáles serán los eventos que serán monitoreados y cuya información es recibida
por un TrackingRecord que como vimos
anteriormente, puede tener como clases concretas los tipos: ActivityTrackingRecord, UserTrackingRecord o WorkflowTrackingRecord.
Posteriormente la infraestructura
de WF manda a llamar el método TryReloadProfile para verificar si se debe recargar el Profile.
Este proceso permite a un cliente o a un servicio cambiar un profile de
seguimiento cambiar dinámicamente.
C#
|
public class
ServicioSeguimiento : TrackingService
{
protected
override bool
TryGetProfile(Type workflowType, out TrackingProfile
profile)
{
//El objetivo de
este método es que el motor de seguimiento
//dependiendo del tipo de WF el servicio puede utilizar
diferentes tracking
//profiles. Aunque es necesario hacer el override en
este ejemplo utilizaremos
//para que el ejemplo compile en esta muestra usaremos
//el mismo profile para cualquier WF
profile = ObtenerProfile();
return
true;
}
protected
override TrackingProfile
GetProfile(Guid workflowInstanceId)
{
// No será implementado para este ejemplo
throw new
NotImplementedException("No implementado");
}
|
|
|
protected
override TrackingProfile
GetProfile(Type workflowType, Version profileVersionId)
{
return
ObtenerProfile();
}
protected
override bool
TryReloadProfile(Type workflowType, Guid workflowInstanceId, out TrackingProfile
profile)
{
// En este caso siempre regresamos falso indicando que
no hay nuevos profiles
profile = null;
return
false;
}
protected
override TrackingChannel
GetTrackingChannel(TrackingParameters
parametros)
{
//El motor de WF llama este método para obtener el
canal para la instancia de monitoreo
return new
CanaldeSeguimiento(parametros);
}
private
TrackingProfile ObtenerProfile()
{
//
Creamos un Tracking Profile
TrackingProfile
profile = new TrackingProfile();
profile.Version
= new Version("3.0.0");
// En este
caso monitorearemos específicamente actividades, no otro tipo de eventos
ActivityTrackPoint PuntoSeguimiento = new ActivityTrackPoint();
ActivityTrackingLocation
LocacionActividad = new ActivityTrackingLocation(typeof(Activity));
LocacionActividad.MatchDerivedTypes
= true;
//Con este código se registran todos los posibles
estados
IEnumerable<ActivityExecutionStatus>
estados = Enum.GetValues(typeof(ActivityExecutionStatus))
as IEnumerable<ActivityExecutionStatus>;
foreach
(ActivityExecutionStatus estado in estados)
{
LocacionActividad.ExecutionStatusEvents.Add(estado);
}
PuntoSeguimiento.MatchingLocations.Add(LocacionActividad);
profile.ActivityTrackPoints.Add(PuntoSeguimiento);
return
profile;
}
}
|
|
Como podemos ver en el código
presentado anteriormente el método GetTrackingChannel
devuelve un objeto del tipo TrackingChannel donde
en este caso específicamente estaremos enviando a la forma la información que
ha sido monitoreada automáticamente al momento de ser ejecutado el flujo de
trabajo.
6) A continuación añadiremos a
nuestro programa una nueva clase denominada CanaldeSeguimiento que heredará de TrackingChannel cuyo objetivo será manejar
para persistirlos. En nuestro ejemplo simplemente se envía la información
recopilada a la etiqueta que se encuentra en la forma.
De esta clase es necesario sobre
escribir los métodos heredados desde la clase abstracta Send y InstanceCompletedOrTerminated para lograr un código
como el siguiente:
|
public class
CanaldeSeguimiento : TrackingChannel
{
private
TrackingParameters Parametros = null;
protected CanaldeSeguimiento()
{
}
public
CanaldeSeguimiento(TrackingParameters
parametros)
{
this.Parametros = parametros;
}
//Este
es el método que se ejecuta para realizar el registro de la actividad
generada por el WF
protected override void Send(TrackingRecord
Registro)
{
ActivityTrackingRecord
RegistroActividad = (ActivityTrackingRecord)Registro;
Programa.FormaInicio.lblSeguimiento.Text+="Hora: " +
RegistroActividad.EventDateTime.ToString();
Programa.FormaInicio.lblSeguimiento.Text
+= "Fecha: " +
RegistroActividad.QualifiedName.ToString();
Programa.FormaInicio.lblSeguimiento.Text += "Tipo:
" + RegistroActividad.ActivityType;
Programa.FormaInicio.lblSeguimiento.Text += "Estado: " +
RegistroActividad.ExecutionStatus.ToString();
}
//Se
llama cuando se termina de ejecutar la instancia
protected override void InstanceCompletedOrTerminated()
{
MessageBox.Show("Se terminó la instancia");
}
}
|
|
Hemos descrito entonces los pasos
básicos para generar un servicio de seguimiento personalizado para cualquier
instancia de un flujo de trabajo, que monitorea la ejecución de actividades y
en este caso muestra la información a la etiqueta definida en nuestra forma principal
oct.
Lo único que falta para que
nuestro Tracking Service
personalizado funcione es agregar el servicio al momento de que se invocan las
islas de los flujos de trabajo es decir, en el
debemos de modificar nuestra invocación con la siguiente línea de código
|
private void
button1_Click(object sender, EventArgs e)
{
WorkflowRuntime
MotorWF = new WorkflowRuntime();
//Añadimos
el servicio que acabamos de crear
MotorWF.AddService(new ServicioSeguimiento());
Type Tipo = typeof(Workflow1);
WorkflowInstance
InstanciaWF = MotorWF.CreateWorkflow(Tipo);
InstanciaWF.Start();
MotorWF.WorkflowCompleted +=
new
EventHandler<WorkflowCompletedEventArgs>(MotorWF_WorkflowCompleted);
}
void
MotorWF_WorkflowCompleted(object sender, WorkflowCompletedEventArgs e)
{
MessageBox.Show("¡El
flujo de trabajo fue finalizado!");
}
}
|
|
Al momento de ejecutar el código anterior y
oprimir el botón de invocación del flujo de trabajo podemos observar cómo el
motor de ejecución de Workflow Foundation ejecuta los diferentes métodos
definidos en las clases ServicioSeguimiento y CanaldeSeguimiento y muestra en
la forma el resultado del seguimiento del flujo de trabajo
![]()
Como pudimos observar los ejemplo
anterior podemos hacer un seguimiento muy específico de todas las situaciones
que están ocurriendo durante la ejecución de nuestro flujo de trabajo para
llevar a una auditoría muy a detalle de lo que sucede en el WF; sin embargo no
siempre es necesario programar lo que hemos visto previamente sino que WF
incluye una solución ya lista para usarse basada en SQL Server que se denomina
SQLTracking y que hace lo mismo que vimos anteriormente pero su persistencia es
evidentemente el servidor de base de datos SQL Server y nosotros lucharemos que
programar absolutamente nada porque todo ya está hecho. Cabe señalar que ésta
implementación utiliza la misma técnica y usa como clase de bases las mismas
clases que utilizamos para nuestro tracking service personalizado.
Para poder utilizar esta
funcionalidad es necesario tener instalada correctamente una instancia de SQL
Server 2005 (Express o cualquier versión comercial) y ejecutar unos scripts que
se distribuyen con la instalación del .NET Framework 3.0 y que se encuentran en
C:\WINDOWS\Microsoft.NET\Framework\v3.0\Windows Workflow Foundation\SQL\EN
Estos scripts son:
- Tracking_Schema.sql Crea la estructura de SQLTracking en la BDD.
-
Logic_Schema.sql, Crea la lógica de negocio de SQLTracking
en la BDD.
Modificando nuestro ejemplo
previo agregaremos ahora el servicio SqlTrackingService que como podemos ver contiene
un constructor sobrecargado en el cual le pasaremos como parámetro la cadena de
conexión que indica la instancia y el nombre de la base de datos de SQL Server.
|
private void
button1_Click(object sender, EventArgs e)
{
WorkflowRuntime
MotorWF = new WorkflowRuntime();
MotorWF.AddService(new ServicioSeguimiento());
//Agregamos servicio SQLTrackingService;
MotorWF.AddService(new
SqlTrackingService(@"Data
Source=.\sqlexpress;" +
"Initial Catalog=Tracking;Integrated Security=sspi"));
Type
Tipo = typeof(Workflow1);
WorkflowInstance
InstanciaWF = MotorWF.CreateWorkflow(Tipo);
InstanciaWF.Start();
MotorWF.WorkflowCompleted +=
new
EventHandler<WorkflowCompletedEventArgs>(MotorWF_WorkflowCompleted);
}
|
|
Podemos ahora
ir al Management Studio de SQL Server y ejecutar el siguiente query que nos
mostrará la efectividad del SqlTrackingService:
T-SQL
|
|
|
SELECT
TrackingWorkflowEvent.Description as Evento,
WorkflowInstanceEvent.EventDateTime as HoraInicial,
WorkflowInstance.WorkflowInstanceId as InstanciaWF,
Type.TypeFullName as NombreWF
FROM
WorkflowInstanceEvent
INNER JOIN
TrackingWorkflowEvent ON
WorkflowInstanceEvent.TrackingWorkflowEventId
= TrackingWorkflowEvent.TrackingWorkflowEventId AND
WorkflowInstanceEvent.TrackingWorkflowEventId
= TrackingWorkflowEvent.TrackingWorkflowEventId
INNER JOIN
WorkflowInstance ON
WorkflowInstance.WorkflowInstanceInternalId=WorkflowInstanceEvent.WorkflowInstanceInternalId
INNER JOIN
Type ON
Type.TypeId = WorkflowInstance.WorkflowTypeId
|
|
El query
anterior nos mostrará el siguiente resultado
Persistencia
Existe otro
concepto muy importante dentro de los flujos de trabajo y que también es provisto
mediante los servicios de ejecución del motor de flujos de trabajo de Workflow
Foundation es la persistencia. Este concepto se le denomina persistencia y es
utilizada siempre que se requiere recordar el estado de una determinada
instancia de un flujo de trabajo para posteriormente ocuparla en otro momento
del tiempo. Este tipo de flujos de trabajo son muy utilizados en los flujos
humanos es decir aquellos en los cuales intervienen diferentes miembros una
organización y cada uno completa una parte de las actividades específicas
dentro del flujo de trabajo pero no lo hacen todos al mismo tiempo sino que
cada quien interviene con sus actividades del flujo en momentos discontinuos.
El motor de flujos de trabajo sobre una solución extremadamente simple y fácil
de utilizar para implementar este tipo de flujo de trabajo también denominados
flujos de trabajo de ejecución larga (Long
running workflows)
Los servicios
de persistencia de Workflow Foundation se encargan de guardar el estado de
cualquier instancia de los flujos de trabajo en lo hacen de una manera
transparente automática al momento de que ocurre algún evento que haga que el
flujo de trabajo entre en un estado de suspensión es decir toda la información
referente al flujo se serializa en un medio persistente (de ahí el nombre)
Modificaremos
ahora el proyecto previamente usado para verificar el funcionamiento de los
servicios de persistencia de WF.
1) Lo primero
que haremos será modificar nuestro flujo de trabajo agregando una actividad del
tipo SuspendActivity y otra CodeActivity
después de la primera, cuyo código será: Programa.FormaInicio.lblMensaje.Text += "MENSAJE DESDE LA CODEACTIVITY2\n";
![]()
2)
Modificaremos también la forma principal del proyecto (frmInicio) y le
agregaremos una caja de texto, así como un botón adicional, de tal manera que
quede parecida a la siguiente:
![]()
3)
Modificaremos ahora la invocación del flujo de trabajo en el primer botón para
añadir el servicio de SqlWorkflowPersistenceService
que se encuentra dentro del espacio de nombres
System.Workflow.Runtime.Hosting, así mismo agregaremos un manejador de eventos
para que el host se suscriba al evento que generará la SuspendActivity y que
notificará al host de dicha suspensión tal modo que la inicialización del motor del flujo
de trabajo deberá parecerse a la siguiente:
|
private void
button1_Click(object sender, EventArgs e)
{
WorkflowRuntime
MotorWF = new WorkflowRuntime();
MotorWF.AddService(new ServicioSeguimiento());
//Agregamos
servicio SQLTrackingService;
MotorWF.AddService(new
SqlTrackingService(@"Data Source=.\sqlexpress;" +
"Initial
Catalog=WF;Integrated Security=sspi"));
//Agregamos
servicio de persistencia
MotorWF.AddService(new
SqlWorkflowPersistenceService (@"Data Source=.\sqlexpress;"
+
"Initial Catalog=WF;Integrated
Security=sspi"));
Type
Tipo = typeof(Workflow1);
WorkflowInstance
InstanciaWF = MotorWF.CreateWorkflow(Tipo);
MotorWF.WorkflowCompleted +=
new
EventHandler<WorkflowCompletedEventArgs>(MotorWF_WorkflowCompleted);
//Nos
suscribimos a la suspensión del flujo de trabajo por la SuspendActivity
// que añadimos al WF.
MotorWF.WorkflowSuspended +=
new EventHandler<WorkflowSuspendedEventArgs>(MotorWF_WorkflowSuspended);
InstanciaWF.Start();
}
|
|
4) En el manejador de de eventos
determinado por la función MotorWF_WorkflowSuspended agregaremos el siguiente
código para obtener el id de instancia del WF que usaremos posteriormente para
solicitar al motor de WF que reactive el flujo de trabajo persistido. Haremos
esto mediante el siguiente código.
C#
|
void MotorWF_WorkflowSuspended(object sender, WorkflowSuspendedEventArgs
e)
{
e.WorkflowInstance.Unload();
MessageBox.Show("WF Persistido!!!");
//Agregamos
el id de instancia a caja de texto para hacer la reactivacion
this.textBox1.Text =
e.WorkflowInstance.InstanceId.ToString();
}
|
|
5)Para
finalizar, al nuevo botón que acabamos de agregar le añadiremos el siguiente
código que invoca a los servicios de persistencia para reactivar el flujo de
trabajo previamente persistido (debido a que fue suspendido y descargado en el
paso previo) utilizando como su identificador el id de la instancia que se
encuentra en la caja de texto.
C#
|
private void
button2_Click(object sender, EventArgs e)
{
WorkflowRuntime
MotorWF = new WorkflowRuntime();
MotorWF.AddService(new
SqlWorkflowPersistenceService(@"Data Source=.\sqlexpress;" +
"Initial
Catalog=WF;Integrated Security=sspi"));
MotorWF.StartRuntime();
MotorWF.WorkflowCompleted +=
new
EventHandler<WorkflowCompletedEventArgs>(MotorWF_WorkflowCompleted);
WorkflowInstance
InstanciaWF = MotorWF.GetWorkflow(new Guid(this.textBox1.Text));
InstanciaWF.Resume();
}
|
|
6) Al ejecutar
el flujo de trabajo podemos observar que la instancia es suspendida después de
que se ejecuta la primera actividad de código, y posteriormente la caja de
texto adquiere el GUID que representa la instancia del WF.
![]()
7) Al oprimir el botón con el
texto Reactivar WF se reactivará el flujo de trabajo persistido mediante
SQLPersistenceServices y el motor de ejecución de WF completará el proceso de ejecución del flujo de trabajo.
Bueno pues ojalá les haya latido el artículo. El código fuente completo de este artículo está aqui
No se despeguen de este blog porque vienen cosas interesantes.
Antes de irme a dormir, algunas cosas:
a) Estamos organizando algo muy padre para juntarnos y platicar sobre tecnología aquí en la Ciudad de México. Muy pronto más detalles.
b) Ultimamente he tenido el gusto de recibir bastante correspondencia de ustedes, mis queridisimos lectores (jajaja chale ke gay) el caso es que me da mucho gusto que me escriban :) pero les recomiendo que lo hagan en los foros de este espacio para que las dudas y las respuestas puedan estar disponibles para todos, de todos modos les seguiré contestando pero si son dudas netamente técnicas (como la mayoría de los mails que he recibido estos dias) les pediría que lo pongan acá en los foros, ah ahora que me acuerdo hay gente que me comenta que no recibe el mail de confirmación cuando se registran. El buen Victor Alameda seguramente pronto verificará que onda con el sistema.
Un abrazo, coman sano, con y sin albur.
Maic.
Conceptos sobre
programación funcional y las mejoras sintácticas de C# 3.0 y VB 9.0
Hola niños ¡Estamos a unas horas del 2008! Espero que se
encuentren muy bien y Santa Claus les haya traído algo más que nuevos depósitos
de grasa en su puerquecito. Me quería despedir del 2007, con un artículo para
toda la banda geek que pulula por la red. Deseo sinceramente que el año
venidero esté lleno de Salud, Dinero y Sexo, o como dicen los cursis “Amor”.
¡No todo es computadoras niños, salgan a la calle y busquen a quien amar, puaf,
escupí lengua!
En fin, al diablo con mi intento de ser gracioso. En este
post podrán encontrar la mayoría de las características sintácticas nuevas que
encontramos en los lenguajes de programación que salieron con la versión de
Visual Studio 2008 (Me refiero a C# 3.0 Y VB 9.0) , o lo que es lo mismo en
este post hablaré de los cambios sintácticos que tienen los lenguajes de
programación de Microsoft para dar soporte a la tecnología denominada LINQ,
además de un breviario sobre programación funcional.
Es importante conocer estos detalles toda vez que si
ignoramos su funcionamiento es muy posible que no podamos explotar cabalidad la
gran cantidad de características que tenemos a nuestra disposición con los
lenguajes.
Bueno pues ahora comencemos
pues a recorrer las nuevas características que estoy seguro le serán muy
interesantes.
1) Inferencia de tipos
Una de las principales características encontramos en .NET
3.5 es la inferencia de tipos,
La inferencia de tipos es fundamental para el funcionamiento
de la tecnología LINQ, toda vez que al momento de hacer un query, no es posible
saber el tipo de datos de la colección
que regresará el mismo query.
Esta característica nos permite utilizar la palabra
reservada var
en C# o Dim en conjunto con Option Infer On en Visual Basic para declarar cualquier
variable antes de un query o bien declararla en línea e inicializarla al mismo
tiempo. Automáticamente el compilador de los lenguajes asumirá el tipo de datos
asignado en la inicialización o en la ejecución del query y hará que la
variable sea fuertemente tipeada durante el resto de la ejecución del programa;
como podemos apreciar esto difiere totalmente el funcionamiento Javascript o del
mismo Visual Basic 6.0 con su tipo de
datos Variant, ya que en estos lenguajes es posible cambiar dinámicamente de
tipo de datos, con su correspondiente pérdida de desempeño y la mayor
probabilidad de incurrir en errores de programación en tiempo de ejecución. En
.NET 3.5 esto NO se da debido a que la
inferencia equipos se hace en tiempo de compilación y no en tiempo de ejecución
como sucede con VB 6.0
Para mostrar esto comenzaremos con crear una simple clase de
discos
C#
public
class Disco
{
public
int Id;
public
string Titulo;
public
string
Interprete;
public
string Genero;
public
double Precio;
}
VB
Public Class
Disco
Public
Id As Integer
Public
Titulo As String
Public Interprete As
String
Public Genero As
String
Public Precio As
Double
End Class
Posteriormente haremos uso de la inferencia de tipos de la
siguiente manera
C#
var lobjDisco=new
Disco() ;
lobjDisco.Genero = "Cumbia";
lobjDisco.Interprete = "Laura Leon";
lobjDisco.Id = 1;
lobjDisco.Titulo = "Noches de cumbia";
MessageBox.Show(lobjDisco.Genero);
VB
Option Infer On
Dim lobjDisco = New
Disco
lobjDisco.Genero = "Cumbia"
lobjDisco.Interprete = "Laura Leon"
lobjDisco.Id = 1
lobjDisco.Titulo = "Noches de cumbia"
lobjDisco.Precio = 230
MsgBox(lobjDisco.Genero)
El código del ejemplo anterior mostrara correctamente el
género del disco si somos algo curiosos podemos tratar de asignar a la variable
lobjDisco un objeto que no se del
tipo disco y podemos ver cómo el compilador nos dirá una grosería toda vez que
la variable es fuertemente tipeada.
2) Inicializadores de objetos.
Esta azúcar sintáctica es realmente útil debido a que
en .NET 2.x y anteriores es necesario generar un constructor sobrecargado si
queremos inicializar las variables de un objeto al momento de que es
instanciado, así sí tenemos 20 variables es necesario generar 20 constructores
(o muchos más si las combinamos) para
poder inicializar las propiedades o campos de nuestro objeto lo cual se traduce
en una gran pérdida de tiempo al momento de estar programando. Con esta
característica sin modificar el código previo de definición de la clase disco
podemos utilizar la siguiente sintaxis que nos permitirá inicializar las
propiedades o campos del objeto:
C#
lobjDisco = new
Disco { Id = 2, Genero = "Trance", Interprete = "Armin Van Buuren" , Precio=300};
VB
lobjDisco = New Disco With {.Id =
2, .Genero = "Trance", .Interprete
= "Armin Van Buuren", .Precio =
130}
3) Tipos anónimos
Los tipos anonimos nos permiten generar tipos al
vuelo sin necesidad de declarar explícitamente la estructura y la definición de
la clase. Esto se usa principalmente cuando queremos hacer algún cálculo o
queremos generar un nuevo tipo basado en el resultado que nos pudiera llegar a
dar un query de LINQ. En la misma manera que sucede con inferencia de tipos los
tipos anónimos son creados en tiempo de compilación y no en tiempo de ejecución
lo que se traduce en que no hay pérdida de rendimiento de la aplicación cabe
señalar que los miembros de los tipos anónimos son de solo lectura
C#
var
lobjDisquera = new { Nombre = "Discos Maic" };
var
lobjDisquera2 = new { Nombre = "Discos Lucha" };
var
lobjDisquera3 = lobjDisquera2;
MessageBox.Show(lobjDisquera3.Nombre);
VB
Dim
lobjDisquera = New With
{.Nombre = "Discos Maic"}
Dim
lobjDisquera2 = New With
{.Nombre = "Discos Lucha"}
Dim
lobjDisquera3 = lobjDisquera2
MsgBox(lobjDisquera3.Nombre)
4) Métodos de
extension
Sabemos nosotros que en el mundo de. Net es possible
utilizar técnicas como la herencia desde una clase abstracta y generar métodos
adicionales por una clase concreta para extender la funcionalidad de una clase
base, sin embargo muchas veces para lograr esto es necesario re compilar el
tipo de datos original y derivado además de que es necesario tener los permisos
correspondientes en la clase base para poder extender exitosamente el tipo.
Los métodos de extensión nos permiten agregar
funcionalidad adicional a una clase base sin necesidad de generar subclases.
Cabe señalar que los métodos de extensión deben de ser estáticos.
Para definir un método de extensión utilizamos la
siguiente sintaxis
C#
public
static class Extensiones
{
public
static void
MostrarPrecio(this Disco
pobjDisco)
{
MessageBox.Show(pobjDisco.Precio.ToString());
}
}
VB
Module Extensiones
<Extension()> Public Sub MostrarPrecio(ByVal pobjDisco As
Disco)
MsgBox(pobjDisco.Precio)
End Sub
End Module
Una vez que nosotros implementamos el código anterior
podemos ver que el tipo disco ahora tienen método de extensión denominado
MostrarPrecio y podemos invocarlo como cualquier otro método.
Cuando nosotros utilizamos LINQ, al momento de hacer
un query, el objeto resultante de este query tiene una gran cantidad de métodos
de extensión añadidos que nos permiten utilizar la funcionalidad de los
operadores de query como group by, order by, count, average etc., De ahí la
importancia de conocer su correcto funcionamiento.
5) Sintaxis de
Query (LINQ)
LINQ como tal es una serie de tecnologías que nos
permiten utilizar sentencias parecidas a SQL para manipular los objetos de la
misma manera que lo hacemos con tablas del paradigma la relaciónal.
La tecnología LINQ esta dividida en diferentes
sabores de acuerdo a su aplicación.
LINQ to
Objects: es la tecnología que examinaremos con el siguiente código
cualquier objeto que sea una colección dentro de. Net es susceptible a que se
le haga un cuello con LINQ y generará a partir de ella un nuevo tipo de datos
obteniendo los resultados del query
C#
lobjDiscos.Add(new Disco{Id =
3,Genero="Pop",Interprete="Fey", Titulo="Vertigo",
Precio=120});
lobjDiscos.Add(new Disco { Id =
4, Genero = "Pop", Interprete = "Simply Red", Titulo = "Sunrise", Precio = 320 });
lobjDiscos.Add(new Disco { Id =
5, Genero = "Rock", Interprete = "Guns n Roses", Titulo = "Use your ilution", Precio = 220 });
lobjDiscos.Add(new
Disco { Id = 6, Genero = "Dance", Interprete = "Gigi Dagostino", Titulo = "L amour tojours", Precio = 99 });
lobjDiscos.Add(new Disco { Id =
7, Genero = "Clasica", Interprete
= "Haendel", Titulo = "Mesias", Precio = 410 });
lobjDiscos.Add(new Disco { Id =
8, Genero = "Hip Hop", Interprete
= "Linkin Park", Titulo = "Meteora", Precio = 60 });
var
lobjDiscosSeleccionados = from
lobjSeleccionDiscos in lobjDiscos
where lobjSeleccionDiscos.Precio > 300
orderby lobjSeleccionDiscos.Id
select new
{lobjSeleccionDiscos.Titulo, lobjSeleccionDiscos.Precio};
foreach
(var lobjDisc in
lobjDiscosSeleccionados)
{
MessageBox.Show(lobjDisc.Titulo
+ " - " +lobjDisc.Precio);
}
VB
lobjDiscos.Add(New
Disco With {.Id = 3, .Genero = "Pop", .Interprete = "Fey", .Titulo = "Vertigo", .Precio = 120})
lobjDiscos.Add(New
Disco With {.Id = 4, .Genero = "Pop", .Interprete = "Simply Red", .Titulo = "Sunrise", .Precio = 320})
lobjDiscos.Add(New Disco With {.Id =
5, .Genero = "Rock", .Interprete =
"Guns n Roses", .Titulo = "Use your ilution", .Precio = 220})
lobjDiscos.Add(New Disco With {.Id =
6, .Genero = "Dance", .Interprete
= "Gigi Dagostino", .Titulo = "L amour tojours", .Precio = 99})
lobjDiscos.Add(New Disco With {.Id =
7, .Genero = "Clasica",
.Interprete = "Haendel", .Titulo =
"Mesias", .Precio = 410})
lobjDiscos.Add(New Disco With {.Id =
8, .Genero = "Hip Hop",
.Interprete = "Linkin Park",
.Titulo = "Meteora", .Precio =
60})
Dim
lobjDiscosSeleccionados = From
lobjSeleccionDiscos In lobjDiscos _
Where lobjSeleccionDiscos.Precio > 300 _
Order
By lobjSeleccionDiscos.Titulo Ascending _
Select
lobjSeleccionDiscos.Titulo, lobjSeleccionDiscos.Precio
For Each lobjDisc In
lobjDiscosSeleccionados
MessageBox.Show(lobjDisc.Titulo.ToString() + "
- " + lobjDisc.Precio.ToString())
Next
Asimismo también tenemos LINQ to dataSet que como ustedes se pueden imaginar nos permite
ejecutar queries is a través de las estructuras DataSet the que
ofrece. Net. Con esto podemos eliminar
desde luego el uso del objeto DataView que se montaba sobre un dataSet y que
nos permitía realizar funcionalidades equivalentes a un motor de base de datos
como el ordenamiento o el filtrado de los datos de acuerdo a sentencias
específicas ahora podemos utilizar LINQ directamente para extraer la
información deseada.
También tenemos LINQ
to XML donde es posible generar un query a partir de la declaración de un árbol
XML, LINQ to SQL que nos permite
(pronto un artículo sobre esto) generar objetos basándonos en la definición de
una base de datos relacional (un ORM con esteroides) y LINQ to Entities, una
tecnología que estará disponible en el futuro cercano cuyo objetivo es poner
una capa intermedia de a basada en XML donde se defina la estructura y mapeo de
los datos además de que contará con soporte a múltiples proveedores de base de
datos
6) Expresiones
lambda y conceptos sobre la programación funcional
El lenguaje de programación C# se está convirtiendo en un
lenguaje de programación funcional.
La programación funcional es un paradigma de la misma manera
que lo es el paradigma orientado objetos o la programación imperativa.
Existen lenguajes con enfoque el paradigma funcional desde
hace ya bastante rato, el ejemplo principal es Haskell.
Así como en la programación orientada a objetos se tiene
como objetivo primero describirle el mundo a la computadora mediante las clases
y luego resolver el algoritmo mediante la interacción (relaciones) entre los
objetos, el objetivo de la programación funcional es establecer “relaciones de
igualdad” (de la misma manera que sucede en las ecuaciones matemáticas).
En la programación funcional debemos pensar que todo es
una función y que el problema se resolverá mediante la generación de funciones
y su descomposición en otras funciones más simples, o bien al revés, que
podemos encontrar la solución a un problema componiendo funciones de funciones y evaluando expresiones que resultan de la
invocación de las mismas funciones. ¿Suena enredado? Para nada, es más fácil de
lo que se puedan imaginar.
Por ejemplo, sabemos que el doble de un numero x será x+x.
Utilizando la sintaxis de C# tenemos .
(En el siguiente ejemplo usamos expresiones lambda, para más
detalle ver este artículo)
C#
Doble x = (int
y) => y + y;
MessageBox.Show(x(2).ToString());
El resultado será 4
Así mismo sabemos que el cuádruple del mismo número será
el doble del doble, en lugar de generar otro método para definirlo, podemos
hacer uso de la inferencia de tipos que es básica en cualquier lenguaje de
programación funcional y escribir lo siguiente (y que desde luego C# y VB la
implementan)
var Cuadruple = x(x(2));
// o bien
var Cuadruple = x(2) + x(2) ;
MessageBox.Show(Cuadruple.ToString());
El resultado será 8
Y desde luego, si queremos saber el óctuple…
var Octuple = Cuadruple+Cuadruple;
MessageBox.Show(Octuple.ToString());
El resultado será 16.
Como podemos ver ya no estamos escribiendo más definiciones
de funciones ni creando su cuerpo, simplemente estamos haciendo referencia
mediante inferencia de tipos a una función que creamos al principio, como
podemos ver esto se traduce en un aumento de la productividad del programador porque
a resumidas cuentas nos estamos ahorrando una gran cantidad de código.
El soporte que tiene C#
para expresiones lambda (la base de la programación funcional) es mucho
mejor que el que existe en VB (por
ejemplo, en VB las expresiones lambda deben ser expresiones que generen valores
y no pueden ser sentencias, es decir no podemos crear una variable local dentro
del cuerpo de una expresión lambda, cosa que sí se puede con C#) y con el
futuro seguramente este soporte será ampliado.
Por su parte el equipo de VB ha decidido unir el destino del
veterano VB al destino de la programación en xml con características como XML
Literals (ver más abajo para más detalle).
Muchos programadores en C# quizá se sientan algo desilusionados debido a que el soporte en xml ahora es muchísimo más exhaustivo
en visual basic que en C#, sin embargo creo que la decisión del equipo de C#
tiene mucha lógica y se fundamenta en que las tecnologías alrededor de los
lenguajes son efímeras. No sabemos que pueda suceder en el futuro con el XML,
sobre todo cuando vienen nuevos como Astoria o Jasper (esperen un artículo de
esto en enero). ¿Seguirá siendo válido el XML en 2 años? ¿En 5? ¿En 15?. Eso
nadie lo sabe así que en C# se prefiere una filosofía más orientada al lenguaje
puro alejándolo de las cosas alrededor.
7) Literales
XML (Sólo VB)
Como les estaba comentando hace unas líneas el soporte a XML
que integra visual basic es mucho mayor al que integra C#. Sin ir más lejos o
simplemente examinen este código, no hay mucho que explicar
VB
Dim
lobjXML = <Peliculas>
<Pelicula>
<Titulo>El Exorcista</Titulo>
<Director>Juanito Perez</Director>
<Genero>Horror</Genero>
</Pelicula>
<Pelicula>
<Titulo>Saw 2 El juego del
miedo</Titulo>
<Director>Juanito Perez</Director>
<Genero>Terror</Genero>
</Pelicula>
<Pelicula>
<Titulo>Silent Hill</Titulo>
<Director>XXX Perez</Director>
<Genero>Suspenso</Genero>
</Pelicula>
</Peliculas>
MessageBox.Show(lobjXML.Elements.Count().ToString)
For
Each lobjElemento As
XElement In lobjXML.Elements
MsgBox(lobjElemento.Value())
Next
Como ustedes pueden ver automáticamente el compilador
reconoce cualquier declaración en xml
Y a partir de ella genera los objetos correspondientes para
que no podamos programar programa ticamente sin necesidad de utilizar clases
como XMLDocument. El código anterior nos muestra una bonita caja de texto con
los valores que se encuentran dentro del fragmento xml. Esto la verdad es
sorprendente, y se le denomina Literal Expression, ¡El XML ES el lenguaje de
programación, es parte íntegra de VB!
Inclusive si no queremos utilizar el For Each podemos
escribir un query y seleccionar aquellas películas que nos gusten mua ja ja…
VB
Dim
SeleccionXML = From Elemento In lobjXML.<Pelicula> _
Where Elemento.<Titulo>.Value = "Silent
Hill" _
Select Elemento.<Genero>
MsgBox(SeleccionXML.First.Value)
Este código nos
mostrará la palabra Suspenso. Y si queremos es todavía más allá es posible
generar XML que tenía como contenido en lugar de valores estáticos variables o
propiedades de objetos, sintaxis que seguramente les parecerá familiar
Dim
lobjXMLHoras = <Horas>
<Hora><Pais>México</Pais><HoraExacta><%= Now %></HoraExacta></Hora>
<Hora><Pais>Japón</Pais><HoraExacta><%= Now.AddHours(6) %></HoraExacta></Hora>
</Horas>
Del ejemplo anterior hemos puesto como valores el elemento
HoraExacta al cálculo de la hora actual y en el caso del segundo elemento
estamos añadiendo unas horas para representar un cálculo.
Algo que no puedo dejar de mencionar y que es medio horrible
es que no es posible de debuggear las expresiones cuery en la ventana de immed.
Esperemos que en próximas revisiones nuestros compas en Microsoft le den un vistazo esto porque se puede volver
un feo dolor de cabeza a la hora de programar cueris complejos. (Si pudieron
con las nested master pages, que no puedan con esto juar juar)
“Query expressions are
not valid in debug windows”
8) Operador
ternario(Sólo VB)
Por todos es conocido que es posible representar un If en C#
de la siguiente manera
C#
a%b==0 ? "Par" : "Non";
A pesar de que las versiones anteriores de visual basic o
tenían una función llamada Iif, esta sintaxis era exactamente eso: una función
por lo cual si alguno de las expresiones que se le pasaban esta función era
inválida tronaba toda nuestra rutina. Como buena noticia ya ningun programador
en C# se podrá burlar de los visualeros. Les presento al poderosísimo operador
ternario en VB:
VB
If(lintNumero Mod 2 = 0, "Par", "Non")
9) Propiedades
autoimplementadas (Sólo C#)
Sabemos nosotros que cuando estamos utilizando propiedades
siempre es indispensable utilizar una variable privada dentro de la clase que
se encargue de mantener el Valor que está expuesto por la propiedad en la
versión 2005 de visual studio se introdujo el concepto de Refactoring que
mediante el IDE nos permitía generar automáticamente estas variables, ahora
esto se llevado a nivel de lenguaje y es posible generar implícitamente la
variable privada que contendrá el tipo utilizando la siguiente sintaxis.
C#
public string Disquera {get;
set;}
Bien, ahora sí, a esperar el año nuevo y fuera de coto, mis
mejores deseos para el 2008, gracias por seguir entrando a DevelopersDotNet y
les aseguro que en el 2008 este blog tratará, como lo ha intentado desde su
creación de poner cosas, aunque sea medianamente originales y que aporten valor
a este horrible pero genial armatoste llamado Internet.
Un abrazo a tod@s y
¡Feliz codificación!
Hola como están los invito a descargar la presentación de la conferencia que di en el congreso Software Gurú de este año (todavía 2007 jeje)
http://www.sg.com.mx/sg07/presentaciones/Herramientas%20y%20tecnologias/SG07.T05.TendenciasDataAccess.pdf
Encontrarán conceptos interesantes que espero estar expandiendo próximamente.
Saludos a to2
Preeliminares
Durante el
tiempo el pasado dando clases de .Net me resulta particularmente llamativo que
al momento de preguntarle algún participante qué es un delegado muchas veces me
encuentro con caras de pánico a pesar de que muchos de sus programadores que
asisten a clase son gente realmente experta a su trabajo y lleva mucho tiempo
programando, sin temor a equivocarme puedo decir que menos del 10% de todos los
participantes ha esbozado una explicación medianamente correcta.
Y creo que
esto se debe no tanto a los programadores, toda vez que muchas veces no es tan necesario entender
para qué sirven los delegados sobre todo cuando Visual Studio se encarga de
generar automáticamente mucho del código que soporta el manejo de eventos
dentro de una aplicación y trae una gran cantidad de delegados listos para
usarse (el más común el EventHandler delegate). Menos culpa aún tienen los programadores
en Visual Basic ya que el mismo lenguaje encapsula toda la tubería de los
delegados y los eventos con sus funciones y palabras reservadas: Handles,
Addhandler, Removehandler, AddressOf y Withevents, inclusive me atrevo a decir
que un programador en VB.NET realmente puede olvidarse en la mayoría de los
casos de los delegados y a pesar de eso seguir siendo un excelente programador
en VB.NET.
Sin embargo
esto está por cambiar. Con el .NET Framework 3.5, Visual Basic 9.0 y C# 3.0 hay
que comprender más a detelle para qué sirven los delegados y de esta manera poder
asimilar y utilizar adecuadamente las nuevas “lambda expressions”
Haremos un
poco de historia y hablaremos de algo que se llama el “mecanismo de publicación
suscripción”
El patrón de diseño observador
Suponga que
está usted en un restaurante y revisa la carta para decidir que platillo
ordenar; en este escenario pueden pasar dos cosas cuando usted se decida: 1) Que
espere hasta que el mesero se aparezca en su mesa y le pregunte que desee y
consumir o 2) Que usted levante la mano y explícitamente le diga al mesero
cuando está listo para que el tome la orden. Evidentemente la opción 2 es la
más adecuada debido a que el mesero no lo tiene que estar esperando sino que
usted le indica cuando pedir y además si el mesero no está usted puede
llamarlo. Pues bien, sin ir muy lejos a esto se les llama mecanismo de
publicación suscripción y es la base del patrón de diseño definido por la banda
de los cuatro llamado el observador. En este caso el publicador es el Comensal
y el suscriptor es el cliente. Esto es la base para la implementación del patrón
de diseño observador
Delegados
Lo mismo
sucede en la programación. Todo el mecanismo de eventos de la plataforma. Net
está basado en delegados, en el ejemplo anterior el delegado sería la Comanda
que traería el platillo que usted eligió, esta comanda viajará y notificará,
aunque también notificará al chef, y al personal de caja para saber qué
cobrarle, algo muy parecido hacen los delegados: “apuntan” a aquellos métodos
que deben ser ejecutados cuando algo sucede.
En otras
palabras un delegado es ”como” un puntero de función de tipo seguro. Ese “como”
no está ahí por casualidad, está porque en el CLR no están definidos los
punteros, así que tenemos que usar un “como” y no un “es”
La
maravilla de los delegados es que no es necesario implementar una interfaz a
una clase (como los Listeners en Java) para poder escuchar un evento
determinado, sino que no importando la clase, cualquier método que cumpla con
la firma (lista de parámetros) puede ser usado para implementar el delegado, de
ahí se desprende lo del tipo seguro.
Por su
parte los eventos notifican a una clase que tiene una relación de composición o
agregación con otra (volvemos a lo mismo la clase compositora seria el
suscriptor) que algo ha sucedido, entonces el delegado lleva los datos hacia la
función adecuada.
A
continuación veremos cómo C# ha ido evolucionando para resolver el problema de
la delegación con sintaxis cada vez más elegante y menos verbosa.
Como lo
acabamos de decir, evidentemente, si un delegado es como un puntero de función,
forzosamente requeriremos de una función. En el caso de C# 1.2 (.NET 1.x)
tenemos explícitamente que declarar en una clase el método. El ejemplo del
comensal es este:
|
using System;
namespace DelegadosEstandar
{
//Delegado que sirve como base para el evento
ComandaOrdenada
public delegate void Orden(string pstrPlatillo);
class Mesero //Clase suscriptora
{
private Comensal lobjComensal;
public Mesero()
{
//Se instancia la clase, es
decir estamos haciendo una relación
// de composición
lobjComensal = new Comensal();
//Se genera el mecanismo de
publicación suscripción
//aqui nos suscribimos y
empezamos a "escuchar" si el comensal pide
lobjComensal.ComandaOrdenada += new Orden(TomarOrden);
}
public void EsperarPedido()
{
lobjComensal.PedirPlatillo();
}
//Este método se ejecutara
cuando se dispare el evento ComandaOrdenada
//en el comensal
public static void TomarOrden(string pstrPlatillo)
{
Console.WriteLine("Tomé la orden de " + pstrPlatillo);
Console.ReadLine();
}
}
class Comensal //Clase publicadora
{
//Este es el evento al que se
suscribirá el mesero
public event Orden ComandaOrdenada;
public void PedirPlatillo()
{
Console.WriteLine("Qué desea comer: ");
string lstrPlatillo = Console.ReadLine();
//Se dispara el evento mientras
Mesero "escucha"
ComandaOrdenada(lstrPlatillo);
}
}
class Programa
{
public static void Main(string[] args)
{
Mesero lobjMesero = new Mesero();
lobjMesero.EsperarPedido();
}
}
}
|
Como
podemos apreciar en el ejemplo anterior, existen 3 clases
a) Mesero:
Es el suscriptor que escucha cuando el Comensal pide algo
b)
Comensal: Publica la orden y genera el evento ComandaOrdenada cuando se ha
decidido por algo, notese que el evento es del tipo del delegado
c)
Programa: Punto de entrada de la aplicación
En este
caso la clase programa instancia al Mesero, además de ejecutar su método
EsperarPedido del mismo, el método EsperarPedido llama a PedirPlatillo que a su vez lee
información del teclado. Cuando se teclea el platillo se dispara el evento
ComandaOrdenada.
Métodos Anónimos
Como
podemos ver esto resulta muy sencillo, sin embargo la sintaxis es algo verbosa.
¿Qué sucedería si yo quiero manejar un evento dentro de la misma clase?. Es
decir que el mismo Comensal maneje su orden sin necesidad de llamar siquiera a
un método. A este tipo de sintaxis se le denomina método anónimo y resultan
parecidas a las inner classes en Java.
El objetivo
principal del método anónimo es reducir la cantidad de código requerida para
establecer una funcionalidad con delegados, sobre todo cuando no estamos interesados
en involucrar relaciones entre las clases. Los métodos anónimos se introdujeron
en C# 2.0 (.NET 2.0)
El ejemplo
del Comensal utilizando un método anónimo la encontramos a continuación:
|
//////////////////Metodos
anonimos con eventos
using System;
namespace DelegadosconMetodosAnonimos
{
public delegate void Orden(string
pstrPlatillo);
class Mesero
{ //Esta
clase ya no tiene la implementación de la toma de pedido
//sino
que se encuentra dentro del mismo Comensal
private Comensal
lobjComensal;
public Mesero()
{
lobjComensal = new Comensal();
}
public void
EsperarPedido()
{
lobjComensal.PedirPlatillo();
}
}
class Comensal
{
//Este
es el evento al que se suscribe el mesero
public event Orden ComandaOrdenada;
public void
PedirPlatillo()
{
Console.WriteLine("Qué desea comer:
");
string lstrPlatillo = Console.ReadLine();
//Metodo
anonimo, ya no necesito el método en la
//clase
Mesero para hacer la suscripción
ComandaOrdenada += delegate(string pstrPlatillo)
{
Console.WriteLine("Tomé la orden de
" + pstrPlatillo);
Console.ReadLine();
};
ComandaOrdenada(lstrPlatillo);
}
}
class Programa
{
public static void Main(string[] args)
{
Mesero lobjMesero = new Mesero();
lobjMesero.EsperarPedido();
}
}
}
|
Expresiones Lambda
Como podemos
apreciar, la misma definición del comportamiento del manejador de evento está
dentro de la misma clase comensal, no
fue necesario implementar un método, sino que automáticamente definimos el
código necesario, simplemente se escribió la palabra clave delegate dentro del
cuerpo del método PedirPlatillo en el Comensal.
Cabe
señalar que inclusive si usted desea puede quitar la firma de la palabra clave
delegate dentro del método Main y de todos modos se hará la suscripción.
En el caso
de C# 3.0 (.NET 3.5) se introduce el concepto de expresiones lambda que pueden
ser utilizadas en cualquier contexto donde se pueda utilizar un método anónimo,
reduciendo aun más la cantidad de código requerido y evidentemente aumentando
la legibilidad.
Para generar
expresiones lambda en C# hay que usar el operador => que significa “apunta a” o “va a”. A continuación
el ejemplo del Comensal con una expresión lambda.
|
//Lambda con eventos
using System;
namespace ExpresionesLambda
{
public delegate void Orden(string pstrPlatillo);
class Mesero
{ //Esta clase ya no tiene la
implementación de la toma de pedido
private Comensal lobjComensal;
public Mesero()
{
lobjComensal = new Comensal();
}
public void EsperarPedido()
{
lobjComensal.PedirPlatillo();
}
}
class Comensal
{
//Este es el evento al que se
suscribe el mesero
public event Orden ComandaOrdenada;
public void PedirPlatillo()
{
Console.WriteLine("Qué desea comer: ");
string lstrPlatillo = Console.ReadLine();
//Expresión lambda, más limpia y
legible que el método anónimo
ComandaOrdenada += pstrPlatillo
=> Console.WriteLine("Tomé la orden de " + pstrPlatillo);
ComandaOrdenada(lstrPlatillo);
Console.ReadLine();
}
}
class Programa
{
public static void Main(string[] args)
{
Mesero lobjMesero = new Mesero();
lobjMesero.EsperarPedido();
}
}
}
|
¿Como ven? ¿Está
padre no? ¿Y Basic? ¿Y el hermoso Basic? ¿Se quedó atrás? Pues ¡No! En Visual
Basic las lambda expressions también son soportadas. Básicamente es lo mismo
sólo que hay que usar la palabra clave Function en lugar de => además de que
las expresiones lambda en VB siempre deben producir un valor o no se dejará
compilar… Visualbeisiqueros del mundo… ¡Deleitáos con expresiones lambda en VB!
Aquí os presento el mismo código anterior pero en VB
|
Public Delegate Sub Orden(ByVal lstrPlatillo As String)
Public Class Mesero
Private lobjComensal As New Comensal
Public Sub EsperarPedido()
lobjComensal.PedirPlatillo()
End Sub
End Class
Public Class Comensal
Public Event ComandaOrdenada As Orden
Public Sub PedirPlatillo()
Console.WriteLine("Qué desea comer: ")
Dim lstrPlatillo As String = Console.ReadLine()
'Expresion lambda en VB a
diferencia de C#
'aqui siempre de devolver un
valor
Console.WriteLine((Function(pstrPlatillo) "Tomé la orden de " + pstrPlatillo)(lstrPlatillo))
'Disparamos el evento
RaiseEvent ComandaOrdenada(lstrPlatillo)
Console.ReadKey()
End Sub
End Class
Module ExpresionesLambda
Sub
Main()
Dim lobjMesero As New Mesero()
lobjMesero.EsperarPedido()
End Sub
End Module
|
Pues así
esto de las lambda expressions. Ojalá les haya gustado.
Este
artículo fue inspirado y dedicado para los participantes de Intersoftware de 2º
semestre de MCTS. (Marco, Sergio, Julio, Juan, Lalo) que según no les entraban los
delegados. Después de varias clases, re-explicando, frustración, enojos y
antiácidos parece que el concepto ya quedó verdaaaad?????. Jaja no se crean.
Sin más que
decir Salu2 a todos, recuerden que cualquier duda o concepto que no haya
quedado claro lo pueden postear y vemos como lo resolvemos.
¡Feliz
Codificación!
Miguel A. Morán B.
Microsoft MVP Visual Developer
Tenemos el gusto de informarles que algunos de los miembros de la comunidad DevelopersDotNet (Memo Morales, Markitos Del Pozo y su servilleta) estaremos haciendo desde agosto hasta septiembre un webcast semanal en el MSDN Media Center de Microsoft. Trataremos variados temas sobre las más recientes tecnologías. Esperamos que se registren cuanto antes y nos hagan el favor de honrarnos con su presencia.
Creo que los temas están bastante interesantes y creo que les pueden ser de bastante utilidad. Todo el código que hagamos en los webcasts estará disponible minutos después en este mismo sitio para que los bajen y los puedan analizar, extender e implementar de inmediato. También les recomiendo que los vean en vivo para que nos puedan hacer preguntas directamente. Los temas los encuentran a continuación
Registrense ¡Ya!
¡Feliz Codificación!
Miguel Angel Morán B.
Microsoft MVP Visual Developer
Los invito a leer el artículo Frameworks habilitadores de Ajax, publicado en la revista Software Gurú, en esta edición de Julio/Agosto de 2007. En este artículo hablo sobre las opciones que tenemos para hacer que nuestros sitios web implementen Ajax, mediante el uso de marcos de trabajo y tecnologías preestablecidas.
El código fuente de dicho artículo lo encontrarán aquí
Saludos y feliz codificación
Miguel Angel Morán B.
Microsoft MVP Visual Developer
Más artículos
Página siguiente >