ჩვენ ვცხოვრობთ სამყაროში, სადაც PHP დეველოპერებს დროდადრო უწევთ ინტერაქცია Windows ოპერაციულ სისტემასთან. WMI (Windows Management Interface) არის ერთ-ერთი ასეთი მაგალითი - ურთიერთქმედება Microsoft Office-თან.

ამ სტატიაში ჩვენ განვიხილავთ მარტივ ინტეგრაციას Word-სა და PHP-ს შორის: Microsoft Word-ის დოკუმენტის გენერირება შეყვანის ველებიდან HTML ფორმით PHP-ის (და მისი Interop გაფართოების) გამოყენებით.

მოსამზადებელი ნაბიჯები

პირველი ნაბიჯი არის დავრწმუნდეთ, რომ ჩვენ გვაქვს დაყენებული ძირითადი WAMP გარემო. ვინაიდან Interop ხელმისაწვდომია მხოლოდ Windows-ზე, ჩვენ გვჭირდება ჩვენი Apache სერვერი და PHP ინსტალაცია Windows-ის აპარატზე განლაგებული. ამ ტევადობით, მე ვიყენებ EasyPHP 14.1-ს, რომლის ინსტალაცია და კონფიგურაცია ძალიან მარტივია.

შემდეგი ნაბიჯი არის Microsoft Office-ის დაყენება. ვერსია არ არის ძალიან მნიშვნელოვანი. მე ვიყენებ Microsoft Office 2013 Pro-ს, მაგრამ Office-ის 2007 წელზე ძველი ვერსია უნდა იმუშაოს.

თქვენ ასევე უნდა დარწმუნდეთ, რომ ჩვენ გვაქვს დაინსტალირებული ბიბლიოთეკები Interop აპლიკაციის შესამუშავებლად (PIA, Primary Interop Assemblies, Basic Interop Assemblies). ამის გარკვევა შეგიძლიათ Windows Explorer-ის გახსნით და დირექტორიაში გადასვლით \ ასამბლეა და იქ უნდა დავინახოთ დაინსტალირებული შეკრებების ნაკრები:

აქ შეგიძლიათ ნახოთ Microsoft.Office.Interop.Word ელემენტი (ხაზგასმულია ეკრანის სურათზე). ეს იქნება ასამბლეა, რომელსაც გამოვიყენებთ დემოში. გთხოვთ, განსაკუთრებული ყურადღება მიაქციოთ ველებს „ასამბლეის სახელი“, „ვერსია“ და „საჯარო გასაღების ნიშანი“. ჩვენ მათ მალე გამოვიყენებთ ჩვენს PHP სკრიპტში.

ეს დირექტორია ასევე შეიცავს სხვა ასამბლეებს (მათ შორის ოფისის მთელ ოჯახს), რომლებიც ხელმისაწვდომია მათ პროგრამებში გამოსაყენებლად (არა მხოლოდ PHP, არამედ VB.net, C # და ა.შ.).

თუ ასამბლეის სია არ შეიცავს მთელ Microsoft.Office.Interop პაკეტს, მაშინ ჩვენ გვჭირდება ან ხელახლა დააინსტალიროთ Office PIA-ს დამატებით, ან ხელით ჩამოტვირთოთ პაკეტი Microsoft-დან და დააინსტალიროთ იგი. უფრო დეტალური ინსტრუქციებისთვის იხილეთ ეს MSDN გვერდი.

კომენტარი: ჩამოსატვირთად და ინსტალაციისთვის ხელმისაწვდომია მხოლოდ PIA სადისტრიბუციო ნაკრები Microsoft Office 2010. ამ პაკეტის ასამბლეის ვერსია არის 14.0.0, ხოლო ვერსია 15 მოდის მხოლოდ Office 2013-თან ერთად.

და ბოლოს, თქვენ უნდა ჩართოთ php_com_dotnet.dll გაფართოება php.ini-ში და გადატვირთოთ სერვერი.

ახლა თქვენ შეგიძლიათ დაიწყოთ პროგრამირება.

HTML ფორმა

ვინაიდან ამ მაგალითის უმეტესი ნაწილი სერვერის მხარეზე მოდის, ჩვენ შევქმნით მარტივ გვერდს ფორმის სახით, რომელიც ასე გამოიყურება:

ჩვენ გვაქვს ტექსტის ველი სახელისთვის, რადიო ღილაკების ჯგუფი სქესისთვის, სლაიდერი ასაკისთვის და ტექსტის შეყვანის ზონა შეტყობინების შესაყვანად, ასევე სამარცხვინო ღილაკი "გაგზავნა".

შეინახეთ ეს ფაილი, როგორც "index.html" ვირტუალური ჰოსტის დირექტორიაში, რათა მასზე წვდომა იყოს ისეთი მისამართით, როგორიცაა http: // test / test / interop.

სერვერის ნაწილი

სერვერის მხარის დამმუშავებლის ფაილი ჩვენი საუბრის მთავარი აქცენტია. დასაწყისისთვის მივცემ ამ ფაილის სრულ კოდს და შემდეგ ეტაპობრივად აგიხსნით.

ხილული = ჭეშმარიტი; $ fn = __DIR__. "\\ template.docx"; $ d = $ w-> Documents-> Open ($ fn); echo "დოკუმენტი ღიაა.

---

"; $ flds = $ d-> ველები; $ count = $ flds-> Count; echo" დოკუმენტში არის $ count ველები.
"; ექო"

"; $ რუკების = დაყენების ველები (); foreach ($ flds როგორც $ index => $ f) ($ f-> აირჩიეთ (); $ გასაღები = $ რუკების [$ ინდექსი]; $ ღირებულება = $ შეყვანის [$ გასაღები]; if ($ გასაღები == "სქესი") (if ($ მნიშვნელობა == "(! LANG: m") $value = "Ბატონი."; else $value = "Ქალბატონი."; } if($key=="printdate") $value= date ("Y-m-d H:i:s"); $w->Selection->TypeText($value); echo "!}
• ველს $ index: $ კლავიშს ვანიჭებ $ მნიშვნელობას
";) ექო"

"; echo" დამუშავება დასრულდა!

---

"; echo" აკრეფა, გთხოვთ დაელოდოთ ...
"; $ d-> ამობეჭდვა (); ძილის (3); ექო" შესრულებულია! "; $ w-> გასვლა (false); $ w = null; ფუნქციის დაყენების ველები () ($ mapping = მასივი (); $ mapping = "სქესი"; $ mapping = "სახელი"; $ mapping = "ასაკი"; $ mapping = "msg"; $ mapping = "დაბეჭდვის თარიღი"; დაბრუნება $ რუკების;)

მას შემდეგ, რაც ჩვენ დავწერეთ ფორმიდან მიღებული მნიშვნელობები $ inputs ცვლადში და ასევე შევქმენით ცარიელი ელემენტი printdate კლავიშით (რატომ გავაკეთეთ ეს - მოგვიანებით განვიხილავთ), გადავდივართ ოთხ ძალიან მნიშვნელოვან ხაზზე:

$ ასამბლეა = "Microsoft.Office.Interop.Word, ვერსია = 15.0.0.0, კულტურა = ნეიტრალური, PublicKeyToken = 71e9bce111e9429c"; $ class = "Microsoft.Office.Interop.Word.ApplicationClass"; $ w = ახალი DOTNET ($ ასამბლეა, $ კლასი); $ w-> ხილული = ჭეშმარიტი;

PHP COM მანიპულატორი მოითხოვს კლასის ინსტალაციას "ასამბლეის" ფარგლებში. ჩვენს შემთხვევაში, ჩვენ ვმუშაობთ Word-თან. თუ გადახედავთ პირველ ეკრანის სურათს, შეგიძლიათ ჩაწეროთ სრული ასამბლეის ხელმოწერა Word-ისთვის:

• „სახელი“, „ვერსია“, „საჯარო გასაღების ნიშანი“ აღებულია ინფორმაციადან, რომლის ნახვაც შესაძლებელია „c: \ Windows \ ასამბლეაში“.
• „კულტურა“ ყოველთვის ნეიტრალურია

კლასს, რომელსაც ჩვენ გვინდა მივმართოთ, ყოველთვის სახელდება „ასამბლეის სახელი“ + „.ApplicationClass“.

ამ ორი პარამეტრის დაყენებით შეგვიძლია მივიღოთ Word-თან მუშაობის ობიექტი.

ეს ობიექტი შეიძლება დარჩეს ფონზე, ან ჩვენ შეგვიძლია მისი გაშვება ხილული ატრიბუტის true-ზე დაყენებით.

შემდეგი ნაბიჯი არის დოკუმენტის გახსნა, რომელიც საჭიროებს დამუშავებას და $ d ცვლადზე "დოკუმენტის" მაგალითის ჩაწერა.

თქვენი დოკუმენტის ფორმის მონაცემების საფუძველზე შინაარსის შექმნის რამდენიმე გზა არსებობს.

ყველაზე უარესი იქნება დოკუმენტის შინაარსის მყარი კოდირება PHP-ში და შემდეგ გამოტანა Word დოკუმენტში. მე მკაცრად გირჩევთ არ გააკეთოთ ეს შემდეგი მიზეზების გამო:

1. თქვენ კარგავთ მოქნილობას. გამომავალი ფაილში ნებისმიერი ცვლილება საჭიროებს PHP კოდში ცვლილებებს.
2. ეს არღვევს კონტროლისა და ხედვის გამიჯვნას
3. სტილების გამოყენება დოკუმენტის შინაარსზე (გასწორება, შრიფტები, სტილები და ა.შ.) სკრიპტში მნიშვნელოვნად გაზრდის კოდის ხაზების რაოდენობას. სტილის შეცვლა პროგრამულად ძალიან რთულია.

კიდევ ერთი ვარიანტი იქნება პოვნა და ჩანაცვლება. PHP-ს აქვს კარგი ჩაშენებული საშუალებები ამისთვის. ჩვენ შეგვიძლია შევქმნათ Word დოკუმენტი, რომელშიც განვათავსებთ ეტიკეტებს სპეციალური დელიმიტერებით, რომლებიც მოგვიანებით შეიცვლება. მაგალითად, ჩვენ შეგვიძლია შევქმნათ დოკუმენტი, რომელიც შეიცავს შემდეგ ნაწყვეტს:

ხოლო PHP-ით მარტივად შეგვიძლია შევცვალოთ ფორმიდან მიღებული „Name“ ველის შიგთავსით.

ეს მარტივია და გვიხსნის ყველა იმ უსიამოვნო შედეგისგან, რასაც პირველი მეთოდით ვაწყდებით. ჩვენ უბრალოდ უნდა გადავწყვიტოთ სწორი დელიმიტერი, ამ შემთხვევაში ჩვენ ვიყენებთ შაბლონს.

მე გირჩევთ მესამე გზას და ის ეფუძნება Word-ის უფრო ღრმა ცოდნას. ჩვენ გამოვიყენებთ ველებს, როგორც ჩანაცვლების ველებს, ხოლო PHP კოდის გამოყენებით, პირდაპირ განვაახლებთ მნიშვნელობებს ველებში შესაბამისი მნიშვნელობებით.

ეს მიდგომა არის მოქნილი, სწრაფი და შეესაბამება Word-ის საუკეთესო პრაქტიკას. ის ასევე თავიდან აიცილებს დოკუმენტში სრული ტექსტის ძიებას, რაც კარგია შესრულებისთვის. გაითვალისწინეთ, რომ ამ გამოსავალს ასევე აქვს უარყოფითი მხარეები.

Word თავიდანვე არ უჭერდა მხარს დასახელებულ ინდექსებს ველებისთვის. მაშინაც კი, თუ ჩვენ დავაზუსტეთ შექმნილი ველების სახელები, მაინც უნდა გამოვიყენოთ ამ ველების რიცხვითი იდენტიფიკატორები. ის ასევე განმარტავს, თუ რატომ უნდა გამოვიყენოთ ცალკე ფუნქცია (setupfields) ველის ინდექსის ფორმიდან ველის სახელზე გამოსაყენებლად.

ამ დემო სახელმძღვანელოში ჩვენ გამოვიყენებთ დოკუმენტს 5 MERGEFIELD ველით. ჩვენ განვათავსებთ შაბლონის დოკუმენტს იმავე ადგილას, სადაც ჩვენი სკრიპტის დამმუშავებელი.

გთხოვთ გაითვალისწინოთ, რომ ბეჭდვის თარიღის ველს არ აქვს შესაბამისი ველი ფორმაზე. ამიტომ ჩვენ დავამატეთ ცარიელი printdate ელემენტი $ შეყვანის მასივში. ამის გარეშე სკრიპტი კვლავ იმუშავებს და იმუშავებს, მაგრამ PHP გამოსცემს გაფრთხილებას, რომ ბეჭდვის თარიღის ინდექსი არ არის $ შეყვანის მასივში.

ველების ახალი მნიშვნელობებით ჩანაცვლების შემდეგ, ჩვენ დავბეჭდავთ დოკუმენტს გამოყენებით

$ d-> PrintOut ();

PrintOut მეთოდი იღებს რამდენიმე არჩევით პარამეტრს და ჩვენ გამოვიყენებთ მის უმარტივეს ფორმას. ეს დაბეჭდავს დოკუმენტის ერთ ასლს Windows მოწყობილობაზე მიმაგრებულ ნაგულისხმევ პრინტერზე.

თქვენ ასევე შეგიძლიათ დარეკოთ PrintPreview, რათა გადახედოთ მიღებულ გამომავალს მის დაბეჭდვამდე. სრულად ავტომატიზებულ გარემოში, ჩვენ რა თქმა უნდა გამოვიყენებთ PrintOut მეთოდს.

თქვენ უნდა დაელოდოთ ცოტა ხნით ადრე Word-ის გასვლამდე, რადგან დრო სჭირდება ბეჭდვის სამუშაოს რიგში. შეფერხების გარეშე (3), $ w-> Quit მეთოდი შესრულებულია დაუყოვნებლივ და სამუშაო არ არის რიგში.

და ბოლოს, ჩვენ ვუწოდებთ $ w-> Quit-ს (false), რომელიც ხურავს Word აპლიკაციას, რომელიც გამოიძახეს ჩვენი სკრიპტით. მეთოდისთვის გადაცემული ერთადერთი პარამეტრი არის იმის თქმა, რომ შეინახოთ ფაილი გასვლამდე. ჩვენ გავაკეთეთ დოკუმენტში ცვლილებები, მაგრამ არ გვინდა მათი შენახვა, რადგან გვჭირდება სუფთა შაბლონი შემდგომი მუშაობისთვის.

კოდის დასრულების შემდეგ, შეგვიძლია ჩავტვირთოთ ჩვენი ფორმის გვერდი, შეავსოთ რამდენიმე მნიშვნელობა და გამოვაგზავნოთ იგი. ქვემოთ მოცემულ სურათებში ნაჩვენებია სკრიპტის გამოსავალი, ისევე როგორც განახლებული Word დოკუმენტი:

დამუშავების სიჩქარის გაუმჯობესება და ცოტა მეტი PIA-ს შესახებ

PHP სუსტად აკრეფილი ენაა. Object ტიპის COM ობიექტი. სკრიპტის დაწერის დროს ჩვენ არ გვაქვს საშუალება მივიღოთ ობიექტის აღწერა, იქნება ეს Word აპლიკაცია, დოკუმენტი თუ ველი. ჩვენ არ ვიცით რა თვისებები აქვს ამ ობიექტს ან რა მეთოდებს უჭერს მხარს.

ეს მნიშვნელოვნად შეანელებს განვითარების სიჩქარეს. განვითარების დასაჩქარებლად გირჩევთ ფუნქციების ჯერ C #-ში ჩაწერას, შემდეგ კი კოდის PHP-ში თარგმნას. მე შემიძლია გირჩიოთ უფასო IDE C # განვითარებისთვის, სახელწოდებით "#განვითარება". თქვენ შეგიძლიათ იპოვოთ იგი. მე მირჩევნია ვიზუალური სტუდია, რადგან #განვითარება უფრო პატარა, მარტივი და სწრაფია.

C # კოდის PHP-ში გადატანა არც ისე საშინელია, როგორც ჟღერს. ნება მომეცით გაჩვენოთ რამდენიმე სტრიქონი C #-ში:

Word.Application w = new Word.Application (); w.Visible = true; სიმებიანი გზა = Application.StartupPath + "\\ template.docx"; Word.Document d = w.Documents.Open (გზა) როგორც Word.Document; Word.Fields flds = d.Fields; int len ​​= flds.Count; foreach (Word.F ველი f flds-ში) (f.Select (); int i = f.Index; w.Selection.TypeText ("...");)

თქვენ შეამჩნევთ, რომ C # კოდი ძალიან ჰგავს PHP კოდს, რომელიც ადრე ვაჩვენე. C # არის მკაცრად აკრეფილი ენა, ამიტომ ამ მაგალითში თქვენ შეამჩნევთ რამდენიმე კასტინგის ოპერატორს და ცვლადები უნდა იყოს აკრეფილი.

ცვლადის ტიპის მითითებით, შეგიძლიათ ისარგებლოთ უფრო მკაფიო კოდით და ავტომატური შევსებით, ხოლო განვითარების სიჩქარე მნიშვნელოვნად გაიზრდება.

თქვენი PHP განვითარების დაჩქარების კიდევ ერთი გზა არის Word-ში მაკროს გამოძახება. ჩვენ ვასრულებთ მოქმედებების იგივე თანმიმდევრობას და შემდეგ ვინახავთ მას მაკროდ. მაკრო იწერება Visual Basic-ში, რომელიც ასევე ადვილად ითარგმნება PHP-ზე.

და რაც მთავარია, Microsoft-ის Office PIA დოკუმენტაცია, განსაკუთრებით თითოეული Office პროგრამის სახელთა სივრცის დოკუმენტაცია, არის ყველაზე დეტალური საცნობარო მასალა. სამი ყველაზე ხშირად გამოყენებული აპლიკაციაა:

• Excel 2013: http://msdn.microsoft.com/en-us/library/microsoft.office.interop.excel(v=office.15).aspx
• Word 2013: http://msdn.microsoft.com/en-us/library/microsoft.office.interop.word(v=office.15).aspx
• PowerPoint 2013: http://msdn.microsoft.com/en-us/library/microsoft.office.interop.powerpoint(v=office.15).aspx

დასკვნა

ამ სტატიაში ჩვენ გაჩვენეთ, თუ როგორ უნდა შეავსოთ Word დოკუმენტი მონაცემებით PHP COM ბიბლიოთეკებისა და Microsoft Office-ის თავსებადობის გამოყენებით.

Windows და Office ფართოდ გამოიყენება ყოველდღიურ ცხოვრებაში. Office/Window-ისა და PHP-ის სიძლიერის ცოდნა სასარგებლო იქნება ყველა PHP და Windows დეველოპერისთვის.

PHP COM გაფართოება გიხსნის ამ კომბინაციის გამოყენების კარს.

ვაგრძელებთ Word-ში ფორმებთან მუშაობის თემას, რომელიც ადრე დავიწყეთ. წინა სტატიებში ფორმებს მხოლოდ „მოწინავე მომხმარებლის“ კუთხით ვუყურებდით, ე.ი. ჩვენ შევქმენით დოკუმენტები, რომელთა შევსება მარტივია ხელით. დღეს მინდა შემოგთავაზოთ ამ ამოცანის გაფართოება და შევეცადოთ გამოვიყენო კონტენტის კონტროლის მექანიზმი დოკუმენტების გენერირებისთვის.

სანამ უშუალოდ დავალებაზე გადავალთ, მსურს რამდენიმე სიტყვა ვთქვა იმის შესახებ, თუ როგორ ინახება Word დოკუმენტებში კონტენტის კონტროლის მონაცემები (მიზანმიმართულად გამოვტოვებ, თუ როგორ არის ისინი დაკავშირებული დოკუმენტის შინაარსთან, მაგრამ იმედი მაქვს, რომ დავბრუნდები ამის შესახებ ოდესმე შემდეგ სტატიებში).

ბუნებრივი კითხვა - რა არის itemProps1.xmlდა მსგავსი კომპონენტები? ეს კომპონენტები ინახავს მონაცემთა წყაროების აღწერილობებს. სავარაუდოდ, როგორც დეველოპერებმა დაგეგმეს, დოკუმენტში ჩადებული xml-ek-ის გარდა, უნდა გამოეყენებინათ სხვებიც, მაგრამ ჯერჯერობით მხოლოდ ეს მეთოდია დანერგილი.

რაც ჩვენთვის სასარგებლოა itemPropsX.xml? ის ფაქტი, რომ ისინი ჩამოთვლიან xml-სქემებს (მათი სამიზნე სახელების სივრცე) რომლებიც გამოიყენება მშობელში ელემენტიX.xml... ეს ნიშნავს, რომ თუ ჩვენ დავაკავშირეთ ერთზე მეტი მორგებული xml დოკუმენტთან, მაშინ, რომ ვიპოვოთ ის, რაც გვჭირდება, უნდა გავიაროთ itemPropsX.xmlკომპონენტები და იპოვნეთ სასურველი წრე და, შესაბამისად, სასურველი ელემენტიX.xml.

ახლა კიდევ ერთი რამ. ჩვენ ხელით არ გავაანალიზებთ კომპონენტებს შორის ურთიერთობებს და არ მოვიძიებთ საჭიროებს მხოლოდ ძირითადი Packaging API-ს გამოყენებით! ამის ნაცვლად, ჩვენ გამოვიყენებთ Open XML SDK-ს (მისი ასამბლეები ხელმისაწვდომია NuGet-ის საშუალებით). რა თქმა უნდა, ადრე ჩვენ არ გვითქვამს სიტყვა ამ API-ს შესახებ, მაგრამ ჩვენი ამოცანისთვის მისგან მინიმალურია საჭირო და ყველა კოდი საკმაოდ გამჭვირვალე იქნება.

ისე, მთავარი შესავალი გაკეთდა, შეგიძლიათ დაიწყოთ მაგალითით.

ტრადიციულად, ჩვენ ავიღებთ იგივე „შეხვედრის მოხსენებას“, რომელიც სტატიაში დავხატეთ. შეგახსენებთ, რომ დოკუმენტის შაბლონი ასე გამოიყურებოდა:

და ასე, XML, რომელზეც დოკუმენტის ველები იყო მიბმული

< meetingNotes xmlns ="urn:MeetingNotes" subject ="" date ="" secretary ="" > < participants > < participant name ="" /> < decisions > < decision problem ="" solution ="" responsible ="" controlDate ="" />

ნაბიჯი 1. მონაცემთა მოდელის შექმნა

სინამდვილეში, ჩვენი ამოცანაა არა მხოლოდ დოკუმენტის გენერირება, არამედ შევქმნათ (ყოველ შემთხვევაში, დრაფტულ ვერსიაში) მოსახერხებელი ინსტრუმენტი, როგორც დეველოპერის, ასევე მომხმარებლისთვის გამოსაყენებლად.

ამიტომ, ჩვენ გამოვაცხადებთ მოდელს, როგორც C # კლასების სტრუქტურას:

საჯარო კლასის შეხვედრის შენიშვნები (public MeetingNotes () (მონაწილეები = ახალი სია (); გადაწყვეტილებები = ახალი სია (); ) საჯარო სტრიქონი საგანი (მიიღე; დაყენება;) საჯარო თარიღიდრო თარიღი (მიიღე; დაყენება;) საჯარო სტრიქონი მდივანი (მიიღე; დაყენება;) საჯარო სია მონაწილეთა (მიიღეთ; დააყენეთ;) საჯარო სია გადაწყვეტილებები (მიიღე; დაყენება;)) საჯარო კლასი გადაწყვეტილება (საჯარო სტრიქონი პრობლემა (მიიღე; დაყენება;) საჯარო სტრიქონი ამოხსნა (მიიღე; დაყენება;) საჯარო სტრიქონი პასუხისმგებელი (მიიღე; დაყენება;) საჯარო DateTime ControlDate (მიღება; დაყენება;)) საჯარო კლასის მონაწილე (საჯარო სტრიქონის სახელი (მიღება; კომპლექტი;))

ზოგადად, არაფერი განსაკუთრებული, გარდა ატრიბუტების დამატებისა XML სერიალიზაციის სამართავად (რადგან სახელები მოდელში და საჭირო XML ოდნავ განსხვავდება).

ნაბიჯი 2. ზემოაღნიშნული მოდელის სერიალიზაცია XML-ზე

ამოცანა, პრინციპში, ტრივიალურია. რასაც ჰქვია "აიღეთ ჩვენი საყვარელი XmlSerializer და წადით", თუ არა ერთი მაგრამ…

სამწუხაროდ, Office-ის ამჟამინდელ ვერსიას, როგორც ჩანს, აქვს შეცდომა, რომელიც შემდეგია: თუ მორგებულია xml წინამთავარი სახელთა სივრცის გამოცხადებით (ის, საიდანაც Word-მა უნდა მიიღოს ელემენტები საჩვენებლად), გამოაცხადეთ კიდევ ერთი, შემდეგ განმეორებადი შიგთავსის კონტროლი იწყებს არასწორად ჩვენებას (მხოლოდ იმდენი ელემენტია ნაჩვენები, რამდენიც თავად შაბლონში იყო - ე.ი. განმეორებითი განყოფილება არ მუშაობს. ).

იმათ. ეს xml მუშაობს:

< test xmlns ="urn:Test" attr1 ="1" attr2 ="2" > < repeatedTag attr ="1" /> < repeatedTag attr ="2" /> < repeatedTag attr ="3" />

და ესეც:

< test xmlns ="urn:Test" attr1 ="1" attr2 ="2" xmlns:t ="urn:TTT" > < repeatedTag attr ="1" /> < repeatedTag attr ="2" /> < repeatedTag attr ="3" />

მაგრამ ეს აღარ არის:

< test xmlns:t ="urn:TTT" xmlns ="urn:Test" attr1 ="1" attr2 ="2" > < repeatedTag attr ="1" /> < repeatedTag attr ="2" /> < repeatedTag attr ="3" />

ვცადე შეცდომის გაგზავნა Microsoft-ის მხარდაჭერაზე Connect-ზე, მაგრამ რატომღაც არ მაქვს წვდომა ოფისის მეშვეობით შეცდომების გაგზავნაზე. და MSDN ფორუმზე დისკუსიამაც არ უშველა.

ზოგადად, აუცილებელი შემოვლითი მანევრი. XML ხელით რომ ჩამოგვეყალიბებინა, პრობლემა არ იქნებოდა - ყველაფერს თავად გავაკეთებდით. თუმცა, ამ შემთხვევაში, მე ნამდვილად მინდა გამოვიყენო სტანდარტული XmlSerializer, რომელიც ნაგულისხმევად ამატებს თავის რამდენიმე სახელთა სივრცეს გამომავალ XML-ში, მაშინაც კი, თუ ეს სახელების სივრცე არ არის გამოყენებული.

ჩვენ გავაკეთებთ სრულ ჩახშობას XmlSerializer-ში ჩვენი საკუთარი სახელების სივრცის გამომუშავების შესახებ. მართალია, ეს მიდგომა იმუშავებს მხოლოდ იმ შემთხვევაში, თუ მას ნამდვილად არ სჭირდება ისინი (თორემ ისინი მაინც დაემატება და მხოლოდ ჩვენსაზე ადრე).

სინამდვილეში, მთელი კოდი (იმ პირობით, რომ ცვლადი შეხვედრის შენიშვნებიშეიცავს ადრე დასახლებულ MeetingNotes ობიექტს):

var serializer = ახალი XmlSerializer (ტიპი (MeetingNotes));
var serializedDataStream = ახალი MemoryStream ();

var namespaces = new XmlSerializerNamespaces ();
სახელთა სივრცეები.დამატება (“”, “”);

serializer.Serialize (serializedDataStream, meetingNotes, namespace);
serializedDataStream.Seek (0, SeekOrigin.Begin);

ნაბიჯი 3. შეიყვანეთ მიღებული XML Word დოკუმენტში.

აქ ჩვენ ვაკეთებთ შემდეგს:

• დააკოპირეთ შაბლონი და გახსენით ასლი
• იპოვეთ მასში საჭირო მორგებული xml (ძებნა სახელთა სივრცის მიხედვით "Urn: MeetingNotes")
• შეცვალეთ კომპონენტის შინაარსი ჩვენი XML-ით

File.Copy (templateName, resultDocumentName, true); გამოყენებით (var document = WordprocessingDocument.Open (resultDocumentName, true)) (var xmlpart = document.MainDocumentPart.CustomXmlParts .Single (xmlPart => xmlPart.CustomXmlPropertiesPart.DataStoreItem.SchemaReferences.OfTy () .ნებისმიერი (sr => sr.Uri.Value == "(! LANG: urn: MeetingNotes"!}

სერიის წინა სტატიებში "დოკუმენტების შევსების ავტომატიზაცია" მე ვისაუბრე იმაზე, თუ როგორ შევქმნათ აპლიკაციის მომხმარებლის ინტერფეისი, მოვაწყოთ შეყვანის მონაცემების ვალიდაცია და მივიღოთ რიცხვი სიტყვებით VBA კოდის გამოყენების გარეშე. ამ დასკვნით სტატიაში ვისაუბრებთ მაგიაზე - Excel-ის სამუშაო წიგნიდან Word დოკუმენტში ყველა საჭირო მნიშვნელობის გადატანა. ნება მომეცით გაჩვენოთ რა უნდა იყოს შედეგი:

მექანიზმის აღწერა

დასაწყისისთვის, ზოგადად აღვწერ, თუ როგორ გადაიცემა მონაცემები Word დოკუმენტში. პირველ რიგში, ჩვენ გვჭირდება Word დოკუმენტის შაბლონი, რომელიც შეიცავს ყველა მარკირებას, ცხრილს და ტექსტის იმ ნაწილს, რომელიც უცვლელი დარჩება. ამ შაბლონში, თქვენ უნდა დაადგინოთ ადგილები, რომლებშიც შეიცვლება Excel სამუშაო წიგნის მნიშვნელობები - ამის გაკეთების ყველაზე მოსახერხებელი გზაა სანიშნეების გამოყენება. ამის შემდეგ თქვენ უნდა მოაწყოთ Excel-ის მონაცემები ისე, რომ შეესაბამებოდეს Word შაბლონს და ბოლოს, რაც არანაკლებ მნიშვნელოვანია, თავად ჩაწეროთ გადაცემის პროცედურა VBA-ში.

ასე რომ, პირველ რიგში.

შექმენით Word დოკუმენტის შაბლონი

აქ ყველაფერი უკიდურესად მარტივია - ჩვენ ვქმნით რეგულარულ დოკუმენტს, ვბეჭდავთ და ვაფორმებთ ტექსტს, ზოგადად, ვცდილობთ მივიღოთ საჭირო ფორმა. იმ ადგილებში, სადაც საჭირო იქნება Excel-ის მნიშვნელობების ჩანაცვლება, თქვენ უნდა შექმნათ სანიშნეები. ეს კეთდება შემდეგნაირად:

ამრიგად, თქვენ უნდა შექმნათ ყველა სანიშნე, ანუ მონიშნოთ ყველა ის ადგილი, სადაც ჩასმული იქნება მონაცემები Excel-დან. შედეგად მიღებული ფაილი უნდა იყოს შენახული, როგორც "MS Word Template" მენიუს ელემენტის "File" -> "Save As ..." გამოყენებით.

Excel-ის მონაცემების მომზადება

მოხერხებულობისთვის მე გადავწყვიტე განვათავსო ყველა მონაცემი, რომელიც უნდა გადავიდეს Word დოკუმენტში ცალკეულ სამუშაო ფურცელზე სახელწოდებით სანიშნეები - სანიშნეები. ამ ფურცელს აქვს ორი სვეტი: პირველი შეიცავს სანიშნეების სახელებს (ზუსტად ისე, როგორც დასახელებულია Word დოკუმენტში), ხოლო მეორე შეიცავს შესაბამის მნიშვნელობებს, რომლებიც უნდა შეიფუთოს.

ამ მნიშვნელობების ზოგიერთი ნაწილი მიიღება უშუალოდ მონაცემთა შეყვანის ფურცლიდან, ზოგი კი დამხმარე ცხრილებიდან, რომლებიც განთავსებულია მხარდაჭერის ფურცელზე. ამ სტატიაში მე არ გავაანალიზებ ფორმულებს, რომლებიც გამოთვლიან საჭირო მნიშვნელობებს, თუ რამე არ არის ნათელი - დასვით კითხვები კომენტარებში.

ამ ეტაპზე მნიშვნელოვანია სანიშნეების ყველა სახელის სწორად მითითება - მონაცემთა გადაცემის სისწორე დამოკიდებულია ამაზე.

გადაცემის პროცედურა

მაგრამ ეს ყველაზე საინტერესოა. მონაცემთა გადაცემის კოდის შესრულების ორი ვარიანტი არსებობს:

• კოდი შესრულებულია Excel-ის სამუშაო წიგნში, მონაცემები გადაეცემა Word-ს თითო მნიშვნელობით და დაუყოვნებლივ მოთავსებულია დოკუმენტში.
• კოდი შესრულებულია ცალკე Word დოკუმენტში, ყველა მონაცემი გადადის Excel-დან ერთ პარტიაში.

შესრულების სიჩქარის თვალსაზრისით, განსაკუთრებით სანიშნეების დიდი რაოდენობით, მეორე ვარიანტი გამოიყურება ბევრად უფრო მიმზიდველი, მაგრამ ის მოითხოვს უფრო რთულ მოქმედებებს. ეს არის ის, რაც მე გამოვიყენე.

აი, რა უნდა გააკეთოთ:

• შექმენით მაკრო ჩართული Word დოკუმენტის შაბლონი.ეს შაბლონი შეიცავს შესრულებად VBA კოდს.
  
• შექმნილ შაბლონში უნდა მოათავსოთ VBA-ში დაწერილი პროგრამა.ამისათვის შაბლონის რედაქტირებისას დააჭირეთ კლავიშთა კომბინაციას Alt + F11 და Visual Basic რედაქტორის გახსნილ ფანჯარაში შეიყვანეთ პროგრამის კოდი.
• Excel-ის სამუშაო წიგნში ჩაწერეთ კოდი, რომელიც იძახებს შევსების პროცედურას ახლად შექმნილი Word შაბლონიდან.

მე არ მოგაწოდებთ პროცედურის ტექსტს სტატიაში - მისი მარტივად ნახვა შესაძლებელია არქივში Template საქაღალდეში მდებარე FillDocument.dotm ფაილში, მაგალითით.

როგორ შეგიძლიათ გამოიყენოთ ეს ყველაფერი თქვენი კონკრეტული პრობლემის გადასაჭრელად?

მე მესმის, რომ სიტყვებით ყველაფერი ძალიან მარტივია, მაგრამ რა ხდება პრაქტიკაში? მე გირჩევთ გამოიყენოთ მხოლოდ მზა ვარიანტი. ჩამოტვირთეთ არქივი მაგალითით, Excel-ის სამუშაო წიგნში დააჭირეთ Alt + F11, რომ გახსნათ Visual Basic რედაქტორი და წაიკითხოთ ჩემი ყველა კომენტარი პროგრამაზე. იმისათვის, რომ შეცვალოთ პროგრამა თქვენს საჭიროებებზე, თქვენ უბრალოდ უნდა შეცვალოთ რამდენიმე მუდმივის მნიშვნელობა, ისინი განთავსებულია პროგრამის დასაწყისში. თქვენ შეგიძლიათ თავისუფლად დააკოპიროთ მთელი პროგრამის ტექსტი თქვენს პროექტში.

არქივის სტრუქტურა

ამ სტატიას თანდართული არქივი შეიცავს რამდენიმე ფაილს.

მთავარი ფაილი არის Excel-ის სამუშაო წიგნი სახელწოდებით "Create Confirmations". ამ სამუშაო წიგნში არის 4 სამუშაო ფურცელი, რომელთაგან მხოლოდ ორია ნაჩვენები: „შეყვანა“ - მონაცემთა შეყვანის ფურცელი და „მონაცემთა ბაზა“ - ყველა შეყვანილი დოკუმენტის არქივი.

Templates საქაღალდე შეიცავს Word დოკუმენტის შაბლონებს. ერთი არის შაბლონი, რომელიც შეიცავს სანიშნეების შევსების პროგრამას, ხოლო მეორე არის ფორმა, რომელიც უნდა შეავსოთ. თქვენ შეგიძლიათ გამოიყენოთ შაბლონი პროგრამით ცვლილებების გარეშე, მაგრამ შევსების ფორმა, რა თქმა უნდა, ხელახლა უნდა შესრულდეს თქვენი საჭიროებების შესაბამისად.

როგორ გადავამუშაოთ მაგალითი "საკუთარი თავისთვის"?

1. მოამზადეთ Word დოკუმენტის შაბლონი, რომელიც უნდა შეავსოთ. შექმენით მასში ყველა საჭირო სანიშნე და შეინახეთ როგორც "MS Word შაბლონი".
2. დააკოპირეთ FillDocument.dotm ფაილი ამ სტატიას მიმაგრებული არქივიდან საქაღალდეში მომზადებული შაბლონით. ეს ფაილი პასუხისმგებელია შაბლონის სანიშნეების შევსებაზე და თქვენ არ გჭირდებათ მასში რაიმეს შეცვლა.
3. მოამზადეთ Excel სამუშაო წიგნი მონაცემთა შეყვანისთვის. თქვენი გადასაწყვეტია, ექნება თუ არა მას რაიმე "მოწინავე" მომხმარებლის ინტერფეისი და შეასრულოს სხვადასხვა ჭკვიანური გამოთვლები. მთავარი ის არის, რომ ის შეიცავს სამუშაო ფურცელს Word-ის შაბლონში სანიშნეის სახელსა და ჩანაცვლებულ მნიშვნელობას შორის შესაბამისობის ცხრილით.
4. ჩადეთ VBA პროგრამის კოდი ნიმუშის ფაილიდან მომზადებულ სამუშაო წიგნში. შეცვალეთ ყველა მუდმივი თქვენი პროექტის მიხედვით.
5. შეამოწმეთ სამუშაოს სისწორე.
6. გამოიყენეთ იგი აქტიურად!

ა, გვარები სვეტში ბდა პროფესიები სვეტში C.

2. შექმენით Word დოკუმენტი (.doc ან.docx)

(A), (B)და (C).

(A), (B)და (C) (A)- სახელი, (B)- გვარი, (C)- პროფესია.

პარამეტრებიპროგრამები.

3. აირჩიეთ ბილიკები ფაილებისა და საქაღალდეებისთვის

აირჩიეთ

4. დააყენეთ თქვენთვის სასურველი მონაცემების ფურცლები და რიგები

Excel ფაილის მონაცემთა ფურცლები

Excel ფაილის მონაცემთა რიგები Excel ფაილის მონაცემთა ფურცლები

1 .

თუ გსურთ, რომ თქვენი Excel ფაილის ყველა ფურცელი და/ან სტრიქონი მონაცემებით მონაწილეობდეს დოკუმენტის ფორმირებაში, დააწკაპუნეთ მარჯვენა ღილაკზე ასოებით. ნომრები(ამ შემთხვევაში მისი წარწერა შეიცვლება ყველა).

5. დააყენეთ შაბლონი ახალი word ფაილების სახელებისთვის

დააყენეთ შაბლონი ახალი Word ფაილების სახელებისთვის:

ახალი Word ფაილების სახელების შაბლონიარის პროგრამის მიერ გენერირებული ახალი დოკუმენტების (word ფაილების) სახელების შაბლონი. აქ სახელის შაბლონი შეიცავს Excel ფაილის სვეტების სახელებს, გარშემორტყმული ხვეული ბრეკეტებით: (A)და (B)... ახალი დოკუმენტის გენერირებისას პროგრამა ჩაანაცვლებს ყველა (A)და (B)შესაბამისი უჯრედის მნიშვნელობები excel ფაილიდან - ეს იქნება ახალი დოკუმენტის სახელი (word ფაილი).

თქვენ შეგიძლიათ დააყენოთ თქვენი ჩარჩოს სიმბოლოები ჩანართში პარამეტრებიპროგრამები.

6. დააწკაპუნეთ "გენერაციაზე"

დააჭირეთ ღილაკს Გენერირებადა პროგრესი გამოჩნდება ეკრანზე. დოკუმენტების რაოდენობა (word-ფაილები) შეიქმნება ზუსტად იმდენი, რამდენი ხაზია excel-ფაილის ფორმირებაში.

7. ყველაფერი

ყველა დოკუმენტი (word ფაილი) იქმნება და განთავსებულია მითითებულ საქაღალდეში საქაღალდე ახალი Word ფაილების შესანახად... ყველაფერი :)

ექსვოგი - ანგარიშის გენერატორი Excel-დან Word-ში შაბლონით

Word ფაილების უფასო გენერატორი შაბლონიდან (Word ფაილი) Excel ფაილის მონაცემების საფუძველზე

მუშაობს Mac OS-ზე, Windows-ზე და Linux-ზე

გაძლევთ საშუალებას მიუთითოთ ახალი გენერირებული სიტყვის ფაილების სახელები

საშუალებას გაძლევთ განსაზღვროთ სასურველი მონაცემების ფურცლები და ხაზები

საშუალებას გაძლევთ დააყენოთ თანდართული სიმბოლოები Excel-ის სვეტების სახელებისთვის

მარტივი გამოსაყენებელი

შეინახეთ თქვენი მონაცემები Excel ფორმატში (.xls და .xlsx) და შექმენით Word ფაილები (.doc და .docx) რამდენიმე დაწკაპუნებით :)

Როგორ მუშაობს?

შეხედეთ თქვენს Excel ფაილს

ამ მაგალითში, Excel ფაილი შეიცავს მომხმარებლის ინფორმაციას. თითოეული ხაზი შეესაბამება კონკრეტულ კლიენტს. სახელები განთავსებულია სვეტში ა, გვარები სვეტში ბდა პროფესიები სვეტში C.

დააწკაპუნეთ სანახავად

Word დოკუმენტის შექმნა (.doc ან.docx)

დააწკაპუნეთ სანახავად

შექმენით „თარგი“ (word-file) ახალი დოკუმენტების გენერირებისთვის (word-files). აქ, "თარგი" ტექსტი შეიცავს Excel ფაილის სვეტების სახელებს, გარშემორტყმული ხვეული ბრეკეტებით: (A), (B)და (C).

პროგრამა გამოიმუშავებს ახალ დოკუმენტებს „თარგის“ მიხედვით, რომელიც შეცვლის ყველა (A), (B)და (C)შესაბამისი უჯრედის მნიშვნელობები excel ფაილიდან: (A)- სახელი, (B)- გვარი, (C)- პროფესია.

ასევე შეგიძლიათ დააყენოთ თქვენი საკუთარი ჩარჩოს სიმბოლოები ჩანართზე პარამეტრებიპროგრამები.

აირჩიეთ ბილიკები ფაილებისა და საქაღალდეებისთვის

აირჩიეთ ფაილებისა და საქაღალდეების ბილიკები (ღილაკები ეტიკეტირებული აირჩიეთ). პროგრამაში თქვენ აყენებთ შემდეგ ბილიკებს:

Excel ფაილი მონაცემებით (* .xls, * .xlsx)- ეს არის გზა თქვენი Excel მონაცემთა ფაილის (მომხმარებლის ინფორმაცია);

Word-ის შაბლონის ფაილი (* .doc, * .docx)- ეს არის გზა თქვენი „თარგის“კენ (წინა საფეხურზე შექმნილი word-ფაილი);

საქაღალდე ახალი Word ფაილების შესანახად- ეს არის გზა საქაღალდეში, სადაც პროგრამა შეინახავს ახალ გენერირებულ დოკუმენტებს.

დააწკაპუნეთ სანახავად

დააყენეთ თქვენთვის სასურველი მონაცემების ფურცლები და რიგები

დააწკაპუნეთ სანახავად

დააყენეთ თქვენი Excel ფაილის ფურცლებისა და ხაზების რაოდენობა მონაცემებით (მომხმარებლის ინფორმაცია), რომლისთვისაც გსურთ დოკუმენტების გენერირება:

Excel ფაილის მონაცემთა ფურცლები- თქვენი Excel ფაილის ფურცლების ნომრები, რომლებიც მონაწილეობას მიიღებენ ახალი დოკუმენტების ფორმირებაში;

Excel ფაილის მონაცემთა რიგები- ფურცლების ხაზების ნომრები (ფურცლები მითითებულია Excel ფაილის მონაცემთა ფურცლები) თქვენი Excel ფაილის, რომელიც მონაწილეობას მიიღებს ახალი დოკუმენტების ფორმირებაში. თითოეული მითითებული ხაზის მონაცემების საფუძველზე შეიქმნება ცალკე დოკუმენტი (word ფაილი).

პროგრამაში ფურცლებისა და ხაზების ნუმერაცია იწყება 1 .