Este documento presenta una introducción a los patrones de diseño de software. Explica brevemente qué son los patrones de diseño, sus orígenes y clasificaciones principales. Luego describe dos patrones fundamentales: el patrón Interfaz, que permite que una clase use los servicios de otra de manera independiente; y el patrón Delegación, que extiende la funcionalidad de una clase a través de otra clase que la proporciona.

1. Patrones de Diseño<br />Sumario<br />A lo largo de esta serie de artículos haremos un repaso de los principales patrones de diseño de software y veremos cómo llevar a cabo su implementación con Visual Basic .NETVeremos qué son los patrones de diseño y cuáles son los patrones de diseño básicos, patrones que aparecen con una gran frecuencia en la práctica. La presentación de cada patrón irá acompañado de una explicación teórica y de una visión práctica, en la que se verá su aplicación con un lenguaje de programación, lo que nos permitirá apreciar mejor su potencial<br />Índice de contenido<br />Patrones de Diseño <br />Introducción <br />Patrones de diseño: concepto y disciplina <br />Los orígenes de los patrones de diseño <br />Clasificación de los patrones de diseño <br />El patrón Interfaz <br />El patrón Delegación <br />Patrones de creación: Singleton . <br />Arriba <br />Introducción<br />El movimiento de los patrones de diseño se encuentra actualmente en auge. Todos los meses surgen nuevas publicaciones escritas. artículos digitales y comunidades en la web que tratan sobre esta disciplina. Además, al tratarse de un campo relacionado con la fase de diseño del software, éste es independiente del lenguaje de programación empleado. Los patrones de diseño pueden ser aplicados en lenguajes tan dispares como Java, C++, PHP, Visual Basic, C#, etc.<br />Un ejemplo de la importancia que están tomando los patrones de diseño de software lo representa el hecho de que la metodología de desarrollo METRICA 3, de la Administración General del Estado, incorpora una tarea dedicada a la identificación de patrones (DSI 2.2: Identificación de Mecanismos Genéricos de Diseño).<br />Arriba <br />Patrones de diseño: concepto y disciplina<br />Los patrones de diseño de software son soluciones reutilizables de problemas recurrentes que aparecen durante el proceso de diseño de software orientado a objetos.<br />¿Por qué surgen los patrones de diseño? Por la necesidad de transmitir la experiencia.<br />Lo que diferencia a un programador brillante y experto de un programador igualmente brillante pero inexperto es la experiencia. Conforme un programador gana experiencia, éste reconoce el parecido entre los nuevos problemas que van surgiendo y los problemas que ya ha resuelto con anterioridad. Incluso cuando tiene más experiencia, es capaz de reconocer que las soluciones a estos problemas siguen patrones recurrentes.<br />Con el conocimiento de estos patrones, los programadores expertos son capaces de identificar las situaciones en las que éstos tienen aplicación, y utilizarlos sin tener que detenerse para analizar el problema y vislumbrar diferentes estrategias de resolución.<br />No obstante, que un programador haya descubierto un determinado patrón no implica que sea capaz de expresar su conocimiento a otros programadores. Aquí es donde aparece la disciplina de los patrones de diseño. Esta disciplina establece una especie de especificación para documentar los patrones de diseño de software orientado a objetos. Según esta especificación, todo patrón de diseño debe ir acompañado de:<br />Nombre del patrón: Gracias a éste nombre podremos identificar al patrón y referimos al mismo cuando discutamos con otros diseñadores durante la fase de diseño.<br />Sinopsis: Breve resumen que nos indica la esencia de la solución proporcionada por el patrón. Es de gran utilidad para los programadores expertos que no conocen el nombre del patrón. De esta forma, se les indica lo que éste hace.<br />Contexto: Descripción detallada del problema recurrente que el patrón viene a solucionar.<br />Solución: Contiene una descripción detallada del patrón, y viene acompañada de un diagrama de clases UML que refleja gráficamente esta solución.<br />Ejemplo de aplicación: La descripción del patrón siempre será más rica si va acompañada de un ejemplo practico.<br />No obstante, a lo largo de esta serie de artículos no emplearemos este formato de documentación, que, aunque exhaustivo, podría resultar difícil de seguir.<br />Arriba <br />Los orígenes de los patrones de diseño<br />Antes de entrar en materia, veremos de forma muy breve los orígenes de los patrones de diseño de software.<br />El concepto de patrón de diseño procede del campo de la arquitectura. Los trabajos del arquitecto Christopher Alexander (véase referencia [1] del cuadro \"
Bibliografía recomendada\"
), publicados a finales de la década de los 70, postulaban la existencia de patrones repetitivos en las soluciones adoptadas en planeamiento urbanístico y construcción. Estas ideas eran susceptibles de ser aplicadas a otras disciplinas, entre ellas, la de la Ingeniería del Software. Así, en el año 1987 los archiconocidos W.Cunningham y Kent Beck (padre de la metodología \"
Extreme Programming\"
) utilizaron algunas de las ideas de Alexander para identificar una serie de patrones en la construcción de interfaces de usuario (véase referencia [2] del cuadro \"
Bibliografía recomendada\"
). Estos patrones se emplearon en el lenguaje SmallTalk (uno de los pioneros de los lenguajes orientados a objetos puros) y dieron lugar al conocidísimo patrón Modelo/Vista/Controlador.<br />En el año 1994 Gamma, Helm, Vlissides y Jhonson (grupo de autores conocido como el Gof o \"
pandilla de los cuatro\"
) publicaron el libro que es considerado la \"
Biblia\"
de los patrones de diseño (véase referencia [3] del cuadro \"
Bibliografía recomendada\"
). Este libro popularizó la idea de los patrones de diseño e introdujo la clasificación de patrones de diseño más extendida en la actualidad. A partir de este momento, se produjo la explosión del fenómeno de los patrones de diseño. Se han desarrollado patrones aplicables a diferentes niveles de la lógica de la aplicación, como persistencia, mensajería, presentación, etc.<br />El último movimiento parece ser el de los patrones para la creación de aplicaciones empresariales, que tratan de cubrir todos los aspectos de un sistema empresarial. En este sentido cabe destacar los trabajos de Martin Fowler (véase referencia [4] del cuadro \"
Bibliografía recomendada\"
), o las publicaciones de Sun (véase referencia [5] del cuadro \"
Bibliografía recomendada\"
) y Microsoft (véase referencia [6] del cuadro \"
Bibliografía recomendada\"
) para mostrar cómo construir aplicaciones empresariales con sus plataformas de desarrollo. Paralelamente al concepto de patrón, ha ido surgiendo el concepto de \"
Antipatrón\"
. Se basa en la idea de que con frecuencia resulta más fácil aprender de los errores, por lo que se trata de catalogar los errores más frecuentes de análisis, diseño y programación.<br />Arriba <br />Clasificación de los patrones de diseño<br />Los patrones de diseño varían tanto en su granularidad como en su nivel de abstracción. Puesto que existen numerosos patrones de diseño, éstos se clasifican en categorías, lo que facilita su aprendizaje y permite referirse a patrones similares mediante la familia a la que pertenecen.<br />En la obra del Gof (véase referencia [3] del cuadro \"
Bibliografía recomendada\"
) se proponen las siguientes categorías:<br />Patrones de creación: Esta categoría agrupa a los patrones que proporcionan guías de cómo construir objetos, cuando su creación implique la toma de una decisión. Esta decisión puede ser básicamente elegir qué subclase dentro de una jerarquía de herencia instanciar, y qué clase tiene la responsabilidad de su creación<br />Patrones estructurales: Los patrones de esta categoría describen mecanismos genéricos para organizar diferentes clases de objetos entre sí.<br />Patrones de comportamiento: Estos patrones se utilizan para organizar, gestionar y combinar el comportamiento de diferentes objetos.<br />A esta clasificación, Mark Grand en su obra \"
Patterns in Java\"
(véase referencia [7] del cuadro \"
Bibliografía recomendada\"
) añade la categoría de Patrones fundamentales\"
. \"
Según este autor, esta categoría engloba a patrones que aparecen con mucha frecuencia en el resto de patrones, de mayor complejidad.<br />Comenzaremos nuestro repaso de los principales patrones de diseño por dos patrones de esta categoría: el patrón Interfaz y el patrón Delegación.<br />Arriba <br />El patrón Interfaz<br />Este patrón prácticamente aparece en el resto de patrones de diseño que vamos a ver a lo largo de esta serie de artículos, por lo que con él nos vamos a detener un poco más. Se utiliza cuando deseamos que una clase que hace uso de los servicios proporcionados por otras clases, permanezca independiente de estas.<br />¿Qué ventajas obtenemos con ello? Reduce el acoplamiento entre clases, y evita la propagación de cambios. ¿Y cómo podemos implementar este patrón? A través de la utilización de interfaces. Una interfaz define un contrato que deben cumplir una serie de clases, independientemente de los detalles internos de implementación de cada una de éstas. Se trata por tanto de un tipo especial de herencia denominado \"
de interfaz\"
. Mediante la aplicación de este patrón de diseño, podemos independizar una clase de otra que le presta servicios, haciendo que no tenga una referencia a la clase que ofrece el servicio, sino a la interfaz que define el contrato del servicio a prestar.<br />¿Cómo podemos implementar este patrón de diseño con Visual Basic .NET?<br />En VB.NET podemos definir una interfaz de la siguiente manera:<br />Listado 01 - Interfaz definida en VB.NET <br />'-------------------------------------------<br />Public Interface IEducado<br /> Sub diHola()<br /> Sub diAdios()<br />End Interface<br />'-------------------------------------------<br />Diagrama de clases UML del patrón Interfaz <br />Esta interfaz define un comportamiento, que podrán heredar otras clases a través de la herencia de interfaz. <br />En el listado 1 tenemos dos implementaciones de esta interfaz con VB.NET. En dicho ejemplo tenemos una interfaz \"
IEducado\"
, que obliga a que todas las clases que la implementen tengan métodos de saludo y despedida, impresos por consola. <br />En el En el listado 2 vemos como la clase Educadolngles implementa estos métodos en inglés, mientras que la clase EducadoEspañol los implementa en español. <br />Listado 02 - Clases que utilizan la interfaz IEducado <br />'-------------------------------------------<br />Public Class EducadoIngles<br /> Implements IEducado<br /> Friend Sub Hola() Implements IEducado.diHola<br /> Console.WriteLine(\"
Hello\"
)<br /> End Sub<br /> Friend Sub Adios() Implements IEducado.diAdios<br /> Console.WriteLine(\"
Bye\"
)<br /> End Sub<br />End Class<br />'-------------------------------------------<br />Public Class EducadoEspañol<br /> Implements IEducado<br /> Friend Sub Hola() Implements IEducado.diHola<br /> Console.WriteLine(\"
Hola\"
)<br /> End Sub<br /> Friend Sub Adios() Implements IEducado.diAdios<br /> Console.WriteLine(\"
Adios\"
)<br /> End Sub<br />End Class<br />'-------------------------------------------<br />Listado 03 - Forma básica de utilizr el Interfaz IEducado <br />'-------------------------------------------<br /> Public Sub ProbarInterfazFormaUno()<br /> ' Instanciar una clase<br /> Dim oEnEspañol As New EducadoEspañol()<br /> ' definicion de la interfaz<br /> ' asignando una clase a la interfaz<br /> Dim iMuyEduado As IEducado = oEnEspañol<br /> ' usando la interfaz<br /> iMuyEduado.diHola()<br /> iMuyEduado.diAdios()<br /> '------------------------------<br /> ' asignar otra clase a la interfaz<br /> ' Instanciar una clase<br /> Dim oEnIngles As New EducadoIngles()<br /> ' asignar la clase a la interfaz<br /> iMuyEduado = oEnIngles<br /> ' usando la interfaz<br /> iMuyEduado.diHola()<br /> iMuyEduado.diAdios()<br /> '----------------<br /> iMuyEduado = Nothing<br /> oEnEspañol = Nothing<br /> oEnIngles = Nothing<br /> End Sub<br /> '-------------------------------------------<br />Supongamos que tenemos una clase encargada de interactuar con el usuario en un entorno de línea de comandos, saludándolo al iniciar la sesión y despidiéndose al terminar. Podemos independizar nuestra clase del idioma empleado haciendo que tenga una referencia a la interfaz educado:<br />Listado 04 - Clase que implementa la interfaz en el constructor<br />'-------------------------------------------<br />'-------------------------------------------<br />Public Class HaceUsoInterfazEducado<br /> Dim iMuyEduado As IEducado<br /> Public Sub New(ByVal UnObjetoIdioma As Object)<br /> ' definicion de la interfaz<br /> ' asignando una clase a la interfaz<br /> ' ctype es por [Option Strict ON]<br /> iMuyEduado = CType(UnObjetoIdioma, IEducado)<br /> End Sub<br /> Public Sub diHola()<br /> iMuyEduado.diHola()<br /> End Sub<br /> Public Sub diAdios()<br /> iMuyEduado.diAdios()<br /> End Sub<br />End Class<br />'-------------------------------------------<br />En función del idioma seleccionado por el usuario, esta clase recibirá en su constructor una implementación u otra, sin necesidad de modificar la clase que hace uso de los servicios ofrecidos por esta interfaz. Es más: podemos seguir añadiendo soporte de nuevos idiomas, creando nuevas implementaciones de la interfaz.<br />Listado 05 - Función que utiliza la clase anterior [HaceUsoInterfazEducado] <br />'-------------------------------------------<br /> Public Sub ProbarInterfazFormaDos()<br /> ' Instanciar una clase en función del idioma a utilizar<br /> Dim oEnEspañol As New EducadoEspañol()<br /> ' instanciar la clase que usa el interfaz<br /> Dim oIEducado As New HaceUsoInterfazEducado(oEnEspañol)<br /> oIEducado.diHola()<br /> oIEducado.diAdios()<br /> oIEducado = Nothing<br /> oEnEspañol = Nothing<br /> End Sub <br />'-------------------------------------------<br />Otros lenguajes más antiguos, como C++ o Visual Basic carecen de interfaces. En su lugar ofrecen otra construcción, las clases abstractas, también presentes en Java y C#.<br />En C++ una clase es abstracta cuando tiene uno de sus métodos \"
virtual\"
. El modificador \"
virtual\"
es similar al modificador \"
abstract\"
de Java y otros lenguajes. En C++ definiríamos el contrato de nuestra interfaz con una clase abstracta (que puede ser pura si todos sus métodos son abstractos), y cada una de las implementaciones de la interfaz serían clases que heredarían de ésta.<br />Incluso las últimas versiones de Visual Basic (5 y 6), antes de su sustitución por Visual Basic .NET, permitían la definición de clases abstractas. Para tal fin, había que crear un módulo de clase con el asistente visual del lenguaje, y dar el valor \"
PublicNoCreatable\"
a la propiedad \"
Instancing\"
del módulo. Esto hacía que no se pudiese utilizar ni el operador \"
new\"
ni la función \"
CreateObject\"
para obtener instancias de la clase. Un módulo podía implementar esta interfaz mediante el uso de la palabra reservada \"
implements\"
.<br />Arriba <br />El patrón Delegación<br />La delegación consiste en un medio de extender y reutilizar la funcionalidad de una clase mediante la creación de otra clase que se la proporcione. Todos los lenguajes orientados a objetos proporcionan mecanismos para implementar este patrón, pues basta con añadir una nueva referencia a la clase que consume el servicio.<br />Diagrama de clases UML del patrón Delegación <br />La importancia del patrón Delegación radica en que nos proporciona un mecanismo para decidir cuándo debemos hacer que una clase herede de otra, o cuando añadirle una referencia para utilizar sus servicios. En nuestro ejemplo de la clase educada, parece claro que hay que utilizar delegación. Muchas veces la decisión nos la da el sentido común (la regla de \"
es un\"
), mientras que otras veces habrá que hacer un análisis del número de herencias posibles. En nuestro ejemplo, añadiendo una referencia a la interfaz \"
IEducado\"
sólo crearemos una clase que consuma sus servicios, mientras que si optamos por el mecanismo de la herencia, tendríamos que crear dos subclases: una de \"
EducadoIngles\"
y otra de \"
EducadoEspañol\"
. Además. conforme fuese creciendo el número de implementaciones de \"
IEducado\"
, habría que ir aumentando el número de herencias. El listado siguiente se muestra la codificación en VB.NET de este patrón.<br />Listado 06 - Patrón delegación (extracto del listado 4)<br />'-------------------------------------------<br />Public Class HaceUsoInterfazEducado<br /> Dim iMuyEduado As IEducado<br />. . . . . . . . .<br />' El código completo de la clase esta en el listado 04<br />End Class<br />'-------------------------------------------<br />Arriba <br />Patrones de creación: Singleton .<br />Una vez introducidos dos de los patrones de diseño fundamentales, Interfaz y Delegación, veremos un patrón del tipo creacional muy frecuente en la práctica: el patrón de diseño Singleton.<br />Este patrón se utiliza cuando queremos garantizar que, de una determinada clase, sólo existe una instancia. De esta forma, todos los objetos que hagan uso de esa clase utilizarán la misma instancia. ¿Cuándo suele ser necesario aplicar un Singleton? Cuando nos encontramos con clases que deben encargarse de gestionar un recurso, bien sea externo (las conexiones a una base de datos, por ejemplo), bien sea interno (información de configuración global a nivel de sistema, información única para el contexto de la aplicación, etc.)<br />Gestor de conexiones con el patrón Singleton <br />¿Cómo se implementa un Singleton? En primer lugar, se debe impedir que los clientes construyan instancias de la clase que se desea hacer Singleton. Para ello, lo normal es hacer su constructor privado. Además, se debe hacer que dicha clase contenga una referencia estática a la única instancia de esa propia clase que puede existir. En el mundo de la orientación a objetos, se denomina estáticas a aquellas propiedades y métodos que son comunes de una clase, y por tanto compartidas por todas sus instancias. Por último, se debe añadir al Singleton un método público y estático que devuelva la única referencia existente de esa clase.<br />En el listado siguiente vemos cómo implementar un Singleton en Visual Basic.NET.<br />Listado 07 - Patrón de creación: Singleton <br />'-------------------------------------------<br />Public Class Singleton<br /> ' Variable que contiene la referencia a ESTA clase <br /> Private Shared m_Instance As Singleton = Nothing<br /> ' constructor privado<br /> Private Sub New()<br /> ' o hacer nada<br /> End Sub<br /> ' método estático <br /> ' permite obtener la referencia de la clase<br /> ' siempre se devuelve la misma referencia<br /> Public Shared ReadOnly Property Instance() As Singleton<br /> Get<br /> If m_Instance Is Nothing Then<br /> m_Instance = New Singleton()<br /> End If<br /> Return m_Instance<br /> End Get<br /> End Property<br />End Class<br />'-------------------------------------------<br />El patrón Singleton Asegura que solo se cree una instancia de la clase y provee un punto global de acceso a esta.<br />En el siguiente ejemplo crearemos una clase que inicialice y retorne un objeto conexión si no existe y si ya existen que nos retorne la instancia existente.<br />El ejemplo está escrito por Enriquillo Mañón, y lo encontre el dia 22/12/2004 en la página siguiente:http://www.microsoft.com/spanish/msdn/comunidad/mtj.net/voices/art151.asp <br />Listado 08 - Patrón de creación: Singleton <br />'-------------------------------------------<br />'Implementación del Patrón Singleton<br />Public Class Conexion<br /> 'Objeto que contendrá la instancia compartida<br /> Private Shared m_objConexion As Conexion<br /> Private m_FechaCreacion As String<br /> 'El Mutex es una clase que proporciona .NET FrameWork<br /> 'Con ella evitaremos que en un ambiente multi thread<br /> 'se cree algún tipo de conflicto<br /> Private Shared m_Mutex As New System.Threading.Mutex<br /> Private Sub New()<br /> m_FechaCreacion = DateTime.Now.ToString<br /> End Sub<br /> 'Este método eliminará la instancia ya existente<br /> Public Shared Sub KillInstance()<br /> m_objConexion = Nothing<br /> End Sub<br /> 'Este será el método que proporcionara el acceso<br /> 'A la instancia existente, si no existe, creara<br /> 'una nueva (método Singleton).<br /> Public Shared Function GetInstance() As Conexion<br /> m_Mutex.WaitOne()<br /> If m_objConexion Is Nothing Then<br /> m_objConexion = New Conexion<br /> End If<br /> m_Mutex.ReleaseMutex()<br /> Return m_objConexion<br /> End Function<br /> 'Propiedad que presenta la fecha y hora en que<br /> 'Fue creada la instancia<br /> Public ReadOnly Property FechaCreada() As String<br /> Get<br /> Return m_FechaCreacion<br /> End Get<br /> End Property<br />End Class<br />'-------------------------------------------<br />La implementación para probar nuestra clase es bastante sencilla, para instanciarla: <br />Listado 09 - Patrón de creación: instanciarla <br />'-------------------------------------------<br /> Try<br /> Dim objConexion As Singleton.Conexion<br /> objConexion = Singleton.Conexion.GetInstance<br /> TextBox1.Text &= \"
Instancia Creada el \"
+ objConexion.FechaCreada & vbCrLf<br /> Catch ex As Exception<br /> MessageBox.Show(ex.Message)<br /> End Try<br />'-------------------------------------------<br />Y para inicializarla:<br />Listado 10 - Patrón de creación: inicializarla <br />'-------------------------------------------<br /> Try<br /> Singleton.Conexion.KillInstance()<br /> TextBox1.Text &= \"
Instancia Eliminada---- \"
& vbCrLf<br /> Catch ex As Exception<br /> MessageBox.Show(ex.Message)<br /> End Try<br />'-------------------------------------------<br />Arriba <br />Para Saber Mas<br />[1] \"
A Pattern Language: Towns, Buildings, Construction. \"
Christopher Alexander. 1977<br />[2] \"
Using Patterns Languages for Object-Oriented Programs\"
. Ward Cunningham, Kent Beck. 1987<br />[3] \"
Desing Patterns: Elements of Reusable Object Oriented Software\"
. Gamma, Helm, Vlissides y Jonson, 1994<br />[4] \"
Patterns Of Enterprise Application Architecture\"
, Martín Fowler<br />[5] \"
Java Blueprints\"
http://java.sun.com/blueprints/patterns/catalog.htm <br />[6] \"
.NET Enterprise Patterns\"
. http://msdn.microsoft.com/architecture/patterns/ <br />[7] \"
Patterns in Java: A Catalog of Reusable Design Patterns Illustrated with UML\"
Mark Grand<br />[8] \"
Te Server Side\"
En esta web encontraremos una seccion dedicada a patrones de diseño. www.theserverside.com <br />Arriba <br />Referencia bibliográfica <br />Este documento esta COPIADO en su totalidad de un articulo escrito por Álvaro Zabala Ordóñez, y fue publicado en la revista Sólo Programadores num. 113 con el título \"
Patrones de Diseño. Un curso practico [I]El articulo original muestra ejemplos en varios lenguajes. En esta COPIA, los he sustituido por ejemplos escritos exclusivamente en Visual Basic .NET, y además he modificado la redacción de los párrafos que hacían referencia a los ejemplos en otros lenguajes al objeto de darle una coherencia al texto final.<br />Usted aprenderá a Implement proven methods to build adaptable, reliable and efficient .NET Web and smart client applications Aplicar métodos probados para crear adaptables, confiables y eficientes. NET y aplicaciones de cliente inteligente Solve complex programming problems with industry-standard design patterns Resolver problemas de programación complejos con los patrones de diseño estándar de la industria Deliver bug-free code using test-driven development in Visual Studio Entregar el código libre de errores con el desarrollo basado en pruebas en Visual Studio Create layered architectures for reusability and avoiding functional overlap Cree capas arquitecturas de reutilización y evitar la superposición funcional Apply best practices for improved class design Aplicar las mejores prácticas para el diseño de la clase mejor Simplify and automate repetitive tasks Simplificar y automatizar las tareas repetitivas Course Benefits Beneficios del curso Knowledge of the .NET languages and libraries alone is not enough to develop robust applications. El conocimiento de la. NET y las bibliotecas no es suficiente para desarrollar aplicaciones robustas. Proven design patterns and best practices, distilled from the wisdom of experts, support you in building applications upon a solid foundation. patrones de diseño probado y las mejores prácticas, extraídas de la sabiduría de los expertos, que ayuda en la creación de aplicaciones sobre una base sólida. This course provides the skills needed to solve real-world software development problems and deliver fast, reliable applications. Este curso proporciona los conocimientos necesarios para resolver los problemas del mundo real de desarrollo de software y ofrecer aplicaciones rápida y fiable. Who Should Attend ¿Quién debe asistir Programmers, system architects and anyone developing .NET applications. arquitectos programadores, y cualquier sistema de desarrollo. NET. Programming experience at the level of Course 419, \"
C# Programming ,\"
or Course 503, \"
Visual Basic Programming for .NET ,\"
is assumed. experiencia de programación a nivel de curso 419, \"
programación de C # , \"
o Curso 503,\"
Visual Basic de programación para. NET \"
, se supone. Hands-On Training Manos a la formación You gain experience implementing .NET best practices and design patterns. Ganas experiencia en la implementación. NET mejores prácticas y patrones de diseño. Exercises, completed in VB or C#, include: Ejercicios, completado en VB o C #, incluyen: Reconciling diverse processing problems with the Strategy pattern La conciliación de diversos problemas de procesamiento con el patrón Estrategia Simplifying a complex system with the Facade pattern La simplificación de un sistema complejo con el patrón Fachada Exploiting Microsoft Entity Framework for data access and updates La explotación de Microsoft Entity Framework para acceso a datos y actualizaciones Creating a Business Domain Object Model Creación de un modelo de objetos de dominio de Negocios Building automated test cases Construcción de casos de prueba automatizado Structuring a testable user interface with the Model View Controller pattern Estructuración de un interfaz de usuario comprobable con el patrón Modelo Vista Controlador Capturing and reusing tests within Visual Studio La captura y reutilización de las pruebas dentro de Visual Studio Course 511 Content Contenido del curso 511 Introduction Introducción Coding with best practices Codificación de las mejores prácticas Simplifying software with design patterns Simplificación de software con patrones de diseño Simplifying Complex Programming with Proven Design Patterns Simplificación de programación complejos con probada patrones de diseño Applying simple interfaces to intricate algorithms La aplicación de interfaces simples a complejos algoritmos Unifying interfaces from subsystems for ease of use and reusability La unificación de interfaces de subsistemas para facilitar su uso y reutilización Implementing the Facade pattern Aplicación del modelo de fachada Varying functionality by programming to interfaces Variando la funcionalidad mediante la programación de interfaces Enhancing the adaptability and flexibility of your application Mejorar la adaptabilidad y la flexibilidad de su aplicación Exploiting the Strategy pattern Explotar el patrón Estrategia Extending object behavior dynamically Ampliación de la conducta objeto de forma dinámica Increasing functionality without impacting existing code El aumento de la funcionalidad sin afectar al código existente Composing objects with the Decorator pattern Composición de objetos con el patrón Decorador Achieving reuse and flexibility El logro de reutilización y flexibilidad Eliminating code duplication by outlining a basis for an algorithm La eliminación de la duplicación de código al esbozar las bases de un algoritmo Employing the Template Method pattern Empleando el modelo de plantilla Método Interfacing incompatible classes Interfaz clases incompatibles Transforming an interface to add value to existing code La transformación de una interfaz para agregar valor a código existente Harnessing the Adapter pattern Aprovechar el modelo del adaptador Applying Test-Driven Development Techniques La aplicación de técnicas de desarrollo basado en pruebas Automating unit testing Automatizar las pruebas unitarias Shortening development cycles with automated tests Acortar los ciclos de desarrollo de pruebas automatizadas Improving quality with consistent test coverage Mejora de la calidad con una cobertura consistente de pruebas Eliminating regression errors with reusable tests La eliminación de los errores de regresión con las pruebas reutilizables Integrating testing and coding La integración de las pruebas y la codificación Applying the test-first programming practice to drive code design La aplicación de la prueba práctica de programación de sesiones para conducir el diseño del código Generating immediate green-light feedback for increased code quality and short feature development cycles Generar retroalimentación inmediata luz verde para el aumento de la calidad del código y los cortos ciclos de desarrollo de funciones Organizing, coordinating and running test cases with Visual Studio Organizar, coordinar y ejecutar los casos de prueba con Visual Studio Architecting a Layered Application Arquitectura de una aplicación de capas Designing the application architecture Diseño de la arquitectura de aplicaciones Layering architectures for reusability, durability and scalability Capas arquitecturas de reutilización, durabilidad y capacidad de ampliación Accessing data from the business tier Acceso a datos de la capa de negocio Decoupling object creation with the Factory pattern La disociación de creación de objetos con el patrón de la fábrica Preserving object identity with the Identity Map pattern Preservar la identidad del objeto con el patrón de identidad Mapa Programming application tiers Programación niveles de la aplicación Structuring a Web or rich client application with the Observer pattern Estructuración de un cliente Web o de aplicaciones ricas con el patrón Observer Organizing state-rich applications with the State pattern Organizador rico estado-aplicaciones con el modelo de Estado Restructuring database tables without impacting application code Reestructuración de las tablas de la base de datos sin afectar el código de la aplicación Modeling a business area Modelado de un área de negocio Liberating rich Business Object Models from database structures using the Domain Model pattern Libertador ricos Business Object modelos de las estructuras de base de datos utilizando el patrón de modelo de dominio Mapping rich Business Objects to database tables with the Data Mapper pattern Cartografía ricos Business Objects a las tablas de base de datos con el patrón Data Mapper Collapsing Business Object hierarchies with the Inheritance Mapper pattern El colapso de las jerarquías de objetos de negocio con el patrón de herencia Mapper Exploiting declarative programming in Microsoft Entity Framework to implement Data Mapping classes La explotación de la programación declarativa en Microsoft Entity Framework para implementar clases de datos de cartografía Applying Best Practices La aplicación de Buenas Prácticas Organizing and implementing business logic La organización y la aplicación de la lógica de negocio Applying domain logic patterns in the middle tier La aplicación de los patrones de dominio de la lógica en el nivel medio Extending Entity types with partial classes Ampliación de tipos de entidad con clases parciales Manipulating groups of Entities with business logic classes La manipulación de los grupos de entidades con las clases de lógica de negocio Best practices in class design Las mejores prácticas en el diseño de clase Guarding against rigidity with the Open/Closed Principle Protección contra la rigidez con el Abierto de Principio / Cerrado Extracting new classes with the Single Responsibility Principle La extracción de las nuevas clases con el Principio de Responsabilidad Individual Effective use of inheritance El uso eficaz de la herencia Automating Repetitive Tasks Automatizar tareas repetitivas Easing data access code Facilitar los datos de código de acceso Reducing database access code by exploiting Entity Navigation Properties La reducción de la base de datos de código de acceso mediante la explotación de la entidad de navegación Propiedades Eliminating database update code with Entity change tracking La eliminación de código de actualización de base de datos con el cambio de entidad de seguimiento Enhancing application code Mejorar el código de aplicación Automating design reviews with FxCop and Visual Studio Analysis Automatización de revisiones de diseño con FxCop y Visual Studio Análisis Eliminating code duplication through refactoring to design patterns La eliminación de la duplicación de código a través de la refactorización para los patrones de diseño << Back to Visual Studio and .NET Course List <<Volver a Visual Studio y. NET Listado de cursos Related Courses Cursos relacionados Building Web Applications with ASP.NET and Ajax - Course 506 Construyendo Aplicaciones Web con ASP.NET y Ajax - Curso 506 ASP.NET WebForms Comprehensive Introduction - Course 512 ASP.NET WebForms Integral Introducción - Curso 512 Building Web Applications with ASP.NET MVC - Course 977 Construyendo Aplicaciones Web con ASP.NET MVC - Curso 977 .NET 4 Programming - Course 2620 . NET 4 Programación - Curso 2620 WPF and Silverlight Introduction - Course 975 WPF y Silverlight Introducción - Curso 975 .NET Web Services Introduction - Course 2601 . Servicios Web NET Introducción - Curso 2601 Programming C# Extended Features - Course 973 De programación C # extendido Características - Curso 973 Programming SharePoint 2010 Applications with .NET - Course 2615 Programación de aplicaciones con SharePoint 2010 -. NET Curso 2615 Windows Azure - Course 2602 Windows Azure - Curso 2602 Course Dates Fechas del curso Attend highlighted events Asistir a eventos destacó in person or online with Learning Tree AnyWare TM . en persona o en línea con Learning Tree AnyWare TM. Feb 8-11 Feb. 8 hasta 11 Reston, VA enroll Reston, VA inscribirse Apr 5-8 5to al 8vo 04 Toronto enroll Toronto inscribirse Apr 19-22 19 a 22 ab. Boston (Waltham) enroll Boston (Waltham) inscribirse Apr 26-29 04 26ta al 29o New York enroll Nueva York inscribirse May 10-13 10 al 13 mayo Los Angeles enroll Los Angeles inscribirse May 10-13 10 al 13 mayo Ottawa enroll Ottawa inscribirse May 17-20 17 al 20 mayo Rockville, MD enroll Rockville, MD inscribirse May 24-27 Mayo 24-27 Chicago (Schaumburg) enroll Chicago (Schaumburg) inscribirse May 31-Jun 3 31 mayo a 3 junio Reston, VA enroll Reston, VA inscribirse Jun 7-10 07 al 10 junio New York enroll Nueva York inscribirse For AnyWare enrollments, please register at least 10 days prior to the start of the course. Para inscripciones AnyWare, por favor regístrese al menos 10 días antes del inicio del curso. More Dates and Locations . Más fechas y lugares . On-Site & En las instalaciones y Custom Training Formación personalizada Bring this or any Learning Tree course to your location or have it customized for your organization. Llevar este o cualquier otro árbol curso de aprendizaje a su ubicación o la han personalizado para su organización. Tuition Matrícula $ 2,890 $ 2.890 Standard Tuition Norma de matrícula Tuition with a Savings Plan Matrícula con un Plan de Ahorro $ 1,700 $ 1.700 Premium-Pass Premium-Pass $ 1,733 1.733 dólares Training Passport Pasaporte de formación $ 2,250 $ 2.250 Voucher 10-Pack Vale 10-Pack $ 2,573 $ 2.573 Government Discount Gobierno de descuento $ 2,600 $ 2.600 Alumni Gold Discount Antiguos Alumnos de descuento de Oro Alumni Gold Discount Attend your first course and you will receive a personalized Alumni Gold Discount card, entitling you to save as much as $320 on each course you take within the following 12 months.Alumni Gold Discount Attend your first course and you will receive a personalized Alumni Gold Discount card, entitling you to save as much as $320 on each course you take within the following 12 months.Federal, State and Local Government Federal, State and Local Government employees can take advantage of government discount pricing for Learning Tree Courses.Federal, State and Local Government Federal, State and Local Government employees can take advantage of government discount pricing for Learning Tree Courses.Training Vouchers With Vouchers, any members of your team can attend any Learning Tree Course anytime. Available in 5- and 10-Course Packs or larger, each Voucher is valid for 12 months and is used in lieu of the tuition for any Learning Tree Public Course.Training Vouchers With Vouchers, any members of your team can attend any Learning Tree Course anytime. Available in 5- and 10-Course Packs or larger, each Voucher is valid for 12 months and is used in lieu of the tuition for any Learning Tree Public Course.Training Passport As a Training Passport holder, one person can take as many as three hands-on courses in 12 months for as little as $1,733 per course.Only $5,200 - save as much as 45%.Training Passport As a Training Passport holder, one person can take as many as three hands-on courses in 12 months for as little as $1,733 per course.Only $5,200 - save as much as 45%.Premium Pass The NEW Premium Pass gives you more time to take more courses while saving more money! Take 4 courses within 24 months for as little as $1,700 per course — at a price of only $6,790, you can SAVE as much as 45% per course.Premium Pass The NEW Premium Pass gives you more time to take more courses while saving more money! Take 4 courses within 24 months for as little as $1,700 per course — at a price of only $6,790, you can SAVE as much as 45% per course.<br />