Come dovrei separare le classi di analisi dei file?

Question

Come dovrei separare le classi di analisi dei file?

#1 da (1 voti)

0

Voglio capire diversi modi per oggettare le classi di progettazione. Ho tre classi diverse. Generalmente sto creando un parser di file.

Le classi:

Dati cliente - che mostra il modello di dati del testo.
Un parser di file, che preleva i dati dal file e li inserisce nell'elenco generico
E lettore di cartelle, che eseguirà FileParse per tutti i file in una directory

Devo separare tutto in classi diverse, combinare le classi 1 e 2 o avere tutto in una classe unita per sotto. Qual è il metodo dell'architetto software? Se non c'è una risposta, quali requisiti o principi aziendali dovrei usare per prendere questa decisione? Penserei che "Principio della singola responsabilità" affermi che dovrebbero essere nella propria classe, o è solo per le funzioni?

    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Text;

    namespace ParseTest
    {
    public class Customer
    {

        public class CustomerData
        {
            // These are the column names in customerdata txt:
            public int CustomerId { get; set; }
            public string CustomerName { get; set; }
            public string CustomerState { get; set; }
            public int ProductId { get; set; }
            public int QuantityBought { get; set; }
        }

        public List<CustomerData> GetCustomer(string filename)
        {
            List<CustomerData> customerdata = new List<CustomerData>();
            //const String CustomerBase = @"C:\Users\Desktop\ParseFile\sample.txt";

            string CustomerBase = filename;

            String fileToLoad = String.Format(CustomerBase);
            using (StreamReader r = new StreamReader(fileToLoad))
            {
                string line;
                while ((line = r.ReadLine()) != null)
                {
                    string[] parts = line.Split(',');
                    // Skip the column names row
                    if (parts[0] == "id") continue;
                    CustomerData dbp = new CustomerData();
                    dbp.CustomerId = Convert.ToInt32(parts[0]);
                    dbp.CustomerName = parts[1];
                    dbp.CustomerState = parts[2];
                    dbp.ProductId = Convert.ToInt32(parts[3]);
                    dbp.QuantityBought = Convert.ToInt32(parts[4]);
                    customerdata.Add(dbp);
                }
            }
            return customerdata;
        }

        public List<CustomerData> GetAllCustomer(string directoryname)
        {

            List<CustomerData> AllFileCustomerData = new List<CustomerData>();

            foreach (string filename in Directory.EnumerateFiles(directoryname, "*.txt"))
            {
                List<CustomerData> customerdata = new List<CustomerData>();
                customerdata = GetCustomer(filename);
                AllFileCustomerData.AddRange(customerdata);

            }
            return AllFileCustomerData;
        }

    }
}

c# file-handling class-design

posta CarSpeed87 22.09.2018 - 05:13

fonte

1 risposta

Leggi altre domande sui tag c# file-handling class-design

Wrapping del client WCF con Stream per lo smaltimento ReactJS - modo corretto di gestire un approccio di progettazione reattivo?

score 1 · Answer 1

Come prospettiva dell'architettura la soluzione ideale è separare il tuo modello da un altro codice in modo da avere una classe chiamata CustomerModel.cs:

public class CustomerModel
{
    // These are the column names in customerdata txt:
    public int CustomerId { get; set; }
    public string CustomerName { get; set; }
    public string CustomerState { get; set; }
    public int ProductId { get; set; }
    public int QuantityBought { get; set; }
}

Quindi la migliore implementazione è un'interfaccia che consente di implementare altri parser di file, se necessario, IFileParser.cs:

public interface IFileParser
{
    List<T> ParseFiles<T>(string[] filePath);
    List<T> ParseDirectory<T>(string directoryPath);
}

Implementa il parser dei file dei tuoi clienti come di seguito, CustomerParser.cs

class CustomerParser : IFileParser
{
    public List<T> ParseFiles<T>(string[] filePath)
    {
        List<CustomerModel> allFileCustomerData = new List<CustomerModel>();

        //string[] customerBase = { @"C:\Users\Ritwik\Desktop\ParseFile\sample.txt"};

        string[] customerBase = filePath;

        foreach (string customerFile in customerBase)
        {
            String fileToLoad = String.Format(customerFile);
            using (StreamReader r = new StreamReader(fileToLoad))
            {
                string line;
                while ((line = r.ReadLine()) != null)
                {
                    string[] parts = line.Split(',');
                    // Skip the column names row
                    if (parts[0] == "id") continue;

                    CustomerModel dbp = new CustomerModel
                    {
                        CustomerId = Convert.ToInt32(parts[0]),
                        CustomerName = parts[1],
                        CustomerState = parts[2],
                        ProductId = Convert.ToInt32(parts[3]),
                        QuantityBought = Convert.ToInt32(parts[4])
                    };

                    allFileCustomerData.Add(dbp);
                }
            }
        }

        return new List<T>(allFileCustomerData as IEnumerable<T> ?? throw new InvalidOperationException());
    }

    public List<T> ParseDirectory<T>(string directoryPath)
    {
        string[] customerFiles = Directory.GetFiles(directoryPath, "*.txt");
        return ParseFiles<T>(customerFiles);
    }

E la tua soluzione dovrebbe essere qualcosa del tipo: