Windows Store App PDF Document does not render when stream disposed after load

Question

I have a working solution to load and render a PDF document from a byte array in a Windows Store App. Lately some users have reported out-of-memory errors though. As you can see in the code below there is one stream I am not disposing of. I've commented out the line. If I do dispose of that stream, then the PDF document does not render anymore. It just shows a completely white image. Could anybody explain why and how I could load and render the PDF document and dispose of all disposables?

private static async Task<PdfDocument> LoadDocumentAsync(byte[] bytes)
{
    using (var stream = new InMemoryRandomAccessStream())
    {
        await stream.WriteAsync(bytes.AsBuffer());

        stream.Seek(0);

        var fileStream = RandomAccessStreamReference.CreateFromStream(stream);
        var inputStream = await fileStream.OpenReadAsync();
        try
        {
            return await PdfDocument.LoadFromStreamAsync(inputStream);
        }
        finally
        {
            // do not dispose otherwise pdf does not load / render correctly. Not disposing though may cause memory issues.
            // inputStream.Dispose();
        }
    }
}

and the code to render the PDF

private static async Task<ObservableCollection<BitmapImage>> RenderPagesAsync(
    PdfDocument document, 
    PdfPageRenderOptions options)
{
    var items = new ObservableCollection<BitmapImage>();

    if (document != null && document.PageCount > 0)
    {
        for (var pageIndex = 0; pageIndex < document.PageCount; pageIndex++)
        {
            using (var page = document.GetPage((uint)pageIndex))
            {
                using (var imageStream = new InMemoryRandomAccessStream())
                {
                    await page.RenderToStreamAsync(imageStream, options);
                    await imageStream.FlushAsync();

                    var renderStream = RandomAccessStreamReference.CreateFromStream(imageStream);
                    using (var stream = await renderStream.OpenReadAsync())
                    {
                        var bitmapImage = new BitmapImage();
                        await bitmapImage.SetSourceAsync(stream);
                        items.Add(bitmapImage);
                    }
                }
            }
        }
    }

    return items;
}

As you can see I am using this RandomAccessStreamReference.CreateFromStream method in both of my methods. I've seen other examples that skip that step and use the InMemoryRandomAccessStream directly to load the PDF document or the bitmap image, but I've not managed to get the PDF to render correctly then. The images will just be completely white again. As I mentioned above, this code does actually render the PDF correctly, but does not dispose of all disposables.

Answer 1

Why

I assume LoadFromStreamAsync(IRandomAccessStream) does not parse the whole stream into the PdfDocument object but instead only parses the main PDF dictionaries and holds a reference to the IRandomAccessStream.

This actually is the sane thing to do, why parse the whole PDF into own objects (a possibly very expensive operation resource-wise) if the user eventually only wants to render one page, or even merely wants to query the number of pages...

Later on, when other methods of the returned PdfDocument are called, e.g. GetPage, these methods try to read the additional data from the stream they need for their task, e.g. for rendering. Unfortunately in your case that means after the finally { inputStream.Dispose(); }

How else

You have to postpone the inputStream.Dispose() until all operations on the PdfDocument are finished. That means some hopefully minor architectural changes for your code. Probably moving the LoadDocumentAsync code as a frame into the RenderPagesAsync method or its caller suffices.