estructurales - ¿Qué patrones de diseño se utilizan en todo.NET Framework?

patrones de diseño pdf

Question

¿Qué clases de .NET Framework implementan los distintos patrones de diseño, como decorador, fábrica, etc.?

Answer 1

Además, NullObject

• String.Empty;
• EventArgs.Empty;

Answer 2

Algunos más patrones de diseño GoF implementados en el marco .Net:

Fachada - Interfaz de nivel superior a un conjunto de interfaces en un subsistema

MessageBox (System.Windows.Forms): proporciona una interfaz de alto nivel reutilizable para algunas de las interfaces de Windows Forms, en lugar de escribir una gran cantidad de código para presentar un cuadro de diálogo al que solo puede llamar MessageBox.Show("Hello world"); .

Esto también se menciona en Design Patterns in C # por Steven John Metsker:

La clase MessageBox es uno de los pocos ejemplos de una fachada en la FCL. Es digno de producción, configurable y diseñado para su reutilización. Por encima de todo, la clase MessageBox cumple con la intención del patrón FACADA al proporcionar una interfaz simple que facilita la visualización de los cuadros de diálogo.

Si desea saber más, consulte el código fuente de MessageBox

Peso de mosca : uso compartido para admitir grandes cantidades de objetos de grano fino de manera eficiente.

El marco .Net utiliza String Interning para ahorrar memoria en cadenas idénticas, esta es una implementación del patrón de peso mosca. Este video de Curtis Lassam hace un gran trabajo al explicar String Interning.

También puede forzar el internado de cadenas llamando a String.Intern("Hello world"); .

Answer 3

Bueno, lo que está pidiendo es probablemente una lista MUY extensa, ya que los patrones de diseño se utilizan en toda la plataforma .NET. Aquí hay algunos ejemplos que se me ocurren de la cabeza:

Adaptador

El patrón de adaptador , un mecanismo común de sistemas y plataformas de puente, se implementa de varias formas en el marco .NET. Uno de los ejemplos más prevalentes de esto en .NET son las envolturas en tiempo de ejecución, o RCW''s. Los RCW, generados con el programa tlbimp.exe , proporcionan adaptadores que permiten que el código administrado de .NET llame fácilmente al código COM heredado a través de una API de .NET.

Método de fábrica

El patrón de método de fábrica es probablemente uno de los patrones más conocidos. Se implementa con bastante frecuencia en todo el marco .NET, especialmente en tiempos primitivos, pero también en muchos otros. Un excelente ejemplo de este patrón en el marco es la clase Convert, que proporciona una gran cantidad de métodos para crear primitivas comunes a partir de otras primitivas comunes.

Además, otra forma generalizada de este patrón son los métodos .Parse () y .TryParse () que se encuentran en muchos tipos primitivos y básicos.

Iterador

El patrón de iterador se implementa a través de un par de interfaces y algunas construcciones de lenguaje, como foreach y la palabra clave yeild en C #. La interfaz IEnumerable y su contraparte genérica se implementan mediante docenas de colecciones en el marco .NET, lo que permite una iteración fácil y dinámica de una gran variedad de conjuntos de datos:

IEnumerable<T>
IEnumerator<T>

foreach(var thing in someEnumerable)
{
   //
}

La palabra clave yeild en C # permite realizar la verdadera forma de un iterador , solo incurrir en el costo de procesar una iteración a través de un bucle cuando se exige esa iteración:

IEnumerable<string> TokenizeMe(string complexString)
{
    string[] tokens = complexString.Split('' '');
    foreach (string token in toekens)
    {
        yield return token;
    }
}

Constructor

El patrón Builder se implementa varias veces en el marco .NET. Un par de notas son los constructores de cadenas de conexión. Las cadenas de conexión pueden ser una cosa delicada, y construirlas dinámicamente en tiempo de ejecución a veces puede ser una molestia. Las clases de Connection String Builder demuestran el patrón de constructor idealmente:

string connectionString = new SqlConnectionStringBuilder
{
    DataSource = "localhost",
    InitialCatalog = "MyDatabase",
    IntegratedSecurity = true,
    Pooling = false
}.ConnectionString;

Otras clases en todo el marco .NET, como UriBuilder, también implementan el patrón de creación.

Observador

El patrón de observador es un patrón común que permite que una clase vea eventos de otra. A partir de .NET 4, este patrón se admite de dos maneras: a través de eventos integrados en el idioma (observadores estrechamente acoplados), y a través de las interfaces IObservable / IObserver (eventos no vinculados).

Los events lenguaje clásico hacen uso de delegados , o punteros de función fuertemente tipados, para rastrear devoluciones de llamadas de eventos en propiedades de eventos . Un evento, cuando se activa, ejecutará cada una de las devoluciones de llamada rastreadas en secuencia. Eventos como este se utilizan de forma generalizada en todo el marco .NET.

public class EventProvider
{
    public event EventHandler SomeEvent;

    protected virtual void OnSomeEvent(EventArgs args)
    {
        if (SomeEvent != null)
        {
            SomeEvent(this, args); // Trigger event
        }
    }
}

public class EventConsumer
{
    public EventConsumer(EventProvider provider)
    {
        provider.SomeEvent += someEventHandler; // Register as observer of event
    }

    private void someEventHandler(EventArgs args)
    {
        // handle event
    }
}

Lo nuevo con el framework .NET 4 son eventos débilmente acoplados. Estos se logran mediante la implementación de las IObservable<out T> e IObserver<in T> , que son más compatibles con el patrón de diseño original de Observer . Aunque no estoy implementado directamente por ningún tipo de marco .NET que conozca, la infraestructura central para el patrón es una parte integral de .NET 4.

public class SomethingObservable: IObservable<SomethingObservable>
{
    private readonly List<IObserver<SomethingObservable>> m_observers;

    public IDisposable Subscribe(IObserver<SomethingObservable> observer)
    {
        if (!m_observers.Contains(observer))
        {
            m_observers.Add(observer);
        }
        var unsubscriber = new Unsubscriber(m_observers, observer)
        return unsubscriber;        
    }

    private class Unsubscriber: IDisposable
    {
        public Unsubscriber(IList<IObserver<SomethingObservable>> observers, IObserver<SomethingObservable> observer)
        {
            m_observers = observers;
            m_observer = observer;
        }

        private readonly IList<IObserver<SomethingObservable>>  m_observers;
        private readonly IObserver<SomethingObservable> m_observer;

        public void Dispose()
        {
            if (m_observer == null) return;
            if (m_observers.Contains(m_observer))
            {
                m_observers.Remove(m_observer);
            }
        }
    }
}

Decorador

El patrón decorador es una forma de proporcionar representaciones o formas alternativas de comportamiento a través de un solo tipo de base. Muy a menudo, se requiere un conjunto común de funcionalidades, pero la implementación real de esa funcionalidad debe cambiar. Un excelente ejemplo de esto en el marco .NET es la clase Stream y sus derivados. Todas las secuencias en .NET proporcionan la misma funcionalidad básica, sin embargo, cada secuencia funciona de manera diferente.

• Corriente
  • MemoryStream
  • BufferedStream
  • FileStream
    • AisladoAlmacenamientoFileStream
  • PipeStream
    • AnonymousPipeClientStream
    • AnonymousPipeServerStream
    • NamedPipeClientStream
    • NamedPipeServerStream
  • CryptoStream
  • GZipStream

Muchos, muchos otros patrones de diseño se utilizan dentro del marco .NET. Casi todos los aspectos de .NET, desde el lenguaje al marco hasta los conceptos fundamentales de tiempo de ejecución, se basan en patrones de diseño comunes. Partes significativas del marco .NET, como ASP.NET, son en sí mismos patrones. Tomemos, por ejemplo, el marco MVC de ASP.NET, que es una implementación de la variante web de MVC, o Model-View-Controller . Los marcos de la interfaz de usuario de WPF y Silverlight admiten directamente un patrón llamado MVVM o Model-View-ViewModel . El canal de ASP.NET en sí mismo es una colección de patrones, que incluye el filtro de intercepción , el controlador de página , el enrutador , etc. Finalmente, uno de los patrones más utilizados, la composición , se usa tanto en el marco de .NET que probablemente sea uno de Los patrones más fundamentales de todo el marco.

Answer 4

La parte superior de mi cabeza :

• El patrón Abstract Factory se usa en la infraestructura ADO.NET 2.0 (clase DbProviderFactory )
• El patrón de Método de plantilla se usa en muchas partes del marco (WinForms, WPF ...)
• El patrón Builder también se usa con bastante frecuencia ( DbConnectionStringBuilder , UriBuilder ...)
• Creo que las instancias predefinidas (propiedades estáticas) de StringComparer , Encoding , Color , etc. son una variante del patrón de Prototipo.
• El patrón Proxy está en todas partes cuando usas .NET remoting
• Los eventos son una variante del patrón Observer.
• El patrón Iterator se utiliza en colecciones.
• El patrón de estrategia se utiliza, por ejemplo, en clases de criptografía.

Probablemente hay más ejemplos, pero eso es todo lo que puedo pensar en este momento ...

Answer 5

Patrón de proveedor : se utiliza en MembershipProvider , RoleProvider , RoleProvider .

Answer 6

Prototipo : especifique el tipo de objetos para crear usando una instancia prototípica y cree nuevos objetos copiando este prototipo.

ICloneable interfaz ICloneable con el método Clone () es un ejemplo clásico de prototipo.

Answer 7

• Patrón de visitante en ExpressionVisitor clase ExpressionVisitor (espacio de nombres Syste.Linq.Expression ).
• Patrón de adaptador en System.Web.Abstractions : envuelva varias clases web ( HttpRequest , HttpResponse ) de una manera más unitaria y verificable, es decir, HttpResponseBase .
• Método de fábrica - Activator.CreateInstance - crea una instancia del objeto especificado.
• Patrón de iterador - todas las implementaciones de IEnumerable .