Exportar objetos em vários formatos enquanto relata o progresso
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
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.
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
}
Download
e SaveAs
são diferentes (não iguais). Download
baixaria o arquivo exportado, enquanto SaveAs
salvaria 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 sealed
classe e implementar IExportTo<T>, IDisposable
nessa 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.