Exportar objetos em vários formatos enquanto relata o progresso

Aug 18 2020

Descrição

Um aplicativo WinForms tem a função de exportar objetos dos seguintes tipos, em vários formatos:

class Item
{
    public int id { get; set; }
    public string description { get; set; }
}

Com o clique de um botão em uma janela, um SaveFileDialogé mostrado, e atualmente oferece a opção de salvar os dados no formato .txt, .csv ou .xlsx. Como às vezes existem centenas ou milhares de objetos e a IU não deve congelar, um Taské usado para executar esta operação. Esta implementação funciona, mas pode ser melhorada.

Código

public partial class ExportWindow : Form
{
    // objects to be exported
    List<Item> items;

    // event handler for the "Export" button click
    private async void exportButton_click(object sender, System.EventArgs e)
    {
        SaveFileDialog exportDialog = new SaveFileDialog();
        exportDialog.Filter = "Text File (*.txt)|*.txt|Comma-separated values file (*.csv)|*.csv|Excel spreadsheet (*.xlsx)|*.xlsx";
        exportDialog.CheckPathExists = true;
        DialogResult result = exportDialog.ShowDialog();
        if (result == DialogResult.OK)
        {
            var ext = System.IO.Path.GetExtension(saveExportFileDlg.FileName);

            try
            { 
                // update status bar
                // (it is a custom control)
                statusBar.text("Exporting");

                // now export it
                await Task.Run(() =>
                {
                    switch (ext.ToLower())
                    {
                        case ".txt":
                            saveAsTxt(exportDialog.FileName);
                            break;

                        case ".csv":
                            saveAsCsv(exportDialog.FileName);
                            break;
                    
                        case ".xlsx":
                            saveAsExcel(exportDialog.FileName);
                            break;

                        default:
                            // shouldn't happen
                            throw new Exception("Specified export format not supported.");
                    }
                });
            }
            catch (System.IO.IOException ex)
            {
                 statusBar.text("Export failed");
                 logger.logError("Export failed" + ex.Message + "\n" + ex.StackTrace);

                 return;
            }
        }
    }

    private delegate void updateProgressDelegate(int percentage);

    public void updateProgress(int percentage)
    {
        if (statusBar.InvokeRequired)
        {
            var d = updateProgressDelegate(updateProgress);
            statusBar.Invoke(d, percentage);
        }
        else
        {
            _updateProgress(percentage);
        }
    }

    private void saveAsTxt(string filename)
    {
        IProgress<int> progress = new Progress<int>(updateProgress);
        
        // save the text file, while reporting progress....
    }

    private void saveAsCsv(string filename)
    {
        IProgress<int> progress = new Progress<int>(updateProgress);
        
        using (StreamWriter writer = StreamWriter(filename))
        {
            // write the headers and the data, while reporting progres...
        }
    }

    private void saveAsExcel(string filename)
    {
        IProgress<int> progress = Progress<int>(updateProgress);

        // EPPlus magic to write the data, while reporting progress...
    }
}

Questões

Como isso pode ser refatorado para torná-lo mais extensível? Ou seja, se eu quisesse adicionar suporte para mais tipos de arquivo, torná-lo fácil e rápido de modificar. A instrução switch pode ficar muito longa. Essencialmente, como cumprir o princípio Aberto / Fechado?

Respostas

5 CharlesNRice Aug 18 2020 at 20:04

Eu sugeriria mover as exportações reais para sua própria classe. Podemos criar uma interface para exportação. Algo na linha de

public interface IExport<T>
{
    Task SaveAsync(string fileName, IEnumerable<T> items, IProgress<int> progress = null);
    string ExportType { get; }
}

Então, cada tipo de exportação pode implementar essa interface.

public class ExportItemsToText : IExport<Item>
{
    public Task SaveAsync(string fileName, IEnumerable<Item> items, IProgress<int> progress = null)
    {
        throw new NotImplementedException();
    }

    public string ExportType => "txt";
}

Então, em seu construtor de ExportWindow

public ExportWindow(IEnumerable<IExport<Item>> exports)
{
    // if using DI otherwise could just fill in dictionary here
    ExportStrategy = exports.ToDictionary(x => x.ExportType, x => x);
}

Em vez de uma instrução switch, agora você pode apenas procurar a chave no dicionário para encontrar qual exportação deve ser executada e, se não encontrada, seria o mesmo que o caso padrão.

IExport<Item> exporter;
if (ExportStrategy.TryGetValue(ext.ToLower(), out exporter))
{
    await exporter.SaveAsync(exportDialog.FileName, items, new Progress<int>(updateProgress))
}
else
{
    throw new Exception("Specified export format not supported.");
}

Agora, no futuro, se adicionar suporte para mais tipos, você apenas implementa a interface e atualiza seu contêiner DI. Ou, se não estiver usando DI, será necessário adicioná-lo ao construtor de ExportWindow.

Não acho que seja uma boa ideia, mas se você realmente não quiser criar uma classe por exportação, o que eu acho que deveria, você poderia fazer o dicionário e IDictionary<string, Action<string>>então apenas colocar seus métodos lá e ao adicionar um novo tipo, crie o método e atualize o dicionário.

2 iSR5 Aug 21 2020 at 06:22

Só quero compartilhar o que tenho, pois já implementei isso (mais ou menos) em um dos meus projetos anteriores (era no ASP.NET), mas pode ser aplicado em qualquer outro ambiente. A implementação foi semelhante à sugestão CharlesNRice. No entanto, o requisito era ter apenas opções para exportar relatórios do sistema (que é usado apenas um modelo de relatório) para Pdf, Excel e Word com uma negociação de ter mais opções de exportação no futuro. Então foi assim que eu fiz:

Primeiro a interface:

public interface IExportTo<T>
{
    IExportTo<T> Generate();

    void Download(string fileName);

    void SaveAs(string fileFullPath);
}

então a classe de contêiner:

public class ExportTo : IDisposable
{
    private readonly IList<T> _source;

    public ExportTo(IList<T> source)
    {
        _source = source;
    }

    public ExportExcel Excel()
    {
        return new ExportExcel(_source);
    }

    public ExportPdf Pdf()
    {
        return new ExportPdf(_source);
    }
    
    public ExportWord Word()
    {
        return new ExportPdf(_source);
    }
    

    #region IDisposable

    private bool _disposed = false;

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    private void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                Dispose();
            }

            _disposed = true;
        }
    }


    ~ExportTo()
    {
        Dispose(false);
    }

    #endregion
}

Implementei uma classe para cada tipo de exportação, como podemos ver na classe acima. Vou compartilhar uma aula (vou simplificá-la a partir da aula real).

public sealed class ExportPdf : IExportTo<T>, IDisposable
{
    private readonly IList<T> _source;

    private ExportPdf() { }

    public ExportPdf(IList<T> source) : this() => _source = source ?? throw new ArgumentNullException(nameof(source));

    public IExportTo<T> Generate()
    {
        // some implementation 
        return this;
    }

    // another overload to generate by Id 
    public IExportTo<T> Generate(long reportId)
    {
        // do some work 
        return this;
    }

    // Download report as file 
    public void Download(string fileName)
    {
       // do some work 
    }

    public void SaveAs(string fileFullPath)
    {
        throw new NotImplementedException("This function has not been implemented yet. Only download is available for now.");
    }


    #region IDisposable

    private bool _disposed = false;

    public void Dispose()
    {   
        Dispose(true);
        GC.SuppressFinalize(this);
    }


    private void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                Dispose();
            }

            _disposed = true;
        }
    }


    ~ExportPdf()
    {
        Dispose(false);
    }

    #endregion
}

Downloade SaveAssão diferentes (não iguais). Downloadbaixaria o arquivo exportado, enquanto SaveAssalvaria a instância do objeto. Mas isso foi implementado assim porque as dependências usadas.

Agora o uso seria assim:

new ExportTo(someList)
.Pdf()
.Generate()
.Download(fileName);

É assim que implementei naquele projeto, poderia ser melhorado, mas para os requisitos de negócios é o suficiente.

Sempre que você precisar adicionar um novo tipo de exportação, basta criar uma nova sealedclasse e implementar IExportTo<T>, IDisposablenessa classe. Por fim, atualize a classe do contêiner com o novo tipo (adicione um método para abrir uma nova instância desse método) e você está pronto para prosseguir.