如何手动关闭/释放EPPlus中通过自定义类初始化方法创建的ExcelPackage实例？

Great question! When building a reusable Excel library with EPPlus, moving beyond the using pattern (which works great for short-lived operations) and implementing explicit Close/resource management makes total sense for an OOP-based custom class. Let's walk through exactly how to handle this.

Key Background: ExcelPackage Implements IDisposable #

First, remember that ExcelPackage implements the .NET IDisposable interface. This means its Dispose() method is the official way to release all underlying resources—including closing open file streams, freeing up memory, and cleaning up any unmanaged handles—just like close() or dispose() in Java.

Step 1: Make Your Custom Excel Class Implement IDisposable #

Since your class holds a reference to an ExcelPackage (a disposable resource), your CustomExcel class should also implement IDisposable. This follows .NET's best practices for resource management, and lets you tie your Close() method to the disposal logic.

Step 2: Implement the Close & Dispose Logic #

Here's a complete example of your custom class with proper resource handling:

using OfficeOpenXml;
using System.IO;

public class CustomExcel : IDisposable
{
    // Hold the ExcelPackage instance as a private field
    private ExcelPackage _excelPackage;
    public ExcelWorksheet CurrentWorksheet { get; private set; }
    // Track if resources have already been disposed to avoid double-disposal
    private bool _isDisposed = false;

    // Constructor with filename parameter
    public CustomExcel(string filePath)
    {
        Init(filePath);
    }

    // Initialize the ExcelPackage
    public void Init(string filePath)
    {
        var fileInfo = new FileInfo(filePath);
        // Create or open the Excel file (adjust based on your needs)
        _excelPackage = new ExcelPackage(fileInfo);
    }

    // Create worksheet and structure
    public void Create()
    {
        // Add a default worksheet (customize this as needed)
        CurrentWorksheet = _excelPackage.Workbook.Worksheets.Add("DataSheet");
        // Add any default formatting or setup logic here
    }

    // Save the Excel file
    public void Save()
    {
        _excelPackage.Save();
    }

    // Your explicit Close method—maps to disposal logic
    public void Close()
    {
        Dispose(true);
    }

    // Core disposal logic (protected for inheritance)
    protected virtual void Dispose(bool disposing)
    {
        if (_isDisposed) return;

        if (disposing)
        {
            // Release managed resources: dispose the ExcelPackage
            _excelPackage?.Dispose();
        }

        // If you had unmanaged resources, release them here (EPPlus doesn't require this)
        _isDisposed = true;
    }

    // Public IDisposable implementation
    public void Dispose()
    {
        Dispose(true);
        // Tell the GC not to run the finalizer for this object
        GC.SuppressFinalize(this);
    }

    // Finalizer (fallback if Dispose/Close is never called)
    ~CustomExcel()
    {
        Dispose(false);
    }
}

Step 3: Understand What's Happening Here #

• Close() Method: This is your user-friendly method that triggers the disposal process. It calls Dispose(true), which tells the logic to release managed resources (like the ExcelPackage).
• Dispose(bool disposing): This is where the actual cleanup happens. The ?.Dispose() call on _excelPackage will close any open file streams, free memory, and clean up all resources tied to the Excel package—exactly what you're looking for in a "close" operation.
• IDisposable Compliance: By implementing IDisposable, users of your library can still use the using pattern if they prefer (which will automatically call Dispose()), while also having the option to call Close() explicitly.
• Finalizer: The ~CustomExcel() method acts as a safety net. If a user forgets to call Close() or Dispose(), the garbage collector will eventually run this finalizer to clean up resources (though it's always better to dispose explicitly).

Example Usage #

Here's how someone would use your custom class:

// Explicit Close call
var myExcel = new CustomExcel(@"C:\CompanyData\Report.xlsx");
myExcel.Create();
// Populate worksheet data...
myExcel.Save();
myExcel.Close(); // Releases all resources

// Or using the using pattern (auto-disposes)
using (var myExcel = new CustomExcel(@"C:\CompanyData\Report.xlsx"))
{
    myExcel.Create();
    myExcel.Save();
}

Important Notes #

• Always check if _excelPackage is null before calling Dispose() (the ?. operator handles this).
• Avoid reusing a CustomExcel instance after calling Close() or Dispose()—once disposed, the internal ExcelPackage is no longer usable.

内容的提问来源于stack exchange，提问作者Zayar Htet