texto - read file c#

Patrón de diseño: analizar esquemas similares pero diferentes en archivos de texto

Question

Gracias de antemano por tu 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 construyendo un motor de procesamiento que acepta archivos de Historial de manos de Poker en línea de una multitud de diferentes sitios web y analiza campos de datos específicos (Hand #, DateTime, Players). Necesitaré la lógica para analizar los archivos para que sean ligeramente diferentes para cada formato, pero el procesamiento de los valores extraídos será el mismo.

Lo primero que pensé fue crear solo 1 clase que aceptara un "esquema" para cada tipo de archivo y analizara / procesara en consecuencia. Estoy seguro de que hay una mejor solución para esto.

¡Gracias!

Punto de bonificación: cualquier implementación específica insinúa en C #.

Answer 1

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

Answer 2

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

Descripciones más completas están disponibles en el libro de Fowler y Kerievsky .

También está disponible en el libro de GoF.

Answer 3

Parece que necesitas el patrón de Estrategia, que te permite implementar un algoritmo de diferentes maneras:

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

Answer 4

Primero, crea tu modelo de "Historial de manos de póker en línea". 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 los parámetros consistentes que requerirá su proceso.

Otro beneficio es que puede crear nuevas Acciones para cada nuevo formato de archivo sin refactorizar el código para los otros formatos.