Embed Size (px)
Citation preview
Fundamentos de globalización• Mantener lasesión HTTP con .NET Framework• Impresión
desde CRM con WordML y FetchXml •Seguridad: Gestión de tickets de sesión •Cómo personalizar el ribbon de Office 2007 •
Delegados y eventos. Primera parte: ¿Enquién delegas tú?
dotNetManíanº
30 O
ctub
re 2
006
• 6,
50 €
(Esp
aña)
Visual Basic • C# • ASP.NET • ADO.NET • .NET Framework • Windows Server System
dotNetManíawww.dotnetmania.com Dedicada a los profesionales de la plataforma .NET
Lejos de convertirnos en cenizas,como parece sugerir la portada, estamostrabajando más que nunca en ofrecerlelos mejores contenidos sin costes adicio-nales. Ya hemos comenzado la produc-ción del Cuaderno Técnico nº5 dedotNetManía que junto con el sexto yséptimo serán gratis para nuestros sus-criptores gracias en parte al patrocinio deMSDN en España. Los temas a tratarserán la optimización de aplicacionesASP.NET, WPF y Sharepoint 2007.
Bienvenido al número 30, de octubrede 2006, de dotNetManía.
Muchas caras nuevas en este primerejemplar de otoño. Por un lado, hay queapreciar en lo que vale la aportación deAndy González, quien nos habla de fun-damentos de globalización de software.Andy es International Program Manager deMicrosoft y durante mucho tiempo ha veni-do responsablizándose de la localización delas herramientas de desarrollo de la com-pañía al castellano, entre otras lenguas. Ytiene valor doble porque sus honorariosserán cedidos a la International DiabetesFederation en su nombre.
También se estrenan Daniel Sabatercon su “Impresión desde CRM conWordML y FetchXml”, y JoaquínGracia con su “Cómo personalizar el rib-bon de Office 2007”, y Jorge Ramo, dela inagotable cantera de buenos redacto-res que es Raona, con su “Seguridad:Gestión de tickets de sesión”.
Este mes tenemos una entrevista delujo a Richard Waymire y Gert Drapersdel equipo de desarrollo de Visual StudioTeam Edition for Database Professionals.Fernando Guerrero tuvo la ocasión decharlar con ellos durante el Tech-Ed 2006de Boston.
Carlos Quintero toma protagonis-mo en la portada con su “Creación deasistentes en Visual Studio”, una formamás de extender Visual Studio, algo en loque Carlos es experto. No se pierdancómo nuestra mascota intenta imitarle sinconseguirlo :-).
Si está comenzando con .NET, unode los imprescindibles este mes es“Delegados y eventos. Primera parte:¿En quién delegas tú?” de “El Guille”.
No quiero terminar sin felicitar a miamigo y compañero Guillermo Som porsu décimo aniversario en la Web. Tal ha sidoel empeño durante estos años en ayudar atantos programadores, que este pequeñohomenaje es lo menos que podíamos hacerpor él. Si aún no lo conoce..., pero ¡qué digo!si le conoce todo el mundo :-).
Para el próximo número ya estamospreparando un pequeño monográfico sobreAJAX, ahora que Atlas, o por mejor decir,Microsoft AJAX Library, ASP.NET 2.0AJAX Extensions y ASP.NET AJAXControl Toolkit están casi listos para salirdel horno.
Como siempre, dentro hay más.Espero que le guste.
dotN
etM
anía
<<
3
dotNetManíaDedicada a los profesionales de la plataforma .NET
Vol. III •Número 30 • Octubre 2006Precio: 6,50€
EditorPaco Marín
Redactor JefeMarino Posadas
Editor técnicoOctavio Hernández
Consejo de RedacciónDino Esposito, Guillermo 'guille' Som, José
Manuel Alarcón, Lorenzo Ponte, Luis MiguelBlanco y Miguel Katrib (Grupo Weboo).
Colaboradores habitualesAntonio Quirós, Braulio Díez, Carlos
Quintero, Eladio Rincón, Javier Aragonés,Jorge Serrano, José Miguel Torres, Iván
González, Pepe Hevia, Salvador Ramos ySergio Vázquez
Además colaboran en este númeroAndy González, Daniel Sabater, FernandoGuerrero, Joaquín Gracia, Jorge Ramo y
Pablo Tilotta
Atención al suscriptorPilar Pérez
IlustracionesYamil Hernández
Edición, suscripciones y publicidad.netalia
c/ Robledal, 13528529 Rivas-Vaciamadrid (Madrid)
www.dotnetmania.com
Tf. (34) 91 666 74 77Fax (34) 91 499 13 64
ImprimeColor Digital
ISSN1698-5451
Depósito LegalM-3.075-2004
>>
<<
dnm.editorial
Paco Marín
30dnm.sumario
dnm
.sum
ario
Métricas para la estimación de software: Puntos por función 10-11Medir o no medir, esa es la cuestión. En la Ingeniería del Software, el uso de métricas,tanto para la estimación como para el seguimiento de proyectos, se impone como unabuena práctica esencial. En este artículo abordaremos esta cuestión desde la perspectivade la estimación, dejando para otros de la serie, los aspectos relativos al seguimiento.
Entrevista a Richard Waymire y Gert Drapers 12-14Durante la celebración de la pasada edición de Tech-Ed en Boston, tuvimos la ocasiónde entrevistar a Richard Waymire, Program Manager/Architect y Gert Drapers,Development Manager/Architect en Microsoft. Ambos son los máximos responsablesdel nuevo Visual Studio Team Edition for Database Professionals, producto destinadoa revolucionar la manera en que los administradores y desarrolladores de bases dedatos y los desarrolladores de aplicaciones colaboran a un nuevo nivel cualitativo.
Fundamentos de globalización 16-18El mayor beneficio de la globalización del software es que proporciona el acceso a usuariosde todo el mundo, porque la globalización permite el desarrollo de aplicaciones en variosidiomas y en varias culturas.
Mantener la sesión HTTP con .NET Framework 19-22En este sencillo pero muy útil truco .NET, nos vamos a imponer el reto de subsanar unapega que muchos desarrolladores han encontrado al intentar crear aplicaciones que consumeninformación de servidores Web utilizando mecanismos de cierto bajo nivel.
Creación de asistentes en Visual Studio 23-28En este artículo veremos una forma más de extensibilidad de Visual Studio, apartede las macros y complementos que ya hemos visto con anterioridad. Se trata de losasistentes (wizards) que se introdujeron con la versión inicial de Visual Studio .NET.En artículos posteriores hablaremos de las novedades y cambios introducidos en VisualStudio 2005 (plantillas, kits de iniciación, etc.).
Impresión desde CRM con WordML y FetchXml 30-34Se trata de una extensión de Microsoft Dynamics CRM que permite convertir lainformación de cualquier entidad CRM (oferta, factura etc) en un documento Word,para imprimir o enviar por correo electrónico. Esta alternativa a Reporting Servicesse basa en FetchXML y una plantilla WML a la que añadimos etiquetas XML quetransformaremos con XSL para obtener el documento final.
Seguridad:Gestión de tickets de sesión 36-38Supongamos que estamos trabajando en un entorno de autenticación en que se utilizandiversos datos biométricos (análisis de retina, huellas dactilares, análisis de voz, etc.), y trasaplicar una función sobre ellos se obtiene un identificador solo conocido por el sistema. Cualquierpersona que quisiera suplantar nuestra identidad debería conocer todos estos datos paraplantear un ataque con éxito, puesto que con un solo error en alguna de las variables elidentificador resultante no sería válido. En este artículo veremos cómo plantear este escenarioen nuestras aplicaciones ASP.NET imitando el modelo del protocolo Kerberos.
Cómo personalizar el ribbon de Office 2007 39-41Siguendo los pasos de este tutorial podrás personalizar el ribbon de Office 2007 de una formarealmente sencilla y fácil. Explicamos cómo crear un add-in de Office 2007 basado en lainterfaz IDTExtensibility2 y la forma en la que puedes añadir pestañas y botones propiosen el ribbon.
Delegados y eventos.Primera parte: ¿En quién delegas tú? 42-47En este número vamos a tratar de los delegados, y también de los eventos (aunque de estosúltimos nos encargaremos con más detalle en el próximo artículo), ya que en .NET estánestrechamente relacionados; tanto es así que no podemos definir un evento sin la intervenciónde un delegado.
dnm.todotnet.qa. Resolución de problemas en ASP.NET 48-50dnm.biblioteca.net 51
Programming ASP.NET 2.0 Core Reference. Dino EspositoApplications = Code + Markup. Charles Petzold
dnm.comunidad.net.10 Años de “El Guille” 52-53
dnm.laboratorio.Chart FX para Visual Studio 2005 54-55
dnm.desvan 58
dotN
etM
anía
<<
6
dnm.noticias<<n
oti
cia
s.n
oti
cia
s.n
oti
cia
s.n
oti
cia
s.n
oti
cia
s.n
oti
cia
s Microsoft lanza la Release Candidate 1 deWindows Vista
El 1 de septiembre, Microsoftanunció la disponibilidad de laRC1 de Windows Vista (build5600) a un grupo de probadores,incluyendo a los actuales partici-pantes del Customer PreviewProgram (CPP). En total, se espe-ra que más de cinco millones deusuarios en todo el mundo ten-gan acceso a la RC1 de WindowsVista.
A través de este programa, losdesarrolladores y profesionales deTI que no tienen acceso a la RC1de Windows Vista a través de otroscanales pueden disponer del códi-go para comenzar a analizarlo. Lacompañía también publicará laRC1 en sus espacios Web MSDNy TechNet para que pueda ser des-cargada por sus suscriptores.
Posteriormente, el 22 de sep-tiembre, Microsoft liberó unanueva revisión (build 5728) paralos probadores habituales asícomo para unos 100.000 partici-
pantes del CPP. Esta build inclu-ye algunas mejoras y cambiosrelacionados con el feedback reci-bido desde el 1º de septiembre.
La información sobre los pre-cios de las distintas versiones deWindows Vista, así como otras desus características, se encuentradisponible en el espacio online:http://www.microsoft.com/windows-vista/getready/editions.
También la RC1 de .NET 3.0
El 1 de septiembre Microsoftliberó también la RC1 de .NETFramework 3.0. Combina lapotencia de .NET Framework2.0 con las extensiones revolucio-narias antes conocidas bajo elacrónimo común WinFX: WPF,WCF, WWF y WCS. .NET 3.0formará parte de Windows Vista,aunque también estará disponi-ble para Windows XP yWindows Server 2003.
Microsoft ha anunciado la disponibilidad de la versión ReleaseCandidate 1 (RC1) de Windows Vista, ampliando el CustomerPreview Program (CPP) a nuevos usuarios
Visual Studio 2005 SDK versión 3.0 RTM
El pasado 15 de septiem-bre, Microsoft sacó oficial-mente a la luz la versión 3.0del SDK de Visual Studio2005, una nueva “vuelta detuerca” a la herramienta quepermite a los desarrolladoresintegrar editores, diseñadores,nuevos lenguajes de programa-ción y otros tipos de herra-mientas dentro del entornointegrado de Visual Studio2005.
Entre las principales nove-dades que esta versión añadepodemos mencionar:• la versión 1.0 de DSL
(Domain Specific Language)Tools,
• MPLEX y MPPG, herra-mientas para la generaciónde analizadores sintácticos ygramaticales en códigomanejado,
• nuevos contenidos relaciona-dos con la extensibilidad deTeam Test y Team FoundationServer,
• nuevos ejemplos relaciona-dos con Iron Python.
Este SDK requiere la ver-sión estándar o superior de VS2005 y puede descargarse de:http://www.microsoft.com/downlo-ads/details.aspx?FamilyId=7E0FDD66-698A-4E6A-B373-BD0642847AB7&displaylang=en.
Visual Basic 2005 PowerPacks
Recientemente han “visto la luz” losVisual Basic 2005 Power Packs, un con-junto de complementos, componentes y uti-lidades destinados a simplificar y agilizar aúnmás el desarrollo de aplicaciones con VisualBasic 2005. Por el momento hay dos “packs”disponibles:• Microsoft Interop Forms Toolkit 1.0.
Kit de herramientas para facilitar laincorporación de formularios .NET aaplicaciones desarrolladas con VisualBasic 6. En vez de tener que actualizartodo el código de las aplicaciones, losdesarrolladores ahora podrán ir migrán-dolas formulario a formulario.
• Microsoft PrintForm Component 1.0.Componente cuyo objetivo central espermitirnos imprimir fácilmente los for-mularios Windows.
Estos “packs” pueden descargarse desdehttp://msdn.microsoft.com/vbasic/downloads/power-packs/default.aspx.
Roadmap y nombres para Atlas
La librería javascript Atlas del lado del clienteva a llamarse Microsoft AJAX Library. Trabajarácon cualquier explorador y también soportará cual-quier servidor Web. La funcionalidad de Atlas dellado del servidor que se integra con ASP.NET sellamará ASP.NET 2.0 AJAX Extensions y, porúltimo, lo que hasta ahora conocemos como AtlasControl Toolkit se llamará ASP.NET AJAXControl Toolkit.
Según Scott Guthrie declara en su bloghttp://weblogs.asp.net/scottgu, la versión final paraAtlas estará disponible a finales de año. Habrá queesperar a las betas y RC para conocer una fechacon más exactitud, pero en cualquier caso pareceque no habrá que espearar a Orcas para tener laprimera versión definitiva.
Visual Studio 2005 Tools for Office SecondEdition Beta disponible
Visual Studio 2005 Tools for Office SecondEdition Beta es un add-on de Visual Studio 2005que permite a los desarrolladores construir aplica-ciones para el 2007 Office System.
Cualquiera que tenga una licencia de VSTOo 2005 Tools for Office o Visual Studio Professionalo superior puede descargarla gratuitamente desde:http://msdn.microsoft.com/office/tool/vsto/2005SE.
Además...
dnm.noticias
dnm.noticias
dotN
etM
anía
<<
7
MSDN y campusMVP le ofrecen de for-ma conjunta esta oportunidad única de for-marte a tu ritmo y desde cualquier lugar enlas últimas tecnologías de desarrollo deMicrosoft, y obtener la certificación oficial.Tanto si no está certificado como si ya poseeuna certificación anterior, este pack puedeinteresarle ya que está orientado a las nuevascertificaciones de .NET 2.0 que han sustitui-do a las antiguas.
Con el pack “Certificación” y solo hasta el31 de octubre de 2006 obtendrá:• Acceso a 6 cursos online, con las tutorías de
de los MVP y MCT de campusMVP.• Un manual oficial de Microsoft (MOC)
orientado a su especialidad.• Un cupón con el que podrá examinarse gra-
tis en cualquier parte del mundo para obte-ner su certificación.
• Gestión gratuita de una bonificación con elEstado para que el curso le salga realmen-te barato.
Para más información: http://www.campusmvp.com o en http://www.microsoft.com/spanish/msdn/spain.
MSDN y campusMVP te invi-tan a certificarte
“A C++/CLI Design Rationale” en castellano
Se trata de un documento de unas 50páginas en el que se explican detallada-mente las decisiones de diseño tomadasdurante la concepción de C++/CLI, elenlace de C++ (el popular lenguaje de pro-gramación creado por Bjarne Stroustrupen los años 80 y estandarizado por ISO)con CLI (Common Language Infrastructure,la infraestructura común para múltipleslenguajes estandarizada por ECMA e ISOy cuya realización práctica más conocidaes Microsoft .NET Framework). C++/CLI está implementado al 100% en elcompilador de Visual C++ incorporadoen la línea de productos de Visual Studio.
Una personalidad de enorme reputa-ción en el mundo de la informática, HerbSutter es ampliamente conocido comoSecretario del Comité de Estandarizaciónde C++ y por sus conferencias y libros rela-cionados con C++ y la programación con-currente. Desde hace cuatro años esArquitecto de Software en Microsoft y fueel líder del equipo que creó C++/CLI.
La versión original del documen-to (en inglés) está disponible enhttp://www.gotw.ca/publications/C++CLIRationale.pdf, y la traducción al castellano pue-de descargarse de http://www.pokrsoft.com/cpp/a_design_rationale_es.zip.
Rafael Ontivero y Octavio Hernández, colaboradores de dotNetManía, hanpuesto a disposición del público una traducción al castellano de “A C++/CLIDesign Rationale”,de Herb Sutter.
Productos Turbo ya disponibles. ¡They’re Back!
El Grupo de He-rramientas de Desa-rrollo de Borland haanunciado reciente-mente la disponibili-dad de su nueva líneade productos Turbo,entornos integrados
para el desarrollo rápido de aplicaciones paraWindows y .NET Framework (versión 1.1).Componen la línea Turbo Delphi y TurboC++ (para el desarrollo Win32) y TurboDelphi para .NET y Turbo C#, para el desa-rrollo de aplicaciones .NET.
Los productos Turbo son versionesde Borland Developer Studio 2006 basa-das en un único lenguaje y plataforma yse ofrecen en dos ediciones:
• Las ediciones Turbo Explorer son de des-carga gratuita y tienen algunas limitacio-nes, como la imposibilidad de incorpo-rar al entorno componentes de terceros.Han sido concebidas principalmentecomo herramienta de aprendizaje.
• Las ediciones Turbo Professional, conun precio aproximado de 400€, sí sonextensibles y personalizables y ofrecentodas las posibilidades del BDS 2006 parael lenguaje y plataforma elegidos. En elcaso de los productos para .NETFramework, éstos permiten crear todotipo de librerías, aplicaciones y serviciostanto para Windows como para la Web.
Para más información y descargas, visitewww.borland.com/us/products/turbo/index.html.
Iron Python es la nueva implemen-tación del lenguaje de programaciónPython para su ejecución bajo la plata-forma .NET. Soporta una consola inte-ractiva con compilación totalmentedinámica, así como integración con.NET Framework, con lo que pone adisposición de los programadores dePython las librerías de .NET al mismotiempo que mantiene la compatibilidadcompleta con el lenguaje Python.
Puede descargarla desde el sitioCodePlex en la dirección: http://www.code-plex.com/Release/ProjectReleases.aspx?ProjectName=IronPython&ReleaseId=423. Másinformación también en el blog de JimHugunin: http://blogs.msdn.com/hugunin/archive/2006/09/05/741605.aspx.
Iron Python 1.0
Carta de Jim Allchin a los desarrolladoresJim Allchin, Presidente para Plata-
formas y Servicios de Microsoft, ha escri-to una carta abierta a los desarrolladores(titulada “Windows Vista: ¡ahora es elmomento!”) en la que los insta a preparar-se para la próxima aparición de WindowsVista y de una nueva generación de herra-mientas destinadas a revolucionar la mane-ra en que desarrollamos aplicaciones: lalínea de productos Expression (acaban de
aparecer las CTP de septiembre deInteractive Designer y Graphic Designery la beta 1 de Expression Web), las nue-vas librerías que se integran en .NETFramework 3.0 y la próxima versión deVisual Studio (“Orcas”).
Puede acceder a la carta desde el redi-señado centro para desarrolladores deWindows Vista en: http://msdn.microsoft.com/windowsvista.
❑ Deseo suscribirme a dotNetManía por un año (11 números) por un precio de 65,00€ IVA incluido y recibir gratuitamente lostres próximos cuadernos técnicos que publique Netalia, aparte del CD Volumen 2 con los ejemplares desde el 12 al 22 en for-mato PDF de alta calidad de forma gratuita. Si su dirección está fuera de España consulte los detalles en www.dotnetmania.com
❑ Deseo que me envíen los números atrasados marcados según el precio de portada. Otros:
FORMA DE PAGO❑ Talón nominativo a nombre NETALIA, S.L.❑ Transferencia bancaria a nombre de NETALIA, S.L. a:
La Caixa - Número de cuenta 2100 4315 48 2200014696 (Indique su nombre en la transferencia)
❑ Domiciliación Bancaria (con renovación automática, previo aviso)Indique su número de cuenta:
❑ Tarjeta de crédito❑ VISA ❑ MASTERCARDNúmero de su tarjeta: Fecha de caducidad: / (imprescindible)
Firma y/o sello
a de de 2006
DATOS DE ENVÍO
CIF/NIF. . . . . . . . . . . . . . . . . . . . Empresa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Nombre y apellidos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .Dirección . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .Población . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .Código Postal . . . . . . . . . . . . . . . . . . . Provincia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .Teléfono . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fax . . . . . . . . . . . . . . . . . . . . . . . . . . . email . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
DATOS DE FACTURACIÓN (sólo si son distintos a los datos de envío)
CIF/NIF. . . . . . . . . . . . . . . . . . . . Empresa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Nombre y apellidos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .Dirección . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .Población . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .Código Postal . . . . . . . . . . . . . . . . . . . Provincia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .Teléfono . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fax . . . . . . . . . . . . . . . . . . . . . . . . . . . email . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Usted autoriza a la mecanizaciónde estos datos. El responsable ydestinatario de éstos es Netalia,S.L. Usted tiene derecho a acce-der a sus datos, modificarlos ycancelarlos cuando lo desee. Susdatos no serán cedidos en ningu-na de las formas posibles a terce-ras partes y no se utilizarán másque para el buen funcionamien-to de su suscripción a la revistadotNetManía y para informar-le de las actividades comercialesque realice la editorial Netalia,S.L. Si no desea recibir informa-ción comercial de dotNetManíamarque la casilla siguiente ❑Puede enviar sus datos por Fax al 91 499 13 64, o por teléfono al 91 666 74 77,
o por email a la dirección [email protected], o también puedeenviarlos por correo postal a la siguiente dirección:
Netalia, S.L.C/ Robledal, 13528529- Rivas Vaciamadrid (Madrid)
Suscríbase y llévese los tres próximos libros gratis
Oferta válida hasta el 31 de octubre de 2006 o hasta agotar existencias
aparte del CD Vol. 2 con los números 12 al 22 en PDF
✃
❑ Nº16 (6,50€) ❑ Nº17 (6,50€) ❑ Nº18 (6,50€) ❑ Nº19 (6,50€) ❑ Nº20 (8,50€) ❑ Nº21 (6,50€) ❑ Nº22 (6,50€)
❑ Nº23 (6,50€) ❑ Nº24 (6,50€) ❑ Nº25 (6,50€) ❑ Nº26 (6,50€) ❑ Nº27 (6,50€) ❑ Nº28 (6,50€) ❑ Nº29 (6,50€)
Métricas para la estimación de software: Puntos por función
Medir o no medir, esa es la cuestión. En la Ingeniería del Software, el uso demétricas, tanto para la estimación como para el seguimiento de proyectos, seimpone como una buena práctica esencial. En este artículo abordaremos estacuestión desde la perspectiva de la estimación, dejando para otros de la serie,los aspectos relativos al seguimiento.
en el artículo de inicio de estaserie, el uso de métricas para la estimación de soft-ware es uno de los signos que con más claridad deno-ta la madurez de la empresa que las emplea. Muchosequipos de desarrollo carecen de instrumentos efica-ces para estimar la carga de trabajo que sus proyectosles supondrá. Esto, por supuesto, redunda en que nose podrá presupuestar eficazmente ni tampoco plani-ficar de forma rigurosa el trabajo de los recursos nece-sarios para el proyecto.
Para subsanar este problema el método más usa-do es el comparativo. Es decir, que dado el históri-co de proyectos realizados por un equipo de traba-jo, cuando surge uno nuevo lo comparamos conaquellos que se parecen y sobre esta comparaciónestimamos el esfuerzo que se necesitará para lle-varlo a cabo. De la estimación del esfuerzo saldráde forma fácil la estimación del coste. Esto puedeparecer algo rudimentario, sobre todo cuando nosmovemos en un mundo técnico cuya concreción serealiza por ingenieros que, en teoría, deberían serel paradigma de la precisión.
Por otro lado, el modo comparativo de hacer lascosas carece de la objetividad necesaria si siemprese compara con los resultados históricos del mis-mo equipo de trabajo, ya que sus ratios de produc-tividad pueden estar totalmente sesgados. Estemétodo sería solo válido si realmente pudiera rea-lizarse una comparación entre distintos equipos.Con esta finalidad surge el denominado método delos Puntos por función, descrito inicialmente porAllan Albretch de IBM en 1979. Este método está
basado en el criterio comparativo que hemos men-cionado, pero de modo universal, lo que le dota delos criterios de objetividad que echábamos en faltaanteriormente.
Con Puntos por función, lo que hacemos es pun-tuar los distintos componentes del software que rea-lizamos según ciertos parámetros: tipo de proceso,número de ficheros que se ven afectados, entradasy salidas, etc. Esto nos lleva a que cada función uni-taria tenga un valor en puntos según su tipo. Pero,además existen coeficientes correctores para cadatipo de aplicación, para cada lenguaje de progra-mación empleado, etc. Todo esto nos lleva a que,dada una aplicación, tenemos un número de pun-tos que miden su complejidad. A partir de aquí, sólotenemos que hacer las extrapolaciones en cuanto alas horas de trabajo; es decir, equivalencias del tipo:1 punto se corresponde con n horas de trabajo, o 1punto de función son n euros a presupuestar alcliente.
Antonio Quirós
dnm.opinion
<< Como ya comentábamos
Antonio Quirós es colaborador habitual de
dotNetManía.Co-fundador de las revistas
clippeRManía, FOXManía yAlgoritmo.Actualmente es
Director de Operaciones enAlhambra-Eidos
La objetivación del proceso de estimación hace que podamos hablar
con nuestro cliente un lenguaje común
Ventajas
• La objetivación del proceso de estimación haceque podamos hablar con nuestro cliente un len-guaje común. Nadie piensa que le está engañan-do nadie, cosa común en los procesos de desa-rrollo de software, donde para un mismo alcancede proyecto es bastante frecuente que los presu-puestos de distintas compañías sean netamentediferentes.
• Esta misma objetivación hace que la planificaciónde la carga de trabajo pueda realizarse con rigor.Los miembros del equipo del proyecto se sientenmás cómodos con estimaciones bien hechas, se evi-tan los continuos esfuerzos adicionales por unaestimación dudosa y se pueden fijar reglas clarasde incentivos con un entorno fiable y común entrela empresa y el empleado.
• La valoración en puntos por función de una apli-cación nos permite adicionar un conjunto demétricas posteriores muy interesantes. Por ejem-plo, los defectos por punto, las intervencionesde mantenimiento por punto, la media históri-ca de esfuerzo para desarrollar un punto, etc.Tradicionalmente, estos indicadores se han calcu-lado por LOC (Line of code), sin embargo la visiónde Puntos por función permite un acercamiento alámbito funcional de la aplicación que aporta muchamás riqueza que la mera unidad de peso que supo-ne la línea de código.
• Cuando se dan procesos de subcontratación, elpunto por función es una unidad de medida másque razonable para valorar la aportación de laempresa subcontratada. En este ámbito existenexperiencias interesantes. Por ejemplo, reciente-mente he estado en contacto con una compañíaque ha desarrollado una, así denominada, máqui-na de programar, basada en MDA y que permitebajo un sistema Web recoger todas las instruc-ciones de diseño, de forma que éstas son valora-das en puntos por función y si queremos que lamáquina genere el código correspondiente, elimporte económico que dicha empresa nos reper-cute está basado en este estándar de medida. Así,el sueño de poder encargar por la Web una apli-cación esta tarde, pagarla con la tarjeta de crédi-to y disponer de ella de forma inmediata pareceque no está tan lejano.
Inconvenientes• Es necesario tener bien determinadas las funciones
que va a tener una aplicación, lo que nos ha debidoconducir de forma previa e inexorable a realizar unaparte importante del esfuerzo de análisis antes de rea-lizar la estimación global del proyecto. Esto nos lle-va a un modelo de contratación diferenciado entre
diseño y construcción que muchas compañías noestán dispuestas a seguir.
• La valoración de un proyecto en puntos por fun-ción es una sobrecarga adicional de trabajo cuyocoste hay que soportar.
• Cada vez que se producen cambios en el alcancede la aplicación, la estimación en puntos por fun-ción tiene que se reconsiderada, si queremos teneruna versión actualizada de la misma. Esto es tiem-po de trabajo adicional.
• Debemos dotar a nuestros analistas y jefes deproyecto con una competencia nueva, la de saberestimar los puntos para cada función de sus apli-caciones.
En cualquier caso, creo que es una excelente prác-tica para cualquier compañía que desarrolle softwareel hecho de que forme a sus profesionales en esta téc-nica y se habitúe a estimar sus aplicaciones de formarigurosa. Seguro que las ventajas que obtendrá seránenormes y ganará en rigor y precisión con sus pro-yectos. No podemos estar continuamente hablandode lo problemático que resulta el proceso de desarro-llar software sin ir dividiendo el gran problema enpequeños subproblemas e ir atacando cada uno de ellosde forma racional e inteligente. Y no cabe duda quela delimitación clara del alcance de una aplicación ydisponer de un criterio objetivo para la estimación dela carga de trabajo es uno de los elementos clave quecontribuirá de forma impactante en la calidad de loque hacemos como empresas que desarrollan softwa-re y, por tanto, en la confiabilidad que el mercadodeposita en nosotros.
dotN
etM
anía
<<
11
dnm.opinion<<
Referencias
[1]Garmus, David y Herron, David. Function PointAnalysis. Measurement Practices for Successful SoftwareProjects. Addison Wesley, 2000.
[2]IFPUG (International Function Point User Group):www.ifpug.org (aquí puede encontrarse un amplio catá-logo bibliográfico sobre el tema).
[3] Asociación Española de Métricas del Software:www.aemes.fi.upm.es.
En cualquier caso, es una excelentepráctica para cualquier compañía
habituarse a estimar sus aplicaciones de forma rigurosa
Entrevista a Richard Waymire y Gert Drapers
Durante la celebración de la pasada edición de Tech-Ed en Boston, tuvimos la ocasiónde entrevistar a Richard Waymire, Program Manager/Architect y Gert Drapers,Development Manager/Architect en Microsoft.Ambos son los máximos responsablesdel nuevo Visual Studio Team Edition for Database Professionals,producto destinado arevolucionar la manera en que los administradores y desarrolladores de bases de datosy los desarrolladores de aplicaciones colaboran a un nuevo nivel cualitativo.
a empezar hablando un poco sobre TeamEdition para Profesionales de Bases de Datos. ¿Qué nospuedes decir en general sobre este nuevo producto?
Richard Waymire: Empecemos esclareciendo porqué lo estamos haciendo. Si se analiza el mercado debases de datos actual, hay una gran necesidad de unmayor control de versiones. Para un servidor de pro-ducción de SQL cualquiera, ¿cuánta gente sabe qué eslo que de verdad ha sido puesto en producción?, ¿cuán-ta gente sabe qué versión del esquema se está utilizan-do actualmente?, ¿existe en general una estrategia deversionado de esa base de datos? Estas son preguntasque la gran mayoría de la gente no puede responder, ylos que pueden es porque han desarrollado solucionesa medida que les han requerido un gran esfuerzo y fre-cuentemente no cubren todas las necesidades. Lo queestamos haciendo es crear un producto que ofrezca unavía para responder a estas preguntas. Y por ello tene-mos una gran integración con el resto de Team System,para no obtener una solución aislada que resuelva úni-camente el problema de SQL, sino para poder integrara desarrolladores de bases de datos y desarrolladoresde aplicaciones en el mismo ciclo de desarrollo. El tra-bajo que se estaba haciendo hasta el momento no teníaen cuenta esa integración. A partir de ahora podremostener el esquema de la base de datos offline para podertrabajar con él y compararlo con la versión de produc-ción, para saber las diferencias o para saber periódica-mente si alguien ha realizado algún cambio. De estemodo se hace posible trabajar sin interrumpir la pro-ducción de SQL.
¿Crees que la comunidad de DBA va a recelar de estaherramienta, pensando que como proviene del lado de losdesarrolladores éstos los van a llevar al “lado oscuro”?
RW: Sí, eso es cierto. Mucha gente va a ser muy escép-tica. Hay algunas cosas que van a hacerse desde VisualStudio y eso es algo a lo que los DBA no están acostum-brados, aunque ya estén usando BI Development Studioy SQL Server Management Studio. Lo que intentamosdecir a este respecto es que Visual Studio es un shell per-fecto para la administración y el desarrollo. Lo que yo creoque va a ocurrir es que los DBA van a ver un gran valoren esta integración con Visual Studio y con los equiposde desarrollo. La integración se va a producir de maneraque el DBA pueda comunicar a los desarrolladores el esta-do de la base de datos, sea capaz de hacer pruebas y des-pliegue al servidor junto con los desarrolladores, y éstospuedan hacer sugerencias y optimizaciones que el DBApueda testear y validar fácilmente. De esta forma se rom-pen las barreras entre DBA y desarrolladores.
Una de las cosas que me alegran de vuestra partici-pación en este producto es que generalmente este tipode herramientas suelen ser desarrolladas desde una visiónde desarrollador. ¿El hecho de que vosotros dos estéisen el equipo de desarrollo asegura una visión de DBA?
RW: Sí, ambos venimos de SQL, y somos muyafortunados de tener un equipo mixto; gente que vie-ne de todas partes del Team Suite, e incluso personasque han trabajado en el núcleo de .NET Framework.Gert y yo tenemos una visión muy clara de lo que que-remos, al igual que el resto de los miembros del equi-po, vengan de donde vengan.
Fernando Guerrero
dnm.directo.entrevistas
<< Vamos a empezar
Fernando Guerreroes MVP en SQL Server, y un
ponente habitual en la mayoría delas conferencias internacionales de
este campo.Viaja permanente-mente alrededor del mundocomo consultor, profesor y
director ejecutivo de Solid Quality Learning.
¿Cómo de grande es vuestro equipo?RW: No es muy grande: algo más
de 40 personas. No llega al tamaño delequipo de herramientas de SQL.
¿Eso significa que Microsoft no loconsidera un producto muy importante?
RW: Me han preguntado ya estoanteriormente durante esta semana.Simplemente hemos comenzado a tra-bajar de la siguiente forma: alguiendecidió que merecía la pena desarro-llar este producto, nos dieron los recur-sos para contratar a gente clave en laindustria, además de gente con muchaexperiencia en Microsoft, y nos pusi-mos en marcha.
No sé si tenéis planes al respecto,pero creo que hay un gran campo pordelante en lo relativo a educar a los pro-fesionales de bases de datos no solosobre las herramientas, sino tambiénsobre los procesos.
RW: Ese es uno de nuestros retosmás grandes. Hoy frecuentemente elpropio DBA es la versión actual de loque hay en producción, y no es buenopara las organizaciones que una sola per-sona sea quien tenga el control de la ver-sión actual. Lo que tiene sentido es tra-tar las versiones de una base de datosSQL como al código fuente y almace-narlo en un sistema de control de ver-siones. Lo que estamos haciendo no essino poner la base de datos allí dondeestá el resto de cosas en una organiza-ción, es decir, bajo control de versiones.
Pasando a un tema más personal,¿cómo te ves en el futuro luego de serun gurú en seguridad y disponibilidadde SQL Server y ahora estar en unaposición más de desarrollador?
RW: Pues creo que he podido apor-tar algo al equipo; soy una persona conun conocimiento profundo de SQLServer, y conozco también a muchosclientes. Además, no estoy en unambiente de desarrollo puro, sino quemi trabajo también contiene aspectosde administración de bases de datos yde administración del ambiente de desa-rrollo. Según mi experiencia, no creoque exista un administrador “puro” deSQL Server; los que conozco siempreestán escribiendo código SQL. Soy muyfeliz por estar trabajando en el desarro-llo de una gran experiencia y por tenerla oportunidad de pensar no solo en lo
que estamos haciendo en este momen-to, sino también en lo que vamos a hacerdentro de 1, 2 ó incluso 5 años.
¿Cómo ves el futuro del producto?RW: Con que solo nos pusiéramos a
trabajar en la lista de cosas que la genteaquí en Tech-Ed nos ha solicitado,tendríamos trabajo para 5 años. Aunqueen realidad lo que me preocupa no es sivamos a tener trabajo o no, sino más bienque sepamos priorizarlo de la mejor mane-ra para hacer las cosas en el orden ópti-mo. Pero ahora en lo que estamos cen-trados realmente es en entregar esta ver-sión a nuestros clientes a final del año.
Este producto ayuda a mejorar losprocesos y las aplicaciones. Tu expe-riencia de trabajo en el mundo real teha dado una gran ventaja en esteaspecto, ¿no?
RW: Lo cierto es que sí, y esperopoder seguir ayudando con mis conoci-mientos. Ahora voy a estar un tiempoviajando, conociendo a algunos clientesy estudiando sus procesos de negocio ysus procesos de desarrollo. Estamosseguros de que ningún producto es per-fecto para todo el mundo, pero tenemosque lograr que el producto sea lo sufi-cientemente extenso y flexible para lamayoría de nuestros clientes.
Entra Gert en la entrevista...Estábamos muy interesados en tener
una entrevista con usted. ¿Cuáles hansido los obstáculos más grandes quehabéis encontrado al desarrollar esteproducto?
Gert Drapers: Uno de los retos másgrandes que hemos tenido que afrontarconsiste en que para poder definir lo queteníamos que hacer teníamos que tenerun completo conocimiento del esquema(tablas, vistas, procedimientos, funciones,índices, triggers, ensamblados…). La úni-ca manera de llegar ahí es analizándolo
todo de un modo integral; de modo queel mayor reto ha sido el de crear una infra-estructura de análisis que nos permita verel T-SQL del usuario e interpretarlo, paracrear un grafo de dependencias que lue-go se utiliza a través de todo el producto.Esto ha sido muy difícil por las siguientesrazones:1. T-SQL es un lenguaje muy exten-
so; no es como C#, que ofrece unacantidad limitada de sentenciasdiferentes.
2. T-SQL es muy ambiguo.
El código T-SQL no es muy prede-cible, ¿cierto?
GD: Exacto. Hay que hacer muchoanálisis y revisar hasta 4 niveles de códi-go para poder entender lo que significael código leído; algo realmente muycomplejo.
Otro gran reto ha sido el cambio dementalidad que nos lleva desde la idea deque todo reside dentro de la base de datoshasta el nuevo concepto en el que todoreside en el Team System. Todos los cam-bios se realizan en modo offline, desco-nectados de la base de datos, lo que haceposible que podamos hacer pruebas sinafectar nada, para luego, cuando estemossatisfechos con los resultados, ponerlosen producción.
Un proyecto como éste surge delhecho de que muchas personas quie-ren probar diferentes formas de modi-ficar el esquema y las consultas paramejorar el rendimiento antes de poner-las en práctica. ¿Qué herramientas deeste tipo tiene Team System para losdesarrolladores?
GD: En este momento, desde el pun-to de vista de rendimiento no proveemosmuchas herramientas. Estamos añadien-do un plan de ejecución para el editor deconsultas de modo que esa informaciónesté disponible; sin embargo, si se dese-
dotN
etM
anía
<<
13
dnm.directo.entrevistas<<
Visual Studio Team Edition para Profesionales de Bases de Datos es un nuevo producto deMicrosoft que tiene como objetivo central la integración del diseño y mantenimiento de lasbases de datos de la empresa dentro del proceso integral de gestión del ciclo de vida de lasaplicaciones corporativas mediante Visual Studio Team System. Las nuevas posibilidades queofrece, como son, por ejemplo, la gestión del versionado de las bases de datos dentro del con-trol de versiones común o la aplicación de las tecnologías de pruebas unitarias y de otros tiposa las bases de datos del sistema harán de este producto una herramienta fundamental de caraa la mejora de la calidad del software.
Para más información, visite http://msdn.microsoft.com/vstudio/teamsystem/dbpro.
Visual Studio Team Edition para Profesionales de Bases de Datos
ara utilizar esta herramienta desde la pers-pectiva del testeo se debería comenzarpor hacer cosas como medir los tiemposde ejecución de ciertas consultas –estaposibilidad la tenemos ya incorporada alproducto–. También están disponiblesalgunas posibilidades de efectuar test guia-dos por los datos (test driven); pero nosqueda algún trabajo aún en lo relativo alas pruebas unitarias. Definitivamente,queremos que los usuarios puedan incor-porar el análisis del rendimiento al ciclode desarrollo; esto es algo en lo que esta-mos trabajando.
Ya están disponibles en la Web algu-nos documentos y una versión preliminar(Community Preview). ¿Qué sugerencia tie-ne para alguien que quiera comenzar a uti-lizar el producto de inmediato?
GD: El producto requiere un cam-bio mental, de tal forma que un primerpaso en la dirección correcta seríacomenzar a pensar en el mantenimien-to del esquema fuera de la base de datos.Este cambio mental será más difícil paralas personas que aún mantienen tododentro de sus bases de datos, y que uti-lizan una herramienta de conexión parapoder hacer cambios en su infraestruc-tura. Team System será capaz de impor-tar sus scripts para realizar una inge-niería inversa, de modo que el usuariopueda trabajar con la base de datos enun ambiente aislado, sin que se cambieel script de producción.
Uno de los problemas potencialesque veo es que algunos DBA no estánacostumbrados a aprender procesos;ellos únicamente escriben código enManagement Studio, sin haber apren-
dido que deben realizar pruebas antesde salir a producción.
GD: En los últimos años ha habidograndes cambios en la industria en lalínea de la regulación del uso de proce-sos. Existen herramientas que ofrecencierta ayuda para realizar cambios direc-tamente sobre el esquema, pero que noayudan en cada uno de los pasos del pro-ceso y no se integran con un sistema deseguimiento de procesos o un adminis-trador de procesos como es TeamFoundation. Nosotros no obligamos autilizar una metodología en particular;muchos clientes nos han preguntado siexiste un proceso al que deban amol-darse, o si hay alguna sugerencia al res-pecto; pues aún no lo tenemos. Una delas preguntas que nos han hecho en laspresentaciones ha sido si pensamos pro-veer a los usuarios de un estándar decodificación y si se desarrollará unaherramienta para forzar a utilizarlo. Estees el tipo de cosas que los clientes quie-ren; no son tan difíciles, solo que con-llevan mucho trabajo.
¿Qué nos puedes contar acerca deldesarrollo de este producto?
GD: La razón principal por la que meincorporé a este equipo es que podía haceralgo impactante para la industria en 18meses. Creo en los pequeños pasos y esoes lo que hemos estado haciendo: escu-chamos a los clientes, implementamosalgo, hacemos demos y luego escuchamosde nuevo, lo que asegura una gran retro-alimentación. Acabamos de hacer algunoscambios sustanciales basados en algunoscomentarios que hemos recibido, y esodemuestra nuestra flexibilidad para tra-
bajar en un producto destinado a satisfa-cer las necesidades del cliente.
¿Cómo se compara este productocon el de otras empresas?
GD: La oferta de nuestro productono se basa en características, sino que másbien es un producto integrado; se tratade cómo se integran sus partes. Si se ana-liza lo que hay en el mercado, podremosencontrar productos con algunas fun-cionalidades similares a las de nuestroproducto; pero nadie lo integra todo enel ciclo de desarrollo. Nuestro objetivocentral como parte del equipo de TeamSystem es suministrar herramientas degestión del ciclo de vida para el desarro-llador de la base de datos. No obstante,hay que señalar que somos los primerosen la industria en incorporar caracterís-ticas como la refactorización de objetosdel esquema. Las herramientas de com-paración de esquemas existen desde hacealgún tiempo y muchas personas las tie-nen a disposición; sin embargo nadie hautilizado aún una de esas herramientasen un proyecto offline, como nadie per-mite aún comparar el contenido de unarchivo T-SQL con una tabla física den-tro de la base de datos.
Mirando un poco hacia atrás, ¿tehabría sido útil este producto ante-riormente?
GD: Por supuesto; en algunas deestas cosas he estado pensando desdehace mucho tiempo. Esta herramientahabría sido ideal para mí en muchos delos proyectos en los que he trabajado,porque habría podido tener una repre-sentación fuera de línea de la base dedatos para poder trabajar en cualquiermomento. Es una herramienta suma-mente útil, independientemente de quese trabaje de forma individual o enequipo.
¿Qué significa para ti pertenecerahora al equipo de Team System des-pués de tantos años dentro del equi-po de SQL?
GD: Aunque formalmente soymiembro del equipo de Team System,para mí este trabajo sigue teniendomucho que ver con el mundo de lasbases de datos, y eso me mantiene moti-vado. Queremos cumplir con los obje-tivos trazados y terminar este produc-to, y sin lugar a dudas lo lograremos.
¡Muchas gracias a ambos!
dotN
etM
anía
<<
14
dnm.directo.entrevistas<<
Fernando Guerrero, Gert Drapers y Richard Waymire
el proceso que habilita al software paramanipular, procesar y mostrar información en cultu-ras internacionales más fácilmente; esto quiere decirque la información con que se trabaja es relativa a lareferencia cultural, incluyendo lo relacionado al idio-ma, el país o región, los calendarios utilizados, losmodelos de formato para las fechas, la moneda y losnúmeros y el criterio de ordenación de las cadenas.La clase CultureInfo de .NET Framework propor-ciona este tipo de funcionalidad útil para desarrollaraplicaciones globalizadas (internacionalizadas).
La mejor manera para entender la globalizaciónes utilizando la clase CultureInfo. La siguiente seriede ejemplos son una colección de escenarios comu-nes que muestran cómo se puede utilizar esta clase de.NET Framework para aprovechar de una maneraóptima las diferentes culturas.
Ejemplos
Calendarios
Los calendarios se representan en divisiones detiempo como semanas, meses y años. El espacio de
nombres System.Globalization incluye las siguientesimplementaciones de la clase base Calendar:GregorianCalendar, HebrewCalendar, HijriCalendar,JapaneseCalendar, JulianCalendar, KoreanCalendar,TaiwanCalendar y ThaiBuddhistCalendar.
El fuente 1 muestra cómo obtener la lista de calen-darios que puede utilizar la referencia cultural th-TH(Tailandés-Tailandia).
Notas
1. La propiedad CultureInfo.OptionalCalendarsobtiene la lista de calendarios que puede utilizarla referencia cultural seleccionada.
2. Diferencia entre EnglishName y NativeName:EnglishName muestra el nombre de la cultura eninglés, mientras que NativeName muestra el nom-bre localizado.
Fundamentos de globalización
El mayor beneficio de la globalización del software es que proporciona el acceso a usua-rios de todo el mundo, porque la globalización permite el desarrollo de aplicacionesen varios idiomas y en varias culturas.
<< La globalización es
Andy González
dnm.firma.solidaria
Andy González esInternational Program Manageren Microsoft. Es responsable
de la calidad de lasherramientas de desarrollo
para Latinoamérica y España,entre las que se incluyen
Visual Studio,Visual StudioTeam System, .NET
Framework y Visual StudioTools for the Office System.
Ha trabajado en Microsoftdurante 6 años, siempre
centrado en la globalizaciónde estos productos.
Dim ci As New CultureInfo(“th-TH”)Dim i As Integer = ci.OptionalCalendars.GetUpperBound(0)
Debug.WriteLine(“The default calendar for the culture “ & _ci.EnglishName & “ is: “ & ci.Calendar.ToString)
Debug.WriteLine(“The optional calendars for “ & _ci.NativeName & “ are:”)
For i = 0 To ci.OptionalCalendars.GetUpperBound(0)Debug.WriteLine(ci.OptionalCalendars(i).ToString)
Next
Fuente 1
The default calendar for the culture Thai (Thailand) is: System.Globalization.ThaiBuddhistCalendarThe optional calendars for ??? (???) are:System.Globalization.ThaiBuddhistCalendarSystem.Globalization.GregorianCalendar
RESULTADO
NOTA
Para implementar estos ejemplos, es necesariohacer referencia a los espacios de nombresGlobalization y Threading:
Imports System.GlobalizationImports System.Threading ][
Fechas
El código del fuente 2 permite obtener el forma-to de fecha para las culturas Inglés-Estados Unidos yÁrabe-Egipto, y muestra no solo cómo el formato esdiferente, sino también la diferencia en el primer díade la semana para ambas culturas.
Notas
1. La propiedad Thread.CurrentCulture establece lacultura para el subproceso actual.
2. La propiedad Thread.CurrentUICulture establece lacultura que utiliza el gestor de recursos para utilizarlos recursos culturales en tiempo de ejecución.
Hora
El ejemplo que se presenta en el fuente 3 es básico ytrata sobre los formatos de hora. A continuación, el ejem-
plo del fuente 4 utiliza el método ToUniversalTime paraconvertir el valor del objeto DateTime actual a la hora uni-versal coordinada (UCT) y mostrar la diferencia entrela hora local y la hora universal.
Notas
1. El método DateTime.ToUniversalTime convierte elvalor del objeto DateTime actual a la hora univer-sal coordinada (UCT).
2. La propiedad TimeZone.CurrentTimeZone estable-ce la zona horaria del equipo.
Números y monedas
.NET Framework permite aprovechar todas laspersonalizaciones dependientes de la cultura posiblespara los valores numéricos, como son:
• Separador de bloques.• Separador decimal.
• Números negativos.• Agrupación de dígitos.• Colocación del símbolo de núme-
ro negativo.• Símbolo monetario
El fuente 5 presenta un ejemplo decódigo.
Ordenación
El ejemplo que se presenta en elfuente 6 muestra la diferencia entre laordenación utilizando el alfabeto tradi-cional y el alfabeto moderno en idiomaespañol.
dotN
etM
anía
<<
17
dnm.firma.solidaria<<
Dim dt As DateTime = DateTime.NowDim ci As CultureInfo = New CultureInfo(“ar-EG”)
Thread.CurrentThread.CurrentCulture = New CultureInfo(“en-US”)Debug.WriteLine(“The Short Date format for: “ & _
Thread.CurrentThread.CurrentUICulture.NativeName & “ is: “)Debug.WriteLine(dt.ToString(“d”))Debug.WriteLine(“The first day of the week is in “ &_
Thread.CurrentThread.CurrentUICulture.NativeName & “ is: “ &_Thread.CurrentThread.CurrentUICulture.DateTimeFormat.FirstDayOfWeek)
Debug.WriteLine(“The Short Date format for: “ & ci.NativeName & “ is: “)Debug.WriteLine(dt.ToString(“d”, ci))Debug.WriteLine(“The first day of the week is in “ & ci.NativeName & _
“ is: “ & ci.DateTimeFormat.FirstDayOfWeek)
Fuente 2
The Short Date format for: English (United States) is: 5/30/2006The first day of the week is in English (United States) is: 0The Short Date format for: ( ) is: 30/05/2006The first day of the week is in (???) is: 6
RESULTADO
Dim en As CultureInfo = New CultureInfo(“en-US”)Dim ci As CultureInfo = New CultureInfo(“es-ES”)Dim dt As DateTime = DateTime.Now
Thread.CurrentThread.CurrentCulture = enDebug.WriteLine(“The Time format for: “ & _
Thread.CurrentThread.CurrentUICulture.NativeName & “ is: “)
Debug.WriteLine(dt.ToString(en.DateTimeFormat.LongTimePattern))Debug.WriteLine(“The Time format for: “ & ci.NativeName & “ is: “)Debug.WriteLine(dt.ToString(ci.DateTimeFormat.LongTimePattern))
Fuente 3
The Time format for: English (United States) is: 9:48:54 AMThe Time format for: español (España) is: 9:48:54
RESULTADO
Dim theTime As DateTime = DateTime.NowDim gmtTime As DateTime = DateTime.Now.ToUniversalTimeDim timeDiff As TimeSpan = theTime.Subtract(gmtTime)
Dim tMinutes As Integer = timeDiff.TotalMinutesDim Minutes As Integer = timeDiff.MinutesDim Hours As Integer = timeDiff.HoursDim myTimeZone As TimeZone = TimeZone.CurrentTimeZone
txtTime.Text = theTime.ToStringtxtGMT.Text = gmtTime.ToStringtxtTimeDiff.Text = “hours: “ & Hours & “ Minutes: “ & MinuteslblTminutes.Text = “(“ & tMinutes & “ Total minutes” & “)”lblTimeZone.Text = myTimeZone.StandardName
Fuente 4
RESULTADO
Culturas personalizadas(Custom Cultures)
La clase CultureInfo proporcionainformación específica sobre la culturacomo el idioma, país, región, calendario,etc., y utiliza clases como DateTimeFormatInfo, NumberFormatInfo, CompareInfo yTextInfo para manejar característicastales como los formatos de fechas ynúmeros, y las comparaciones de cade-nas de caracteres.
Las aplicaciones que se ejecuten en unequipo solo podrán utilizar las culturasdefinidas de antemano en la claseCultureInfo. Ahora bien, es posible utili-zar la clase CultureAndRegionInfoBuilderpara crear una nueva cultura o reempla-
zar una ya definida, einstalarla en un equipo.Ésta puede ser utilizadapor cualquier aplicaciónque se ejecute en el equi-po donde se haya insta-lado. Para instalar unacultura, es necesariotener derechos de admi-nistrador.
Microsoft LocaleBuilder
Microsoft Windows Vista soporta másde 200 localidades y más de 100 idiomas,pero esto aún no es suficiente para cubrirtodas las necesidades del mundo del soft-
ware. Microsoft LocaleBuilder es una herra-mienta que proporcionala posibilidad de cambiarla información local pre-definida por informaciónregional específica. Estaherramienta ha sido cre-ada para satisfacer lasnecesidades de clientesen regiones para la cualWindows Vista no hadefinido una configura-ción regional.
Conclusión
En este artículo hemos presentado, através de ejemplos prácticos, las ampliasposibilidades que nos ofrece .NETFramework para la globalización de nues-tras aplicaciones.El importe correspondiente a los
derechos de autor de este artículo ha sidocedido por el autor a la InternationalDiabetes Federation. ¡Gracias Andy!
El objetivo del proyecto “Life for aChild” es dar a los niños con diabetes los cuidados clínicos y la edu-cación necesaria sobre su enfermedad para seguir con vida.Los cen-tros de diabetes beneficiados están en países como Fiji,Nueva Guinea,Filipinas, India, Rumania, Bolivia,Azerbaiján, Montenegro, Sri Lanka,República Democrática del Congo o Ruanda.
Si considera ésta una causa justa y solidaria y desea hacer unadonación como ha hecho Andy,puede hacerlo en www.lifeforachild.idf.org.
dotN
etM
anía
<<
18
dnm.firma.solidaria<<
Dim i As Integer = 1000000Dim j As Integer = -1000Dim en As CultureInfo = New CultureInfo(“en-US”)Dim es As CultureInfo = New CultureInfo(“es-ES”)
Thread.CurrentThread.CurrentCulture = en
Debug.WriteLine(“The initial amount is: “ & i)Debug.WriteLine(“The amount in “ & _
Thread.CurrentThread.CurrentCulture.NativeName & “is: “ &_i.ToString(“c”))
Debug.WriteLine(“The amount in “ & es.NativeName & “is: “ & _i.ToString(“c”, es))
Debug.WriteLine(“The initial amount is: “ & j)Debug.WriteLine(“The amount in “ & _
Thread.CurrentThread.CurrentCulture.NativeName & “is: “ & _j.ToString(“c”))
Debug.WriteLine(“The amount in “ & es.NativeName & “is: “ & _j.ToString(“c”, es))
Fuente 5
The initial amount is: 1000000The amount in English (United States)is: $1,000,000.00The amount in español (España)is: 1.000.000,00
The initial amount is: -1000The amount in English (United States)is: ($1,000.00)The amount in español (España)is: -1.000,00
RESULTADO
Dim stringArray(3) As String
stringArray(1) = “color”stringArray(2) = “calor”stringArray(3) = “calle”
Debug.WriteLine(“The Array contains: “)Debug.WriteLine(stringArray(1))Debug.WriteLine(stringArray(2))Debug.WriteLine(stringArray(3))
Thread.CurrentThread.CurrentCulture = New CultureInfo(3082)
Array.Sort(stringArray)
Debug.WriteLine(“After sorting in the array in Spanish”&_“ - Spain (Modern Sort): “)
Debug.WriteLine(stringArray(1))Debug.WriteLine(stringArray(2))Debug.WriteLine(stringArray(3))
Thread.CurrentThread.CurrentCulture = New CultureInfo(1034)Array.Sort(stringArray)Debug.WriteLine(“After sorting again in “ &_
“Spanish-Spain (Traditional Sort): “)Debug.WriteLine(stringArray(1))Debug.WriteLine(stringArray(2))Debug.WriteLine(stringArray(3))
Fuente 6
The Array contains: colorcalorcalle
After sorting in the array in Spanish - Spain (Modern Sort): callecalorcolor
After sorting again in Spanish - Spain (Traditional Sort): calorcallecolor
RESULTADO
Referencias
[1]Para encontrar más información, visitehttp://msdn2.microsoft.com/es-es/library/sys-tem.globalization(VS.80).aspx.
[2]
Para obtener más información acerca deMicrosoft Locale Builder, visite http://www.microsoft.com/downloads/details.aspx?FamilyId=12ADFFC8-A4DA-424B-8D62-17C1E0FFC116&displaylang=en.
Life for a Child with Diabetes
dotN
etM
anía
<<
19
Mantener la sesión HTTP con .NET Framework
En este sencillo pero muy útil truco .NET, nos vamos a imponer el reto desubsanar una pega que muchos desarrolladores han encontrado al intentarcrear aplicaciones que consumen información de servidores Web utilizandomecanismos de cierto bajo nivel…
<< al simular desde un formularioWindows el envío de datos mediante POST, para enton-ces recoger el resultado HTML y visualizarlo en unavista Web dentro de un formulario Windows.
El problema que se plantea es el de cómo no per-der la sesión para que las páginas ASP, JSP, etc., sepanen todo momento quiénes somos, a pesar de no queno utilizamos ningún navegador estándar para estastareas. El caso es que vamos a escribir un User-Agentpropio aprovechando los conocimientos del proto-colo HTTP y sus cabeceras, de tal forma que el ser-vidor nunca pierda la pista de quiénes somos.
Un poquito de… conceptos HTTPDesde la aparición de las aplicaciones Web, uno de
los problemas que se plantearon fue el de cómo man-tener una referencia del navegador que estaba conecta-do al servidor. ¿Por qué? Pues porque las aplicacionesWeb ofrecen normalmente un sistema de navegaciónpor un conjunto de opciones que requieren el almace-namiento de información acerca de quién está conec-tado. De esta forma es posible mantener el nombre delusuario en las páginas por las que pasa, hacer un segui-miento de los productos que selecciona, mantener infor-mación el tiempo suficiente como para poder hacer cál-culos, procesos, accesos a datos…
Todo lo anterior no es posible tal y como lo plan-tea el protocolo HTTP 1.0. ¿Y eso? Pues porqueHTTP 1.0 es como la Dorita de la película “Elpequeño Nemo”: se olvida de quiénes somos en cadaconversación que tenemos. HTTP es un protocolodesconectado, es decir, que responde al patrón“conectamos-descargamos la página-nos desconec-tamos”. Y cada petición es un evento completamen-
te nuevo (hay que recordar que HTTP fue pensadooriginalmente para la descarga de documentos). Estollevó a los cabezones que desarrollaban el estándar aromperse la cabeza y desarrollar una mejora.
El protocolo HTTP 1.1 establecía una nueva cabe-cera de tipo cookie que almacenaba un identificador queel servidor Web generaba con cada nueva conexión.De esta forma, esta cookie de sesión era enviada en cadapetición-respuesta, conociéndose así en todo momen-to al cliente de la conexión. Esto llevó al protocoloHTTP a ser persistente entre llamadas. Y los subsis-temas CGI de los servidores pudieron comenzar aalmacenar datos en su memoria acerca de la sesión delos clientes conectados. Comenzaba, pues, lo rico deljuego que todos conocemos ahora….
Ahora bien, en la actualidad los servidores Webya no son solo contenedores de documentos, sinocompletos servidores de aplicaciones. Y el uso coti-diano de la Web nos lleva a pedir más. De hecho, elproblema es el propio HTML: es demasiado limita-do para poder “ir más allá”. Es por eso que se plan-tean dos iniciativas:
a) Clientes relativamente inteligentes, gráfica-mente potentes, basados en servicios de lógicadistribuida (Smart Clients).
b) Clientes ligeros AJAX, mediante los cuales(empleando tecnologías abiertas: JavaScript yXML, junto con los servicios de lógica distri-buidos), se hace posible escribir clientes Webmás accesibles y ricos.
La cosa es que Internet 2.0 está a la vuelta de laesquina y la cosa promete revolucionar. Y digo yo…¿qué tal un término medio? Me explico: ni a) ni b),sino un punto intermedio.
Pepe Hevia
dnm.plataforma.net
Como por ejemplo,
Pepe Heviacolabora habitualmente con
dotNetManía. Es arquitecto desoftware senior en Alhambra-
Eidos.Tiene las certificaciones deMCAD,MCSD.NET y MCT en
.NET Framework.Ha escritovarios libros sobre la plataforma
.NET (lalibreriadigital.com)
dotN
etM
anía
<<
20
dnm.plataforma.net<<
El problema de a) es que pasa por un modelo deservicios Web que no guardan estado de sesión algu-no por la propia filosofía del paradigma SOA; el pro-blema de b) es que, aunque AJAX plantea un interfazHTML rico, es relativamente complejo a la hora dedesarrollar, ya que hay que conocer muy a fondoJavaScript, DOM y HTML dinámico. Y no siempreel resultado es efectivo en todos los navegadores.
Así que, ¿por qué no usar los interfaces ricos delas plataformas clientes, y hacer que las páginasASP.NET se encarguen del modelo de negocio?Quitamos HTML y dejamos una plataforma con losmismos elementos que ya conocemos: sesión, aplica-ción, etc. Es decir, reemplazamos el navegador deInternet, y creamos “navegadores” específicos de laaplicación Web. Pero claro, si el Internet Explorer secomunica con los servidores y se emplea la sesión paramantener la navegación, ¿cómo podemos hacer queuna navegación de Windows Forms haga lo mismoque las páginas ASP.NET? Pues bien, haciendo quenuestro aplicativo procese las cookies de sesión HTTP1.1 de forma correcta. Y el truco: conocer el proto-colo HTTP y sus RFC. Esto nos permitirá:
a) Generar menús Win32 e interfaces gráficasbasadas en potentes TreeViews u otros contro-les más avanzados a partir de XML de serviciosde un servidor Web. Nos quitamos de encimala pesadilla de los diseños de menús HTML.
b) Navegar desde los menús empleando ventanasMDI, cuadros de diálogo, etc., que enviarándatos POST a servicios HTTP.
c) Validar la información a enviar al servidorempleando todos los mecanismos de validaciónde los controles Windows.
d) Mantener la sesión entre ventanas Windows, em-pleando las cookies de sesión de un servidor HTTPpara mantener la coherencia en los servicios.
e) Aprovechar la potencia de un entorno GDI/DirectX para poder dotar a los interfaces de ser-vicios nuevos.
f) La lógica queda encapsulada en sencillas pági-nas ASP.NET centralizadas. No deberemos pre-ocuparnos por los cambios en los clientes.
g) El despliegue de clientes, gracias a las tecno-logías PUSH de .NET, es… ¡pan comido!
h) Un largo etcétera.
Para que HTTP sea un protocolo Keep-Alive, laprimera vez que nos conectamos a una páginaASP.NET se nos estampa una cabecera Set-Cookie conel identificador que nos hace únicos en un contextodel servidor Web. Es a partir de ese momento quegozamos del objeto Session en las páginasASP/ASP.NET, etc. Lo importante es que el navega-dor, en cada diálogo petición-respuesta, debe enviarcontinuamente al servidor dicha cookie para que el ser-vidor nos tenga localizados. Y ¡voilá! Os aconsejo queveáis un poco más adelante cómo queda el protoco-lo, para que veáis cómo se implementa el control desesión HTTP en nuestro ejemplo (figura 3).
La arquitectura
Para demostrar cómo funciona nuestra propues-ta, podríamos complicarnos mucho la vida montan-do cualquier tipo de aplicación típica de la Web. Peronos vamos a limitar a crear una sencilla aplicación quenos permitirá introducir quiénes somos, y nos dará lainformación de nuestra sesión. Simplificando el aná-lisis (vea figura 1):
Para poder implementar la lógica de negocio nece-sitaremos dos capas y un CommandPattern para el pro-tocolo de comunicaciones basado en HTTP (a todoel conjunto, modelo orientado a servicios).
Ahora que viene Internet 2.0,planteo yo:si .NET tie-ne un despliegue tan sencillo como ClickOnce; unaejecución segura garantizada gracias a los permisosde seguridad;un tamaño compacto,etc., ¿por qué noorientarse a desarrollar clientes ricos firmados digi-talmente para hacer más rico el uso del cliente y lared,empleando protocolos abiertos? ¡Es justo el cami-no de en medio!
TIP
Muchas veces lo que parece complicado es muy sen-cillo. Con un poco de HTTP, un poco de imaginacióny – sobre todo - buenas herramientas,se puede hacerprácticamente todo.
TIP
Figura 1. Los casos de uso de nuestro ejemplo.
Me gusta mucho analizar antes de poner manos a laobra. Fijaros cómo, a partir de un sencillo diagramade lo que quiero hacer (figura 1), obtengo un diagra-ma de arquitectura (figura 2).
TIP
Finalmente, el protocolo que encap-sula nuestro manipulador se describe enla figura 3.
Lo que necesitamos de la capade cliente
Con el patrón de diseñoCommandPattern nos será posible encap-sular lo que necesitamos de HTTP tan-to en petición como en respuesta desdelos servicios de los controles de los for-mularios. Así encapsulamos su funcio-
nalidad en un comando, y obtenemosuna respuesta independientemente decómo funcione por dentro (de manerasimilar a como trabajan objetos tan
conocidos como losde ADO.NET, porponer un ejemplo).La clase responsa-ble de este patrón esla clase ServiciosCP,que se encarga de:• Registrar los datos
del usuario em-pleando la páginaASPX Registro.aspx. Codifica losdatos en un cuer-po POST, realizala petición HTTPy de su respuestaextrae dos cosas: lacookie de sesión y elmensaje de res-
puesta del servidor. Como muestra elfuente 1, es necesario extraer la cookiede sesión de la cabecera HTTP Set-Cookie, y extraer de su formato (defini-do en las RFC W3C) la cadena queguarda el par clave=valor. Es impor-tante indicar el ContentType para que elservidor ASP.NET reconozca correcta-mente el formato del POST.
• Recoger los datos de informaciónde la sesión del usuario, encapsu-lando el funcionamiento del servi-cio que ofrece la página ASPXMostrarDatos.aspx. Como se puedever en el fuente 2, el envío de lasesión se realiza como una cabeceraHTTP Cookie con el valor obtenidodel proceso de registro (que generóla cabecera Set-Cookie).
Es importante recalcar que no seestán empleando servicios Web ASMX,sino páginas ASPX puras y duras (esposible hacerlo con servicios Web,pero en tal caso es necesario activar elsoporte de Stateful y control de sesióncon las directivas adecuadas). Es porello que todo el peso de la serializa-ción de los comandos recae directa-mente sobre HTTP, y que debemosemplear las maravillosas clases HTTPde .NET: WebRequest, HTTPWebRequest yHTTPWebResponse, del espacio de nombresSystem.NET; clases que encapsulan lamanipulación del protocolo.
Nuestro manipulador lo definirá elprograma principal y se lo pasará a losformularios que lo requieran. Ahí estáel mantenimiento de la sesión: no per-der bajo ningún concepto la cookie desesión.
dotN
etM
anía
<<
21
dnm.plataforma.net<<
Figura 2.Arquitectura en capas. Fijaosen la sincronía de cada elemento. Una
preciosidad, el modelo orientado a servicios.
Figura 3. Diagrama del protocolo empleado.
Public Class ServiciosCPPrivate mSesion As Cookie = Nothing
Public Shared Function ParserCookie(ByVal cabecera As String) As StringDim tokens As String() = cabecera.Split(“;”)Return tokens(0)
End Function
Public Function Registrar(ByVal nombre As String, _ByVal apellido As String) As String
Dim cliente As HTTPWebRequest = _WebRequest.Create(“HTTP://localhost/ServidorSesion/Registro.aspx”)
cliente.Method = “POST”cliente.ContentType = “application/x-www-form-urlencoded”Dim post As New StreamWriter(cliente.GetRequestStream())post.Write(String.Format(“nombre={0}&apellido={1}”, nombre, apellido))post.Close()
‘Recoger la respuesta, entre ella, la cookie de sesiónDim resp As HTTPWebResponse = cliente.GetResponse()mSesion = ParserCookie(resp.Headers(“Set-Cookie”))Dim msg As New StreamReader(resp.GetResponseStream())Dim result As String = msg.ReadToEnd()msg.Close()Return result
End Function
(...)End Class
Fuente 1. Comando Registrar.
Lo que necesitamos de la capade servidor…
Sólo nos queda poner el condimen-to en el plato, como hacen nuestrosmaestros cocineros de la tele, para dejarcasi todo terminado. Necesitamos solocoordinar el cliente con los servicios denegocio de las páginas ASPX. En nin-guno de los casos la página devolveráHTML, así que limpiaremos el docu-mento HTML dejando sólo la directi-va @Page, y escribiremos el código en elevento Page_Load del code-behind.
La página de Registro recogerá elPOST y creará la sesión (simplementeusando el objeto integrado Session, verfuente 3). La página de MostrarDatoscompondrá un documento XML con lainformación que podemos sacar de lasesión ASP (fuente 4). Y eso es todo. Lobueno de ASP es que la propia plata-forma gestiona la persistencia de lasesión de forma nativa. Nosotros noslimitamos solo a usar sus servicios.
En el código fuente, además de lasesión es posible enviar cualquier datorelevante almacenado en los objetosintegrados ASP.NET. Ya puestos...Además, tal cual está diseñado el sis-tema, como el documento devuelto esXML, podremos ampliar la lista tan-to como queramos. En nuestro caso,hemos añadido la ruta del host cliente
y un nombre establecido en la cabe-cera HTTP: el agente de usuario (quemuestra que no todo es InternetExplorer).
Todo funcionando…Bien pues ya solo nos queda el pere-
jil. Ver todo funcionando. Simplementese ejecuta el Registro, y accedemos a laventana de “Mostrar Datos” bien des-de el propio formulario de alta, bien des-de el menú. El caso es que se trata deinstancias distintas. Y lo que se puedever es que todas comparten la mismasesión ASP.NET en todo momento. Yatenemos las bases para montar aplica-ciones inteligentes que suplen la fun-ción de un navegador HTML. Ahorapodremos montar navegadores de ser-vicios en la futura Web 2.0. Javascriptmola, pero .NET mola más.
Vosotros podéis ir ya imaginandoarquitecturas. Os propongo algo queresolveremos en futuros artículos:menús dinámicos, formularios dinámi-cos de entrada y respuesta. ¡Todo diri-gido por la Web!
El código fuente de este proyectose puede obtener desde la página Webde la revista (http://www.dotnetma-nia.com), o bien desde mi sitio Web(www.heviatec.net).
dotN
etM
anía
<<
22
dnm.plataforma.net<<
Public Class ServiciosCPPrivate mSesion As Cookie = Nothing
(...)Public Function MostrarDatos() As DataSetIf mSesion Is Nothing Then
Throw New Exception(“La sesión no está establecida”)End If
Dim cliente As HTTPWebRequest = _WebRequest.Create(“HTTP://localhost/ServidorSesion/MostrarDatos.aspx”)
cliente.Method = “GET”cliente.CookieContainer.Add(mSesion)
‘Recoger la respuesta, entre ella, la cookie de sesiónDim resp As HTTPWebResponse = cliente.GetResponse()mSesion = resp.Headers.Add(“Cookie”,mSesion)Dim msg As New StreamReader(resp.GetResponseStream())Dim result As String = msg.ReadToEnd()msg.Close()
‘Obtener el DataSet del XML de retornoDim dsDatos As New DataSet(“INFO”)dsDatos.ReadXml(new StringReader(result),XmlReadMode.InferSchema)Return dsDatos
End FunctionEnd Class
Fuente 2. Comando MostrarDatos.
Public Class RegistroInherits System.Web.UI.Page
(...)
Private Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs)Handles MyBase.Load
‘Preparar la sesión.Session.Add(“nombre”, Request.Form(“nombre”))Session.Add(“apellido”, Request.Form(“apellido”))
‘Generar la respuesta. Ya viajará la cookie de sesion.Response.Write(“OK”)
End SubEnd Class
Fuente 3. Code-behind de Registro.aspx
Public Class MostrarDatosInherits System.Web.UI.Page
(...)Private Sub Page_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles MyBase.LoadResponse.ContentType = “text/xml”Response.Write(“<DATOSSESION><SESION>”)Response.Write(String.Format(“<nombre>{0}</nombre>”, Session(“nombre”)))Response.Write(String.Format(“<apellido>{0}</apellido>”, Session(“apellido”)))Response.Write(String.Format(“<idSesion>{0}</idSesion>”, Session.SessionID))Response.Write(String.Format(“<esNueva>{0}</esNueva>”, Session.IsNewSession))Response.Write(String.Format(“<timeOut>{0}</timeOut>”, Session.Timeout))Response.Write(String.Format(“<ip>{0}</ip>”, Request.UserHostAddress))Response.Write(“</SESION></DATOSSESION>”)
End SubEnd Class
Fuente 4. Code-Behind de MostrarDatos.aspx
<<
23
Creación de asistentes en Visual StudioEn este artículo veremos una forma más de extensibilidad de Visual Studio, aparte delas macros y complementos que ya hemos visto con anterioridad.Se trata de los asis-tentes (wizards) que se introdujeron con la versión inicial de Visual Studio .NET. Enartículos posteriores hablaremos de las novedades y cambios introducidos en VisualStudio 2005 (plantillas, kits de iniciación, etc.).
<< hemos hablado de dos formas deextensibilidad de Visual Studio que eran las macrosy los complementos (add-ins). Existe una tercera for-ma de extensibilidad de alto nivel, aunque de alcan-ce más reducido que las anteriores, que son los asis-tentes (wizards). Todos sabemos lo que es un asisten-te, pues se popularizaron mucho desde Windows 95:es un cuadro de diálogo que a través de una serie depasos (pulsando el típico botón “Siguiente”) nos per-mite realizar una tarea más o menos compleja. En elcaso más sencillo, un asistente puede constar de unúnico paso y no requerir información del usuario.Los asistentes de Visual Studio permiten generar deforma automática código repetitivo, que empleamosuna y otra vez en nuestros proyectos. Preguntandoal usuario algunos datos, el asistente puede persona-lizar el código generado con dichos valores.
Tipos de asistentesVisual Studio .NET permite crear tres tipos de
asistentes:• Asistente para nuevo proyecto. Es el que se ejecuta
cuando seleccionamos un tipo de proyecto en eldiálogo que aparece al pulsar el menú “Archivo -Nuevo - Proyecto…” de Visual Studio. En esecuadro de diálogo aparecen los distintos tipos deproyectos que podemos crear, agrupa-dos por lenguaje(VB.NET, C#)o por tipo(proyectosde instala-ción, debase dedatos, etc.).
En la mayoría de los proyectos, el asistente quese ejecuta al seleccionar un tipo de proyecto nomuestra ninguna ventana para pedir informaciónadicional, porque sólo con el nombre del proyec-to, tipo y carpeta ya puede generar el código fuen-te. Imaginemos que en nuestra empresa tenemosun framework de desarrollo y todos los proyectosque se crean siguen una serie de pautas: referen-cias que se han de incluir, archivos obligatorios(tal vez almacenados en una carpeta central), etc.En este caso nos puede interesar un asistente paraun nuevo tipo de proyecto que ahorre a nuestrosprogramadores el tener que realizar esas tareasmanualmente cada vez que quieran crear una nue-va aplicación. Aunque esto se puede realizar des-de una macro o un complemento, el Asistente paranuevo proyecto de Visual Studio se creó específica-mente para esto.
• Asistente para nuevo archivo. Es similar al asistentepara nuevo proyecto. Cuando ya tenemos un pro-yecto creado, si pulsamos el menú “Proyecto -Agregar nuevo elemento…” semuestra un cuadrode diálogo queofrece distintostipos de archivoque podemos añadir
Carlos Quintero
dnm.plataforma.net
En entregas anteriores
Carlos J.Quintero esMicrosoft MVP de Visual Basic
desde principios del año 2004. Esautor del popular complemento
MZ-Tools 3.0 para VB6,VB5 yVBA,de MZ-Tools 4.0 para Visual
Studio .NET 2002/ 2003, y deMZ-Tools 2005 para Visual
Studio 2005. Estas herramientasestán disponibles en
http://www.mztools.com
dotN
etM
anía
dotN
etM
anía
<<
24
dnm.plataforma.net<<
a nuestro proyecto. Al seleccionaruno de ellos, se invoca el asistentepara ese tipo de archivo que, comoen el caso anterior, la mayoría de lasveces no preguntará ninguna infor-mación adicional. Supongamos queen nuestras aplicaciones tenemosque añadir muchos archivos concódigo que se repite entre ellos (porejemplo, que todos los archivosincluyan un encabezado de docu-mentación). De nuevo, aunque estopuede realizarse con una macro ocomplemento, puede interesarnosque aparezca un archivo de este tipoen el cuadro de diálogo “Nuevo ele-mento” de Visual Studio.
• Asistente a medida (custom wizard). Esel típico asistente que sí preguntainformación adicional y muestra losbotones “Anterior” y “Siguiente”.En el caso de Visual Studio .NET,los asistentes de este tipo permitenrealizar cualquier tarea, y no sola-mente crear nuevos proyectos oarchivos (a costa de requerir la codi-ficación necesaria para llevar a cabodicha tarea, claro).
En este artículo nos centraremossobre todo en los dos primeros tipos yaque son los más específicos y sencillos.Éstos son muy similares entre sí, asíque los explicaremos conjuntamente,aunque en los ejemplos usaremos unAsistente para nuevo archivo.
Creación de asistentesNuestro objetivo es, por tanto, hacer
que en los cuadros de diálogo “Nuevo pro-yecto” o “Nuevo elemento” aparezcanplantillas de proyectos o archivos propor-cionados por nosotros (junto a las que pro-porciona Visual Studio) y que cuando elusuario las seleccione, se invoque nuestro
asistente para crear el proyecto o archivoen la solución de Visual Studio. El asis-tente creará un nuevo proyecto en la solu-ción o añadirá un archivo al proyecto exis-tente a partir de unas plantillas.
Físicamente, un asistente es simple-mente una DLL registrada como com-ponente COM que implementa la inter-faz EnvDTE.IDTWizard (del ensambladoEnvDTE.dll que tendremos que añadir alproyecto del asistente). Esta interfaz sólocontiene un método llamado Execute quees llamado por Visual Studio para ejecu-tar el asistente. El asistente es libre dehacer lo que quiera en este método (espe-cialmente si es un asistente a medida),pero en el caso de asistentes para nuevoproyecto o nuevo archivo básicamente elasistente creará un nuevo proyecto oarchivo.
Más adelante hablaremos de la inter-faz IDTWizard y su método Execute, peroprimero vamos a enumerar los pasosbásicos para crear un Asistente para nue-vo proyecto o nuevo archivo que desa-rrollaremos en los siguientes apartados:• Creación de las plantillas de proyec-
to o archivo que usará el asistente. Al
distribuir nuestro asistente, tendre-mos que distribuir no solamente elasistente sino dichas plantillas.
• Creación de la DLL del asistente conuna clase que implemente la interfazIDTWizard.
• En la implementación del métodoExecute de la interfaz IDTWizard, usarlos métodos AddFromTemplate delmodelo de extensibilidad de Visual
Studio para crear nuevos proyectos oarchivos a partir de plantillas.
• Reemplazar los símbolos (placeholders)de las plantillas por sus valores reales,que ha especificado el usuario al invo-car el asistente (nombre del proyectoo de la clase, etc.).
• Registro COM (ActiveX) de dichaDLL. Ya hemos mencionado en otrasocasiones que Visual Studio .NET noes una aplicación .NET, sino que sigueusando COM para su extensibilidad.
• Registro del asistente en Visual Studiomediante un archivo .vsz. Medianteeste archivo, el asistente se da a cono-cer a Visual Studio y hace que aparez-can las plantillas en los cuadros de diá-logo “Nuevo proyecto” o “Nuevo ele-mento” del IDE.
Creación de plantillasComo hemos mencionado, el propó-
sito de un Asistente para nuevo proyecto onuevo archivo es generar el código del pro-yecto o del archivo. Aunque el asistentepodría generar este código directamenteañadiendo un proyecto o archivo en blan-co y usando el modelo de extensibilidadpara escribir código (línea a línea o párra-fo a párrafo), un enfoque más adecuadoconsiste en que use plantillas de códigoexternas al propio asistente. De esta mane-ra se puede actualizar el contenido dedichas plantillas sin necesidad de cambiary recompilar la DLL del asistente. Coneste enfoque, lo que el asistente tiene quehacer es obtener la carpeta donde estáninstaladas dichas plantillas y mediante lafunción AddFromTemplate del modelo deextensibilidad copiarlas a la carpeta de des-tino especificada por el usuario y añadir-las a la solución o al proyecto, según eltipo de asistente (proyecto o archivo, res-pectivamente).
Por tanto, nuestro primer pasopara crear un asistente de este tipo serácrear las plantillas que usará el asis-tente. ¿Cómo se hace esto? Pues la
Visual Studio .NET permite crear tres tipos de asistentes:para nuevo proyecto, nuevo archivo, o a medida
Físicamente un asistente es simplemente una DLL,registrada como componente COM, que implementa
la interfaz EnvDTE.IDTWizard
forma más fácil es crear un nuevo proyecto o archi-vo como hacemos normalmente y personalizarlocomo deseemos para que nos sirva de plantilla. Unavez creadas las plantillas, se pueden almacenar encualquier carpeta, siempre que el asistente puedaluego encontrarlas. Por ello, lo más fácil es guar-darlas en una subcarpeta de la carpeta donde estáinstalado el asistente. En el fuente 1 se muestra unaplantilla muy sencilla para crear un archivo de cla-se VB.NET personalizado con un encabezado.Como se puede observar, hemos usado unas varia-bles (con los caracteres %) que más tarde reempla-zaremos por sus valores (como veremos en otroapartado).
Creación de la DLL
Para crear la DLL del asistente tenemos que crearun proyecto en Visual Studio del tipo Biblioteca de clases(Class Library), al que añadiremos un archivo de clase yuna referencia al ensamblado EnvDTE.dll. Como hay queregistrar el asistente como componente COM (ActiveX),esta clase tiene que tener los siguientes atributos del espa-cio de nombres System.Runtime.InteropServices:ComVisible(True), ProgId(<progid>) y Clsid(<clsid>),donde <progid> puede ser por ejemplo“AsistentesVSNET.Asistentes” y <clsid> es unGUID único. Asimismo, es conveniente cambiar enel archivo AssemblyInfo.vb el valor del atributoAssemblyVersion a “1.0.0.0”, para indicar que elensamblado siempre es compatible hacia atrás(podemos versionar el archivo de la DLL con elatributo AssemblyFileVersion en su lugar). Final-mente, para poder depurar el asistente, en las pági-nas de propiedades del proyecto seleccionaremos“Arrancar programa externo” como acción de ini-cio e indicaremos la ruta al ejecutable de VisualStudio .NET (C:\Archivos de programa\MicrosoftVisual Studio .NET 2003\Common7\IDE\devenv.exe)y marcaremos la casilla “Registrar para interopera-bilidad COM” en la sección “Compilación” paraque se registre la DLL como componente ActiveX.
La interfaz IDTWizardLa clase principal del asistente tiene que imple-
mentar la interfaz EnvDTE.IDTWizard, que tieneun único método llamado Execute:
Public Sub Execute(ByVal Application As Object,_ByVal hwndOwner As Integer, _ByRef ContextParams As Object( ), _ByRef CustomParams As Object( ), _ByRef retval As EnvDTE.wizardResult)
Sus parámetros son los siguientes:• Application: es el objeto EnvDTE.DTE que repre-
senta la instancia del IDE. Ya hemos hablado deeste objeto en los artículos sobre complemen-tos o macros.
• hWndOwner: el manejador (handle) de la ventanaque muestra el cuadro de diálogo del asistente,para el caso de que el asistente tenga que mos-trar algún cuadro de diálogo que tendríamosque emparentar con esa ventana.
• ContextParams: es un array de elementos de tipoObject con información de contexto que pro-porciona Visual Studio.
• CustomParams: es un array de objetos de tipoObject con información definida por el creadordel asistente.
• retval: el resultado de la llamada a la función.
dotN
etM
anía
<<
25
dnm.plataforma.net<<
PosiciónValor del array ContextParams Descripción
0 Tipo de asistente El valor EnvDTE.Constants.vsWizardNewProject.1 Nombre del proyecto Nombre del proyecto que se ha de crear (sin
extensión).2 Carpeta local Carpeta en la que se ha de crear el proyecto.3 Carpeta de instalación Carpeta donde está instalado Visual Studio.4 Exclusivo • Si es True, el asistente debería cerrar la
solución actual y crear una nueva.• Si es False,el asistente ha de añadir el nue-
vo proyecto a la solución actual.5 Nombre de la solución El nombre de la solución que se ha de crear
si el usuario especificó “Crear carpeta parala solución” en el cuadro de diálogo “Nuevoproyecto”.
6 Silencioso Si es True, el asistente no debe preguntarnada al usuario, usando valores por defecto.
Tabla 1
PosiciónValor del array ContextParams Descripción
0 Tipo de asistente El valor EnvDTE.Constants.vsWizardAddItem.1 Nombre del proyecto El nombre del proyecto al que se está aña-
diendo el nuevo archivo.2 Archivos de proyecto La colección EnvDTE.ProjectItems a la que
se debería añadir el nuevo archivo.3 Carpeta nuevo archivo La carpeta de destino del nuevo archivo.4 Nombre nuevo archivo El nombre que introdujo el usuario en el cua-
dro de diálogo “Nuevo archivo”.
5 Carpeta instalación delproducto
La carpeta en la que está instalado el lenguajede programación del proyecto.
6 Silencioso Si es True,el asistente no debe preguntar nadaal usuario, usando valores por defecto.
Tabla 2
'-----------------------------------------------------' Autor : %AUTOR%' Fecha : %FECHA%'-----------------------------------------------------Public Class %NOMBRE_CLASE%
End Class
Fuente 1
Cuando Visual Studio llama a estemétodo del asistente para ejecutarlo, enese punto el asistente puede hacer lo quequiera sin restricciones. Para ello dis-pone de la información que se le pasaen los distintos parámetros de la fun-ción. El parámetro más importante esContextParams, ya que proporcionainformación que el asistente puedeemplear para generar código. Comohemos dicho, se trata de un array deobjetos de tipo Object, pero su longitudy tipo real dependen del tipo de asisten-te. La tabla 1 muestra los valores paraun Asistente de nuevo proyecto, y la tabla2 para un Asistente nuevo archivo.
Lo primero que debería hacer un asis-tente es comprobar el valor del primerelemento del array ContextParams, paradeterminar si es del tipo de asistente espe-rado. El fuente 2 muestra el código delasistente.
Uso de las plantillasUna vez recuperados los valores de
los parámetros que recibe el métodoExecute de la interfaz IDTWizard, el asis-tente tiene que recuperar la plantilla deproyecto o de archivo que va a usar de lacarpeta donde residen que, como indi-camos antes, normalmente será una sub-carpeta de la carpeta donde está la DLLdel asistente. En .NET un ensambladopuede saber la ubicación de su ejecuta-ble usando el método System.Reflection.Assembly.GetExecutingAssembly.Location.Por tanto, el asistente podría extraer laparte del directorio (excluyendo la par-te final del archivo) y añadir la subcar-peta de las plantillas para obtener la rutacompleta a las mismas. La funciónObtenerCarpetaPlantillas muestracómo realizar este paso.
La forma de añadir un proyecto auna solución es mediante el métodoAddFromTemplate de la clase EnvDTE.Solution:
dotN
etM
anía
<<
26
dnm.plataforma.net<<
Imports System.Runtime.InteropServicesImports System.Windows.Forms
<ComVisible(True), _ProgId(“AsistentesVSNET.Asistentes”), Guid(“17F0492C-7060-4fc1-B2DE-B7C37F367D10”)>_
Public Class AsistenteImplements EnvDTE.IDTWizardPublic Sub Execute(ByVal Application As Object, _
ByVal hwndOwner As Integer, _ByRef ContextParams() As Object, _ByRef CustomParams() As Object, _ByRef retval As EnvDTE.wizardResult) Implements EnvDTE.IDTWizard.Execute
Dim sTipoAsistente As StringDim objDTE As EnvDTE.DTEDim colProjectItems As EnvDTE.ProjectItemsDim sNombreProyecto As StringDim sCarpetaDestino As StringDim sNombreSolucion As StringDim sNombreArchivo As StringDim bExclusivo As BooleanDim bSilencioso As BooleanDim bContinuar As Boolean
‘ Valor por defectoretval = EnvDTE.wizardResult.wizardResultFailureTry
sTipoAsistente = CType(ContextParams(0), String)Select Case sTipoAsistente.ToLower
Case EnvDTE.Constants.vsWizardNewProject.ToLowersNombreProyecto = CType(ContextParams(1), String)sCarpetaDestino = CType(ContextParams(2), String)bExclusivo = CType(ContextParams(4), Boolean)sNombreSolucion = CType(ContextParams(5), String)bSilencioso = CType(ContextParams(6), Boolean)
‘ Si es un nuevo proyecto exclusivo, hay que dar al usuario la ‘ oportunidad de guardar la solución actualbContinuar = TrueIf bExclusivo Then
If objDTE.ItemOperations.PromptToSave = _EnvDTE.vsPromptResult.vsPromptResultCancelled ThenbContinuar = False
End IfEnd IfIf bContinuar Then
retval = AñadirProyecto(objDTE, sNombreProyecto, _sCarpetaDestino,bExclusivo,sNombreSolucion, bSilencioso)
End If
Case EnvDTE.Constants.vsWizardAddItem.ToLowersNombreProyecto = CType(ContextParams(1), String)colProjectItems = CType(ContextParams(2), EnvDTE.ProjectItems)sCarpetaDestino = CType(ContextParams(3), String)sNombreArchivo = CType(ContextParams(4), String)bSilencioso = CType(ContextParams(6), Boolean)retval = AñadirArchivo(objDTE, sNombreProyecto, colProjectItems, _
sCarpetaDestino, sNombreArchivo, bSilencioso)End Select
Catch objException As ExceptionMessageBox.Show(objException.ToString)
End TryEnd Sub
Private Function AñadirProyecto(ByVal objDTE As EnvDTE.DTE, _ByVal sNombreProyecto As String, ByVal sCarpetaDestino As String, _ByVal bExclusivo As Boolean, ByVal sNombreSolucion As String, _ByVal bSilencioso As Boolean) As EnvDTE.wizardResultDim eResultado As EnvDTE.wizardResult = EnvDTE.wizardResult.wizardResultSuccessDim sArchivoPlantilla As String
Fuente 2 (continúa...)
Public Function AddFromTemplate(_ByVal FileName As String, _ByVal Destination As String, _ByVal ProjectName As String, _Optional ByVal Exclusive As _Boolean = False) As EnvDTE.Project
donde los parámetros usados son lossiguientes:• FileName: la ruta completa a la plan-
tilla.• Destination: la carpeta de destino
del proyecto (el asistente debe cre-ar esta carpeta antes de llamar a estafunción).
• ProjectName: el nombre del archivode proyecto sin extensión.
• Exclusive: si es True, la soluciónactual es cerrada y se crea una nue-va. En caso contrario, se añade elproyecto nuevo a la solución actual.
Y la función devuelve el proyectocreado (del tipo EnvDTE.Project).
La forma de añadir un proyecto auna solución es mediante el métodoAddFromTemplate de la clase EnvDTE.ProjectItems:
Donde los parámetros usados sonlos siguientes:• FileName: la ruta completa a la plan-
tilla.• Name: el nombre del archivo (inclu-
yendo su extensión).
Y la función devuelve el archivo cre-ado (del tipo EnvDTE.ProjectItem).
Reemplazos de variablesCuando creamos un proyecto o archi-
vo con las funciones AddFromTemplateque hemos visto, el archivo que se gene-ra tiene unos valores por defecto que noserán adecuados. Por ejemplo, el nom-bre de una clase será siempre Class1 oel nombre que hayamos escrito en laplantilla (ver fuente 1). Por ello, es muycomún usar en la plantilla símbolos quetienen que ser sustituidos en este pun-to por sus valores. Los símbolos puedentener cualquier formato, pero en nues-tro caso hemos usado el carácter % paradelimitar el nombre del símbolo, porejemplo %NOMBRE_CLASE%. La funciónReemplazarSimbolos muestra cómoreemplazar los símbolos de la plantilla
dotN
etM
anía
<<
27
dnm.plataforma.net<<
TrysArchivoPlantilla = ObtenerCarpetaPlantillas() & “PlantillaProyecto”objDTE.Solution.AddFromTemplate( sArchivoPlantilla, sCarpetaDestino, _
sNombreProyecto, bExclusivo)Catch objException As Exception
MessageBox.Show(objException.ToString)eResultado = EnvDTE.wizardResult.wizardResultFailure
End TryReturn eResultado
End Function
Private Function AñadirArchivo(ByVal objDTE As EnvDTE.DTE, _ByVal sNombreProyecto As String, ByVal colProjectItems As EnvDTE.ProjectItems, _ByVal sCarpetaDestino As String, ByVal sNombreArchivoSinExtension As String, _ByVal bSilencioso As Boolean) As EnvDTE.wizardResult
Dim eResultado As EnvDTE.wizardResult = EnvDTE.wizardResult.wizardResultSuccessDim objProjectItem As EnvDTE.ProjectItemDim sArchivoPlantilla As StringTry
sArchivoPlantilla = ObtenerCarpetaPlantillas() & “Plantilla.vb”objProjectItem = colProjectItems.AddFromTemplate(sArchivoPlantilla, _
sNombreArchivoSinExtension & “.vb”)ReemplazarSimbolos(objProjectItem, sNombreArchivoSinExtension)
Catch objException As ExceptionMessageBox.Show(objException.ToString)eResultado = EnvDTE.wizardResult.wizardResultFailure
End TryReturn eResultado
End Function
Private Sub ReemplazarSimbolos(ByVal objProjectItem As EnvDTE.ProjectItem, _ByVal sNombreArchivoSinExtension As String)
Dim eFindOptions As EnvDTE.vsFindOptionsDim objWindow As EnvDTE.WindowDim objTextDocument As EnvDTE.TextDocument
‘ Abre la ventanaobjWindow = objProjectItem.Open(EnvDTE.Constants.vsViewKindTextView)
‘ Obtiene el documento de textoobjTextDocument = DirectCast(objWindow.Document.Object, EnvDTE.TextDocument)
‘ Establece las opciones de búsquedaeFindOptions = EnvDTE.vsFindOptions.vsFindOptionsFromStart Or _
EnvDTE.vsFindOptions.vsFindOptionsMatchCase Or _EnvDTE.vsFindOptions.vsFindOptionsMatchWholeWord
‘ Realiza los reemplazosobjTextDocument.ReplacePattern(“%AUTOR%”, System.Environment.UserName, _
eFindOptions)objTextDocument.ReplacePattern(“%FECHA%”, Now.ToShortDateString, eFindOptions)objTextDocument.ReplacePattern(“%NOMBRE_CLASE%”, _
sNombreArchivoSinExtension, eFindOptions)End Sub
Private Function ObtenerCarpetaPlantillas() As StringDim sRutaEnsamblado As StringDim sCarpetaEnsamblado As StringDim sPlantillaCarpetas As String
sRutaEnsamblado = System.Reflection.Assembly.GetExecutingAssembly.Location()sCarpetaEnsamblado = System.IO.Path.GetDirectoryName(sRutaEnsamblado)sPlantillaCarpetas = sCarpetaEnsamblado & “\Plantillas\”Return sPlantillaCarpetas
End FunctionEnd Class
(...continuación) Fuente 2
Public Function AddFromTemplate(_ByVal FileName As String, _ByVal Name As String) As_
EnvDTE.ProjectItem
por sus valores adecuados usando la funciónTextDocument.ReplacePattern del modelo de extensi-bilidad. En este punto ya podemos compilar el asis-tente para ver si tiene errores.
Registro del asistenteUna vez compilado, nuestro asistente ha de ser
registrado de dos maneras distintas:• Como componente COM (ActiveX): durante la eta-
pa de depuración esto lo hace Visual Studio sihemos marcado la casilla “Registrar para intero-perabilidad COM” en las propiedades del proyec-to, pero para la instalación final deberá ser nues-tro programa de instalación el que lo haga en lamáquina del usuario final.
• Como asistente de Visual Studio: de igual manera quelos complementos (add-ins) se han de dar a cono-cer a Visual Studio, los asistentes también tienenque informar a Visual Studio de su existencia. Estose realiza mediante un archivo de texto con laextensión .vsz cuya primera línea es la cadena“VSWIZARD 7.0” (incluso si estamos usandoVisual Studio .NET 2003, cuya versión es 7.1). Lasegunda línea es de la forma:
Wizard=<Progid>
o
Wizard=<CLSID>
y especifica el ProgId (como “AsistentesVSNET.Asistentes”) o el ClsId (como “17F0492C-7060-4fc1-B2DE-B7C37F367D10”) que identifica alcomponente COM (ActiveX) de nuestro asisten-te (estos atributos se establecieron en la clase prin-cipal del asistente). A continuación puede habermás líneas opcionales de la forma:
Param=<valor1>
Param=<valor2>
donde estos valores serán pasados al método Executede la interfaz IDTWizard en el parámetro CustomParams(que es un array de objetos de tipo Object).
Por último, sólo queda indicar dónde se colocaeste archivo .vsz:• Para un Asistente de nuevo proyecto, se ha de colo-
car en la carpeta C:\Archivos de programa\Microsoft Visual Studio .NET 2003\Vb7\
VBProjects para proyectos VB.NET o en la car-peta C:\Archivos de programa\Microsoft VisualStudio .NET 2003\VC#\CSharpProjects para pro-yectos C#. Si miramos en esas carpetas veremosunos cuantos archivos .vsz proporcionados porVisual Studio. Al colocar un archivo .vsz en estascarpetas, cuando abrimos el cuadro de diálogo“Nuevo proyecto” de Visual Studio, éste añadenuestro asistente como plantilla en la parte dere-cha del cuadro de diálogo para el lenguaje deprogramación seleccionado en el árbol de laizquierda.
• Para un Asistente de nuevo archivo, las carpetas sonC:\Archivos de programa\Microsoft Visual Studio
.NET 2003\Vb7\VBProjectItems\Local Project
Items para VB.NET y C:\Archivos de
programa\Microsoft Visual Studio .NET 2003\VC#\
CSharpProjectItems\Local Project Items para C#,pero en este caso debemos crear una subcarpetadonde dejar el archivo .vsz.
Para cambiar la imagen del asistente que apareceen los cuadros de diálogo de Visual Studio, basta conque creemos un archivo de icono (.ico) con el mis-mo nombre que el archivo .vsz y lo coloquemos enesa misma carpeta.
Depuración del asistenteCon todo esto, ya podemos poner un punto de rup-
tura en el método Execute de nuestro asistente y empe-zar a depurar. Se abrirá una segunda instancia de VisualStudio (ya que lo configuramos así anteriormente) y enesta segunda instancia podremos abrir los cuadros dediálogo de “Nuevo proyecto” o “Nuevo archivo”. Si elasistente está registrado correctamente, aparecerá en esoscuadros de diálogo y al pulsar sobre él la ejecución sedetendrá en nuestro punto de ruptura y podremos depu-rar el asistente. Cuando todo esté probado, sólo nos que-dará crear el programa de instalación para distribuirlo aotros usuarios.
dotN
etM
anía
<<
28
dnm.plataforma.net<<
Bibliografía
[1]Creating a wizard (MSDN Visual Studio .NET)
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vsintro7/html/vxconCreatingWizard.asp
[2]Capítulo 9 (“Visual Studio .NET Wizards”) del libro “Inside
Microsoft Visual Studio .NET 2003”, de Craig Skibo y
otros:http://www.microsoft.com/mspress/books/6425.asp.
Un enfoque más adecuado consiste enque use plantillas de código externas
al propio asistente
Impresión desde CRM con WordML y FetchXML
Se trata de una extensión de Microsoft Dynamics CRM que permite convertir lainformación de cualquier entidad CRM (oferta, factura, etc.) en un documentoWord, para imprimir o enviar por correo electrónico. Esta alternativa a ReportingServices se basa en FetchXML y una plantilla WML a la que añadimos etiquetasXML que transformaremos con XSL para obtener el documento final.
<< una manera de aumentar lasposibilidades de MS-CRM con una funcionalidadque en muchos casos “se le supone” a la herra-mienta: la impresión de datos. No me refiero a unaimpresión “plana” que sirva para uso interno, sinoa un formato más presentable: con gráficos, tablasetc. El tipo de documento que presentaríamos a uncliente sin avergonzarnos. Vaya por delante que laherramienta número uno para esta tarea es SQLReporting Services. Por potencia, flexibilidad yrobustez es la mejor manera de volcar a papel cual-quier información contenida en nuestro CRM. Detodas formas, no está mal saber que existen alter-nativas como la que presentamos en este artículo.Se trata de aprovechar la coincidencia de Office yCRM en un lenguaje de datos: XML. Vamos porpartes: desde la versión 2003, Office integra el len-guaje WordML para expresar documentos Worden un lenguaje XML. Por otro lado, CRM permi-te a través del lenguaje FetchXML lanzar consul-
tas a la aplicación que devuelven a su vez datos enXML. Seguimos dentro de XML: la tecnología XSLpermite hacer transformaciones XML entre undocumento origen y uno destino. De modo que sigeneramos la XSL necesaria, los datos de CRM sepueden convertir en un documento Word de lacomplejidad que necesitemos.
La pregunta que surge ahora es ¿cómo genera-mos esta transformación XSL? Ahí radicaba el pro-blema de esta aproximación antes de la apariciónde la WordML Inference Tool (wml2xslt). Estaherramienta permite generar una XSL a partir deun documento Word cualquiera: a este documen-to lo llamaremos a partir de aquí la semilla. Este esel punto fuerte de esta aproximación: mientras quecon Reporting Services el cliente tiene que dar unaidea aproximada de qué aspecto debe tener su infor-me, con la aproximación WML el cliente puededarnos directamente un documento ejemplo que
Daniel Sabater
dnm.dynamics.crm
En este artículo describimos
Daniel SabaterEs Consultor CRM,MCAD,MBS
Certified Professional en CRM.Actualmente trabaja para
CRM i/o .net (www.crmio.net).Puecde contactar con él en
[email protected] 1.XML + XSL = WML
Desde la versión 2003,Office integra ellenguaje WordML para expresar
documentos Word en un lenguaje XML
dotN
etM
anía
<<
32
dnm.dynamics.crm<<
muestra el aspecto exacto que quiere que tenga sumáscara de impresión. El desarrollador sólo tendráque agregar los campos XML en los lugares ade-cuados del documento. A partir del documentosemilla, la herramienta wml2xslt genera la trans-formación XSL necesaria. Sólo falta un punto:¿cómo conseguimos los campos XML a insertar enel documento Word? Una opción es consultar elesquema de CRM en la dirección http://<miser-vidorcrm>/sdk/list.aspx y construir un ejemploXML “a mano”. Una opción más rápida es fabri-car un pequeño programa que vuelque desde CRMesta información, que es lo que veremos en la pró-xima sección.
FetchXML es un lenguaje XML para realizarconsultas integrado en la plataforma de CRM.Permite establecer criterios de búsqueda, colum-nas deseadas, ordenación, etc. A cualquiera quehaya hecho una consulta SQL le resultará fami-liar su funcionalidad –aunque no su sintaxis–. Porotro lado, cualquiera que haya hecho una búsquedaavanzada desde la interfaz de usuario está usandoFetchXML sin saberlo. Una búsqueda guardadano es otra cosa que una consulta FetchXML alma-cenada que se puede lanzar a petición del usuario.Lo que véis en el fuente 1 es un ejemplo deFetchXML que devuelve información de todas lasofertas (quotes) cuyo quoteid sea “xxx” (en negrita).
Su sintaxis es sencilla de manejar y nos permiteacceder de manera segura, a través del servicio Webde CRM (crmservice.asmx), a consultas complejas. Y
cuando digo segura, me refiero a que tiene en cuen-ta el nivel de seguridad definido en CRM para el usua-rio que hace la consulta. Por ejemplo, aunque pidatodas las cuentas de CRM, la consulta sólo devolveráaquellas para las que el usuario que la lanza tiene per-misos de lectura.
Ya sólo nos falta un pequeño programa que lan-ce todo este montaje. En nuestro caso, se trata deuna página ASPX que lanza la consulta, recoge losresultados, aplica la transformación y vuelca elresultado al navegador del cliente. Para más como-didad, hemos creado una serie de parámetros quenos permiten escoger la consulta (FML) y la trans-formación (XSL). El atributo que contiene el iden-tificador del registro lo añade CRM automática-mente con el nombre oid gracias al parámetroPassParams=1. Copiamos la carpeta imprimir con elfichero imprimir.aspx al directorio de la Web deCRM. Solo un detalle: la consulta debe cambiardependiendo del registro que queramos imprimir,algo que configuraremos en el atributo value delelemento condition dentro de filter. Es decir,accedemos al nodo /fetch/entity/filter/condi-tion/@value y cambiamos su valor por el identifi-cador que nos pase CRM.
Otro detalle de imprimir.aspx en el que podemosfijarnos es la realización de la consulta. El SDK deCRM nos permite lanzar consultas al sistema demanera muy sencilla a través del servicio Web crm-service.asmx y el método fetch:
<?xml version=’1.0’ encoding=’utf-8’ ?><fetch mapping=’logical’ distinct=’true’>
<entity name=’quote’><filter>
<condition attribute=’quoteid’ operator=’eq’value=’xxx’/>
</filter><attribute name=’quotenumber’/><attribute name=’name’/><attribute name=’totalamount’/><attribute name=’totaltax’/><attribute name=’totallineitemamount’/><attribute name=’customerid’/><link-entity name=’systemuser’ from=’systemuserid’to=’owninguser’>
<attribute name=’fullname’/></link-entity><link-entity name=’account’ from=’accountid’to=’customerid’>
<attribute name=’name’/></link-entity>
</entity></fetch>
Fuente 1. FetchXML
string id = Request[‘oid’];XmlElement nodoCondicion = (XmlElement)docFetch.SelectSingleNode(‘/fetch/entity/filter/condition’);nodoCondicion.SetAttribute(‘value’, id);
Fuente 2. Detalle de imprimir.aspx
CrmService crm = new CrmService();crm.Url = ‘http://maquinacrm/mscrmservices/2006/crmservice.asmx’;string consulta = ‘<fetch>...</fetch>’;string resultado = crm.Fetch(consulta);
Fuente 3. Detalle de imprimir.aspx.
FetchXML es un lenguaje XML para realizar consultas integrado
en la plataforma de CRM
Por último, el espacio de nombres Xml.Xsl nosproporciona clases que dan acceso al motor de trans-formaciones XSL de .NET. Solo tenemos que lla-mar al método Transform para aplicar una transfor-mación XSL a un documento XML. Una opcióncómoda es volcar el resultado de la transformaciónal stream asociado al objeto Response del formula-rio Web:
La configuración de nuestra aplicación Web solorequiere un parámetro: la dirección del servidor CRMcontra el que va a trabajar. Esto se configura como encualquier aplicación ASP.NET, en el fichero web.con-fig. Hemos añadido una sección appSettings dondeañadimos dicho parámetro:
Entramos ahora en la configuración de CRM.CRM permite agregar a su interfaz de usuario nue-vas secciones, opciones de menú y botones. El fiche-
ro isv.config.xml es el que especifica cuáles sonestas nuevas opciones y en qué consisten.Inicialmente, agregamos dos botones a la ficha dela entidad que nos interesa. Supongamos que es elobjeto oferta (quote) lo que queremos imprimir.Fabricamos un botón para ayudarnos a generar lasemilla y otro para imprimir el documento. El pri-mer botón sólo lo usaremos durante la fase de desa-rrollo, más adelante lo inhabilitaremos (veáse elfuente 6).
Con el primer botón ejecutaremos la página impri-mir.aspx con el parametro semilla=1. Esto generaráun fichero en el directorio imprimir con nombresemillaOferta.xml. Es importante que lancemos esteproceso desde un registro de CRM que tenga todoslos datos que queramos imprimir; de otra manera noaparecerán en la semilla. Abrimos este fichero conWord 2003: veremos los distintos campos devueltospor CRM como etiquetas XML (ojo: los campos enblanco no aparecerán).
Por otro lado, sin cerrar el otro fichero, abrimosen el mismo Word el ejemplo de impresión que nosha proporcionado el cliente. Seleccionamos todo elfichero y lo copiamos al fichero semilla.xml que aúnmantenemos abierto. Ahora queda la parte más tedio-sa: colocar cada cosa en su sitio trasladando las eti-quetas XML a su lugar correspondiente.
dotN
etM
anía
<<
33
dnm.dynamics.crm<<
<configuration version=’3.0.0000.0’><Entities><Entity name=’quote’><ToolBar ValidForCreate=’0’ ValidForUpdate=’1’><Button Title=’Imprimir’ I
con=’/_imgs/ico_18_debug.gif’Url=’/imprimir/imprimir.aspx?xsl=
oferta&fml=oferta’PassParams=’1’/>
<Button Title=’Generar Semilla’Icon=’/_imgs/ico_18_debug.gif’Url=’/imprimir/imprimir.aspx?xsl=oferta&fml=
oferta&semilla=1’PassParams=’1’/>
</ToolBar></Entity>
</Entities></configuration>
Fuente 6. isv.config.xml durante el desarrollo
Figura 2. SemillaOferta.xml en Word.
XslTransform xsl = new XslTransform();xsl.Load(ficheroXsl, null);…xsl.Transform(docXml, null, Response.OutputStream,null);
Fuente 4.Detalle de imprimir.aspx
<appSettings><add key=’UrlServidorCRM’ value=’http://maquinacrm:9999/>’</appSettings>
Fuente 5. Detalle de web.config.
El espacio de nombres Xml.Xsl nos proporciona clases que dan acceso
al motor de transformaciones XSL de .NET
dotN
etM
anía
<<
34
dnm.dynamics.crm<<
Ya estamos terminando: nuestro fichero semi-lla.xml casi está listo para ser utilizado. Sólo tene-mos que guardarlo con formato XML a través delmenú “Fichero” de Word en la opción “Guardarcomo...” escogiendo como formato XML (ojo: la casi-lla “Guardar datos solamente” debe estar inhabilita-da). La semilla ya está lista: podemos cerrar todos losdocumentos de Word.
Lo siguiente es lanzar la aplicación wml2xsltque, como su nombre sugiere, convierte un docu-mento WML en una transformación XSL. Su sin-taxis es:
wml2xslt semillaOferta.xml -o oferta.xsl
Con este último punto acabamos de generar latransformación XSL que necesita nuestra páginaimprimir.aspx con el siguiente formato (esto es loque configuramos previamente en el fichero de con-figuración isv.config.xml):
imprimir.aspx?fml=oferta&xsl=oferta
Para probar la impresión, vamos al registro deCRM que hemos creado para las pruebas, abri-mos su formulario y pulsamos el botón“Imprimir”. Aparecerá un diálogo de confirma-ción para guardar o abrir el documento, que
tendrá como título el nombre de la XSL pero conextensión .doc.
Por último, si todo ha ido bien, ya podemos qui-tar de CRM el botón de “Generar semilla”. Lo máscómodo sería comentar la línea, lo que en sintaxisXML tiene el siguiente aspecto:
Conclusiones
En este artículo hemos visto una forma alter-nativa de imprimir desde CRM a través de la tec-nología XML y gracias a la inclusión del lenguajede consulta FetchXML en la aplicación. En unprincipio puede parecer largo, pero con la prácti-ca veréis cómo se puede convertir en una herra-mienta de productividad muy ventajosa. Recordadque el trabajo de decir “dónde va cada cosa”, deelegir gráficos, diseñar tablas, etc., lo está reali-zando el cliente, que además estará más satisfechopor ver que el resultado es exactamente como él loquiere, y que los cambios que haya que realizar seaplican rápidamente: solo hay que enviarle la semi-lla y pedirle que cambie lo que quiera para luegorepetir el paso de generación con wml2xslt. Todala estructura que hemos montado puede perma-necer intacta, cambiando como mucho el fichero.fml para incluir o excluir atributos.
<configuration version=’3.0.0000.0’><Entities>
<Entity name=’quote’><ToolBar ValidForCreate=’1’ ValidForUpdate=’1’>
<Button Title=’Imprimir’ Icon=’/_imgs/ico_18_debug.gif’Url=’/imprimir/imprimir.aspx?xsl=oferta&fml=oferta’PassParams=’1’/>
<!— Button Title=’Generar Semilla’ Icon=’/_imgs/ico_18_debug.gif’Url=’/imprimir/imprimir.aspx?xsl=oferta&fml=oferta&semilla=1’PassParams=’1’ / —>
</ToolBar></Entity>
</Entities></configuration>
Fuente 7.isv.config.xml definitivo.
Esta forma alternativa de imprimir mediante XML se puede convertir en la práctica en una herramienta de productividad muy ventajosa
Figura 3. Semilla.xml con el fichero agregado.
Internet es un medio inseguro... Así empieza la intro-ducción al protocolo Kerberos: invitándonos a refle-xionar sobre la necesidad de implementar mecanis-mos de seguridad en nuestras aplicaciones. Una bue-na práctica consiste en que estos mecanismos esténvalidados por expertos en seguridad, dado el enormeriesgo de vulnerabilidades no controladas si los cons-truimos nosotros mismos desde cero.
Kerberos es un protocolo de autenticación desa-rrollado por el MIT basado en criptografía asimétri-ca y tickets de sesión con una más que probada efica-cia en sistemas como, por ejemplo, la autenticaciónde usuarios bajo Windows 2000. Así pues, ¿por quéno adaptar su modelo al sistema de seguridad de nues-tras aplicaciones?
Nuestra soluciónPlanteemos ahora un entorno de un portal Web
desarrollado en ASP.NET, con multitud de usuariosaccediendo desde Internet a una serie de recursosinternos y con autenticación basada en credencialesde usuario. Una buena práctica para aumentar la segu-ridad de este entorno consiste en el uso de tickets desesión protegidos por criptografía y que otorguenacceso temporal a los recursos.
Dependiendo del grado de seguridad que necesi-temos, podemos utilizar criptografía de clave asimétri-
ca o simétrica. El uso de la primera opción implica quecada usuario que accede al portal necesita de una cla-ve pública y privada facilitada por una entidad certifi-cadora. Kerberos utiliza criptografía asimétrica en suprotocolo, de forma que la única credencial presenta-da por el usuario es su firma, dato suficiente para sureconocimiento. No obstante, el uso de certificados ycriptografía de clave asimétrica, pese a ser más seguro,no siempre es posible, sobre todo si queremos dar dealta a usuarios de manera ágil y dinámica.
Supondremos en nuestro ejemplo el uso de crip-tografía de clave simétrica en el servidor, de formaque nuestra implementación será transparente parael usuario de la aplicación.
Seguridad:Gestión de tickets de sesión
Supongamos que estamos trabajando en un entorno de autenticación en que se utili-zan diversos datos biométricos (análisis de retina,huellas dactilares,análisis de voz,etc.),y tras aplicar una función sobre ellos se obtiene un identificador solo conocido por elsistema. Cualquier persona que quisiera suplantar nuestra identidad debería conocertodos estos datos para plantear un ataque con éxito,puesto que con un solo error enalguna de las variables el identificador resultante no sería válido.En este artículo vere-mos cómo plantear este escenario en nuestras aplicaciones ASP.NET imitando el mode-lo del protocolo Kerberos.
<< Introducción a Kerberos
Jorge Ramo
dnm.asp.net
Jorge Ramoes consultor de tecnología en
Raona,MCAD (MicrosoftCertified Application Developer) en
desarrollo de aplicacionescon .NET Framework.
Kerberos utiliza criptografía asimétrica,de forma que la única credencial
presentada por el usuario es su firma
El ticket de sesión
Estudiemos ahora qué es y de qué se compone unticket de sesión. De la composición del ticket depen-derá el grado de seguridad de la solución. En Kerberos,por ejemplo, un ticket posee 6 componentes.
En nuestra implementación adaptaremos la defi-nición de ticket a nuestras necesidades, dependien-do del contexto y del grado de seguridad que nece-sitemos:
Para la generación de la clave del ticket utilizare-mos criptografía, encriptando los diferentes datos deusuario: IP de acceso, identificador de sesión asigna-do por ASP.NET, cadena del navegador y, en gene-ral, cualquier dato identificativo del origen del usua-rio. La clave de ticket obtenida, por tanto, dependeráde todos los datos recopilados.
Funcionamiento del sistema
Una vez definido el ticket, veamos paso a pasocómo se comporta el sistema:1. El usuario introduce sus credenciales en el for-
mulario de acceso. 2. Las credenciales se validan contra el sistema de
registro de usuarios (Active Directory, base dedatos, formulario, etc.).
3. Si la validación es correcta, el servidor recoge losdatos necesarios (usuario, IP, agente, ID de sesión)
y, mediante criptografía simétrica(en nuestro ejemplo), se generauna clave de ticket, consistente enuna cadena alfanumérica.
4. El sistema almacena los datos delticket y su clave asociada en la basede datos, registrándolo como ticketválido y activo.
5. Por cada acción que realice el usuario, el sistemadeberá recoger los datos necesarios y volver a gene-rar la clave de ticket, comprobando que sea la mis-ma que está almacenada en la base de datos, y queel ticket a la cual pertenece está aún activo. Además,debemos comprobar también que la diferenciaentre el momento de generación de la últimaacción y el actual no superen el plazo de expira-ción (timeout) previsto en nuestra aplicación. Ental caso, se debe denegar la acción, informar queel ticket ha expirado y rellenar su fecha y hora deexpiración.
6. El usuario se desconecta y el ticket pasa a serinactivo.
Credenciales de acceso
La implementación de tickets de sesión que hemosvisto protege de ataques de robo de sesión (session hijac-king) una vez el usuario ha entrado en el sistema. Comoya comentábamos inicialmente, un usuario que deseehacerse pasar por nosotros deberá suplantar todos losdatos contenidos en el ticket, puesto que un cambioen alguno de ellos generaría un ticket no válido.
Para obtener un entorno de alta seguridad comple-to deberemos proteger también el acceso al sistemaimplantando unas credenciales seguras de acceso. Unaposible solución consistiría en utilizar los datos de gene-ración de la clave del ticket y asociarlos al usuario comoparte de sus credenciales. No obstante, debemos teneren cuenta que si alguno de estos datos cambia, no será
dotN
etM
anía
<<
37
dnm.asp.net<<
Ticket Kerberos• Nombre de cliente• Nombre de servidor• Dirección de red • Sello de tiempo • Tiempo de vida • Clave de sesión
Nuestro Ticket• Clave de ticket (sirve como
identificador)• Nombre de usuario (el intro-
ducido por el usuario para vali-darse)
• Sello de tiempo del momentode generación del ticket
• Sello de expiración del ticket(en blanco mientras el ticketesté activo)
Tabla 1
Figura 1
Para obtener un entorno de alta seguridad completo deberemos
implantar unas credenciales seguras de acceso
posible el acceso del usuario. Por ejemplo, si asociamosla dirección IP de un usuario como parte de sus creden-ciales, le será imposible acceder a la aplicación desde unaubicación con diferente IP.
La implementación con más alto grado de segu-ridad consiste en el uso de certificados de clave asimé-trica y una entidad certificadora que actúe de inter-mediario entre el portal y los usuarios. Las funcionesprincipales de este tercero de confianza serían gene-rar las claves pública y privada de los usuarios y cer-tificar su validez. Esta última implementación sería lamás parecida al modelo Kerberos.
Vulnerabilidades
El grado de seguridad del sistema depende de: 1. La facilidad de ser suplantados los datos en los
que se basa el sistema para garantizar que elusuario que realiza la petición es el que ha ini-ciado sesión.Variables como el agente de usuario (User Agent)del navegador son fácilmente obtenibles por unusuario malicioso que intente suplantarnos. Porotra parte, la dirección IP del usuario tambiénes fácilmente obtenible pero no tan fácil desuplantar, a menos que el atacante se encuentredetrás de nuestro mismo proxy.
2. El nivel de seguridad de las credenciales de acce-so. De nada nos sirve proteger mediante valida-ción por ticket las acciones del usuario si el acce-so al sistema se realiza mediante una contraseñafrágil y fácil de obtener.
3. El método utilizado para generar la clave del tic-ket en el servidor. Si utilizamos criptografía simé-trica, debemos proteger la clave privada utilizadaen el proceso de encriptación.
4. El nivel de seguridad del servidor del portal.Debemos proteger la validación y generación detickets de ataques externos, puesto que si un ata-cante consigue comprometer esta parte puedetener acceso a todo el sistema.
5. Otra opción recomendable a implantar es el usode encriptación en todas las comunicaciones.De esta forma se evita que cualquier atacantepueda “escuchar” nuestra red y recoger los datosdel usuario necesarios para la elaboración de laclave de ticket.
Aplicación de la soluciónLa implementación mediante tickets no es única-
mente aplicable a aplicaciones Web, sino que es per-fectamente extensible a cualquier tipo de aplicacióncliente/servidor que requiera autenticación entre usua-rios o bien entre servidores.
Otra opción consiste en extender nuestra solución ygenerar tickets solo válidos para ciertos recursos, con-virtiendo así a los tickets en una solución válida para laautenticación y autorización de usuarios.
dotN
etM
anía
<<
38
dnm.asp.net<<
// Valida las credenciales del usuario, // Genera y registra el ticket de usuarioLogin(Credentials usercredentials) : Bool{
if (ValidateUser(userCredentials)){
Ticket userTicket = GenerateTicket(userCredentials.Username);Register(userTicket);return true;
}else{return false;
}}
// Genera un ticket seguroGenerateTicket(Credentials usercredentials) : Ticket{
Ticket generateTicket = new Ticket();generateTicket.Ticketid = Encrypt(userCredentials.Username);generateTicket.GenerationTimeStamp = Now;return generateTicket;
}
// Valida al usuario a través del ticket y ejecuta una cierta acción. DoAction(userParams,Action action){
Ticket tempTicket = GenerateTicket(userParams);Ticket userTicket = GetActiveTicket(userParams.Username);if ( tempTicket.Ticketid == userTicket.Ticketid ){
BeginTransaction();RegisterAction(userTicket,Now);// Implementación de la acción.EndTransaction();
}}
Fuente 1. Pseudo código de la clase TicketManager.
Figura 2
que Office 2003 tiene es que hay ungran número de sitios en donde uno tiene que mirarpara encontrar la funcionalidad que desea: menús,submenús, barras de herramientas visibles, barras deherramientas que sólo se acceden desde algunosmenús, barras de herramientas emergentes, panelesde tareas, paneles de tareas que sólo aparecen bajoun determinado contexto, etc.
Para realizar algunas tareas los usuarios tienenque buscar en diferentes sitios las acciones que nece-sitan, algo que se convierte a veces en una tarea pesa-da de realizar.
En la nueva interfaz de usuario de Office 2007 seintroduce el ribbon. El ribbon es una región en la par-te superior de la pantalla que muestra de una formasencilla el conjunto de comandos que se pueden rea-lizar con un programa.
El ribbon está organizado por pestañas, y éstas asu vez tienen grupos de controles agrupados por fun-cionalidad, como se puede ver en la figura 1.
Una de las características que ofrece Office 2007es que se puede personalizar la interfaz de usuario delas aplicaciones que lo componen añadiendo ele-mentos al ribbon. La personalización del ribbon deOffice 2007 se puede realizar a dos niveles:• A nivel de documento/plantilla. A este nivel sólo
veremos la personalización que hayamos realiza-
do si abrimos un documento o una plantillaespecífica. Para realizar esta personalización modi-ficaremos nuestro documento o plantilla, inclu-yendo en ellos el XML de personalización de lainterfaz de usuario.
• A nivel de aplicación. De esta forma, la personaliza-ción de la interfaz de usuario estará siempre dispo-nible, independientemente del documento que ten-gamos abierto. Para obtener la personalización anivel de aplicación deberemos crear un add-in quese cargará siempre que se cargue la aplicación.
En el ejemplo que presentaremos a continua-ción, realizaremos la personalización de la inter-faz de usuario de Office 2007 a nivel de aplicación;concretamente, vamos a personalizar el ribbon deExcel 2007.
Creando un add-in de Office 2007Como hemos dicho antes,
lo primero que necesitamos escrear un add-in compartido(shared add-in) que se instanciecuando Excel 2007 se cargue.
Abrimos Visual Studio2005 y creamos un nuevo pro-yecto de add-in compartido:
• Seleccionamos la opción del menú “File->New->Project” (figura 2).
• Nos aparece el asistente de add-ins. Pulsamos“Siguiente”.
• Seleccionamos el lenguaje de programación quedeseamos usar (en este caso C#). “Siguiente”.
• Luego seleccionamos las aplicaciones en las cua-
dotN
etM
anía
<<
39
Cómo personalizar el ribbon de Office 2007
Siguendo los pasos de este tutorial podrás personalizar el ribbon de Office 2007de una forma realmente sencilla y fácil. Explicamos cómo crear un add-in de Office2007 basado en la interfaz IDTExtensibility2 y la forma en la que puedes añadirpestañas y botones propios en el ribbon.
<<
Joaquín Gracia
dnm.futuro
Joaquin Gracia es IngenieroSuperior Informático y trabaja en
el Aragón Microsoft TechnologyCenter. Ponente habitual en los
ISV Community Days y endistintos eventos de Microsoft
sobre tecnologías futuras.Autorde Webestilo.com y
Ingenierosoftware.com
Uno de los problemas
Figura 1. El ribbon de Office 2007.
les nuestro add-in se cargará. En este ejemplo, voya seleccionar solo “Excel” (figura 3). Pulsamos“Siguiente”.
• Ponemos un nombre a nuestro add-in, así comouna descripción. “Siguiente”.
• Por último, marcamos las dos opciones finales:o Quiero que mi add-in se cargue cuando la apli-
cación se cargue.o Mi add-in debería estar disponible para todos los
usuarios de la máquina en la que se instale.• Pulsamos “Siguiente”.• Pulsamos “Finalizar”.
Este asistente nos creará dos proyectos en unasolución (figura 4):
• El proyecto del add-in propiamente dicho.Contiene el código de nuestro add-in.
• El proyecto de la instalación del add-in. Este creaun instalable a partir de resultado del proyectoanterior.
Para que el add-in sea manejado correctamentepor Excel debemos implementar la interfazIDTExtensibility2, que contiene los métodos que semuestran en la tabla 1.
Cuando creamos un proyecto de add-in se nos pro-porciona una implementación por defecto de estainterfaz, así que generalmente no tenemos que preo-cuparnos por ella.
Personalizando la interfaz de usuarioLo siguiente que tenemos que hacer es imple-
mentar la interfaz IRibbonExtensibility, que nos per-mite personalizar la interfaz de usuario de la aplica-ción huésped, en este caso Excel, cargando la defini-ción del mismo en XML.
Esta interfaz sólo tiene un miembro:
public string GetCustomUI(string ribbonID)
que debe devolver una cadena XML con la definiciónde nuestra interfaz de usuario personalizada.
Para nuestro ejemplo vamos a usar el XML delfuente 1.
En el XML anterior se define una nueva pes-taña llamada “MiEmpresa” con el elemento <tabid=”MiEmpresa” label=”MiEmpresa”>. A continuación,indicamos que queremos crear un grupo de contro-les que llamaremos “Herramientas”, lo que realiza-mos con el elemento <group id=”Herramientas”label=”Herramientas”>; dentro de este grupo de con-troles añadimos un botón, estableciendo que cuan-
dotN
etM
anía
<<
40
dnm.futuro<<
Figura 2
Figura 3
Figura 4
Método Objetivovoid OnAddInsUpdate(ref Array custom)
Método que se llama cuandootro add-in se carga.
void OnBeginShutdown(ref Array custom)
Método que se llama cuan-do la aplicación host se va adescargar.
void OnConnection(object Application,ext_ConnectMode ConnectMode,object AddInInst,ref Array custom)
Método que se llama cuandoel add-in se carga.
void OnDisconnection(ext_DisconnectMode
RemoveMode,ref Array custom)
Método que se llama cuandoel add-in se va a descargar.
void OnStartupComplete(ref Array custom)
Método que se llama cuandoel add-in se ha cargado porcompleto.
Tabla 1.Miembros de IDTExtensibility2
do éste se pulse se deberá llamar a lafunción HolaMundo; de esto se encargael elemento <button id="MisBotones"onAction="HolaMundo" size="normal"
label="MisBotones" />.El código que genera el XML del
fuente 1 se presenta en el fuente 2.
Añadiendo acciones personali-zadas
Ahora crearemos una acción quese ejecutará al pulsar sobre el botón“MisBotones”, para lo cual añadire-mos una referencia a la librería deExcel. Pulsamos con el botón derechosobre la carpeta Referencias del pro-yecto, seleccionamos “Agregar refe-rencia” y añadimos una referencia aMicrosoft.office.Interop.Excel .También es conveniente añadir lasiguente línea al principio de nuestroprograma:
using Excel = Microsoft.Office.Interop.Excel;
Y ya estamos listos paraimplementar el métodoHolaMundo que hemos defi-nido en el documentoXML como acción asocia-
da al botón (fuente 3). Nuestra acciónde ejemplo inserta el texto “HolaMundo” en la celda de Excel que estéactiva en ese momento.
Para finalizar, sólo nos queda compi-lar nuestra solución yejecutar el proyecto deinstalación. Al ejecutarel proyecto de instala-ción, el add-in se regis-trará para que sea car-gado cuando arranca-mos Excel.
Como se puedeobservar en la figura5, después de ejecu-tar la instalación ten-dremos en Excel unanueva pestaña conun botón con la fun-cionalidad antes des-crita.
En todo momen-to, podemos ver quéadd-ins tenemos ins-talados en las opcio-nes de Excel (figura6). Desde ahí podemosactivarlos y desac-tivarlos cuando que-ramos.
ConclusionesComo hemos mostrado en este artí-
culo, la creación de un add-in para per-sonalizar el ribbon de cualquier aplica-ción de Office 2007 es realmente sen-cillo. No obstante, cuando salga la nue-va versión de Visual Studio Tools forOffice (VSTO), el proceso será aúnmucho más fácil, ya que esta herra-mienta incorporará proyectos de add-in predefinidos para cada una de lasaplicaciones que componen Office2007. Mientras tanto, podemos desa-rrollar nuestros prototipos de integra-ción con el ribbon siguiendo las pautasque hemos detallado aquí.
dotN
etM
anía
<<
41
dnm.futuro<<
Fuente 1
<customUI xmlns=”http://schemas.microsoft.com/office/2006/01/customui”><ribbon><tabs><tab id=”MiEmpresa” label=”MiEmpresa”><group id=”Herramientas” label=”Herramientas”><button id=”MisBotones” onAction=”HolaMundo”
size=”normal” label=”MisBotones” /></group>
</tab></tabs>
</ribbon></customUI>
Fuente 2
public string GetCustomUI( string ribbonID){string customui;
customui = "<customUI xmlns=\"http://schemas.microsoft.com/office/2006/01/customui\" >";customui += "<ribbon>";customui += "<tabs>";customui += "<tab id=\"MiEmpresa\" label=\"MiEmpresa\">";customui += "<group id=\"Herramientas\" label=\"Herramientas\" >";customui += "<button id=\"MisBotones\" onAction=\"HolaMundo\"
size=\"normal\" label=\"MisBotones\" />";customui += "</group>";customui += "</tab>";customui += "</tabs>";customui += "</ribbon>";customui += "</customUI>";
return customui;}
Fuente 3
public void HolaMundo(IRibbonControl control){Excel.Application app = (Excel.Application) this.applicationObject;app.ActiveCell.Value2 = "¡¡¡Hola Mundo!!!";
}
Figura 6. Add-ins instalados en Excel.
Figura 5. Excel después de la instalación del add-in.
Seguramente los programadores de Visual Basicestarán pensando que lo dicho en la entradilla no estotalmente cierto. Bueno, posiblemente no, porquesi están leyendo dotNetManía sabrán lo que se escon-de tras los eventos. Pero no está de más aclararlo paraque no queden dudas.
Lo cierto es que Visual Basic es un lenguaje muyprotector, y nos “libera” de ciertas tareas para facili-tarnos el trabajo real, de forma que nos podamos con-centrar en lo que de verdad importa y olvidarnos unpoco de ciertos “asuntillos” que en parte solo noshacen teclear más.
Aclaremos un poco todo esto que acabo de comen-tar. En Visual Basic, para definir un evento solo hay queescribir la instrucción Event seguida de la definición quedaremos al método que recibirá los eventos. Por ejem-plo, si nuestra clase es del tipo Button, podemos definirel evento Click de la siguiente forma:
Public Event Click( ByVal sender As Object,_ByVal e As EventArgs )
Como podemos comprobar, esa es la definiciónque usaremos en cualquier formulario que quierainterceptar la pulsación en un botón. Simple, ¿ver-dad? Veamos ahora cómo tendría que definir ese mis-mo evento un programador de C#:
public delegate void ClickEventHandler(object sender, EventArgs e);
public event ClickEventHandler Click;
En este caso, primero se define un delegado y acontinuación hay que definir el evento que debe serdel tipo de ese delegado. Complicado, ¿verdad? Ahoramismo no entraremos en muchos detalles sobre esto,antes veamos cómo se lanzaría ese evento tanto des-de Visual Basic como desde C#:
' En Visual Basic:RaiseEvent Click(sender, e)
// En C#:if( Click != null ){
Click(sender, e);}
Indudablemente en Visual Basic sigue siendo muchomás fácil, más simple, menos complicado, no tenemosque comprobar nada... Y es cierto, a eso es a lo que merefería con lo de que Visual Basic es muy “protector” ynos libera de ciertos detalles que en realidad no nece-sitamos saber, o al menos, no es obligatorio que sepa-mos. Por otra parte a los programadores de C#, segu-ramente por aquello de que les gusta “escribir más”código, pues... ¡que escriban más! Aunque, como vere-mos en este artículo, eso ya está cambiando, y ahorapodrán hacer también ciertas cosas sin necesidad deescribir tanto, ya que el propio compilador de C# seencargará de algunos aspectos, digamos, de trasfondo.Pero al final, tanto C# como Visual Basic deben seguirlas reglas de .NET, y aunque nosotros como usuariosno tengamos que preocuparnos, los compiladores sí quelo harán.
Delegados y eventosPrimera parte: ¿En quién delegas tú?
En este número vamos a tratar de los delegados,y también de los eventos (aunque deestos últimos nos encargaremos con más detalle en el próximo artículo), ya que en.NET están estrechamente relacionados;tanto es así que no podemos definir un even-to sin la intervención de un delegado.
<< Delegados y eventos en Visual Basic y C#
dnm.inicio.fundamentos
Guillermo “Guille” Som
dnm.incio.fundamentos
Guillermo “Guille” Somes Microsoft MVP de Visual Basic
desde 1997. Es redactor dedotNetManía,miembro de Ineta
Speakers Bureau Latin America,mentor de Solid Quality LearningIberoamérica y autor del libro
Manual Imprescindible de Visual Basic .NET.
http://www.elguille.info
Independientemente de las bromas,tenemos que ser conscientes (sobre todolos programadores de Visual Basic) deque algunas veces el que nos “mimen”tanto no es bueno, ya que nos acostum-bran mal, y cuando creemos que todova a ser sencillo, llega la versión 2005 ynos dicen que si queremos usar la nue-va instrucción Custom Event debemossaber manejar los delegados, además deque también debemos saber en quémedida están relacionados con los even-tos. Esto a los programadores de C# noles pillaría tan desprevenidos. Así, si aho-ra les dicen que pueden crear métodosanónimos, y que esos métodos anóni-mos los podrán crear donde se puedausar un delegado, o que ya no es nece-sario usar un constructor para crear untipo delegado o que por medio de lacovarianza o la contravarianza podránusar de forma más óptima los delega-dos, simplemente estarán preparados ysabrán soportar el cambio...
Pero como siempre hay gente nue-va, (tanto en C# como en Visual Basic),no está de más que algunos puntos esténtotalmente claros, así que eso es lo quevamos a intentar en este primer artícu-lo dedicado a los delegados y a los even-tos. Y en los que seguirán, terminare-mos por aclarar casi cualquier duda queposiblemente se nos pueda presentar ala hora de trabajar con los eventos y conlos delegados.
¿Qué son y para qué sirven losdelegados?
Como sabemos, .NET Frameworkse caracteriza por ser un entorno decódigo administrado (managed code) o loque es lo mismo, a .NET no le gustanlas sorpresas. Si una función tiene quedevolver un valor de tipo String, debedevolver un valor de tipo String; si unmétodo debe recibir dos parámetros detipo Object, eso es lo que recibirá. Ytodo esto los lenguajes adscritos a .NETdeben respetarlo, ya que de no ser así,.NET no permitirá la ejecución delcódigo. Y esto es aplicable a todo lo que.NET controla, es decir, a todo lo queestá bajo su influencia. Lo que no quie-re decir que no podamos hacer cosas que.NET no permita; pero si lo hacemos,debemos hacerlo por la puerta falsa. De
esto saben mucho los que han desarro-llado con C, incluso los que desarrollancon C#. Aunque en todas las puertas fal-sas de .NET siempre hay alguien que“está por allí” y revisa que en realidadno hagamos demasiadas trastadas. Estoen otros lenguajes no es así, y por erroro porque así lo hayamos previsto, pode-mos crear grandes problemas, si no, ¿porqué aparecen los fallos de proteccióngeneral? (las típicas pantallas azules delas versiones anteriores de Windows,que ahora simplemente están remoza-das y han cambiado de look por un cua-dro de diálogo más “mono”).
Este tipo de problema se debe a unacceso indebido a la memoria, normal-mente causado por un acceso a una posi-ción de memoria que no estaba dentro delrango que teníamos permitido. .NET esmás estricto y menos permisivo para estascuestiones, por tanto, si queremos estarbajo el abrigo de la seguridad de .NETdebemos seguir sus normas.
Como sabemos, .NET define unaserie de tipos de datos, los cuales pode-mos usar indistintamente desde un len-guaje u otro, ya que independientemen-te del nombre que cada compilador ledé, en realidad estamos trabajando conlos tipos definidos en la librería de cla-ses, o mejor dicho, en el sistema de tiposcomunes (CTS). Y los delegados no sonuna excepción.
Pero... ¿qué es un delegado? Undelegado es una referencia a una fun-ción, lo que también se conoce como unpuntero a una función, es decir, un dele-gado permite acceder a una función deforma casi anónima, ya que simplemen-te tiene la dirección de memoria dedicha función. Y sabiendo la direcciónde memoria, podemos acceder a ella.Pero en .NET esto debe estar contro-lado, de forma que ese acceso no sea
arbitrario, es decir, que no nos “cole-mos” donde no debemos, ya que, comoya he dicho, a .NET no le gustan lassorpresas, por eso impone reglas quedebemos cumplir; si las cumplimos,pasamos, si no las cumplimos, no nosdeja seguir.
Y esto es así por todo lo comentadoanteriormente, ya que el CLR quiereseguridad y la única forma de tenerla escreando normas de conducta y de utili-zación, en este caso, de la memoria o delacceso a esas partes de la memoria en laque están las definiciones de los méto-dos o funciones.
Por tanto, si queremos acceder a unmétodo, tenemos que hacerlo por mediode un puntero controlado, y la forma decontrolar ese acceso es definiendo unprototipo en el que indiquemos de quétipo es ese método, si recibe paráme-tros, y de hacerlo cuántos y de qué tiposon. Una vez que tenemos definidostodos estos requerimientos, es cuandole decimos al runtime de .NET que nospermita acceder a esa función. De estaforma, podrá controlar que estamosaccediendo al sitio correcto.
Esa definición del prototipo de fun-ción (o método) al que queremos acce-der lo hacemos por medio de un delega-do. Podemos pensar que un delegado esen cierto modo similar a las interfaces (verdotNetManía nº 16), que como sabemosdefinen un contrato que debemos respe-tar. Sabiendo esto, si queremos acceder auna función que devuelve una cadena yque recibe un parámetro de tipo Cliente,debemos definir un delegado con esascaracterísticas, y cuando posteriormentequeramos acceder a ese método, en lugarde hacerlo directamente o por medio deun puntero directo, usaremos un objetodel tipo definido por el delegado. Lo quenos lleva a una segunda definición de lo
Un delegado permite acceder a una función de forma casi anónima,ya que simplemente tiene la
dirección de memoria de dicha función
dotN
etM
anía
<<
43
dnm.inicio.fundamentos<<
que es un delegado, en la que podemosdecir que es un tipo especial que nos per-mite definir la forma de acceder a unafunción.
Veamos el ejemplo del método quedevuelve una cadena y recibe un paráme-tro de tipo Cliente. Ese método lo pode-mos definir en C# de esta forma:
public string MiFuncion(Cliente c){return “...”;}
La forma de usar ese método seríaalgo así:
string s = MiFuncion( new Cliente() );
Por supuesto aquí no estamos usan-do ningún puntero, simplemente esta-mos accediendo a ese método de formadirecta. Es más, debido a que no esta-mos indicando dónde está dicha fun-ción, suponemos que estamos accedien-do desde la propia clase en la que estádefinido. Pero si quisiéramos accederde una forma más anónima, podríamosdefinir un delegado que tenga esa defi-nición y solo tendríamos que indicardónde está definido para permitirnos elacceso, sin necesidad de usar una ins-tancia de la clase que lo define.
¿Por qué tanta complicación?Porque debemos suponer que en cier-tas circunstancias no tenemos una for-ma directa de acceder a ese método, yaque si la tuviéramos, no tendríamosnecesidad de complicarnos la vida y usa-ríamos la forma directa mostrada ante-riormente. Por ejemplo, si queremosque desde otra parte del código alguienpueda acceder a ese método sin necesi-dad de saber si está definido en una cla-se o en otra, podemos usar un delegadoy por medio de dicho delegado accederal método.
Veamos la definición del delegadoque nos permitiría acceder a esa función
y cómo podemos usarlo. Primero defi-nimos el delegado usando la misma “fir-ma” que tiene el método al que quere-mos acceder:
Para usar el delegado, definimos unavariable de ese tipo, y como los delegadosen realidad son como clases, podemos usarel mismo código que usamos para crearcualquier tipo, con la diferencia de que enel constructor debemos indicarle la fun-ción a la que queremos acceder:
MiFuncionDelegado mfd = newMiFuncionDelegado(MiFuncion);
En este caso, también estamos acce-diendo desde la propia clase al métodoMiFuncion, pero lo dejamos así para man-tener las cosas simples.
Para acceder a esa función pormedio del delegado que acabamos decrear, lo haremos así:
string s = mfd( new Cliente() );
Que como podemos comprobar, esun código muy parecido al usado ante-riormente, pero con la diferencia de queen este código no usamos el nombre dela función, sino el del objeto creado apartir del delegado.
Ahora supongamos que este últimocódigo lo queremos usar en cualquiermétodo de cualquier clase, sin importarcómo y dónde se haya definido, ¿cómopodríamos hacerlo? porque para poderdefinir una variable como en este caso,deberíamos tener “cercana” la función ala que queremos acceder. Y si la tenemoscerca, pues no necesitamos usar un dele-
gado. Veamos el siguiente código y segu-ro que esa cercanía no es tan necesaria:
public static void usarMiFuncionDelegado(MiFuncionDelegado mfd)
{string s = mfd( new Cliente() );
}
En este caso, tenemos un método quedefine un parámetro del tipo del delega-do, por tanto, podemos llamar a ese méto-do pasándole la dirección de una funciónque cumpla con la definición del delega-do y no importará donde estén definidos,ni el método ni la función a la que acce-
deremos por medio del delega-do. La única condición es quedesde donde hagamos la llama-da, tengamos acceso a ambosmétodos (o funciones), pero notienen porqué estar todas defi-nidas en una misma clase, ¡ni
siquiera en un mismo ensamblado!Para acceder a este método lo pode-
mos hacer de esta forma:
static void Main(string[] args){
Cliente c = new Cliente();usarMiFuncionDelegado(c.MiFuncion);
}
Debemos notar en la forma en quellamamos al método que recibe el dele-gado, ya que simplemente le hemospasado el nombre de la función. Esto esnuevo en C# 2.0 (aunque no en VisualBasic), y la forma en que tendríamos quehacerlo en las versiones anteriores seríaesta otra:
usarMiFuncionDelegado(newMiFuncionDelegado(c.MiFuncion));
Es decir, pasando como argumentoun objeto creado a partir del “tipo” deldelegado.
De igual forma, el código que mos-tramos anteriormente en el que usába-mos también un constructor de ese tipolo podríamos haber escrito de esta otraforma, que como vemos, es más simplee igualmente comprensible.
dotN
etM
anía
<<
44
dnm.inicio.fundamentos<<
Fuente 1. Definición de un delegado para acceder a unmétodo definido con la misma firma.
public delegate string MiFuncionDelegado(Cliente c);
Fuente 2. C# 2.0 permite asignardirectamente la función sin necesidad
de un constructor.
MiFuncionDelegado mfd = MiFuncion;
Los delegados definen la “firma” que los métodos a los que queremos acceder deben tener
En cualquier caso, lo que estamospasando es la dirección de memoria dela función.
De todo lo que hemos visto debemosconcluir que los delegados definen la “fir-ma” que los métodos a los que queremosacceder deben tener, y que podemos acce-der a esos métodos por medio de instan-cias creadas a partir del delegado, y si esta-mos usando C# 2.0 el compilador se pue-de encargar de averiguar qué delegado esel que debe usarse y lo usará de formatransparente para nosotros.
Antes de ver qué relación tiene todoesto con los eventos, repasaremos algu-nas otras características de los delega-dos que en el fondo también están rela-cionadas con los eventos, o en la formaque finalmente las utilizan los eventos,pero que no necesariamente usaremospara trabajar con los eventos.
Usos prácticos de los delega-dos
Para que nos quede más claro el fun-cionamiento de los delegados, vamos a veren qué situaciones podemos usarlos.Algunos de los usos que vamos a ver sonexclusivos de C# 2.0, y aunque ya se hantratado en otros números de esta revista,no viene mal darles un repaso. Debido aesa exclusividad de uso en C#, decirle alos lectores que prefieren Visual Basic queno pasen al siguiente artículo, ya que aúnquedan cosas que explicar que tambiénson válidas para ese lenguaje, aunque(como es costumbre en esta sección), elcódigo mostrado será prácticamente en
exclusiva para C#. Enotro artículo tratare-mos temas que sonespecíficos de VisualBasic y por consi-guiente todo el códi-
go será en ese lenguaje, ya que comocomenté anteriormente los delegados sonuna pieza clave para los eventos, y debe-mos saber cómo funcionan los delegadospara comprender mejor cómo funcionanlos eventos.
Novedades de C# respecto alos delegados
En la versión 2.0 de C# (tal comoexplicó Octavio Hernández en el núme-ro 20 de esta revista) podemos usar losdelegados de forma directa, es decir, sinnecesidad de que tengamos que crear unainstancia de la clase del delegado al que lepasamos como parámetro del construc-tor la función a la que queremos apuntar,tal como hemos visto en el código delfuente 2. En esos casos, el compiladorcomprueba el tipo de la variable que reci-be el puntero a la función y si tiene la mis-ma firma que la función, será el propiocompilador el que haga el uso adecuadodel delegado correspondiente. De hecho,si examinamos el código IL generado porel compilador será el mismo en los doscasos.
En el código del fuente 3 tenemoslas dos formas de realizar la asignacióny en el fuente 4 vemos el código IL quecrea el compilador, el cual es exactamen-te el mismo en ambos casos.
Métodos anónimos
Los métodos anónimos son otra delas novedades de C# que están relacio-nadas con los delegados. Y es que en C#2.0 podemos usar una definición de undelegado en cualquier sitio que el com-pilador esperaría que se asignara undelegado.
El ejemplo más claro del uso de losmétodos anónimos es para relacionar unevento con un código, pero como aúnno hemos tratado con detalle los even-tos, vamos a verlo con el código que esta-mos usando últimamente. En el códigodel fuente 5 podemos ver cómo crear unmétodo anónimo con la misma firma queel delegado MiFuncionDelegado, pero aldefinirlo nosotros de forma indepen-diente podemos escribir en el cuerpo dela función anónima lo que creamos con-veniente.
Como es evidente, en este caso nohace falta usar un método anónimo, yaque sería más fácil mostrar directamen-te el saludo, en lugar de dar tantas vuel-tas, pero lo importante es ver cómo se
dotN
etM
anía
<<
45
dnm.inicio.fundamentos<<
En Visual Basic, la forma de acceder a una función siempre es por mediode la instrucción AddressOf y la podemos usar también de las dosformas que acabamos de ver, es decir por medio de un objeto del tipodel delegado o de forma directa, en cuyo caso, (al igual que ocurre conC# 2.0), será el propio compilador el que determinará si esa funcióncumple o no los requisitos del parámetro que espera el método:
usarMiFuncionDelegado(AddressOf c.MiFuncion)
usarMiFuncionDelegado(NewMiFuncionDelegado(AddressOf c.MiFuncion))
En las asignaciones también podemos usar cualquiera de las dos formas:
Dim mfd As MiFuncionDelegadomfd = New MiFuncionDelegado(AddressOf MiFuncion)
Dim mfd As MiFuncionDelegado = AddressOf MiFuncion
NOTA
Fuente 3. Las dos formas equivalentes deasignar el puntero a una función.
void usaMiFuncion2(){MiFuncionDelegado mfd = MiFuncion;string s = mfd(new Cliente());
}void usaMiFuncion3(){
MiFuncionDelegado mfd = newMiFuncionDelegado(MiFuncion);
string s = mfd(new Cliente());}
Fuente 4. El código IL es el mismo para las dos formas mostradas en el fuente 3.
ldftn instance string Cliente::MiFuncion(class Cliente)newobj instance void MiFuncionDelegado::.ctor(object,native int)stloc.0ldloc.0newobj instance void Cliente::.ctor()callvirt instance string MiFuncionDelegado::Invoke(class Cliente)stloc.1ret
Fuente 5. Definición de un método anónimo.
public static void usaMiFuncion4(){MiFuncionDelegado mfd;mfd = delegate(Cliente c)
{return “Hola “ + c.Nombre;};string s = mfd(new Cliente(“Pepe”));Console.WriteLine(s);
}
dotN
etM
anía
<<
46
dnm.inicio.fundamentos<<
pueden usar los métodos anónimos, los cuales tienenmayor utilidad con los eventos o cuando queramossimplemente definir la función “apuntada” de formadirecta, ya que como hemos visto anteriormente, esavariable que apunta al método la podemos pasar comoargumento a otro método.
En cualquier caso, lo que no nos estará permitidohacer es modificar la firma del delegado; por tanto, si senos ocurre la brillante idea de añadir un nuevo paráme-tro a la función, tal como vemos en el siguiente códigofuente, el compilador nos avisará (entre otras cosas), queMiFuncionDelegado no tiene dos argumentos.
mfd = delegate(Cliente c, string saludo){return saludo + “ “ + c.Nombre;
};
Es importante saber que aunque estemos decla-rando un “método” anónimo, en realidad no es unmétodo, al menos en el sentido de los ámbitos ocobertura de las variables, ya que desde ese méto-do anónimo podemos acceder a cualquier variableque hayamos declarado anteriormente, y la varia-ble definida en el parámetro también tendrá el mis-mo ámbito que el método o propiedad que contie-ne esa definición anónima. Debemos pensar en queel cuerpo del método anónimo en realidad es comocualquier otro bloque de código que podamosincluir dentro de un par de llaves.
En el código del fuente 6 podemos ver ese con-flicto entre la variable definida directamente y la defi-nida como parámetro del método anónimo.
Covarianza y contravarianza
La primera vez que leí estas dos palabras, penséque el tema tratado debía ser muy complicado, segu-ramente para gente más experta que yo en C#. Y comosoy un catetillo de pueblo que no tiene estudios, des-pués de leer la descripción de la ayuda de Visual Studio2005 pensé en la suerte que tenía de que mi lenguajematerno no fuese el C#. Pero si iba a hablar de estoen este artículo, lo lógico era que me empapara deltema, al menos si lo iba a tratar. Y con esto pasa comocon casi todo, hasta que no lo tienes entre las manos,no sabes el tacto que tiene.
Sobre la covarianza, la documentación nos diceque: Cuando un método delegado tiene un tipo de valordevuelto que es más derivado que la firma de delegado, sedenomina covariante. En realidad, al leerlo sabiendoqué es lo que significa no era tan rebuscada la defini-ción. Pero para dejarlo en un lenguaje más llano, dire-mos que esto significa que podemos usar delegadosque devuelvan un tipo y el receptor de ese valor pue-de ser cualquier clase de ese mismo tipo o de cualquierotra clase derivada.
Por ejemplo, en el siguiente código, tenemos ladefinición de una clase Persona y un delegado quedevuelve un valor de ese tipo:
public delegate Persona PersonaCallback();
public class Persona{
// Omitidas las definiciones// de las propiedades Nombre y Apellidos
}
Y definimos una clase derivada, a la que llamare-mos Colega, en la que definimos un método estáticoque devuelve un objeto de ese mismo tipo:
public class Colega : Persona{
public static Colega NuevoColega(){
return new Colega();}// Omitida la definición de la propiedad Correo
}
Podemos usar esa función como el método al queapuntará el delegado PersonaCallback, que como hemosvisto, devuelve un objeto del tipo Persona:
PersonaCallback nColega;nColega = Colega.NuevoColega;
Colega unColega = (Colega)nColega();// Omitidas las asignaciones a las propiedades
En la asignación a la variable unColega debemoshacer una conversión (cast) ya que el valor devueltopor el delegado es del tipo Persona, independiente-mente del tipo que devuelva en realidad la función ala que hace referencia ese delegado.
En las versiones anteriores, para conseguir estomismo teníamos que definir un delegado para cadauna de los tipos que quisiéramos devolver. Ni que decirtiene que esto solo lo podemos hacer con C#; en VisualBasic no está permitida esta forma de usar los valoresdevueltos por un delegado.
Veamos ahora qué nos dice la documentación sobrela contravarianza: Cuando una firma de método delegadotiene uno o más parámetros de tipos que derivan de los tiposde los parámetros de método, ese método se denomina con-travariante. Lo que viene a significar que los tipos de
Fuente 6. El ámbito de un método anónimo es el mismo queel del bloque en el que se define.
Cliente c = new Cliente();usarMiFuncionDelegado(c.MiFuncion);
MiFuncionDelegado mfd;mfd = delegate(Cliente c) {return “Hola “ + c.Nombre;};string s = mfd(new Cliente(“Manolo”));Console.WriteLine(s);
datos que podemos usar como parámetros al llamar aun delegado pueden ser del mismo tipo que está defi-nido en el delegado (así era hasta la versión 2.0), o decualquier tipo derivado. Si el compilador ve una rela-ción de herencia entre el tipo usado y el definido enel delegado, lo permitirá.
Siguiendo con el ejemplo del delegado que recibeun parámetro de tipo Cliente, (ver el fuente 1), vamos arediseñar la clase y el método MiFuncionpara que devuel-va un saludo al nombre indicado en la propiedad Nombrede la clase. A continuación creamos la clase ClienteOroque se deriva de Cliente. Tanto en una como en otra cla-se hemos definido un constructor que recibe como pará-metro el nombre a usar. En el fuente 7 vemos esas dosdefiniciones de estas clases.
Ahora podemos usar cualquier función que reci-ba un delegado que apunte a MiFuncion y el compila-dor (realmente el runtime) usará la clase que corres-ponda.
ClienteOro co = new ClienteOro(“Paco”);MiFuncionDelegado mfd2;mfd2 = co.MiFuncion;string sco = mfd2(co);Console.WriteLine(sco);
Incluso podemos crear un método anónimo queuse un objeto del tipo ClienteOro como parámetro,
pero siempre y cuando el método anónimo tenga lafirma correcta, es decir, el parámetro en la definicióndel método anónimo debe ser del mismo tipo que elindicado en la definición del delegado, pero a la horade usarlo podemos indicar cualquier objeto de un tipoCliente o derivado:
MiFuncionDelegado mfd3;mfd3 = delegate(Cliente co2) {return “A sus pies “ +
co2.Nombre;};Console.WriteLine(mfd3(co));
Pero el uso más práctico de esta característica será(como casi todo lo relacionado con los delegados),cuando lo apliquemos a los eventos.
Cuando utilizamos los métodos de eventos de loscontroles de Windows Forms, el segundo parámetrosuele (o debería) ser una clase derivada de EventArgs,pero dependiendo del evento, ese parámetro será deltipo adecuado para el evento en cuestión. Por ejem-plo, el evento KeyPress recibe un parámetro del tipoKeyPressEventArgs, pero en C# podemos definir elmétodo que intercepta ese evento de cualquiera deestas dos formas:
private void txtNombre_KeyPress( object sender,KeyPressEventArgs e)
{ ... }
private void txtNombre_KeyPress( object sender,EventArgs e)
{ ... }
La segunda forma, a pesar de ser menos espe-cífica, seguramente la usaremos en casos muy con-cretos y siempre que necesitemos esa “generalidad”,pero no adelantemos acontecimientos, ya que cuan-do tratemos el tema de los eventos veremos algu-nas aplicaciones prácticas de esta posibilidad quetiene C#, ya que en Visual Basic siempre tendre-mos que definir los parámetros de los eventos deltipo exacto.
ConclusionesAún no hemos terminado con algunas de las
cosas interesantes o importantes de los delegados,pero será en el próximo artículo donde veremosotra característica interesante de los delegados: lamultidifusión. Esa forma de usar los delegados lacomprenderemos mejor cuando sepamos más sobrela estrecha relación de estas clases especiales conlos eventos.
Como es costumbre en esta sección, en el sitioWeb de dotNetManía está disponible el código deejemplo para poder bajarlo, aunque en el caso de VisualBasic no será equivalente al de C#, simplemente por-que aquél no soporta algunas de las características delos delegados que hemos tratado.
Fuente 7. Definición simplificada de las clases Cliente y ClienteOro.
public class Cliente{
// Omitida la definición de la propiedad Nombrepublic Cliente() { }public Cliente(string nombre){ this.Nombre = nombre; }//public virtual string MiFuncion(Cliente c) {
return “Que tal “ + c.Nombre; }
}
class ClienteOro : Cliente{
public ClienteOro() { }public ClienteOro(string nombre){ this.Nombre = nombre; }
}
El hecho de definir un constructor con parámetro en las cla-ses del fuente 7 es para facilitar el uso de las mismas, de for-ma que en una sola instrucción podamos asignar el valor dela propiedad Nombre, de esa forma nuestro código de ejem-plo podrá mostrar algo.Pero la razón de que lo hayamos teni-do que hacer en las dos clases es porque los constructoresno se heredan; por tanto, si queremos esa funcionalidad enlas dos clases, debemos definirlos en ambas.
NOTA
dotN
etM
anía
<<
47
dnm.inicio.fundamentos<<
visito regularmente que muestran infor-mación actualizada desde otros sitios, por ejemplonoticias deportivas. Y no creo que ninguno de misclientes realmente quiera enriquecer su sitio Web contal tipo de información. No obstante, eso no es óbi-ce para que piense que la importación de datos exter-nos desde otros sitios es una característica poderosay debiera considerarse…
Hay dos formas típicas de implementar unacaracterística similar: • Una es utilizando un servicio Web para obte-
ner la información expuesta por el sitio. Estosignifica, normalmente, que algún tipo de acuer-do ha sido suscrito entre ambas partes. Cuantomás valiosa sea la información, más posibilida-des hay de que tengas que pagar por ella. Desdeel punto de vista tecnológico, obtienes la infor-mación que llega del sitio (normalmente, cade-nas), y la muestras donde te apetece.
• La segunda aproximación al problema suponela suscripción a una fuente RSS (sindicación).Un sitio de esa clase publica la información y lapone a disposición del público de forma gratui-ta. En este caso, se abre un socket de control delpunto original del RSS, se lee la información–una cadena XML–, y se incorpora a las pági-nas propias.
En ambos casos, existe un acuerdo explícito oimplícito entre el sitio Web y tú. Pero, para comen-tarlo todo, existe una tercera aproximación al pro-blema: el típico screen scraping (arañar la pantalla).Nacido en los entornos de mainframe hace 25 años,ha vuelto a renacer con el advenimiento de la Web.
Consiste en la capacidad de descargar la páginacompleta y analizarla en busca de información deinterés. Por ejemplo, podríamos descargar una pági-na con resultados de la bolsa de valores, y configu-rarla para mostrar solamente los índices de nues-tro interés. Después, se analizan todos los gráficosy el texto y se capturan los dos o tres elementos quebuscamos.
Si el sitio Web dispone de una oferta RSS, esasería mi opción preferida. La técnica de screen scra-ping debería considerarse solamente como la últi-ma opción. En la práctica, lo normal es utilizarherramientas como RssBandit o SharpReader paraleer los fuentes RSS.
¿Cómo puedes leer una fuente RSS medianteprograma e incorporarla a una página Web? Lamayoría de los sitios Web (incluyendo MSDN) lohacen mediante un control compuesto. El núcleode este control contiene un código similar al delcódigo fuente 1.
Si el sitio Web dispone de una oferta RSS, esa sería mi opción preferida. La técnica de screen
scraping debería considerarse sola-mente como la última opción
Resolución de problemas en ASP.NET
Dino Esposito
dnm.todotnet.qa
<< Algunos sitios que
“”
Dino Esposito es mentor de Solid Quality
Learning y autor de “ProgrammingMicrosoft ASP.NET 2.0 CoreReference” y “Programming
ASP.NET 2.0 Applications AdvancedTopics”, ambos de Microsoft
Press.Afincado en Italia,Dino esun ponente habitual en los
eventos de la industria a nivelmundial.Visita su blog en:
http://weblogs.asp.net/despos.Puede enviarle sus consultas [email protected]
Este mes respondemos algunas preguntas relacionadas con el desarrollo Web yASP.NET en particular. Las cuestiones versan sobre importación de datos de recur-sos externos y sitios Web, tareas enlazadas de tipo asíncrono,y cómo mostrar imá-genes almacenadas en bases de datos.
La variable Text contiene la información en for-mato nativo XML. El contenedor ProcessFeedrecorre los elementos XML y construye textoHTML publicable. Mediante otra opción más ele-gante, podríamos devolver un array de objetos per-sonalizados desde ProcessFeed que solo almacenelíneas individuales para transformarlas después entexto de marcado. El código del fuente 2 muestracómo construir una lista de enlaces a las últimasnoticias.
Y este código se puede incorporar fácilmente enun control compuesto hecho a partir de una tablao una rejilla.
He construido varias soluciones utilizado tare-as asíncronas, pero confieso que no presto muchaatención al término “vinculado a entrada/salida”(I/O Bound). ¿Se supone que es peligrosa cualquieroperación asíncrona no estrictamente relacionadacon actividad de entrada/salida?
Cualquier operación puede ser etiquetada deforma sencilla de dos maneras posibles: vinculada ala CPU o a entrada/salida. En el primer caso, esta-mos ante una operación cuya duración se determi-na por la velocidad del procesador y la cantidad dememoria disponible. La vinculación a entrada/sali-da indica la situación opuesta, cuando la CPUmayormente espera a que otros dispositivos termi-nen sus tareas.
Ahora bien, ¿cuál es el propósito de las tareasasíncronas? Normalmente, resolver situaciones enlas que la IU debe de tener un alto nivel de respues-ta, mientras espera que una tarea en background,potencialmente larga, concluye. Desde esta pers-pectiva, no hay diferencias relevantes entre los dostipos de operaciones. Esto es correcto cuando esta-mos considerando escenarios con clientes ricos, talescomo las aplicaciones Windows Forms. Para apli-caciones ASP.NET, las cosas son algo distintas, perola conclusión viene a ser que si el código ha sidoescrito para Windows, probablemente servirá tam-bién en este caso.
¿Qué operaciones son candidatas a ser imple-mentadas mediante páginas asíncronas? O, dichode otra forma, ¿qué operaciones fuerzan o sugierenla adopción de una página asíncrona en una aplica-ción ASP.NET? Vamos a formalizar someramenteel concepto de proceso asíncrono en el contexto deASP.NET.
La necesidad de procesamiento asíncrono sur-ge cuando el tiempo invertido en obtener los datos
dotN
etM
anía
<<
49
dnm.todotnet.qa<<
La necesidad de procesamientoasíncrono surge cuando el
tiempo invertido en obtener losdatos de entrada o salida
resulta excesivo respecto alrequerido para procesarlo
“”
To
do
tNet.
qa@
do
tnetm
an
ia.c
om
To
do
tNet.
qa@
do
tnetm
an
ia.c
om
string ProcessFeed(string feed){
StringBuilder sb = new StringBuilder();
XmlDocument doc = new XmlDocument();doc.LoadXml(feed);
XPathNavigator nav = doc.CreateNavigator();XPathNodeIterator iterator;
// Title and descriptioniterator = nav.Select("/rss/channel/title");iterator.MoveNext();sb.AppendFormat("<h3>{0}</h3>", iterator.Current.Value);iterator = nav.Select("/rss/channel/description");iterator.MoveNext();sb.AppendFormat("<i>{0}</i>", iterator.Current.Value);
XmlNodeList items = doc.SelectNodes("/rss/channel/item");sb.Append("<ul>");foreach(XmlNode n in items){XmlNode title = n.SelectSingleNode("title");XmlNode link = n.SelectSingleNode("link");XmlNode date = n.SelectSingleNode("pubDate");sb.AppendFormat("<li><a href=\"{0}\">{1}</a> on
{2}</li>", link.InnerText, title.InnerText, date.InnerText);
}sb.Append("</ul>");
return sb.ToString();}
WebRequest req;string rssData = String.Empty;req = WebRequest.Create(RSSFEED);using (WebResponse response = req.GetResponse()){
StreamReader reader;string text = String.Empty;using (reader = new
StreamReader(response.GetResponseStream())){
text = reader.ReadToEnd();}
// Process the RSS datarssData = ProcessFeed(text);
}
Fuente 1
Fuente 2
de entrada o salida resulta excesivo respecto alrequerido para procesarlo. En tales situaciones, laCPU se encuentra en estado de espera, o de infrau-tilización, esperando la mayor del tiempo que algosuceda. En particular, las operaciones vinculadas aentrada/salida en el contexto de ASP.NET son toda-vía más dañinas, porque los procesos del servidorpueden bloquearse y el pool de subprocesos del ser-vidor es un recurso crítico y limitado.
Nos damos cuenta de las ventajas reales cuan-do usamos el modelo asíncrono en las operacionesvinculadas a entradas/salidas. En la implementa-ción de .NET Framework, cuando se realiza unallamada asíncrona, ningún subproceso se bloqueamientras la operación está pendiente.
Ejemplos típicos de este tipo de operaciones sonlas que requieren acceso a algún tipo de recursoremoto o interacción con dispositivos de hardwa-re externos. Procesos con bases de datos remotas ollamadas a servicios Web no locales, son ejemploscomunes de esta clase de operaciones, para las quedebería considerarse seriamente la construcción depáginas asíncronas.
En ASP.NET, las operaciones de larga duraciónasociadas a la CPU (por ejemplo, algoritmos com-plejos que actúen sobre datos en memoria), tam-bién deberían implementarse de forma asíncronapara preservar los recursos disponibles en el servi-dor en un nivel suficientemente alto. De todas for-mas, en este escenario, la CPU está siempre carga-da con algún trabajo y la ganancia es considerable-mente menor.
En resumen, cualquier tarea pesada debería pro-gramarse de forma asíncrona, tanto en Windowscomo en ASP.NET. Pero en este caso, resulta espe-cialmente importante para las operaciones vincu-ladas a procesos de entrada/salida. Si estas opera-ciones (como llamar a un servicio Web remoto), seimplementan de forma asíncrona, la CPU del ser-vidor Web no se ve afectada, y puede procesar otraspeticiones con rapidez.
Para operaciones vinculadas a la CPU, los pro-cesos asíncronos también resultan en una ligeramejora de las aplicaciones Windows a causa de suejecución en una hebra separada, si bien para el casode aplicaciones ASP.NET no deberían esperarsegrandes mejoras. Todavía es mejor el proceso asín-crono, pero las páginas se generarán a la velocidadque la CPU sea capaz de procesarlas. Quizá, unmejor abordaje de esta situación pasaría por sepa-rar esas operaciones de larga duración a otro ser-vidor especializado y transformar las tareas vincu-ladas a la CPU en tareas vinculadas a procesos deentrada/salida.
En los primeros días de ASP.NET 2.0 –he esta-do trabajando con él desde las primeras versionesalfa, en verano 2003– era muy fácil hacer referen-
cia a imágenes almacenadas en una base de datosSQL Server usando un control a medida llamado<asp:DynamicImage>. El control fue eliminado de lasversiones posteriores y también de la versión final.Sin embargo, sigo teniendo el mismo problema queme llevó a probar esa versión. ¿Cómo creo mi pro-pio control para carga dinámica de imágenes enASP.NET 2.0?
En ASP.NET 2.0 existen dos controles de ser-vidor para mostrar imágenes: Image y HTMLImage.Ambos suministran una fina capa de abstracciónsobre algunas de las propiedades del elemento <img>de HTML. Al final, ambos permiten, simplemen-te, referenciar imágenes por URL y establecer algu-nos atributos de presentación.
Como indicas, en el mundo real las imágenespueden tener orígenes muy diversos. Pueden estaren ficheros o bases de datos, o ser generadas diná-micamente en memoria utilizando usando una APIgráfica. En el primer caso, la solución es directa através de la etiqueta <img> y la API de ASP.NET.En el resto, los programadores tienen que escribirsu propio código para hacerlo accesible vía URL.En ASP.NET, las URL solo pueden apuntar a unmanejador personalizado (HTTPHandler). El controlDynamicImage se basaba en uno de estos manejado-res –cacheimageservice.axd– que se ha eliminadoen la versión final.
En ASP.NET 2.0 debes crear un manejadorsimilar y diseñarlo para que acepte en la cadena deconsulta cualquier información que pueda ser útilpara identificar la imagen y su origen. El controlDynamicImage eliminado encapsulaba buena partede esa información (cadenas de conexión, consul-tas, ID, etc.), ocultando su complejidad a los desa-rrolladores.
El manejador HTTP deberá ejecutar cualquiercódigo necesario para leer la imagen y establecer eltipo MIME adecuado, devolviendo sus bytes. Paraevitar consultas repetidas y ahorrar algunos ciclos deCPU, el manejador puede almacenar imágenes encaché y recuperarlas posteriormente.
dotN
etM
anía
<<
50
dnm.todotnet.qa<<
To
do
tNet.
qa@
do
tnetm
an
ia.c
om
To
do
tNet.
qa@
do
tnetm
an
ia.c
om
Traducido por Marino Posadas
En ASP.NET 2.0 debes crear unmanejador similar y diseñarlo para
que acepte en la cadena de consulta cualquier información
que pueda ser útil para identificarla imagen y su origen
“”
dotN
etM
anía
<<
51
<<
Programming ASP.NET 2.0 Core ReferenceDino Esposito
Editorial: Microsoft PressISBN: 0735621764Páginas: 800Primera edición: 2006Idioma: Inglés
Ya habíamos comentado en esta sección la obra anterior de nuestro colaborador DinoEsposito y su buena acogida entre los lectores. En esta ocasión, Dino hace una cober-tura completa de los entresijos de ASP.NET sin dejar cabo suelto, en un volumen exten-so y con abundantes ejemplos.
Asumiendo que el lector es conocedor de las técnicas de ASP.NET en general, abordatodos los temas desde el punto de vista del desarrollador –que él también es– dandosoluciones concretas a problemas concretos, recorriendo desde el modelo de compila-ción y la construcción de elementos personalizados, hasta la generación de controles ylos consejos necesarios para su óptimo diseño y funcionamiento. Como dice su título:una referencia fundamental.
Applications = Code + Markup:A Guide to the Microsoft Windows Presentation FoundationCharles Petzold
Editorial: Microsoft PressISBN: 0735619573Páginas: 1.020Primera edición: 2006Idioma: Inglés
Sabíamos por nuestro admirado Jeff Prosise que Charles Petzold estaba escribiendoun par de libros de envergadura. Este es el primero, dedicado a la programación paraWindows Vista, dentro del marco WPF (antes llamado Avalon), la API gráfica que darásoporte al nuevo sistema operativo. No es una introducción porque su longitud haceque se presente a los lectores como una referencia de todo lo que es posible hacer en elcontexto de esa nueva interfaz de usuario.
Los lectores que lo hemos tenido en nuestras manos, sentimos (otros comentarios tambiénlo avalan así) que nos encontramos ante un nuevo mundo dentro del desarrollo, de una com-plejidad enorme y también de enormes posibilidades. Menos mal que, como ya ha hechootras veces, el maestro Petzold vuelve a presentar lo difícil como si fuera evidente.
dnm.biblioteca.net<<
dnm.biblioteca.netPor Marino Posadas
10 Años de “El Guille”
estadísticas y los números, no creo queningún programador tenga en claro cuántos sitios Websobre programación hay en Internet. Solo los mejorespermanecen en la mente de miles de desarrolladores.
La competencia es feroz, las luchas por el posicio-namiento son insalubres. Pero dentro de los miles ymiles de sitios sobre programación que existen, solouno está al margen de todo eso; un sitio que no nece-sita de presentaciones, de posicionamientos, no nece-sita emprender luchas para captar usuarios; un sitio queestuvo ahí cuando lo hemos necesitado, cada día desdehace 10 años atrás (cuando casi nadie se animaba a mon-tar un sitio así); un sitio que podría estar inundado depublicidad y ganar así muchísimo dinero, sin embargosu webmaster quiere otro tipo de calidad para sus usua-rios, a costa de no ganar tanto como merece... Ojalá quela venta de sus dos libros solucionen esa injusticia.
Desde la época del dial up hasta la navegación ADSL,quienes teníamos dudas de Clipper, Visual Basic 3, 4,5, 6 y -desde hace unos años- .NET, sabíamos que conconcurrir a www.elguille.info saciaríamos nuestra sed deconocimientos.
Me refiero al famoso sitio de El Guille (GuillermoSom Cerezo) quien además de todo eso, nos daba ynos da lecciones de sencillez, de calidez y de ética, tansolo con su ejemplo.
Sabemos que “El Guille no lo sabe todo” y que su díatiene 24 horas igual que el nuestro, pero sin embargo setoma el trabajo de contestar los correos electrónicos, dedar la cara, de recorrer el mundo evangelizando a quienesprefieren los “;” del C# para que se vuelquen a VisualBasic. Y sobre todo para regalar su don de gente.
Es casi imposible no apreciarlo. Una de mis mayo-res satisfacciones en mis años de webmaster fue lograrsu amistad y confianza.
Creo que este es un buen momento para que quie-nes aprecian y admiran a El Guille puedan hacerlo. Espor eso que esta nota estará conformada por las viven-cias, opiniones, saludos de mucha gente que quiere ren-dirle un sincero y sentido homenaje.
¡¡¡ENHORABUENA GUILLE !!!
Pablo Tilotta
<< En el mundo de las
“E l Guille es un tipo especial, desde luego. Lleva diezaños con el sitio Web -posiblemente- más famoso de hablahispana dedicado a la programación, allá por donde va,siempre hay alguien que quiere hacerse una foto con él,ha recorrido medio mundo divulgando tecnologías deMicrosoft..., y sigue siendo tan humilde y sencillo comosiempre. Cuántos jovenzuelos me he encontrado, amigo
Guillermo, que con mucho menos hay que hablarles de usted. Gracias por ser comoeres y te deseo de corazón muchos años más dando la lata como solo tú sabes :-).Aquí les dejo unas fotografías de mi álbum”.
Paco Marín, editor de dotNetManía.
El Guille, feliz.:-)Guille posando con uno de sus múltiples fans en el
pasado CodeCamp de Vic, en España.
En este artículo rendimos un sencillo pero merecido homenaje a “El Guille” porel décimo aniversario de su sitio ElGuille.info, posiblemente el sitio más conocidopor los desarrolladores de Visual Basic del mundo entero. Le saludan sus amigosde Microsoft en España y Latinoamérica, de Solid Quality Learning, de INETA y,cómo no, de esta revista desde la que les martiriza cada mes.
Pablo Tilottaes Analista de Sistemas
desde hace casi 20 años.Luego de ser usuario de varios
foros y disconforme con la falta de compromiso de muchos
sitios, crea en 2003VB-MUNDO (www.vb-mundo.com),
un portal profesional paradesarrolladores.
Si bien el Guille es muy conocido por sus charlas, artículos, libros y su sitio Web,tuve la suerte de compartir con él muchos viajes por Latinoamérica. No es que
cambie mucho… A ver cómo les explico, sigue siendo muy simpático y amablepero, por ejemplo, no comer carne en Argentina porque no es finita comola que come en su casa y muy pero muy cocida, ¡¡¡es increíble!!! Sí, de ver-dad, cuando nos visitó se la pasó comiendo pan y verduras.
Otra… En la región andina se la pasaba pidiendo bocadillos o pan contomate y aceite de oliva… ya le dije que para la próxima se traiga su aceite.
No se imaginan en Perú,ya ni recuerdo en qué ciudad, lo que fue convencer a lapersona que prepara el desayuno que por favor le consiguiera pan tostado (porque
OJO, si no es pan de panadería no come), que corte un tomate, lo frote sobre el pan y que le trai-ga aceite de oliva …, ¡¡¡eso para el desayuno!!! Por suerte tomó café y el famoso zumo (se confor-mó con zumos de frutas locales que no existen en España).
Ahora hablando de informática, si por casualidad te has olvidado algún cable, o algo para tucomputadora, El Guille abre su maleta y ¡ahí lo tiene! Te salva siempre ;-D.
Y lo que no se imaginan es al Guille en el gran país del norte, ¡hablando en inglés! Y aquí la cosase agudiza, ya que en las reuniones anuales de los MVP en Seattle,hemos tenido la dicha de encon-trarnos muchos de habla de hispana y bueno, no hay quien se salve.
Pero nunca lo vi bailar o cantar, ¿porque será? Realmente para mí ha sido un lujo poder compartir con él todas estas experiencias, siempre
haciendo chistes y contento, no tengo más que palabras de agradecimiento. Y claro, ahora me doycuenta, como cumple 10 años, es como un niño y dentro de INETA me dicen que soy como lamamá de todos, ¿será por eso que me pone tantos problemas con la comida?
Y ahora les dejo unas fotos de nuestros viajes, donde podrán ver la otra cara del Guille… ;-D ¡¡¡Feliz Cumple Guille!!!
Nilda Beatriz Díaz, INETA Latam - Comité Web (www.inetalatam.org), Gerente deProyectos Latinoamérica. Desde el tercer planeta a partir del Sol.
La otra cara de El Guille
dotN
etM
anía
<<
53
dnm.comunidad.net
“Desde Microsoft Ibérica yespecialmente desde el área dedesarrolladores y MSDN es unplacer haber contado con la amistady el buen hacer de Guille durante
estos 10 últimos años. Muchas gracias Guille por todolo que nos has enseñado y por tu dedicación a lacomunidad de desarrolladores sin descanso. Un abrazo”(Alfonso Rodríguez,Responsable de progra-mas para desarrolladores en Microsoft Ibérica).
“Desde Microsoft Cono sur,felicitamos al Guille no solo por sus10 años, sino también por sus infinitasganas de compartir su conocimiento.Realmente es increíble y admirable
su voluntad. Te enviamos desde aquí un gran saludo, todoslo que hacemos MSDN Cono Sur.” (María FernandaPérez Marino, Gerente de comunidadesMSDN - Microsoft Cono Sur).
“Un recuerdo de un fabuloso día en el Río Pacuaréen Costa Rica. El Guille, José Berrios (INETALATAM) y Adolfo Wiernik (Solid QualityLearning) mostrando sus musculaturas y habilidadespara el deporte. ¡Felicitaciones Guille!, Un abrazo”
(Adolfo Wiernik,mentor y director de operaciones de SolidQuality Learning en America Latina.
Aquí lo pueden ver subiendo una duna, sí eseque está de espaldas es él, en Ica-Perú
En Ica-Perú, el Guille en estado puro En el aeropuerto de Guayaquil, colocándole gotas
en los ojos a Pablo Narváez
“Yo aún no había nacido y El Guilleya era MVP, el primero en España,allá por el 97. Con él descubrí elsignificado de MVP: no sé qué hacíayo por el stand de "Ask the experts"
en el TechEd 2003, pero recuerdo que se me acercó unmuchacho muy emocionado a preguntarme: "¿está elGuille?, ¡tengo que conocerlo como sea!, ¡he aprendidotanto en su Web!... ¡Muchas gracias Guille!, deja elVizual Beizi que ya te lo sabes y vente al Güindous Zerver;-).” (Alberto Amescua,TechNet España).
El Guille, justo antes de ser rescatado (es broma)La cuestión es llevar Visual Basic al último rincón del
planeta :-)
comerciales o científicosde alta calidad a sus aplicaciones Windows o Web basa-das en .NET Framework, Chart FX para Visual Studio2005 puede ser una excelente opción. Un producto deamplia solera (el fabricante, Software FX, produce com-ponentes gráficos para las principales herramientas dedesarrollo desde 1993), este paquete permite crear deuna manera sencilla y consistente más de 100 tipos dife-rentes de gráficos basados en datos para integrar en lasaplicaciones .NET. En este artículo ofrecemos un pri-mer acercamiento a esta excelente librería.
Primera impresiónInstalación
Gracias a las bondades incorporadas por Microsofta la plataforma .NET, raro es el caso en el que hay quehacer algún señalamiento especial con relación a los pro-cesos de instalación o despliegue de librerías de códigomanejado. La instalación de Chart FX para Visual Studio2005 no es una excepción, y basta con pulsar unas cuan-tas veces el botón “Siguiente” para lograr la instalaciónde las librerías que componen el producto, la combina-ción de los archivos de ayuda con la colección de ayudasMSDN instaladas, y la instalación y el registro de losasistentes específicos que ofrece la herramienta comoparte de su integración en el entorno de desarrollo deVisual Studio 2005.
Es de destacar que al finalizar la instalación, se lan-za automáticamente el Samples & Resource Center (Centrode Ejemplos y Recursos), una aplicación de escritoriocon conexión a servicios Web del fabricante para sumi-nistrar todo tipo de información de referencia y ejem-plos de utilización del producto. Desde esta interfaz tam-bién es posible obtener soporte técnico, conocer la dis-ponibilidad de nuevas actualizaciones o conectarse a losforos relacionados con el producto y mantenidos porSoftware FX.
Documentación y ejemplos
La documentación de iniciación y referencia queacompaña al producto es excelente. Eso sí, debemos seña-lar que se encuentra en perfecto inglés; pero eso es algoa lo que los desarrolladores de habla hispana nos hemosya acostumbrado. Tanto la Guía del Programador comola Referencia de la API pueden consultarse cómodamen-te desde el Centro (filtrándolas tanto por lenguaje - C#o VB –como por tecnología– Windows Forms oASP.NET), así como desde dentro de la ayuda en líneade MSDN.
En cuanto a los ejemplos, hay que decir que el paque-te también brilla en este aspecto; incluye un total de 40ejemplos completos, divididos más o menos equitativa-mente entre aplicaciones Windows y Web; más ejem-plos pueden descargarse del sitio Web de Software FX.
Utilizando el producto
Una primera aplicación
Para comenzar a trabajar en modo visual con los com-ponentes que integran Chart FX, es conveniente perso-nalizar el Cuadro de herramientas de Visual Studio, inser-tando los componentes contenidos en los ensambladosChartFX.WinForms.dll y ChartFX.WebForms.dll. A partir
Chart FX para Visual Studio 2005Este mes analizamos Chart FX para Visual Studio 2005, una de las herramientaslíderes del mercado para la integración de gráficos comerciales y científicos enlas aplicaciones para .NET Framework.
Octavio Hernández
dnm.laboratorio.net
<< Si necesita incorporar gráficos
Octavio Hernándezes redactor de
dotNetManía, Ingenieroen Informática de
Sistemas y MVP de C#.
de ese momento, se podrá arrastrar esoscomponentes para soltarlos sobre los for-mularios de nuestras aplicaciones.
La vía más rápida y simple para fami-liarizarse con Chart FX es insertar un grá-fico en un formulario Windows o Web.Las tareas asociadas al componente cubrentodas las necesidades básicas de configura-ción del gráfico. Adicionalmente, a travésde la Ventana de propiedades de VisualStudio es posible asignar valores a todas laspropiedades de tiempo de diseño que ofre-ce el componente. Y finalmente, median-te código se puede acceder a todo el exten-so modelo de objetos de Chart FX utili-zando cualquiera de los lenguajes .NET.
Por supuesto, los componentes sopor-tan perfectamente las técnicas de enlace adatos que proponen .NET Framework2.0 y Visual Studio 2005.
Formatos de salida en las aplicacionesWeb
Un elemento a destacar en la fun-cionalidad que ofrece Chart FX para eldesarrollo Web es la amplia variedad deformatos de salida soportados. Estos sepresentan en la tabla 1.
Despliegue de aplicaciones ytemas relacionados
Despliegue de las aplicacionesComo ya hemos mencionado antes,
tampoco hay mucho que decir en lo rela-tivo al despliegue de las aplicaciones queutilicen ChartFX; tratándose de una libre-ría desarrollada al 100% utilizando códi-go manejado, el despliegue es cuestión sim-plemente de copiar los ensambladoscorrespondientes al directorio de destino,en los casos de despliegue manual, oincluirlos en el programa de instalaciónpara implantarlos en el equipo de destino.
Con respecto a las licencias, hay quedecir que el despliegue de los ensambla-dos redistribuibles de ChartFX es total-mente libre de royalties en el caso de apli-caciones Windows. En el caso de las apli-caciones Web, una licencia de desarrollopermite el despliegue sobre un único ser-vidor Web, no importa la cantidad de pro-cesadores que tenga; se deberán adquirirlicencias adicionales para instalar los com-ponentes Web en un segundo y sucesivosservidores Web.
Internacionalización
Otra de las ventajasimportantes de ChartFXestá perfectamente glo-balizado, tanto en el casode los ensamblados paraWindows como para laWeb. El fabricante ofre-ce ensamblados satélitespara numerosos idiomas(incluido el castellano), yadicionalmente ofrecetoda la información téc-nica necesaria para quesea posible crear nuevosrecursos localizados.
Otros productosrelacionadosExtensiones deChartFX
Los creadores deChartFX han dotado alproducto de una arqui-tectura abierta y adapta-ble, de modo que searelativamente sencilloextender las libreríasbásicas con nuevas fun-cionalidades. La propiaempresa ofrece diferen-tes extensiones, algunasde las cuales son gratui-tas, mientras que otrasno. La tabla 2 enumeralas principales.
Chart FX Gauges
Chart FX Gauges es una librería decontroles que simulan paneles digita-les, lineales, radiales, etc. y que ofre-cen la posibilidad de presentar en tiem-po real datos obtenidos de maneradinámica. También están disponiblespara Windows y la Web, utilizando enambos casos una misma API.
ConclusionesEs evidente que ChartFX para Visual
Studio 2005 es un producto sólido, encuyo desarrollo se han cuidado hasta losmás mínimos detalles para garantizar unaexperiencia de usuario satisfactoria inclu-
so al programador más exigente.Esperamos mediante estas primerasimpresiones haber despertado el interésdel lector, que tiene en sus manos la posi-bilidad de evaluar esta excelente herra-mienta (junto con otras también mencio-nadas en este artículo) gracias al CD queacompaña este mes a la revista.
dotN
etM
anía
<<
55
dnm.laboratorio.net<<
Ficha técnicaNombre Chart FX
Versión Chart FX for VisualStudio® 2005
Fabricante Software FX
Web www.softwarefx.com
Distribuidor ABOX (www.abox.com)
Precio Desde 799$
Valoración
Formato Explicación.NET Permite al usuario final un alto nivel de interactividad con
relación al gráfico.El cliente debe utilizar Internet Explorery tener .NET Framework instalado y configurado.
PNG Formato de mapa de bits portable y con muchas ven-tajas sobre GIF, es el formato de salida por defectorecomendado por Software FX.
JPG Formato fotográfico que no ofrece en general buenosresultados al mostrar gráficos comerciales. Generadopor defecto cuando el cliente Web no soporta PNG.
SVG Formato vectorial (Scalable Vector Graphics). Requieresoporte adecuado en el cliente, pues los gráficos sedibujan en él.Muy eficiente gracias al pequeño tamañode los ficheros.
Flash Formato muy popular,requiere que el reproductor deFlash esté instalado en el cliente.
DHTML HTML dinámico,que utiliza scripts para los menús,etc.Accesibilidad Presenta los resultados en forma textual, para que
puedan ser leídos por un lector de pantalla a perso-nas disminuidas.
Tabla 1.Formatos de salida que ofrece ChartFX para aplicaciones Web.
Extensión ExplicaciónChart FX Annotations Extensión que hace posible incorporar anota-
ciones de diferentes tipos a los gráficos.Chart FX OLAP Ofrece elementos de interfaz de usuario orien-
tados específicamente a las operaciones depivotado,corte y profundización típicas de lossistemas de Business Intelligence.
Chart FX Financial Permite ejecutar análisis técnicos de datosfinancieros y presentarlos utilizando tipos degráficos especiales para el análisis financiero.
Chart FX Maps Librería de mapas dinámicos que pueden inte-grarse con Chart FX para mostrar los valoresde un gráfico sobre un mapa.
Chart FX Statistical Amplía la potencia de Chart FX añadiendo posi-bilidades adicionales de análisis estadístico.
Tabla 2 Extensiones de ChartFX.
dnm.club >>> dnm.club >>> dnm.club >>> dnm.club >>>[ ]
dnm.club >>> dnm.club >>> dnm.club >>> dnm.club >>> dnm.club >
Windows Scripting:Ten Windows XP PerformanceTweaks: Y desde la misma fuente, también tenemos estedocumento especialmente dedicado a los muchos que hemosactualizado nuestro hardware recientemente, con diez reco-mendaciones para la mejora (notable) en el rendimiento(http://www.aspfree.com/c/a/Windows-Scripting/Ten-Windows-XP-Performance-Tweaks).
XNA Studio Express Beta 1: Aunque no se trata de una utili-dad, sino de una herramienta de desarrollo, no podemos dejarde mencionar su disponibilidad en el sitio de descargashttp://msdn.microsoft.com/directx/xna/gse. Para más datos sobre sufuncionamiento es recomendable visitar la página oficial(http://msdn.microsoft.com/directx/XNA), si bien anticipamos queun requisito imprescindible es instalarse Visual Studio C# ExpressEdition (gratuita). Además, en la página de Microsoft GameDeveloper presentations (http://msdn.microsoft.com/directx/presenta-tions), pueden encontrarse ya abundantes materiales expuestosen el evento Gamefest 2006.
Expectación ante la posible presentación de Windows Vistaen el Tech-Ed ’06 de Barcelona
Considerando que la compañía noha modificado su calendario de salida delproducto, la disponibilidad de la RC1 y
algunos otros factores, casi todas las voces de la red se haceneco de la más que posible salida del producto para ISV coinci-diendo con el evento de Barcelona.
De hecho, los contenidos de Tech-Ed Developers van a cen-trarse en la API de Vista (.NET Framework 3.0), según se des-prende de la Agenda Oficial, y sus ponentes: lo mejor de lo mejor.
Desde el propio arquitecto principal de .NET (y autor dellenguaje C#), A. Hejlsberg (que tiene 4 presentaciones progra-madas, sobre C# y direcciones futuras del lenguaje), pasando porIvar Jakobson (co-autor del estándar UML, que hablará sobreTeam System), Kimberly Tripp (SQL Server 2005), BobBeauchemin (SQL Server 2005), David Chappell (BusinessProcess Management), Roy Osherove (que hablará sobre meto-dologías ágiles y Team System, y cuyo blog recomendábamos enel número anterior), Fritz Onion (ASP.NET 2.0, pero con unasesión sobre .NET 3.0), Ted Pattison (SharePoint), Ingo
Rammer (Windows Workflow Foundation), Jeff Prosise (AJAXy Atlas), Steve Swartz (extensísima intervención, junto a ClemensVasters con 6 presentaciones fragmentadas sobre MicrosoftApplication Server Platform), y un larguísimo etcétera que daríapara varias páginas. Todos bajo la tutela del presentador oficialde la keynote, Eric Rudder, Senior Vice President de EstrategiaTecnológica de la compañía, quien definirá el año venidero como“el más importante y prolífico en la historia de Microsoft”.
Presentado un chip que transfiere datos mediante láserCientíficos de la Universidad de California e
Intel Corporation, han presentado un nuevomodelo de chip capaz de transferir informaciónmediante un haz láser, generado por el propiochip, eliminando de esta forma la necesidad de
cableado en la transferencia. El avance es de una trascendencianotable para John E. Bowers, director del Centro de ÓpticaMultidisciplinar de la citada universidad, quien reconoce quesu disponibilidad deberá esperar dos o tres años, pero que esta-rá presente en todas partes, incluidas las conexiones a domici-lio mediante fibra.
dotN
etM
anía
<<
58
dnm.desvan<<
Marino Posadas
Practical Examples of Namespaces in VB.NET 2005: Unpráctico dossier sobre la herencia en lanueva versión de VB, que forma partede una serie de documentos gratuitospublicados en ASPFree.com (http://www.aspfree.com/c/a/VB.NET/Practical-Examples-of-Namespaces-in-VBNET-2005)
Documentos en la Red Blogs del mes
no
tici
as.
no
tici
as.
no
tici
as
Utilidades del mes
“A la Vista”, Blog de Catherine Heller, evangelistatécnica ubicada en Redmond, y bien conocida enEspaña, donde residió muchos años. Especialmente
dedicado a la programación con Windows Vista. Accesibleen http://blogs.msdn.com/cheller.
Jusep.NET: Sitio en castellano dedicadoprincipalmente al desarrollo mediante
XAML y .NET Framework 3.0. También dispone de noti-ciarios, pero destacamos sobre todo el código fuente. Accesibleen http://jusep-net.blogspot.com.
Dimio’s Utilities: Se trata de unpaquete de utilidades freeware, dis-
ponibles en el sitio Web de Dimio (http://dimio.alter-vista.org/eng) dondepodemos encontrardesde herramientasque permiten guar-dar el MBR del sis-tema (Master BootRecord), hasta sincronizadores de dispositivos, gesto-res programados de actividad y muchos otros.
![[제86회 Open Technet]OGC 표준 기반의 공간자료 분석과 시각화 기술 개발](https://img.pdfslide.tips/doc/110x75/58857d9c1a28abbb7e8b6bb1/86-open-technetogc-.jpg)
![[SOS 2009] Microsoft Technet: TMG Preview Técnico](https://img.pdfslide.tips/doc/110x75/557576d4d8b42adb7e8b4857/sos-2009-microsoft-technet-tmg-preview-tecnico.jpg)
