`PresentationDocument.Save()` doesn't apply changes

[ashahabov]

Description

PresentationDocument.Save() doesn't apply changes that are deleting presentation sections. It works if I call doc.Close() (check Repro), but I don't wanna close presentation before mStream.ToArray().

Looks like PresentationDocument.Save() doesn't flush changes to mStream stream.

Information

• .NET Target: .NET 6
• DocumentFormat.OpenXml Version: 2.16.0

Repro

base.pptx

using DocumentFormat.OpenXml.Office2010.PowerPoint;
using DocumentFormat.OpenXml.Packaging;

using var fStream = File.OpenRead(@"c:\temp\base.pptx");
var mStream = new MemoryStream();
fStream.CopyTo(mStream);
fStream.Close();

using var doc = PresentationDocument.Open(mStream, true);
var sectionList = doc.PresentationPart!.Presentation.PresentationExtensionList?.Descendants<SectionList>().First();

sectionList.Remove();
doc.Save();
// doc.Close() // it works

File.WriteAllBytes(@"c:\temp\edited.pptx", mStream.ToArray());

// ...

Observed

edited.pptx still has section.

Expected

edited.pptx doesn't have sections.

[ThomasBarnekow]

@adamshakhabov, looked into the issue and could reproduce it. I can't explain why this happens. On the other hand, I am asking myself why you would do what you are doing. For example, what's the point of a using statement and explicitly closing a file stream, for example. I would also always close or dispose an OpenXmlPackage before continuing to work with the stream on which the package was opened. For example, I would always write it like this:

using MemoryStream stream = ReadAllBytesToMemoryStream("Resources\\base.pptx");
using (PresentationDocument doc = PresentationDocument.Open(stream, true))
{
    SectionList sectionList = doc.PresentationPart!.Presentation.PresentationExtensionList!.Descendants<SectionList>().First();
    sectionList.Remove();
}

There is no need to explicitly save or close the document and you can safely use the stream. Of course, this closes the PresentationDocument. However, it also works as expected.

[ashahabov]

@ThomasBarnekow, I agree with you and I almost never use Save() in my production cases. Just closing the document is applicable. But what about the following use case:

There is a presentation with 150 slides and I need to split it to two presentations: base_51-150.pptx contains 51-150 and base_101-150.pptx contains 101-150 slides of base.pptx presentation.

If Save() would work as expected, I can do something this:

using MemoryStream stream = ReadAllBytesToMemoryStream("Resources\\base.pptx");
using (PresentationDocument doc = PresentationDocument.Open(stream, true))
{
    // Remove 1-50 slides
    // ...
    doc.Save();
    File.WriteAllBytes("base_51-150.pptx", stream.ToArray());
    
    // Remove 1-50 which is now initial 51-100 slides
    // ...
    doc.Save();
    File.WriteAllBytes("base_101-150.pptx", stream.ToArray());
}

instead of something like that:

var count = 2;
while (count != 0)
{
    using MemoryStream stream = ReadAllBytesToMemoryStream("Resources\\base.pptx");
    using (PresentationDocument doc = PresentationDocument.Open(stream, true))
    {
        // Remove 1-50 or 1-100 slides depend on count
        // ...
    }
    
    // Save stream to base_51-150.pptx or base_101-150.pptx depend on count
    // ...
    
    count--;
}

I think the first version is more optimal, especially if we should process a lot of such presentations and they contain many charts or other heavy parts.

[ThomasBarnekow]

Let's rewrite your first case to not introduce a different concept (loop):

// Step 1: Get the stream.
using MemoryStream stream = ReadAllBytesToMemoryStream("Resources\\base.pptx");

// Step 2: Transform the stream by changing the document stored on it.
using (PresentationDocument doc = PresentationDocument.Open(stream, true))
{
    // Remove 1-50 slides
} 

File.WriteAllBytes("base_51-150.pptx", stream.ToArray());

// Step 3: Transform the stream by changing the document stored on it.
using (PresentationDocument doc = PresentationDocument.Open(stream, true))
{    
    // Remove 1-50 which is now initial 51-100 slides
}

File.WriteAllBytes("base_101-150.pptx", stream.ToArray());

It seems that you must properly dispose (or close) the PresentationDocument (or any other OpenXmlPackage for that matter) to write the changes back to the stream. If you look at the source code, you see that the SDK flushes the Package. However, it seems that the stream is only really written if the Package (from the System.IO.Packaging namespace is closed. That only happens when you close or dispose the OpenXmlPackage, not when just saving it. A using statement leads to the proper disposal (and closing) of the OpenXmlPackage and underlying Package.

[ThomasBarnekow]

@adamshakhabov, can we close this issue?

[ashahabov]

Yes, but I still think that PresentationDocument.Save() doesn't work correctly — its result doesn't correspond to the method name. Something wrong with flashing.

The above solutions look like workarounds. For example, in your last example, I have to make an extra PresentationDocument.Open() call. Doesn't look efficient.

[alexrosenfeld10]

I just ran into this issue. Why bother having the Save() method if it doesn't actually do what it says?

[twsouthwick]

I'm going to check if the work done for v3.0 will help with this.