Undocumented breaking change in .NET 10: System.IO.Packaging.Package disposal causes "Package object was closed and disposed" error with DocumentFormat.OpenXml

[damianabb]

Description

FYI, this is a summary generated by copilot, I'll try to copy/paste only the relevant information:

Summary
After upgrading from .NET 8 to .NET 10, code using DocumentFormat.OpenXml (version 3.5.1, previously version: 3.3.0) with System.IO.Packaging.Package throws InvalidOperationException: "Package object was closed and disposed, so cannot carry out operations on this object or any stream opened on a part of this package." during document disposal.
This appears to be an undocumented breaking change in .NET 10's disposal behavior that is not listed in the official breaking changes documentation: https://learn.microsoft.com/en-us/dotnet/core/compatibility/10

Environment
• .NET Version: .NET 10.0
• OS: Windows
• Visual Studio: 2026 (18.5.0-insiders)
• DocumentFormat.OpenXml: 3.5.1
• Previous working version: .NET 8 with \OpenXml library v: 3.3.0

Reproduction Steps

Code that worked in .NET 8:

public byte[] Export(string fileTemplate, string fileName, Func<string, string> Replace)
{
    string filePath = System.IO.Path.Combine(Directory.GetCurrentDirectory(), "Data/");
    var fileTemp = filePath + fileTemplate;
    using var stream = new MemoryStream(System.IO.File.ReadAllBytes(fileTemp), true);
    using var wordDoc = WordprocessingDocument.Open(stream, true);
    string docText = "";
    if (wordDoc != null && wordDoc.MainDocumentPart != null)
    {
        XmlDocument doc = new XmlDocument();
        var s = wordDoc.MainDocumentPart.GetStream(FileMode.OpenOrCreate, FileAccess.ReadWrite);
        doc.Load(s);
        docText = doc.OuterXml;
        s.Seek(0, SeekOrigin.Begin);
        docText = Replace.Invoke(docText);
        doc.LoadXml(docText);
        doc.Save(s);
        wordDoc.Save();
    }            
    return stream.ToArray();
}

Expected behavior

Code should work as it did in .NET 8, with the document being saved and the byte array returned successfully.

Actual behavior

Exception thrown during wordDoc.Dispose():

System.InvalidOperationException: Package object was closed and disposed, so cannot carry out operations on this object or any stream opened on a part of this package.
   at System.IO.Packaging.Package.ThrowIfObjectDisposed()
   at System.IO.Packaging.Package.get_FileOpenAccess()
   at DocumentFormat.OpenXml.Features.PackageFeatureBase.DocumentFormat.OpenXml.Packaging.IPackage.get_FileOpenAccess()
   at DocumentFormat.OpenXml.Packaging.Builder.DelegatingPackageFeature.get_FileOpenAccess()
   at DocumentFormat.OpenXml.Packaging.Builder.DelegatingPackageFeature.get_FileOpenAccess()
   at DocumentFormat.OpenXml.Packaging.OpenXmlPackage.SavePartContents(Boolean save)
   at DocumentFormat.OpenXml.Packaging.OpenXmlPackage.Dispose(Boolean disposing)

Regression?

Yes, it worked on .NET 8, OpenXML 3.3.0

Known Workarounds

Root Cause Analysis
The disposal behavior of System.IO.Packaging.Package appears to have changed in .NET 10. When using using var for both the MemoryStream and WordprocessingDocument, the underlying Package is disposed before the WordprocessingDocument can complete its save operation during disposal.

Workaround:

public byte[] Export(string fileTemplate, string fileName, Func<string, string> Replace)
{
    string filePath = System.IO.Path.Combine(Directory.GetCurrentDirectory(), "Data/");
    var fileTemp = filePath + fileTemplate;

    using var inputStream = new MemoryStream(System.IO.File.ReadAllBytes(fileTemp));
    using var outputStream = new MemoryStream();
    
    using (var sourceDoc = WordprocessingDocument.Open(inputStream, false))
    {
        using var destDoc = (WordprocessingDocument)sourceDoc.Clone(outputStream, true);
        
        if (destDoc?.MainDocumentPart != null)
        {
            string docText;
            XmlDocument doc = new XmlDocument();
            
            var s = destDoc.MainDocumentPart.GetStream(FileMode.OpenOrCreate, FileAccess.ReadWrite);
            doc.Load(s);
            docText = doc.OuterXml;
            
            docText = Replace.Invoke(docText);
            
            s.Seek(0, SeekOrigin.Begin);
            doc.LoadXml(docText);
            doc.Save(s);
        }
        
        destDoc.Save();
    }

    return outputStream.ToArray();
}

Configuration

No response

Other information

No response

[stephentoub]

Can you share a complete, minimal, standalone repro?

[KalleOlaviNiemitalo]

That code looks risky for the same reason as #123419 (comment): new MemoryStream(System.IO.File.ReadAllBytes(fileTemp), true) makes a MemoryStream backed by an array that cannot be expanded nor replaced, so there is a risk that the subsequent doc.Save(s) and wordDoc.Save() might not fit in that array.

However, based on the stack trace, I don't believe the exception was caused by the MemoryStream overflowing.

[damianabb]

Thanks for reaching out! I'm tight on time so I'll have to ask the copilot to get you the code and if there's anything more you need, I'll try to update the issue. @stephentoub

Standalone repro:

PackageDisposalRepro.scproj

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="DocumentFormat.OpenXml" Version="3.5.1" />
  </ItemGroup>

</Project>

Program.cs:

using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;
using System.Xml;

namespace PackageDisposalRepro;

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("System.IO.Packaging.Package Disposal Bug Reproduction");
        Console.WriteLine($".NET Version: {Environment.Version}");
        Console.WriteLine($"DocumentFormat.OpenXml Version: 3.5.1");
        Console.WriteLine();

        try
        {
            // Step 1: Create a simple Word document template in memory
            Console.WriteLine("Step 1: Creating template document...");
            var templateBytes = CreateSimpleWordDocument();
            Console.WriteLine($"Template created: {templateBytes.Length} bytes");
            Console.WriteLine();

            // Step 2: Try to modify the document using the problematic pattern
            Console.WriteLine("Step 2: Attempting to modify document (problematic pattern)...");
            var result = ModifyDocumentProblematicPattern(templateBytes);
            Console.WriteLine($"SUCCESS: Modified document: {result.Length} bytes");
            Console.WriteLine("✅ No exception thrown - bug may be fixed or environment-specific");
        }
        catch (InvalidOperationException ex) when (ex.Message.Contains("Package object was closed and disposed"))
        {
            Console.WriteLine("❌ EXCEPTION CAUGHT: Package disposal issue reproduced!");
            Console.WriteLine($"Exception: {ex.Message}");
            Console.WriteLine();
            Console.WriteLine("Stack trace:");
            Console.WriteLine(ex.StackTrace);
            Console.WriteLine();
            Console.WriteLine("This confirms the breaking change in .NET 9/10.");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ Unexpected exception: {ex.Message}");
            Console.WriteLine(ex.StackTrace);
        }

        Console.WriteLine();
        Console.WriteLine("Press any key to exit...");
        Console.ReadKey();
    }

    /// <summary>
    /// Creates a simple Word document with placeholder text
    /// </summary>
    static byte[] CreateSimpleWordDocument()
    {
        using var stream = new MemoryStream();
        using (var wordDoc = WordprocessingDocument.Create(stream, WordprocessingDocumentType.Document))
        {
            var mainPart = wordDoc.AddMainDocumentPart();
            mainPart.Document = new Document(
                new Body(
                    new Paragraph(
                        new Run(
                            new Text("PLACEHOLDER_TEXT")
                        )
                    )
                )
            );
            mainPart.Document.Save();
        }
        return stream.ToArray();
    }

    /// <summary>
    /// This pattern worked in .NET 8 but fails in .NET 9/10
    /// </summary>
    static byte[] ModifyDocumentProblematicPattern(byte[] templateBytes)
    {
        // This pattern causes "Package object was closed and disposed" in .NET 10
        using var stream = new MemoryStream(templateBytes, true);
        using var wordDoc = WordprocessingDocument.Open(stream, true);

        if (wordDoc?.MainDocumentPart != null)
        {
            var doc = new XmlDocument();
            var partStream = wordDoc.MainDocumentPart.GetStream(FileMode.OpenOrCreate, FileAccess.ReadWrite);

            // Load, modify, and save back to the part stream
            doc.Load(partStream);
            string docText = doc.OuterXml;

            // Simulate text replacement
            docText = docText.Replace("PLACEHOLDER_TEXT", "REPLACED_TEXT");

            partStream.Seek(0, SeekOrigin.Begin);
            doc.LoadXml(docText);
            doc.Save(partStream);

            // This Save() call triggers the disposal issue in .NET 10
            wordDoc.Save();
        }

        // Accessing stream after wordDoc disposal triggers the exception
        return stream.ToArray();
    }

    /// <summary>
    /// Workaround pattern that works in .NET 10
    /// </summary>
    static byte[] ModifyDocumentWorkaround(byte[] templateBytes)
    {
        using var inputStream = new MemoryStream(templateBytes);
        using var outputStream = new MemoryStream();

        using (var sourceDoc = WordprocessingDocument.Open(inputStream, false))
        {
            using var destDoc = (WordprocessingDocument)sourceDoc.Clone(outputStream, true);

            if (destDoc?.MainDocumentPart != null)
            {
                var doc = new XmlDocument();
                var partStream = destDoc.MainDocumentPart.GetStream(FileMode.OpenOrCreate, FileAccess.ReadWrite);

                doc.Load(partStream);
                string docText = doc.OuterXml;
                docText = docText.Replace("PLACEHOLDER_TEXT", "REPLACED_TEXT");

                partStream.Seek(0, SeekOrigin.Begin);
                doc.LoadXml(docText);
                doc.Save(partStream);
            }

            destDoc.Save();
        }

        return outputStream.ToArray();
    }
}

README.md:

# System.IO.Packaging.Package Disposal Bug - Minimal Reproduction

This is a minimal standalone reproduction of a breaking change in .NET 9/10 affecting `System.IO.Packaging.Package` disposal when used with DocumentFormat.OpenXml.

## Issue Summary

Code that worked in .NET 8 with DocumentFormat.OpenXml 3.3.0 throws `InvalidOperationException: "Package object was closed and disposed"` in .NET 10 with DocumentFormat.OpenXml 3.5.1.

## How to Reproduce

### Prerequisites
- .NET 10 SDK installed
- No additional files needed - creates document in memory

### Steps to Run

1. Clone or download this reproduction
2. Run the application:
   ```bash
   cd MinimalReproduction
   dotnet run

Expected Behavior (in .NET 8)

✅ Program completes successfully, document is modified and returned

Actual Behavior (in .NET 10)

❌ Exception thrown:

System.InvalidOperationException: Package object was closed and disposed, so cannot carry out operations on this object or any stream opened on a part of this package.
   at System.IO.Packaging.Package.ThrowIfObjectDisposed()
   at System.IO.Packaging.Package.get_FileOpenAccess()
   at DocumentFormat.OpenXml.Packaging.OpenXmlPackage.Dispose(Boolean disposing)

Testing Against .NET 8

To compare behavior with .NET 8, change the TargetFramework in PackageDisposalRepro.csproj:

<TargetFramework>net8.0</TargetFramework>

And update the DocumentFormat.OpenXml version to 3.3.0:

<PackageReference Include="DocumentFormat.OpenXml" Version="3.3.0" />

Then run:

dotnet run

You should see it complete successfully.

Code Patterns

Problematic Pattern (fails in .NET 10)

using var stream = new MemoryStream(templateBytes, true);
using var wordDoc = WordprocessingDocument.Open(stream, true);
// Modify document...
wordDoc.Save();
return stream.ToArray(); // ❌ Throws exception

Workaround Pattern (works in .NET 10)

using var inputStream = new MemoryStream(templateBytes);
using var outputStream = new MemoryStream();

using (var sourceDoc = WordprocessingDocument.Open(inputStream, false))
{
    using var destDoc = (WordprocessingDocument)sourceDoc.Clone(outputStream, true);
    // Modify destDoc...
    destDoc.Save();
}

return outputStream.ToArray(); // ✅ Works

Related GitHub Issue

[Link to your issue once created]