Recomendación de patrones de diseño para la opción de filtro

Question

Estoy pensando en crear un objeto de filtro que filtre y elimine todo, como las etiquetas html de un contexto. Pero quiero que sea independiente, lo que significa que el patrón de diseño que puedo aplicar me ayudará a agregar más filtros en el futuro sin afectar los códigos actuales. Pensé en Abstract Factory, pero parece que no va a funcionar como quiero. Así que tal vez constructor, pero se ve igual. No sé, estoy un poco confundido, alguien me recomiende un patrón de diseño que pueda resolver mi problema, pero antes de eso déjenme explicar el problema un poco.

Digamos que tengo una clase que tiene descripción de campo o propiedad. Y necesito filtros que eliminen las cosas que quiero de esta propiedad de Descripción. Entonces, cada vez que aplico el filtro, puedo agregar más filtro en el nivel subyacente. Entonces, en lugar de volver a tocar el campo Descripción, puedo agregar fácilmente más filtros y todos los filtros se ejecutarán para el campo Descripción y eliminaré lo que se supone que deben eliminar del contexto Descripción.

Espero poder describir mi problema. Creo que algunos de ustedes se encontraron con la misma situación antes.

Gracias de antemano ...

Editar:

realmente quiero crear filtros como los tipos/clases en lugar de los métodos regulares o lo que sea. Me gusta:

class TextFilter : IFilter 
{ 
    private string something; 
    public string Awesome {get;set;} 
    public string FilterYo(string textFiltered) 
    { 
     // Do filtering 
    } 
} 

class HtmlFilter : IFilter 
{ 
    private string something; 
    private string iGotSomething; 
    public string Awesome {get;set;} 
    public string FilterYo(string textFiltered) 
    { 
     // Do filtering 
    } 
} 

class Main 
{ 
    protected void Main(object sender, EventArgs e) 
    { 
     InputClass input = new InputClass(); 
     string filtered = new StartFiltering().Filter(input.Description); // at this moment, my input class shouldn't know anything about filters or something. I don't know if it makes any sense but this is what in my mind. 
    } 
} 

En este punto si quiero aplicar Abstract Factory que no tendría sentido o también Builder. Porque no quiero una cosa en particular, los necesito a todos un poco.

Gracias por sus respuestas, por cierto.

Edición 2 - Posible respuesta para mí

bien permite pensar patrón de estrategia con interfaces en lugar de los delegados.

interface IFilter //Strategy interface 
{ 
    string Filter(string text); 
} 

class LinkFilter:IFilter //Strategy concrete class 
{ 
    public string Filter(string text) 
    { 
    //filter link tags and return pure text; 
    } 
} 

class PictureFilter:IFilter //Strategy concrete class 
{ 
    public string Filter(string text) 
    { 
    //filter links and return pure text; 
    } 
} 

class Context 
{ 
    private IFilter _filter; 
    private string _text; 
    public Context(IFilter filter,string text) 
    { 
     this._filter = filter; 
     this._text = text; 
    } 

    public void UpdateFilter(IFilter filter) 
    { 
     this._filter = filter; 
    } 

    public string RunFilter() 
    { 

    this._text = _filter.Filter(this._text); 
    return this._text; 
    } 
} 

class MainProgram 
{ 
    static void Main() 
    { 
     MyObject obj = new MyObject(); 
     LinkFilter lfilter = new LinkFilter(); 
     PictureFilter pfilter = new PictureFilter(); 
     Context con = new Context(lfilter,obj.Description); 
     string desc = con.RunFilter(); 
     con.UpdateFilter(pfilter); 
     desc = con.RunFilter(); 
    } 
} 

Answer 1

¿Has visto strategy pattern? Te permite intercambiar algoritmos.

Si eso no es lo que está buscando, quizás el decorator pattern sea más adecuado. Esto le permitirá ajustar filtros y aplicar varios si es necesario.

Answer 2

Para mí esto suena como el patrón Strategy.

podría ser algo como esto (el código está en VB):

 Function GetFilteredDescription(ByVal iSpecificFilterFunction As AbstractFilterFunction) As Result 
      Return iSpecificFilterFunction.Filter(Me.description) 
     End Function 

Nota: el GetFilteredDescription es función miembro de la clase.

Answer 3

Puede utilizar a continuación patrones:

• patrón de estrategia para los diferentes tipos de filtros
• cadena de responsabilidad para su pila de filtros (Usted puede agregar Patrón de comandos aquí por diferentes cadenas en un entorno multitarea, o puede implementar cadena basada en prioridad, etc.)
• Builder o Abstract Factory para crear instancias de filtros.

Answer 4

¿Qué ocurre con el patrón de proveedor? http://msdn.microsoft.com/en-us/library/ms972319.aspx

Es similar a Strategy, y se usa a fondo en productos de Microsoft.

Answer 5

¿Por qué no acaba de ir de peso ligero: defina su filtro como Func<string, string>. Si se mantiene esto en una colección (List<Func<string, string>>), que sólo puede hacer:

var text = myObject.DescriptionProperty 
foreach (var func in myFuncList) 
{ 
    text = func(text); 
} 

También puede utilizar LINQ para acortar el bucle de arriba:

var text = myFuncList.Aggregate(text, (seed, func) => func(seed)); 

esta manera, usted no tiene que define una jerarquía de clase para filtrar. Esto es bueno para el medio ambiente, ya que nos estaremos quedando sin clases y espacios de nombres muy pronto.

para envolver las cosas, te sugieren Lista subclase:

public class FilterCollection : List<Func<string, string>> 
{ 
    public string Filter(string text) 
    { 
     return this.Aggregate(text, (seed, func) => func(seed)); 
    } 
}