C# – OpenXml Sdk – Copy Sections of docx into another docx

cdocxopenxmlopenxml-sdk

I am trying the following code. It takes a fileName (docx file with many sections) and I try to iterate through each section getting the section name. The problem is that I end up with unreadable docx files. It does not error, but I think I am doing something wrong with getting the elements in the section.

public void Split(string fileName) {
            using (WordprocessingDocument myDoc =
                WordprocessingDocument.Open(fileName, true)) {
                string curCliCode = "";
                MainDocumentPart mdp = myDoc.MainDocumentPart;

                foreach (var element in mdp.Document.Body.ChildElements) {
                    if (element.Descendants().OfType<SectionProperties>().Count() == 1) {
                        //get the name of the section from the footer
                        var footer = (FooterPart) mdp.GetPartById(
                                                      element.Descendants().OfType<SectionProperties>().First().OfType
                                                          <FooterReference>().First().
                                                          Id.Value);
                        foreach (Paragraph p in footer.Footer.ChildElements.OfType<Paragraph>()) {
                            if (p.InnerText != "") {
                                curCliCode = p.InnerText;
                            }
                        }
                        if (curCliCode != "") {
                            var forFile = new List<OpenXmlElement>();
                            var els = element.ElementsBefore();
                            if (els != null) {
                                foreach (var e in els) {
                                    if (e != null) {
                                        forFile.Add(e);
                                    }
                                }
                                for (int i = 0; i < els.Count(); i++) {
                                    els.ElementAt(i).Remove();
                                }
                            }
                            Create(curCliCode, forFile);
                        }
                    }
                }

            }
        }
        private void Create(string cliCode,IEnumerable<OpenXmlElement> docParts) {
            var parts = from e in docParts select e.Clone();
            const string template = @"\Test\toSplit\blank.docx";
            string destination = string.Format(@"\Test\{0}.docx", cliCode);
            File.Copy(template, destination,true);
            /* Create the package and main document part */
            using (WordprocessingDocument myDoc =
                WordprocessingDocument.Open(destination, true)) {
                MainDocumentPart mainPart = myDoc.MainDocumentPart;
                /* Create the contents */
                foreach(var part in parts) {
                    mainPart.Document.Body.Append((OpenXmlElement)part);
                }

                /* Save the results and close */
                mainPart.Document.Save();
                myDoc.Close();
            }
        }

Does anyone know what the problem could be (or how to properly copy a section from one document to another)?

Best Answer

I've done some work in this area, and what I have found invaluable is diffing a known good file with a prospective file; the error is usually fairly obvious.

What I would do is take a file that you know works, and copy all of the sections into the template. Theoretically, the two files should be identical. Run a diff on them the document.xml inside the docx file, and you'll see the difference.

BTW, I'm assuming that you know that the docx is actually a zip; change the extension to "zip", and you'll be able to get at the actual xml files which compose the format.

As far as diff tools, I use Beyond Compare from Scooter Software.

Related Solutions

C# – How to copy the contents of one stream to another

From .NET 4.5 on, there is the Stream.CopyToAsync method

input.CopyToAsync(output);

This will return a Task that can be continued on when completed, like so:

await input.CopyToAsync(output)

// Code from here on will be run in a continuation.

Note that depending on where the call to CopyToAsync is made, the code that follows may or may not continue on the same thread that called it.

The SynchronizationContext that was captured when calling await will determine what thread the continuation will be executed on.

Additionally, this call (and this is an implementation detail subject to change) still sequences reads and writes (it just doesn't waste a threads blocking on I/O completion).

From .NET 4.0 on, there's is the Stream.CopyTo method

input.CopyTo(output);

For .NET 3.5 and before

There isn't anything baked into the framework to assist with this; you have to copy the content manually, like so:

public static void CopyStream(Stream input, Stream output)
{
    byte[] buffer = new byte[32768];
    int read;
    while ((read = input.Read(buffer, 0, buffer.Length)) > 0)
    {
        output.Write (buffer, 0, read);
    }
}

Note 1: This method will allow you to report on progress (x bytes read so far ...)
Note 2: Why use a fixed buffer size and not input.Length? Because that Length may not be available! From the docs:

If a class derived from Stream does not support seeking, calls to Length, SetLength, Position, and Seek throw a NotSupportedException.

C# – Inserting Image into DocX using OpenXML and setting the size

The sizes, in EMUs (English Metric Unit -- read this for a good explanation), are set in the Extents (the Cx and Cy). In order to get a pic into a DocX I usually do it like so:

Get the image's dimensions and resolution
Compute the image's width in EMUs: wEmu = imgWidthPixels / imgHorizontalDpi * emuPerInch
Compute the image's height in EMUs: hEmu = imgHeightPixels / imgVerticalDpi * emuPerInch
Compute the max page width in EMUs (I've found that if the image is too wide, it won't show)
If the image's width in EMUs is greater than the max page width's, I scale the image's width and height so that the width of image is equal to that of the page (when I say page, I'm referring to the "usable" page, that is minus the margins):

var ratio = hEmu / wEmu;
wEmu = maxPageWidthEmu;
hEmu = wEmu * ratio;
I then use the width as the value of Cx and height as the value of Cy, both in the DW.Extent and in the A.Extents (of the A.Transform2D of the PIC.ShapeProperties).

Note that the emuPerInch value is 914400.
I have this running (in a service) but I don't have the code with me right now.

UPDATE

This is the code I use:

var img = new BitmapImage(new Uri(fileName, UriKind.RelativeOrAbsolute));
var widthPx = img.PixelWidth;
var heightPx = img.PixelHeight;
var horzRezDpi = img.DpiX;
var vertRezDpi = img.DpiY;
const int emusPerInch = 914400;
const int emusPerCm = 360000;
var widthEmus = (long)(widthPx / horzRezDpi * emusPerInch);
var heightEmus = (long)(heightPx / vertRezDpi * emusPerInch);
var maxWidthEmus = (long)(maxWidthCm * emusPerCm);
if (widthEmus > maxWidthEmus) {
  var ratio = (heightEmus * 1.0m) / widthEmus;
  widthEmus = maxWidthEmus;
  heightEmus = (long)(widthEmus * ratio);
}

In my case, my page's measures are in cm, hence the emusPerCm you see above.

UPDATE 2 (to answer @andw)

To have the file locked during the minimum possible time, open it with a FileStream and pass the resulting stream to the StreamSource property of the BitmapImage:

var img = new BitmapImage();
using (var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read)) {
    img.BeginInit();
    img.StreamSource = fs;
    img.EndInit();
}
// The file is now unlocked
var widthPx = img.PixelWidth;
...

Best Answer

Related Solutions

C# – How to copy the contents of one stream to another

C# – Inserting Image into DocX using OpenXML and setting the size

Related Topic