Экспорт объектов в различных форматах с отчетом о прогрессе
Описание
Приложение WinForms имеет функцию экспорта объектов следующего типа в различных форматах:
class Item
{
public int id { get; set; }
public string description { get; set; }
}
При нажатии кнопки в окне SaveFileDialogотображается значок , и в настоящее время он предоставляет возможность сохранить данные в формате .txt, .csv или .xlsx. Поскольку иногда существуют сотни или тысячи объектов и пользовательский интерфейс не должен зависать, Taskдля выполнения этой операции используется a . Эта реализация работает, но ее можно улучшить.
Код
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...
}
}
Вопросов
Как это можно отредактировать, чтобы сделать его более расширяемым? То есть, если я хотел добавить поддержку большего количества типов файлов, упростить и ускорить изменение. Оператор switch может быть очень длинным. По сути, как соблюсти принцип Открыто / Закрыто?
Ответы
Я бы посоветовал переместить фактический экспорт (ы) в их собственный класс. Мы можем создать интерфейс для экспорта. Что-то вроде
public interface IExport<T>
{
Task SaveAsync(string fileName, IEnumerable<T> items, IProgress<int> progress = null);
string ExportType { get; }
}
Тогда каждый тип экспорта может реализовать этот интерфейс.
public class ExportItemsToText : IExport<Item>
{
public Task SaveAsync(string fileName, IEnumerable<Item> items, IProgress<int> progress = null)
{
throw new NotImplementedException();
}
public string ExportType => "txt";
}
Затем в вашем конструкторе 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);
}
Вместо оператора switch теперь вы можете просто найти ключ в словаре, чтобы найти, какой экспорт следует запустить, и, если он не найден, будет таким же, как и в вашем случае по умолчанию.
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.");
}
Теперь, в будущем, при добавлении поддержки для большего количества типов вы просто реализуете интерфейс и обновите свой контейнер DI. Или, если не используется DI, необходимо добавить его в конструктор вашего ExportWindow.
Я не думаю, что это отличная идея, но если вы действительно не хотите создавать класс для каждого экспорта, что, я думаю, вам следует, вы можете создать словарь, а IDictionary<string, Action<string>>затем просто поместить туда свои методы и при добавлении нового типа создать метод и обновите словарь.
Я просто хочу поделиться тем, что у меня есть, поскольку я уже реализовал это (вроде) в одном из моих предыдущих проектов (это было на ASP.NET), но его можно применить в любой другой среде. Реализация была аналогична предложению CharlesNRice. Однако требовалось иметь только опции для экспорта системных отчетов (для которых используется только один шаблон отчета) в Pdf, Excel и Word с согласованием наличия дополнительных опций экспорта в будущем. Вот как я это сделал:
Сначала интерфейс:
public interface IExportTo<T>
{
IExportTo<T> Generate();
void Download(string fileName);
void SaveAs(string fileFullPath);
}
затем контейнерный класс:
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
}
Я реализовал класс для каждого типа экспорта, как мы видим в приведенном выше классе. Я поделюсь одним классом (я упрощу его, хотя из реального класса).
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и SaveAsразные (не одинаковые). Downloadзагрузит экспортированный файл, а SaveAsэкземпляр объекта сохранит. Но это было реализовано так, потому что использовались зависимости.
Теперь использование должно быть таким:
new ExportTo(someList)
.Pdf()
.Generate()
.Download(fileName);
Вот как я реализовал в этом проекте, это можно улучшить, но для бизнес-требований этого достаточно.
Всякий раз, когда вам нужно добавить новый тип экспорта, просто создайте новый sealedкласс, а затем реализуйте его IExportTo<T>, IDisposableв этом классе. Наконец, обновите класс контейнера с новым типом (добавьте метод, чтобы открыть новый экземпляр этого метода), и все готово.