I'm having following code,in this code i am reading the content of file as a stream,
after reading it as stream I need to crate new document which will maintain the format after replacement of placeholder,if I m reading file from path it is replacing placeholder write in new file and show it properly with format ,but if im reading the same content using stream it doesnot throw any error,it creates the file ,but while opening it shows file corrupted
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.Text.RegularExpressions;
using System;
using System.Xml;
using System.Xml.Xsl;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;
namespace ConsoleApplication1
{
class newprogramme
{
static void Main(string[] args)
{
#region Document Body
Stream fileStram = new MemoryStream(Convert.FromBase64String(documentBody));
WordprocessingDocument doc = WordprocessingDocument.Open(fileStram, true);
//WordprocessingDocument doc = WordprocessingDocument.Open(#"C:\Users\gaurav12799\Desktop\TestDoc.docx", true);
Body body = doc.MainDocumentPart.Document.Body;
var paras = body.Elements<Paragraph>();
foreach (var para in paras)
{
foreach (var run in para.Elements<Run>())
{
foreach (var text in run.Elements<Text>())
{
if (text.Text.Contains("name"))
{
text.Text = text.Text.Replace("name", "gaurav");
}
}
}
}
doc.MainDocumentPart.Document.Save();
//WordprocessingDocument newDoc = WordprocessingDocument.Open(doc.MainDocumentPart.GetStream(),false);
string fileName = "D:\\Test.doc";
using (FileStream fileStream = new FileStream(fileName, FileMode.OpenOrCreate))
{
Stream stream = doc.MainDocumentPart.GetStream();
byte[] data = new byte[stream.Length];
stream.Read(data, 0, data.Length);
fileStream.Write(data, 0, data.Length);
fileStream.Close();
}
}
}
}
This is my stream format data
string documentBody = #"UEsDBBQABgAIAAAAIQAJJIeCgQEAAI4FAAATAAgCW0NvbnRlbnRfVHlwZXNdLnhtbCCiBAIooAACAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0lE1Pg0AQhu8m/geyVwPbejDGlPag9ah NrPG8LkPZyH5kZ
/v17x1KS6qhpVq9kMAy7/vMCzOD0UqX0QI8KmtS1k96LAIjbabMLGWv08f4lkUYhMlEaQ2kbA3IRsPLi8F07QAjqjaYs iIEd8c5ygK0wMQ6MHSSW69F
oFs/407IDzEDft3r3XBpTQAT4lBpsOHgAXIxL0M0XtHjmsRDiSy6r1+svFImnCuVFIFI+cJk31zirUNClZt3sFAOrwiD8VaH6uSww bbu
maLxKoNoInx4Epow+NL6jGdWzjX1kByXaeG0ea4kNPWVmvNWAiJlrsukOdFCmR3/QQ4M6xLw7ylq3RPt31QoxnkOkj52dx4a46rpp LbYq
+12gxAopFNMvv6CcVfouFXuRFjC+8u/UeyJd4LkNBpT8V7CCYn/MIxGuhMi0LwD31z7Z3NsZI5Z0mRMvHVI
+8P/ou3dgqiqYxo5Bz4oaFZE24g1jrR7zu4Pqu2WQdbizTfbdPgJAAD//wMAUEsDBBQABgAIAAAAIQAekRq38wAAAE4CAAALAAgCX3JlbHMvLnJlbHM
gogQCKKAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAjJLbSgNBDIbvBd9hyH032woi0tneS
KF3IusDhJnsAXcOzKTavr2jILpQ217m9OfLT9abg5vUO6c8Bq9hWdWg2JtgR99reG23iwdQWchbmoJnDUfOsGlub9YvPJGUoTyMMaui4rOGQSQ
+ImYzsKNchci+VLqQHEkJU4+RzBv1jKu6vsf0VwOamabaWQ1pZ
+9AtcdYNl/WDl03Gn4KZu/Yy4kVyAdhb9kuYipsScZyjWop9SwabDDPJZ2RYqwKNuBpotX1RP9fi46FLAmhCYnP83x1nANaXg902aJ5x687HyFZLBZ9
e/tDg7MvaD4BAAD//wMAUEsDBBQABgAIAAAAIQB8O5c5IgEAALkDAAAcAAgBd29yZC9fcmVscy9kb2N1bWVudC54bWwucmVscyCiBAEooAABAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKyTTU
+EMBCG7yb
+B9K7FFZdjdmyFzXZq67x3C1TaISWdMYP/r0VswrKogcuTWaavs/TSbtav9VV9AIejbOCpXHCIrDK5cYWgj1sb08uWYQkbS4rZ0GwFpCts
+Oj1R1UksIhLE2DUUixKFhJ1FxxjqqEWmLsGrBhRztfSwqlL3gj1ZMsgC
+SZMl9P4Nlg8xokwvmN/kpi7ZtE8h/ZzutjYJrp55rsDSC4AhE4WYYMqUvgATbd+Lgyfi4wuKAQm2Ud+g0xcrV/JP
+Qb0YXowjtRXgo6HyRmtQ1Mf/3JrySA94jI
z5H6PoyL1BdPUUfjknnsILgW96V/JuTacczud00M7SVu6qnsdXa0ribE6JV9jd/3qVveZehA8+XPYOAAD//wMAUEsDBBQABgAIAAAAIQBRbm8SgQIAA
EwHAAARAAAAd29yZC9kb2N1bWVudC54bWysVclu2zAQvRfoPwg85NRYsuK4gRrZQJqlORQwmvZc0BQlsZY4AklZdb+
+Q2qxEwVplh4EcZl5897MkDxf/i4Lb8uVFiBjMp0ExOOSQSJkFpMf36+Pz4inDZUJLUDymOy4JsvF
+3fnTZQAq0sujYcQUkdNxWKSG1NFvq9ZzkuqJ6VgCjSkZsKg9CFNBeN
+Ayrxw2AauFGlgHGtMd5nKrdUkw6uHKNBxSXGSkGV1OgJqMwvqdrU1TGiV9SItSiE2SF2MO9hICa1klFH6HggZF2illD36z3USMUjcVvPyy4DLqKveI
EcQOpcVHsZr0VDiXlPafuUiG1Z9HZNNZ2N4g2Sn1ODS0UbLMUecAT3SDKS1qks2jzY+u6r+hBxGjwlpquIhRg4PIfC/Zg9k5IKOcC8LjWHycUT8Zb
+vlFQVwOdSrwN7VZuBix7MF/ALJi7k3coTb8IYHR073JaceKVLLrNJCi6LpBRM515tiPJAi
+LNSQ7+6+8JsLLJvkWkyAIT6fhySnply55SuvCjHdWB0sOZKXs7xdDzy0tYqJElhviL859jNBurgE29na4M1QZtBMJgthQkpZI7ucNXFC2sT6WXGt7J
ZPBsgN7OWeHeE/m9cVJeIU3Uqd8LNMGcYrM4ovwjgrzyX6W6FGGY/w+WGXG6UNDq/J/EPtn/g+JQeNRxb0d1Mvlo2w0Z2alepUPS5bd/cGtBt
+YMJy5QuQ4Pj3DcZux7Cu1zgYqXJ+1Jq6u++kajIFyPy94it3SG+ecJhxv74+hg08BzME0q42bduEYFBqj6Yoy7Abr4ljgm3ajhO2CQki
+EoYhy5O528WstxJdAdqGxrX+GVz8BQAA//8DAFBLAwQUAAYACAAAACEAMN1
DKagGAACkGwAAFQAAAHdvcmQvdGhlbWUvdGhlbWUxLnhtbOxZT2/bNhS/D9h3IHRvYyd2Ggd1itixmy1NG8Ruhx5piZbYUKJA0kl9G9rjgAHDumGHFd
hth2FbgRbYpfs02TpsHdCvsEdSksVYXpI22IqtPiQS
+eP7/x4fqavX7scMHRIhKU/aXv1yzUMk8XlAk7Dt3R72L615SCqcBJjxhLS9KZHetY3337uK11VEYoJgfSLXcduLlErXl5akD8NYXuYpSWBuzEWMFby
KcCkQ+AjoxmxpuVZbXYoxTTyU4BjI3hqPqU/QUJP0NnLiPQaviZJ6wGdioEkTZ4XBBgd1jZBT2WUCHWLW9oBPwI
+G5L7yEMNSwUTbq5mft7RxdQmvZ4uYWrC2tK5vftm6bEFwsGx4inBUMK33G60rWwV9A2BqHtfr9bq9ekHPALDvg6ZWljLNRn
+t3slplkD2cZ52t9asNVx8if7KnMytTqfTbGWyWKIGZB8bc/i12mpjc9nBG5DFN
+fwjc5mt7vq4A3I4lfn8P0rrdWGizegiNHkYA6tHdrvZ9QLyJiz7Ur4GsDXahl8hoJoKKJLsxjzRC2KtRjf46IPAA1kWNEEqWlKxtiHKO7ieCQo1gzw
OsGlGTvky7khzQtJX9BUtb0PUwwZMaP36vn3r54/RccPnh0/+On44cPjBz9aQs6qbZyE5VUvv/3sz8cfoz
+efvPy0RfVeFnG//rDJ7/8/Hk1ENJnJs6LL5/89uzJi68+/f27RxXwTYFHZfiQxkSim+QI7fMYFDNWcSUnI3G
+FcMI0/KKzSSUOMGaSwX9nooc9M0pZpl3HDk6xLXgHQHlowp4fXLPEXgQiYmiFZx3otgB7nLOOlxUWmFH8yqZeThJwmrmYlLG7WN8WMW7ixPHv71JCn
UzD0tH8W5EHDH3GE4UDklCFNJz/ICQCu3uUurYdZf6gks+VuguRR1MK00ypCMnmmaLtmkMfplW6Qz+dmyzewd1OKvSeoscukjICswqhB8S5pjx
Op4oHFeRHOKYlQ1+A6uoSsjBVPhlXE8q8HRIGEe9gEhZteaWAH1LTt/BULEq3b7LprGLFIoeVNG8gTkvI7f4QTfCcVqFHdAkKmM/kAcQohjtcVUF3+V
uhuh38ANOFrr7DiWOu0+vBrdp6Ig0CxA9MxEVvrxOuBO/gykbY2JKDRR1p1bHNPm7ws0oVG7L4eIKN5TKF18/rpD7bS3Zm7B7VeXM9olCvQh3sjx3uQ
jo21+dt/Ak2SOQEPNb1Lvi/K44e//54rwony++JM
+qMBRo3YvYRtu03fHCrntMGRuoKSM3pGm8Jew9QR8G9Tpz4iTFKSyN4FFnMjBwcKHAZg0SXH1EVTSIcApNe93TREKZkQ4lSrmEw6IZrqSt8dD4K3vUb
OpDiK0cEqtdHtjhFT2cnzUKMkaq0Bxoc0YrmsBZma1cyYiCbq/DrK6FOjO3uhHNFEWHW6GyNrE5lIPJC9VgsLAmNDUIWiGw8iqc+TVrOOxgRgJtd
+uj3C3GCxfpIhnhgGQ+0nrP
+6hunJTHypwiWg8bDPrgeIrVStxamuwbcDuLk8rsGgvY5d57Ey/lETzzElA7mY4sKScnS9BR22s1l5se8nHa9sZwTobHOAWvS91HYhbCZZOvhA37U5P
ZZPnMm61cMTcJ6nD1Ye0+p7BTB1Ih1RaWkQ0NM5WFAEs0Jyv/chPMelEKVFSjs0mxsgbB8K9JAXZ0XUvGY+KrsrNLI9p29jUrpXyiiBhEwREasYnYx
+B+HaqgT0AlXHeYiqBf4G5OW9tMucU5S7ryjZjB2XHM0ghn5VanaJ7JFm4KUiGDeSuJB7pVym6UO78qJuUvSJVyGP/PVNH7Cdw
+rATaAz5cDQuMdKa0PS5UxKEKpRH1+wIaB1M7IFrgfhemIajggtr8F
+RQ/7c5Z2mYtIZDpNqnIRIU9iMVCUL2oCyZ6DuFWD3buyxJlhEyEVUSV6ZW7BE5JGyoa
+Cq3ts9FEGom2qSlQGDOxl/7nuWQaNQNznlfHMqWbH32hz4pzsfm8ygl
FuHTUOT278QsWgPZruqXW+W53tvWRE9MWuzGnlWALPSVtDK0v41RTjnVmsr1pzGy81cOPDivMYwWDREKdwhIf0H9j8qfGa/dugNdcj3obYi
+HihiUHYQFRfso0H0gXSDo6gcbKDNpg0KWvarHXSVss36wvudAu
+J4ytJTuLv89p7KI5c9k5uXiRxs4s7Njaji00NXj2ZIrC0Dg/yBjHmM9k5S9ZfHQPHL0F3wwmTEkTTPCdSmDooQcmDyD5LUezdOMvAAAA//8DAFBLAw
QUAAYACAAAACEA0c5eAHwDAACwCAAAEQAAAHdvcmQvc2V0dGluZ3MueG1stFZbb9s2FH4f0P8g6HmOLnayTYhStGndtYjXYUp/ACUdy0R4A0lZcX/9D
kkxapA0KFbsydS5fOf28dCXr+85S46gDZWiTouzPE1AdLKnYqjTL7fb1e9pYiwRPWFSQJ2ewKSvr179cjlVBqxFM5MghDAV7+r0YK2qssx0B
+DEnEkFApV7qTmx
+KmHjBN9N6pVJ7kilraUUXvKyjy/SGcYWaejFtUMseK009LIvXUuldzvaQfzT/TQPxI3eL6T3chBWB8x08AwBynMgSoT0fh/RcMSDxHk
+FIRR86i3VTkL1nO5U5S9w8eP5Kec1BadmAMDoizUC4nVDzAFJsnQA+tPsNWZyF25qDQvcj9acncsCf
+z0w7TPGGtproMGYkgMuCd9XHQUhNWoakmopNeoWM
+iolT6ZKge5wSHX6R55mTo61yH1jiQXUGgWMeXp2DAhiTdWgCUdi1WmQeJ8e9mRk9pa0jZUKjY4EU/6tnCG7A9Gks6AbRTpEu5bCasmiXS//kvYaSaq
xhyGJQFmXTjg1gf7oIQjHIoJ0pvRO9uAyGzV90qfv9tk5+CyxHb6G5wNJvK6a9oClMWjsicEWk2/oV3gj+k
+jsRQviSf2T2TwUgIgXOTPeLlvTwq2QOyIbfqfgvlJbBlVO6q11B9Fj9T42WBZHKIbJ+6+3sTDP1LaOIY8L8+Lcn0eeu
HMFk2+Li+Ki+c03/fZvl2X770Pxp
+j8srtjb/11WU4uVEmPNDgmvBWU5Ls3GZBQvCq1XdvqYj6FnCzwreaZmyjcrUKCsMJY1vkelT4C8Crnhr1DvYelu2IHhbc2UI/K8V79ekBy11T0B
+0HFWINmmiwohiuGKzmfGosDeUR7kZ2yZ6CdwO36hG0X8+ageYLe2ZKouPiqf6DRFDnASI1ZfGmeJEmW7cwwM7ohReaTRph6JOGR0OtnD0tPjV4wPkP
9qhnHWl1+GX0/kP0rnK0Ho+OINwRKv5sMjWUbZeZLheg91mkZ1H2fkiu4gyfACn6oD3SeNyu8OlEY9OvpeMyQn6P6OwTp
+IQhPMgSjAubrdh6SWlRfMy9AkxwrucbFCTy2+64r2nNzjs5+XnpazNSMnOdpHtg7JGatH0qQnlqC7H9UjZxwdburHuUxVDx1FOjYn3i6r9iwkzqixD
SjcylZqLNkvwl898vJX4+pfAAAA//8DAFBLAwQUAAYACAAAACEAF6AWTgIBAACsAQAAFAAAAHdvcmQvd2ViU2V0dGluZ3MueG1sjNDBSgMxEAbgu
+A7LLm32ZUisnS3IFLxIoL6AGl2dhvMZMJMaqxPb9qqIF56yySZj5l/ufpAX70Di6PQqWZeqwqCpcGFqVOvL
+vZjaokmTAYTwE6tQdRq/7yYpnbDJtnSKn8lKooQVq0ndqmFFutxW4BjcwpQiiPIzGaVEqeNBp
+28WZJYwmuY3zLu31VV1fq2+Gz1FoHJ2FO7I7hJCO/ZrBF5GCbF2UHy2fo2XiITJZECn7oD95aFz4ZZrFPwidZRIa07wso08T6QNV2pv6eEKvKrTtwx
SIzcaXBHOzUH2Jj2Jy6D5hTXzLlAVYH66N95SfHu9Lof9k3H8BAAD//wMAUEsDBBQABgAIAAAAIQCG7lbeXwgAAHJAAAAaAAAAd29yZC9zdHlsZXNXa
XRoRWZmZWN0cy54bWzEW21zmzgQ/n4z9x8Yvqd+SZpcM3U7adJeM9OXtE7mPst
YjpkA4gDHSX/9rVYgYzCwG+jcJwch7bOr3X1WdrRv3z+FgfMok9RX0cydvBq7jow8tfSj+5l7d/vp6C/XSTMRLUWgIjlzn2Xqvn/35x9vt
+dp9hzI1AEBUXq+jb2Zu86y
+Hw0Sr21DEX6KvS9RKVqlb3yVDhSq5XvydFWJcvRdDwZ419xojyZpoB2KaJHkbq5uLAuTcUyAqyVSkKRpa9Ucj8KRfKwiY9Aeiwyf
+EHfvYMssenhRg1czdJdJ4rdGQV0kvOjUL5R7EiqVlxANesvFLeJpRRhoijRAagg4rStR/vzHipNDBxXaj02GbEYxgU87bx5KSGZ02m
+OAqEVtwxU5gTdyBzViaRWFg9kH7d+fVqsTJuM2Y3CNahNWBosI
+ZqFJKPzIinnZ1pQ3F/KhT3z/nahNbNWJ/X7SrqMHK0unJUOz8SlmXtm0lCWglrrztYil64Te
+fV9pBKxCECj7eTE0RHpvgOqWCrvSq7EJshS/ZjcJPlj/oQfn1SUpc72XKSe798ChYCU0AeBny
+i1HfhjRRpdpH64uDLtZ518I2XZiVpH/yl7440YvoLZD6KYOZOp8XIpdZgbywQ0X0xJqOju3lZk5lrhxYgd+aK5Gh
+oYWN0Mzis2RuvGc8PKEqsfAg8wBHrDIJJAQspnECX3t3egaMZh5+bvTmik2mchAUAGBlsfBY2XHgJmCquWFseCtXX5T3IJfzDF7MXMSCwbvrm8RXCd
DozH3zRmPC4FyG/md/uZS6QORjd9HaX8p/1jK6S
+VyN/7jE9JzLtFTmygD9U/PMAqCdPnxyZOxpkkQHQnt4W96AXAYuKOEgwpt/J02ZqCCioP/FpAT48ODKGspdElzUP9WILR60xtoqi0qG4ByWboe9xdx
0l/E6/4iMHj77cVZfy3gINPXIyY2SlFJd2qmPBN85X04ftMSsnpFLYo6V9SCpnNFLUY6V9RConNFLQI6V9Qc3rmi5t/OFTV3tq7wBBJXNYqOcTdIiX3
rZwHUyQ6mm/SkurzUODci
EfeJiNeOLqxVtdvIcr5ZZDRVkU5fTpbzLFH6uNmxI1Cddeq+mJM/hvFapD6cyruAem79rT76OH8nPhxfO6Bem+Cr2YQHk4Ml7CYQnlyrYCkT51Y
+GY8y1n9TztycMjqV6+nWL/79OnPgVKhLbifYacOmN++Ekf/FT3EPWqv5aYMpXcJJPjxtiMtm4V/l0t
+ExdYQTiOnhs8Zbq5AoIrtW3SiXVTPrk4rtAMoJphywTcB5RP0N8WFL1/7mKK/KUUvlE/Q3xSuF8rH
+Gj3L5tpruBnFYeUXmfs3L1UgUpWm6DIgU56OGNnsIWgmcBOYiufRBJn7Azeo0/nwvPgmxslTtm+2PEoA4XtDoOCyUa3he2UCu1NGBaxHVTBmjKw
+nEtA4hNuj/lo69/BOYWA2Rpe9bsTOfjhh2AEkQ6Q//YqKz7DD1t4DwqynUEP5ek0qGhHTdkHhUtjydT7xg
+7lf4GED9KiADqF8pZAA1xEfzmcfWRDpI/
+LIwGLTsq1iGHZkZj5jM7MF4pWAgeom4fzVkL3NsVCvmwQUtoPqdZOAwvZOpZbZuknAGqxuErAaqkazj8qcyjGKXTfLQPYkQLBoGPImAA1D3gSgYcib
ANSfvLtBhiNvAhabGyynlsmbAIRTOF/1LVCZvAlAbG4wbJf/ZlTUPZTS/uV2APImoLAdVCdvAgrbO03kTcDCKZxIqGBZqiNgDUPeBKBhyJsANAx5E4C
GIW8C0DDkTQDqT97dIMORNwGLzQ2WU8vkTQBi04MFKpM3AQincLjhIHlj1v928iagsB1UJ28CCts7FUK1h1QCFttBFSxL3gQsnMIJhhwLg5tj1DDkTb
BoGPImAA1D3gSgYcibANSfvLtBhiNvAhabGyynlsmbAMSmBwtUJm8CEJsbDpI3JuNvJ28CCttBdfImoLC9UyFUy3MELLaDKliWvAlYGC
+9yZsAhFNeCsSxaBjyJlg0DHkTgIYhbwJQf/LuBhmOvAlYbG6wnFombwIQmx4sUJm8CUBsbjhI3pgjv
528CShsB9XJm4DC9k6FUC15E7DYDqpgWaojYA1D3gQgDMze5E0AwikvAMIs4rhpGPImWDQMeROA+pN3N8hw5E3AYnOD5dQyeROA2PRggcrkTQBic4O
+Zwv3RcnXUycNQUC9Z1DcaiADThucRAXMDfwpVzKBrkLZfTukJ2BhIQOxITyoJn5Q6sGhXew+bggQMpS/CHyFV7qf8ZZOqRHh+Kylk
+D2+6Xz2TTA1NZhSO3fvIHuoXK7ELYn6cYh0DN7jqFlJy5ulmtp0CCk
+7ryFiDsCb2GhqC8rUcv1n0+MBGbqvJh/L9tjgp/AyIurEN5a8DyoCOqBSq/8G7vIOF19ypww614VGTXklGomd
+O352hzLy9O5qtemf6JniLznhTvHWPHJxivFpXEJqzUKUuDcFli8C0mMEf19ESLNzm3VnGmcsnYUTB
+0sZBF8FNqRlKm6eGshVZt5OxlgBK6IWKstU2Lw
+wQviqMkhARAOZWXMozaiOU6iTbiQSX7dvDEkdeXATrT9kDR3XRtCgbrTzbrtpYtNkA8iCJSK8CZ/NVjzd+aaP
+q1ENBm9113zdXSCFoEH4rxktBLyJz
+0QN94TpkEHQ8nr6eTKHfBTVqalzEf8jmbYsn9uFw22LeIgkfe72fM/dWrFUodP5gV2d5wINm1fy1yQDbxDk5zXPi166J04yBb6DltC1+9njG26QQvt
gsWaW16ga3ec7ZuaDivoOMhdY0OJPpyGav4Tb8D/tdZEf67j8AAAD//wMAUEsDBBQABgAIAAAAIQAarjuLTAEAAIcCAAARAAgBZG9jUHJvcHMvY29yZ
S54bWwgogQBKKAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACckl9rwyAUxd8H+w7B90RtyxiSpNCN7mWFwTo29iZ628qiEbVN+
+1nkjbL/jzt0Zxzf55zTT4/6io5gPOqNgWiGUEJGFFLZbYFelkv01uU
+MCN5FVtoEAn8GheXl/lwjJRO3hytQUXFPgkkoxnwhZoF4JlGHuxA819Fh0mipvaaR7i0W2x5eKDbwFPCLnBGgKXPHDcAlM7ENEZKcWAtHtXdQApMFS
gwQSPaUbxlzeA0/7PgU4ZObUKJxs7neOO2VL04uA+ejUYm6bJmmkXI+an
+G31+NxVTZVpdyUAlbkUTDjgoXblA987fkgWOx4Uz/FIabdYcR9WceEbBXJx+mn+bWhnHBxU
+2LlJMfjY7y1K9lfDTKJsVlf8qK8Tu/u10tUTgidpZSkdLamhNEZI+S9zfZtvq3Rf9DnhP8mXgBll/j7r1N
+AgAA//8DAFBLAwQUAAYACAAAACEAaBAaatsHAACBPQAADwAAAHdvcmQvc3R5bGVzLnhtbMSbbXObOBDH39/MfQeG96kfksbXTN1OmrbXzPQhrZO51z
LIsSaAfICbpJ/+ViusYDCwG+jcqwSM9rfSrv6LE+3rtw9x5P2UaaZ0MvcnL8a+J5NAhyq5nfs31x
+P/vK9LBdJKCKdyLn/KDP/7Zs//3h9f5blj5HMPDCQZGdxMPfXeb45G42yYC1jkb3QG5nAhyudxiKHy/R2FIv0brs5CnS8Eblaqkjlj6PpeHzqF2ZSi
hW9WqlAvtfBNpZJjuNHqYzAok6ytdpkO2v3FGv3Og03qQ5klsGk48jai4VKnJnJSc1QrIJUZ3qVv4DJjKxHI2MKhk/G+Fsc
+V4cnF3eJjoVywgW735y4r+BlQt18F6uxDbKM3O
ZXqXFZXGFPz7qJM+8+zORBUpdw5KCgViBrU/nSaZ8+ESKLD/PlDj44do8dfCTIMtL1t6pUPkjQ8x
+gc2fIpr70+nuzoXxYO9eJJLb3T2ZHN0syp7MfXdrCXbnvkiPFufG2AinuftZmu5mb/Jwha5sRADBAI5Y5RKSAnLEcCJlcnA6g3yxFz
+2Zl3FNtcFBA0ArGwWLisrDrkCmbOwCQyfytVnHdzJcJHDB3MfWXDz5vIqVTqFJJ37r14ZJtxcyFh9UmEozX4p7t0kaxXKf9Yyuclk+HT/
+0dM/sJioLdJDu6fzjALoiz88BDIjUlbMJ0IE+GvZgAkDoSjxEGHturJG3ujQsWb/+6QExvDg5S1FGaHe+h/Kwhnve0NmpoZlSeAdlm
+Hvc3cdLfxMv+JjB5+63FrL8XoOt9I2Jzo5SV9KDmOrDJV16H41ctKWtG1LKoc0QtaTpH1HKkc0QtJTpH1DKgc0Qt4J0javHtHFELZ
+uIQKBwVbPoGFeDtLGvVR5JM75VgCY9pa4oNd6VSMVtKjZrzxTWqtttYrnYLnOaqyinzxfLRZ7q5LZzRaA6m637bE3+EG/WIlPwltSx9NOeS39t3nq8
v1MVdqJe2uSrzQlfTA6WsKtIBHKto1Cm3rV8sBFljP+qvYV9y
+h0rmdYP6vbde4t1lhyO2GnDYvevBLW/meV4Rq0bqbThql0GSfF8LQhL5uNf5Gh2sa7pSG8jZxaPWeEuYJAF9uX6MSEqL67OmdhAkCZgi0X/CmgfYL/
trjw7ZsYU/y3peiZ9gn+28L1TPuYH
+3xZSvNe/jS6pG214y9dy90pNPVNtrtgU55mLF3sEPQpsDexM4+SSRm7B28J5/eeRDANzdKnrJj8aSjDAo7HJaCm40+F3ZQKrI3YcyIHaAKa8pg9dNa
Bogtuj/kT2X+JsYtBqjS7l2zczsfN6wAlCDSO/T3rc6736GnDZpHpVwm8OeSTHo02nHDzqPSinyy9Y4R436FjwHqVwEZoH6lkAFqyI/mdx5XE+mQ
/sWRwWLLsqtimHZkZZ6xldmBeCVgoLpJeP9q2L3NuVCvmwQKO0D1ukmgsKNTqWWubhJYg9VNAquhajTHqKypnEmx62YZ5N4ECDMaRrwJoGHEmwAaRrw
JoP7i3Q0ZTrwJLLY2OE0tizcBhI9wvuo7UFm8CSC2Nli1K/5mtKt7aKX9y
+0A4k2gsANUF28ChR2dJvEmsPARTiZUWE7qCKxhxJsAGka8CaBhxJsAGka8CaBhxJsA6i/e3ZDhxJvAYmuD09SyeBNAbHlwoLJ4E0D4CEcbDoo37vrf
Lt4ECjtAdfEmUNjRqQiqe0klsNgBqrCceBNY
+AgnGQoWJjdnUsOIN2FGw4g3ATSMeBNAw4g3AdRfvLshw4k3gcXWBqepZfEmgNjy4EBl8SaA2NpwULxxM/528SZQ2AGqizeBwo5ORVCdzhFY7ABVWE6
8CSzMl97iTQDhI88FcWY0jHgTZjSMeBNAw4g3AdRfvLshw4k3gcXWBqepZfEmgNjy4EBl8SaA2NpwULxxj/x28SZQ2AGqizeBwo5ORVCdeBNY7ABVWE
7qCKxhxJsAwsTsLd4EED7yDBDuIk6YhhFvwoyGEW8CqL94d0OGE28Ci60NTlPL4k0AseXBgcriTQCxtcGcs4XzouTjqZOGJKCeM9idaiADpw1BogKLC
f6QK5lCk5XsPh3SE7ibIYPYkB7UKb7T+s6jHew+bkgQMkotI6XxSPcjntIpNSIcz1o6Ca6/XXifbANMbRym1P7JG
+geKrcLYXuSaRwCP/PHDbTsbHYny401aBAyfV1FCxC2yF1CQ1DR1mMGmz4feBCbqorb
+H/bggq/AxEH1lHBGlgBdES1oIoD7+4MEh53r4IbTsWjI08tGTs3i9PxT
+9Q9rm9M5qtfufmJHiLz3hSvHWNPHzERrXuIDRnoUtdHkLIlpFtMYNfLpMQZghNgvhfMxvM8EFYU/D5hYyiLwIb0nK9aX40kqvcfjoZYwWsmFrqPNdx
8/gUD4ijJ4cMQDqUnbGXZhLNeZJs4
6VMocOrZc2/alM5sBNtPyXtWdeGVKCudLNve9vFbZB3Ioq0TvAkfzVZi8/sMX/0aymgze6b6ZqrbSNoEbzb3S8ZvYCd0z97oE3WpAxCx+Ppy8kU
+l3Qo6bGRUytom3xxF0cblssWiThx17v59y/FmsdCxNL7Oos3wgyd2V3gGvinJwWe
+LXUxOnvQexgZbTtvzZ05lgm0H6YrNkVdaqC9wWOe8pBJXwHVQsnE1DMJmBbI4aLsP/sN673ZG9+Q8AAP//AwBQSwMEFAAGAAgAAAAhANStIeTrAQAA
qwUAABIAAAB3b3JkL2ZvbnRUYWJsZS54bWy0k1Fr2zAQx98H+w5G740lx8laU6e0WQN72cPoPoCiyLGYJRmdEi/ffifL8WAhtF6pDMb+n+7P3Y
+7+4ffukmO0oGypiRsRkkijbA7ZfYl+fmyubklCXhudryxRpbkJIE8rD5/uu
+KyhoPCeYbKLQoSe19W6QpiFpqDjPbSoPByjrNPf66faq5+3Vob4TVLfdqqxrlT2lG6ZIMNu4tLraqlJBfrThoaXyfnzrZoKM1UKsWzm7dW9w663ats
0ICYM+6iX6aKzPasPzCSCvhLNjKz7CZNFaUBitMZ7T/0g1JtCi
+7Y11fNsgu47lZDWAS7rCcI3imjdq61QfaLmxIBnGjrwpCc3ohi7wHZ6czsObpMFB1NyB9ONFGuWKa9Wczip0CiAGWuVFfdaP3KlQUAyB2mPgAFtakm
eKJ9tsSFRYSXIUHtejkmFR8bDhznxUcHKwsN6nv8Lueh9U0GfI6utM4+hckHhRWkLyXXbJD6u5uUIko0sksUAegcx8EhHX+/YEJxDJHsf
+sZM1tvLlNj/3/5fI3etEos8EIrzGiq+AeEIQYSgCivzjR4PhZDz/C2JJF09D2yOI7DUQjLKpINZc445cIxFGIXIIozFtSf5vJC6XhOYjm5EE7VcCV
+s9SzJsC6z+AAAA//8DAFBLAwQUAAYACAAAACEA5NMa63UBAADHAgAAEAAIAWRvY1
Byb3BzL2FwcC54bWwgogQBKKAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAACcUstOwzAQvCPxD1Hu1GmFEFRbI9QKceBRqWk5W/YmsXBsyzaI/j2bpk2DuOHTzqw9nh0b7r9bk31hiNrZRT6dFHmGVj
qlbb3It+Xj1W2exSSsEsZZXOR7jPk9v7yAdXAeQ9IYM5KwcZE3Kfk5Y1E22Io4obalTuVCKxLBUDNXVVriysnPFm1is6K4Yfid0CpUV34QzHvF
+Vf6r6hysvMXd+Xek2EOJbbeiIT8tbNjJsqlFtjAQumSMKVukRdEDwDWosbIp8D6At5dUJFfA
+sLWDYiCJkoPz67ATaC8OC90VIkCpa/aBlcdFXK3g4RZN1xYOMtQLFsUH4GnfadiTGEZ217G31BtoKog/DN0duAYCOFwSXNzithIgI7E7B0rRd2z8nn
qSK9j7j1pVt14RyP/CZHM77r1Gy8kORldjeedtSADUWCiuyf5M4EPNFzBNPdSUnZGtVpz99Gl9+u/5d8ej0paB0CO3H0JMOH4T8AAAD//wMAUEsBAi0
AFAAGAAgAAAAhAAkkh4KBAQAAjgUAABMAAAAAAAAAAAAAAAAAAAAAAFtDb250ZW50X1R5cGVzXS54bWxQSwECLQAUAAYACAAAACEAHpEat/MAAABOAg
AACwAAAAAAAAAAAAAAAAC6AwAAX3JlbHMvLnJ
lbHNQSwECLQAUAAYACAAAACEAfDuXOSIBAAC5AwAAHAAAAAAAAAAAAAAAAADeBgAAd29yZC9fcmVscy9kb2N1bWVudC54bWwucmVsc1BLAQItABQABg
AIAAAAIQBRbm8SgQIAAEwHAAARAAAAAAAAAAAAAAAAAEIJAAB3b3JkL2RvY3VtZW50LnhtbFBLAQItABQABgAIAAAAIQAw3UMpqAYAAKQbAAAVAAAAA
AAAAAAAAAAAAPILAAB3b3JkL3RoZW1lL3RoZW1lMS54bWxQSwECLQAUAAYACAAAACEA0c5eAHwDAACwCAAAEQAAAAAAAAAAAAAAAADNEgAAd29yZC9z
ZXR0aW5ncy54bWxQSwECLQAUAAYACAAAACEAF6AWTgIBAACsAQAAFAAAAAAAAAAAAAAAAAB4FgAAd29yZC93ZWJTZXR0aW5ncy54bWxQSwECLQAUAAY
ACAAAACEAhu5W3l8IAAByQAAAGgAAAAAAAAAAAAAAAACsFwAAd29yZC9zdHlsZXNXaXRoRWZmZWN0cy54bWxQSwECLQAUAAYACAAAACEAGq47i0wBAA
CHAgAAEQAAAAAAAAAAAAAAAABDIAAAZG9jUHJvcHMvY29yZS54bWxQSwECLQAUAAYACAAAACEAaBAaatsHAACBPQAADwAAAAAAAAAAAAAAAADGIgAAd
29yZC9zdHlsZXMueG1sUEsBAi0AFAAGAAgAAAAhANStIeTrAQAAqwUAABIAAAAAAAAAAAAAAAAAzioAAHdvcmQvZm9udFRhYmxlLnhtbFBLAQItABQA
BgAIAAAAIQDk0xrrdQEAAMcCAAAQAAAAAAAAAAAAAAAAAOksAABkb2NQcm9wcy9hcHAueG1sUEsFBgAAAAAMAAwACQMAAJQvAAAAAA==";
and my 1st word file contains data
as Hi <>
How are you?
and output file is
Hi <>
How are you?
I need to read the contains of file through stream and store it using stram as given in code
can any body helps..
It sounds like you want to do some kind of mail merging where you have your template document with placeholders and some data to fill into those placeholders to get the output document which keeps the formatting of the template.
I am solving these kind of tasks by using a toolkit which supports OpenXML and uses previously designed Word template (formatting and placeholders). Data is prepared in .NET application (collections of data model classes). Template file can be read as filestream (as in your scenario) or by referrencing a file path. At the end you get a new Word docx document which keeps the formatting of the template and contains the data. Take a look at this example.
Related
We are trying to manipulate a word document to remove a paragraph based on certain conditions. But the word file produced always ends up being corrupted when we try to open it with the error:
Word found unreadable content
The below code corrupts the file but if we remove the line:
Document document = mdp.Document;
The the file is saved and opens without issue. Is there an obvious issue that I am missing?
var readAllBytes = File.ReadAllBytes(#"C:\Original.docx");
using (var stream = new MemoryStream(readAllBytes))
{
using (WordprocessingDocument wpd = WordprocessingDocument.Open(stream, true))
{
MainDocumentPart mdp = wpd.MainDocumentPart;
Document document = mdp.Document;
}
}
File.WriteAllBytes(#"C:\New.docx", readAllBytes);
UPDATE:
using (WordprocessingDocument wpd = WordprocessingDocument.Open(#"C:\Original.docx", true))
{
MainDocumentPart mdp = wpd.MainDocumentPart;
Document document = mdp.Document;
document.Save();
}
Running the code above on a physical file we can still open Original.docx without the error so it seems limited to modifying a stream.
Here's a method that reads a document into a MemoryStream:
public static MemoryStream ReadAllBytesToMemoryStream(string path)
{
byte[] buffer = File.ReadAllBytes(path);
var destStream = new MemoryStream(buffer.Length);
destStream.Write(buffer, 0, buffer.Length);
destStream.Seek(0, SeekOrigin.Begin);
return destStream;
}
Note how the MemoryStream is instantiated. I am passing the capacity rather than the buffer (as in your own code). Why is that?
When using MemoryStream() or MemoryStream(int), you are creating a resizable MemoryStream instance, which you will want in case you make changes to your document. When using MemoryStream(byte[]) (as in your code), the MemoryStream instance is not resizable, which will be problematic unless you don't make any changes to your document or your changes will only ever make it shrink in size.
Now, to read a Word document into a MemoryStream, manipulate that Word document in memory, and end up with a consistent MemoryStream, you will have to do the following:
// Get a MemoryStream.
// In this example, the MemoryStream is created by reading a file stored
// in the file system. Depending on the Stream you "receive", it makes
// sense to copy the Stream to a MemoryStream before processing.
MemoryStream stream = ReadAllBytesToMemoryStream(#"C:\Original.docx");
// Open the Word document on the MemoryStream.
using (WordprocessingDocument wpd = WordprocessingDocument.Open(stream, true)
{
MainDocumentPart mdp = wpd.MainDocumentPart;
Document document = mdp.Document;
// Manipulate document ...
}
// After having closed the WordprocessingDocument (by leaving the using statement),
// you can use the MemoryStream for whatever comes next, e.g., to write it to a
// file stored in the file system.
File.WriteAllBytes(#"C:\New.docx", stream.GetBuffer());
Note that you will have to reset the stream.Position property by calling stream.Seek(0, SeekOrigin.Begin) whenever your next action depends on that MemoryStream.Position property (e.g., CopyTo, CopyToAsync). Right after having left the using statement, the stream's position will be equal to its length.
I am able to copy the contents and edit , but i am not getting the same template as the old one, the template is getting changed, and i have a image on my old file and that image is also not getting copied into my new file , rest of the other contents are getting copied,c an someone help me to make my new pdf file template as the old one, here is my code below.
public static void Main(string[] args)
{
var editedText = ExtractTextFromPdf(#"C:\backup_temp\Template.pdf");
string outputfile =#"C:\backup_temp\Result.pdf";
using (var fileStream = new FileStream(outputfile, FileMode.Create,
FileAccess.Write))
{
Document document = new Document(PageSize.A4, 25, 25, 30, 30);
PdfWriter writer = PdfWriter.GetInstance(document, fileStream);
document.Open();
document.Open();
document.Add(new Paragraph(editedText));
document.Close();
writer.Close();
fileStream.Close();
}
}
public static string ExtractTextFromPdf(string path)
{
using (PdfReader reader = new PdfReader(path))
{
StringBuilder text = new StringBuilder();
for (int i = 1; i <= reader.NumberOfPages; i++)
{
text.Append(PdfTextExtractor.GetTextFromPage(reader, i));
text.Replace("[DMxxxxxxx]", "[DM123456]");
}
return text.ToString();
}
}
As Bruno says, if your "template" is another pdf document, you can not achieve this functionality in a trivial way. Pdf documents do not automatically reflow their content. And to the best of my knowledge, there is no pdf library that will allow you to insert/replace/edit content and still produce a nice-looking document.
The best solution in your case would be:
store the template document as an easy to edit format
generate the pdf document based on this easy template
Example use-case:
I have some HTML document that contains the precise layout and images and text, and some placeholders for things I want to fill in.
I use JSoup (or some other library) to edit the DOM structure of my template, this is very easy since I can give elements IDs and simply change the content by ID. I don't need regular expressions.
I use pdfHTML (iText add-on) to convert my html document to pdf
I need to convert a powerpoint template from potx to pptx. As seen here: http://www.codeproject.com/Tips/366463/Create-PowerPoint-presentation-using-PowerPoint-te I have tried with the following code. However the resulting pptx document is invalid and can't be opened by Office Powerpoint. If I skip the line newDoc.ChangeDocumentType then the resulting document is valid, but not converted to pptx.
templateContentBytes is a byte array containing the content of the potx document.
And temppath points to its local version.
using (var stream = new MemoryStream())
{
stream.Write(templateContentBytes, 0, templateContentBytes.Length);
using (var newdoc = PresentationDocument.Open(stream, true))
{
newdoc.ChangeDocumentType(PresentationDocumentType.Presentation);
PresentationPart presentationPart = newdoc.PresentationPart;
presentationPart.PresentationPropertiesPart.AddExternalRelationship(
"http://schemas.openxmlformats.org/officeDocument/2006/" + "relationships/attachedTemplate",
new Uri(tempPath, UriKind.Absolute));
presentationPart.Presentation.Save();
File.WriteAllBytes(tempPathResult, stream.ToArray());
I had the same problem, just move
File.WriteAllBytes(tempPathResult, stream.ToArray());
outside of the using
I'm having a very strange issue with XFA Forms in iText / iTextSharp (iTextSharp 5.3.3 via NuGet). I am trying to fill out a static XFA styled form, however my changes are not taking.
I have both editions of iText in Action and have been consulting the second edition as well as the iTextSharp code sample conversions from the book.
Background: I have an XFA Form that I can fill out manually using Adobe Acrobat on my computer. Using iTextSharp I can read what the Xfa XML data is and see the structure of the data. I am essentially trying to mimic that with iText.
What the data looks like when I add data and save in Acrobat (note: this is only the specific section for datasets)
Here is the XML file I am trying to read in to replace the existing data (note: this is the entire contexts of that file):
However, when I pass the path to the replacement XML File in and try to set the data, the new file created (a copy of the original with the data replaced) without any errors being thrown, but the data is not being updated. I can see that the new file is created and I can open it, but there is no data in the file.
Here is the code being utilized to replace the data or populate for the first time, which is a variation of http://sourceforge.net/p/itextsharp/code/HEAD/tree/trunk/book/iTextExamplesWeb/iTextExamplesWeb/iTextInAction2Ed/Chapter08/XfaMovie.cs
public void Generate(string sourceFilePath, string destinationtFilePath, string replacementXmlFilePath)
{
PdfReader pdfReader = new PdfReader(sourceFilePath);
using (MemoryStream ms = new MemoryStream())
{
using (PdfStamper stamper = new PdfStamper(pdfReader, ms))
{
XfaForm xfaForm = new XfaForm(pdfReader);
XmlDocument doc = new XmlDocument();
doc.Load(replacementXmlFilePath);
xfaForm.DomDocument = doc;
xfaForm.Changed = true;
XfaForm.SetXfa(xfaForm, stamper.Reader, stamper.Writer);
}
var bytes = ms.ToArray();
File.WriteAllBytes(destinationtFilePath, bytes);
}
}
Any help would be very much appreciated.
I found the issue. The replacement DomDocument needs to be the entire merged XML of the new document, not just the data or datasets portion.
I upvoted your answer, because it's not incorrect (I'm happy my reference to the demo led you to have another look at your code), but now that I have a second look at your original code, I think it's better to use the book example:
public byte[] ManipulatePdf(String src, String xml) {
PdfReader reader = new PdfReader(src);
using (MemoryStream ms = new MemoryStream()) {
using (PdfStamper stamper = new PdfStamper(reader, ms)) {
AcroFields form = stamper.AcroFields;
XfaForm xfa = form.Xfa;
xfa.FillXfaForm(XmlReader.Create(new StringReader(xml)));
}
return ms.ToArray();
}
}
As you can see, it's not necessary to replace the whole XFA XML. If you use the FillXfaForm method, the data is sufficient.
Note: for the C# version of the examples, see http://tinyurl.com/iiacsCH08 (change the 08 into a number from 01 to 16 for the examples of the other chapters).
Im using Open XML SDK to read and write information to custom xml parts in a Word document.
Im serializing a xml structure into a class , modifying the data and serializing it back into the document.
Example code
DocumentFormat.OpenXml.Packaging.CustomXmlPart myPart = GetCustomXmlPart(mainPart, AITNamespaces.SiteDataNameSpace);
StreamReader myStrR = new System.IO.StreamReader(myPart.GetStream());
string myXML = myStrR.ReadToEnd();
sitedata = ObjectXMLSerializer<WDSiteData>.LoadString(myXML);
Site selSite = _applicationService.GetApplicationData().Sites.Find(item => item.Id == siteId);
sitedata.SiteId= selSite.Id;
sitedata.SiteName = "ööööaaaaaåååå"; // selSite.SiteName;
myXML = ObjectXMLSerializer<WDSiteData>.GetXMLString(sitedata);
myPart = GetCustomXmlPart(wordProcDocument.MainDocumentPart, AITNamespaces.SiteDataNameSpace);
using (StreamWriter sw = new StreamWriter(myPart.GetStream(FileMode.Create)))
{
sw.Write(myXML);
}
My problem is that the national characters become encoded and the text "ööööaaaaaåååå" is displayed in the word document as "????????aaaaa????????"
The actual encoding is done
myXML = ObjectXMLSerializer<WDSiteData>.GetXMLString(sitedata);
Anyone has a clue on how to go about handling national characters this way.
For whom it concerns , my trouble was that in my serializer the encoding was fixed
return ASCIIEncoding.ASCII.GetString(memStream.ToArray());
When i changed to
return ASCIIEncoding.UTF8.GetString(memStream.ToArray());
all is well.