Patrón de diseño: análisis de esquemas similares pero diferentes en archivos de texto

Question

gracias de antemano por su ayuda. Me pregunto si hay un patrón (de diseño) que pueda aplicarse a este problema.

Estoy buscando analizar, procesar y extraer valores de archivos de texto con formatos similares pero diferentes.

Más específicamente, estoy creando un motor de procesamiento que acepta archivos de historial de manos de póker en línea de una multitud de sitios web diferentes y analiza campos de datos específicos (número de mano, fecha y hora, jugadores). Necesitaré que la lógica para analizar los archivos sea ligeramente diferente para cada formato, pero el procesamiento de los valores extraídos será el mismo.

Mi primer pensamiento sería crear solo 1 clase que acepte un " esquema " para cada tipo de archivo y analiza / procesa en consecuencia. Estoy seguro de que hay una mejor solución para esto.

¡Gracias!

Punto de bonificación: Cualquier sugerencia de implementación específica en C #.

Answer 1

Esto suena como un candidato para el patrón de Estrategia. Se puede encontrar un ejemplo en C # aquí y otro aquí . Una breve descripción está disponible en Wikipedia .

Hay descripciones más completas disponibles en el libro de Fowler y Kerievsky .

También está disponible en el libro GoF.

Answer 2

El " Proveedor " patrón es el que estás buscando ... es lo que se usa en ADO.Net. Cada proveedor de base de datos tiene un "Proveedor" de datos separado. que "sabe" cómo leer los datos de su producto específico de proveedores de bases de datos, pero entregarlos en un formato estándar (interfaz) a los sistemas posteriores ... Deberá escribir un pequeño "Proveedor". componente (una sola clase será suficiente) que "sabe" el formato para cada uno de los diferentes proveedores de datos de historial de póker de su sitio web, y expone esos datos exactamente de la misma manera al sistema ascendente que los lee ...

Answer 3

Parece que necesita el patrón de estrategia, que le permite implementar un algoritmo de diferentes maneras:

http://en.wikipedia.org/wiki/Strategy_pattern

Answer 4

Primero, crea tu " Historial de manos de póker en línea " modelo . Este modelo representará los datos y podrá procesar estos datos independientemente de la fuente. Luego, cree proveedores para cada uno de los diferentes formatos de origen que deben ser capaces de convertir la información del archivo en el modelo.

EDITAR: por ejemplo,

public interface IDataProvider
{
    IOnlinePokerInfo ParseFileInformation(FileInfo input);
}

public interface IOnlinePokerInfo
{
    int Hand { get; set; }
    DateTime DateInfo { get; set; }
    List<IPlayer> Players { get; set; }
    void ProcessInformation();
}

public interface IPlayer
{
    string Name { get; set; }
}

public class MyOnlinePokerInfo : IOnlinePokerInfo
{
    private int hand;
    private DateTime date;
    private List<IPlayer> players;

    public int Hand { get { return hand; } set { hand = value; } }
    public DateTime DateInfo { get { return date; } set { date = value; } }
    public List<IPlayer> Players { get { return players; } set { players = value; } }

    public MyOnlinePokerInfo(int hand, DateTime date)
    {
        this.hand = hand;
        this.date = date;
        players = new List<IPlayer>();
    }

    public MyOnlinePokerInfo(int hand, DateTime date, List<IPlayer> players)
        : this(hand, date)
    {
        this.players = players;
    }

    public void AddPlayer(IPlayer player)
    {
        players.Add(player);
    }

    public void ProcessInformation()
    {
        Console.WriteLine(ToString());
    }

    public override string ToString()
    {
        StringBuilder info = new StringBuilder("Hand #: " + hand + " Date: " + date.ToLongDateString());
        info.Append("\nPlayers:");
        foreach (var s in players)
        {
            info.Append("\n"); 
            info.Append(s.Name);
        }
        return info.ToString();
    }
}

public class MySampleProvider1 : IDataProvider
{
    public IOnlinePokerInfo ParseFileInformation(FileInfo input)
    {
        MyOnlinePokerInfo info = new MyOnlinePokerInfo(1, DateTime.Now);
        IPlayer p = new MyPlayer("me");
        info.AddPlayer(p);
        return info;
    }
}

public class MySampleProvider2 : IDataProvider
{
    public IOnlinePokerInfo ParseFileInformation(FileInfo input)
    {
        MyOnlinePokerInfo info = new MyOnlinePokerInfo(2, DateTime.Now);
        IPlayer p = new MyPlayer("you");
        info.AddPlayer(p);
        return info;
    }
}

public class MyPlayer : IPlayer
{
    private string name;
    public string Name { get { return name; } set { name = value; } }

    public MyPlayer(string name)
    {
        this.name = name;
    }
}

public class OnlinePokerInfoManager
{
    static void Main(string[] args)
    {
        List<IOnlinePokerInfo> infos = new List<IOnlinePokerInfo>();

        MySampleProvider1 prov1 = new MySampleProvider1();
        infos.Add(prov1.ParseFileInformation(new FileInfo(@"c:\file1.txt")));

        MySampleProvider2 prov2 = new MySampleProvider2();
        infos.Add(prov2.ParseFileInformation(new FileInfo(@"c:\file2.log")));

        foreach (var m in infos)
        {
            m.ProcessInformation();
        }
    }
}

Answer 5

También podría considerar usar el Patrón de comando donde tendría una Acción para alcanzar el tiempo del tipo de archivo que necesita procesar. De esta manera, puede tener flexibilidad para todos los formatos y cumplir con los parámetros consistentes que requerirá su proceso.

Otra ventaja es que puede crear nuevas acciones para cada nuevo formato de archivo sin refactorizar el código para los otros formatos.