Patrón de diseño para la importación de datos de varios tipos de origen y a varios tipos de destino

Tengo que diseñar y construir un script de importación (en C #) que pueda manejar lo siguiente:

• leer datos de varias fuentes (XML, XSLX, CSV)
• verifique los datos
• escribir los datos en varios tipos de objetos (cliente, dirección)

Los datos provendrán de varias fuentes, pero una fuente siempre tendrá un formato de importación (ya sea csv, xml, xslx). Los formatos de importación pueden variar de una fuente a otra. Se pueden agregar nuevos formatos de importación en el futuro. Los tipos de objetos de destino son siempre los mismos (cliente, direcciones y algunos más).

He estado pensando en usar genéricos y leí algo sobre el patrón de fábrica, pero soy un novato bastante grande en esta área, por lo que cualquier consejo es más que bienvenido.

¿Cuál es un patrón de diseño apropiado para resolver este problema?

Estás yendo por la borda con conceptos sofisticados fue demasiado pronto. Genéricos: cuando vea un caso, úselos, pero de lo contrario no se preocupe. Patrón de fábrica: demasiada flexibilidad (y confusión adicional) para esto todavía.

Mantenlo simple. Utiliza prácticas fundamentales.

1. Trate de imaginar las cosas comunes entre hacer una lectura para XML, una lectura para CSV lo que sea. Cosas como, siguiente disco, siguiente línea. Dado que se pueden agregar nuevos formatos, trate de imaginar la similitud que el formato a determinar tendría con los conocidos. Utilice esta característica común y defina una 'interfaz' o un contrato al que deben adherirse todos los formatos. Aunque se adhieren al terreno común, todos pueden tener sus reglas internas específicas.

2. Para validar los datos, intente proporcionar una forma de conectar fácilmente bloques de códigos de validación nuevos o diferentes. Nuevamente, intente definir una interfaz donde cada validador, responsable de un tipo particular de construcción de datos, se adhiera a un contrato.

3. Para crear las construcciones de datos, probablemente estará limitado por quien diseñe los objetos de salida sugeridos más que nada. Intente averiguar cuál es el siguiente paso para los objetos de datos, y ¿hay alguna optimización que pueda hacer al conocer el uso final? Por ejemplo, si sabe que los objetos se utilizarán en una aplicación interactiva, podría ayudar al desarrollador de esa aplicación al proporcionar 'sumas' o recuentos de los objetos u otro tipo de información derivada.

Yo diría que la mayoría de estos son patrones de plantilla o patrones de estrategia. Todo el proyecto sería un patrón Adaptador.

Lo obvio es aplicar el patrón de estrategia . Tenga una clase base genérica ReadStrategyy para cada formato de entrada una subclase como XmlReadStrategy, CSVReadStrategyetc. Esto le permitirá cambiar el procesamiento de importación independientemente del procesamiento de verificación y el procesamiento de salida.

Dependiendo de los detalles, también es posible mantener la mayoría de las partes de la importación genérica e intercambiar solo partes del procesamiento de entrada (por ejemplo, la lectura de un registro). Esto puede llevarlo al patrón Método de plantilla .

Un patrón adecuado para una utilidad de importación que puede necesitar extender en el futuro sería usar MEF: puede mantener bajo el uso de memoria cargando el convertidor que necesita sobre la marcha desde una lista perezosa, crear importaciones MEF decoradas con atributos que ayudan a seleccionar el convertidor adecuado para la importación que está intentando realizar y proporciona una manera fácil de separar las diferentes clases de importación.

Cada parte MEF se puede construir para satisfacer una interfaz de importación con algunos métodos estándar que convierten una fila del archivo de importación a sus datos de salida o anulan una clase base con la funcionalidad básica.

MEF es un marco para crear una arquitectura de complemento: es cómo se construyen Outlook y Visual Studio, todas esas extensiones encantadoras en VS son partes de MEF.

Para crear una aplicación MEF (Managed Extensability Framework) comience por incluir una referencia a System.ComponentModel.Composition

Defina interfaces para especificar qué hará el convertidor

public interface IImportConverter
{
    int UserId { set; }        
    bool Validate(byte[] fileData, string fileName, ImportType importType);
    ImportResult ImportData(byte[] fileData, string fileName, ImportType importType);
}

Esto se puede usar para todos los tipos de archivos que desea importar.

Agregue atributos a una nueva clase que defina lo que la clase "Exportará"

[Export(typeof(IImportConverter))]
[MyImport(ImportType.Address, ImportFileType.CSV, "4eca4a5f-74e0")]
public class ImportCSVFormat1 : ImportCSV, IImportConverter
{
 ...interface methods...
}

Esto definiría una clase que importará archivos CSV (de un formato particular: Format1) y tiene atributos personalizados que configuran Metadatos de atributos de exportación MEF. Repita esto para cada formato o tipo de archivo que desee importar. Puede establecer atributos personalizados con una clase como:

[MetadataAttribute]
[AttributeUsage(AttributeTargets.All, AllowMultiple = false)]
public class ImportAttribute : ExportAttribute
{
    public ImportAttribute(ImportType importType, ImportFileType fileType, string customerUID)
        : base(typeof(IImportConverter))
    {
        ImportType = importType;
        FileType = fileType;
        CustomerUID = customerUID;
    }

    public ImportType ImportType { get; set; }
    public ImportFileType FileType { get; set; }
    public string CustomerUID { get; set; }
}

Para usar realmente los convertidores MEF, debe importar las partes MEF que crea cuando se ejecuta su código de conversión:

[ImportMany(AllowRecomposition = true)]
protected internal Lazy<IImportConverter, IImportMetadata>[] converters { get; set; }
AggregateCatalog catalog = new AggregateCatalog();

catalog recopila las partes de una carpeta, el valor predeterminado es la ubicación de la aplicación.

converters es una lista perezosa de las partes MEF importadas

Luego, cuando sepa qué tipo de archivo desea convertir ( importFileTypey importType) obtenga un convertidor de la lista de partes importadas enconverters

var tmpConverter = (from x in converters
                    where x.Metadata.FileType == importFileType
                    && x.Metadata.ImportType == importType 
                    && (x.Metadata.CustomerUID == import.ImportDataCustomer.CustomerUID)
                    select x).OrderByDescending(x => x.Metadata.CustomerUID).FirstOrDefault();

if (tmpConverter != null)
{
     var converter = (IImportConverter)tmpConverter.Value;
     result = converter.ImportData(import.ImportDataFile, import.ImportDataFileName, importType);
....
}

La llamada a converter.ImportDatautilizará el código en la clase importada.

Puede parecer una gran cantidad de código y puede llevar un tiempo entender qué está pasando, pero es extremadamente flexible cuando se trata de agregar nuevos tipos de convertidor e incluso puede permitirle agregar nuevos durante el tiempo de ejecución.

¿Cuál es un patrón de diseño apropiado para resolver este problema?

Los modismos de C # implican usar el marco de serialización incorporado para hacer esto. Anota los objetos con metadatos y luego crea una instancia de diferentes serializadores que usan esas anotaciones para extraer datos para ponerlos en la forma correcta, o viceversa.

Xml, JSON y las formas binarias son las más comunes, pero no me sorprendería si ya existen otras en un buen paquete para que las consumas.