დღეს XML არის ინდუსტრიის სტანდარტი სხვადასხვა გადაწყვეტილებებს შორის მონაცემთა სწრაფად და ეფექტურად გაცვლისთვის. თუმცა, არსებობს მრავალი დავალება, სადაც მომხმარებლებს სჭირდებათ XML მონაცემების სხვა ფორმით წარმოდგენა. ამ შემთხვევებში საჭიროა გადამყვანი პროგრამები. ისინი ახდენენ უფსკრული XML-სა და ცხრილების პოპულარულ ფორმატებს შორის. თუ რეგულარულად გჭირდებათ XML მონაცემების კონვერტაცია, მაშინ აუცილებლად უნდა გამოიყენოთ Advanced XML Converter! Advanced XML Converter-ით აღარ გჭირდებათ რთული XML ტრანსფორმაციების და XSL სტილის ფურცლების დაწერა. გადაიყვანეთ XML HTML, CSV, DBF, XLS, SQL მყისიერად! Advanced XML Converter დაგეხმარებათ გადაიყვანოთ სხვა ფორმატებში, როგორიცაა HTML, CSV, DBF, XLS და SQL. როგორც კი ჩაიტვირთება XML ფაილი და დააჭერთ ღილაკს "Convert", პროგრამა გამოიმუშავებს სწრაფ და მაღალხარისხიან გამოსავალს ერთ-ერთ ცხრილის ფორმატში. სწორი გამოსავლის უზრუნველსაყოფად Advanced XML Converter იყენებს ორიგინალური XML ფაილის იერარქიულ სტრუქტურას. თქვენ შეგიძლიათ აირჩიოთ მონაცემები, რომლებიც უნდა იყოს წარმოდგენილი გამომავალ ფაილში. თქვენ ასევე შეგიძლიათ გადაიყვანოთ ერთზე მეტი ფაილი სერიული გაშვების გამოყენებით. Advanced XML Converter-ით აღარ გჭირდებათ რთული კონვერტაციის ან XSL ტრანსფორმაციის სკრიპტების დაწერა. XML-ის HTML, CSV, DBF, XLS, SQL კონვერტაცია სწრაფი და ინტუიციურია!

	ჩამოტვირთეთ Advanced XML Converter

თქვენ შეგიძლიათ ამოიღოთ ყველა XML მონაცემი ან მხოლოდ მონაცემები კონკრეტული ტეგებიდან Advanced XML Converter-ით. ამოღებული მონაცემების ნახვისას შეგიძლიათ სწრაფად გადახვიდეთ სხვადასხვა ხედებს შორის (ახალი ანალიზისა და მონაცემების გადატვირთვის გარეშე). თქვენ შეგიძლიათ დააყენოთ ექსპორტის ვარიანტები თითოეული გამომავალი ფორმატისთვის (როგორიცაა HTML ცხრილის სტილები და CSV დელიმიტერები ექსპორტირებული ველებისთვის და სხვა ვარიანტები). Advanced XML Converter გაძლევთ საშუალებას შეინახოთ ყველა ცხრილი ერთ ფაილში ან რამდენიმე ფაილში ცალკე, ასევე მოქნილად დააკონფიგურიროთ წინასწარი გადახედვისა და გამომავალი პარამეტრები.

პროგრამული უზრუნველყოფა არ საჭიროებს დრაივერების ან დამატებითი კომპონენტების ინსტალაციას, რადგან ის აგებულია Internet Explorer-ის პარსერზე, რომელიც ხელმისაწვდომია უმეტეს სისტემებზე. გაფართოებული XML კონვერტორი არ საჭიროებს .NET Framework ან XML სქემებს. პროგრამა არ საჭიროებს XML ფაილის სტრუქტურის ღრმა ცოდნას და მნიშვნელოვნად უწყობს ხელს დიდი რაოდენობით XML მონაცემების კონვერტაციას. როგორც მომხმარებელი, თქვენ შეძლებთ იხილოთ ყველაზე რთული XML დოკუმენტები სხვადასხვა ხედვის ცხრილებში, რომლებიც ადვილად იკითხება. ეს ძალიან მოსახერხებელია მონაცემთა ბაზებში ან სპეციალიზებულ სისტემებში ინფორმაციის გადასატანად, რომლებიც საჭიროებენ უბრალო ტექსტთან მიახლოებულ ფორმატს.

თუ თქვენ ეძებთ XML მონაცემების კონვერტაციის სწრაფ სისტემას, Advanced XML Converter საუკეთესო არჩევანია! ხელმისაწვდომი და მარტივი გამოსაყენებელი პროგრამა ახორციელებს მონაცემთა კომპლექსურ ტრანსფორმაციას წუთებში!

	Advanced XML Converter-ის უახლესი ვერსია უზრუნველყოფს მარტივ, სწრაფ და ძალიან ეფექტურ საშუალებას XML ფაილებიდან მონაცემების ამოსაღებად და პოპულარულ HTML, DBF, CSV, Excel და SQL ფორმატებში შესანახად.
	გაფართოებული XML კონვერტორის საშუალებით შეგიძლიათ:
	ამოიღეთ ყველა XML მონაცემები ან მონაცემები მხოლოდ კონკრეტული ტეგებიდან, მონაცემთა პრეზენტაციის სხვადასხვა ვარიანტს შორის გადართვა (მონაცემების ხელახალი ანალიზი არ არის საჭირო), კონფიგურაციის მორგებული პარამეტრების კონფიგურაცია თითოეული გამომავალი ფორმატისთვის (როგორიცაა HTML სტილის ფურცლები ან CSV გამსაზღვრები და სხვა ვარიანტები), შეინახეთ XML-დან ამოღებული ყველა ცხრილი ერთ ფაილში ან რამდენიმე გამომავალ ფაილში.

ალბათ ხშირად გჭირდებათ ა XMLფაილი ან საქაღალდე XMLფაილები ერთ ან რამდენიმეში DBFფაილები. პრობლემა იმაშია XMLსტრუქტურა, მისი იერარქია და ბუდობრივი დონეები განსხვავდება ფაილიდან ფაილში. ამ სტატიაში ჩვენ დეტალურად განვიხილავთ, თუ როგორ უნდა შემოვიტანოთ XMLნებისმიერი სტრუქტურის ფაილი ბინაში DBFმაგიდა.

ახალი ფუნქცია ე.წ მორგებული XML იმპორტიგანხორციელდა ქ DBF მეთაური პროფესიონალივერსია 2.7 (build 40). ეს ბრძანება ხელმისაწვდომია ბრძანების ხაზის ინტერფეისის საშუალებით. სინტაქსი ასეთია:

dbfcommander.exe -icx [<-attr>]

როგორც ხედავთ, არსებობს ოთხი პარამეტრი:

• -icx- ნიშნავს მორგებული XML იმპორტი.
• – ფაილის სრული სახელი (მათ შორის გზა) ან საქაღალდის სახელი, რომელიც შეიცავს XMLიმპორტირებული ფაილები. თქვენ ასევე შეგიძლიათ ჩატვირთოთ მხოლოდ გარკვეული ფაილები ნიღბის გამოყენებით, მაგ. " D:\xml\some_prefix_*.xml". ამ შემთხვევაში მხოლოდ ფაილები, რომელთა გაფართოებაც არის XMLდა რომლის სახელიც იწყება " ზოგიერთი_პრეფიქსი„გადაიქცევა DBF. თუ გსურთ საქაღალდეში არსებული ყველა ფაილის კონვერტაცია, გამოიყენეთ შემდეგი ნიღაბი: D:\xml\*.xml".
• – დანიშნულების საქაღალდე, მაგ. " D:\dbf\“.ამ შემთხვევაში ყველა არსებული DBFფაილები დაიწერება. თუ გსურთ წყაროს იმპორტი XMLფაილები ერთში DBFფაილი, გამოიყენეთ ფაილის ზუსტი სახელი, მაგ. " D:\dbf\result.dbfმაგრამ ამ შემთხვევაში მიღებული ფაილი უნდა შეიქმნას კონვერტაციის პროცესის დაწყებამდე, წინააღმდეგ შემთხვევაში წარმოიქმნება შეცდომა. თუ ერთი DBFფაილი გამოიყენება მიღებული მონაცემებისთვის, ის არ გადაიწერება და ყოველი ახალი ჩანაწერი ჩაიდება იმავე ფაილში.
• – სრული სახელწოდება ე.წ. რუკის ფაილი“, რაც მარტივია DBFფაილი, რომელიც შეიცავს წყაროს განმარტებას და შედეგად მიღებული ფაილის ველებს. ქვემოთ განვიხილავთ რუქ-ფაილის შექმნის პროცესს.
• <-attr> - გამოიყენეთ ეს პარამეტრი, თუ გსურთ გარკვეული ატრიბუტების მქონე ტეგების იმპორტი.

DBF ველების განმარტება, ან როგორ შევქმნათ რუკა-ფაილი

ყოველთვის უკეთესია რაღაცის სწავლა მაგალითის გამოყენებით. ჩვენს სიტუაციაში, ჩვენ გვჭირდება რამდენიმე ცნობილი XML. ავიღოთ ა RSS ახალი ამბების არხი XMLფაილი (ხელმისაწვდომია):

როგორც ხედავთ, ოთხია<ნივთი>-ში ჩასმული ელემენტები<არხი> ელემენტი, რომელიც თავად არის მოთავსებული ზედა დონეზე<rss> ელემენტი. ასევე არსებობს ისეთივე მობუდარი დონის ელემენტები, როგორიც არის<ნივთი> ელემენტები:<გენერატორი>, <სათაური>, <აღწერა> და ა.შ.

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

რუქ-ფაილის შესაქმნელად, ჯერ შევქმნათ შედეგი DBFფაილი. ჩვენ გვჭირდება ის, რადგან შემდეგ ჩვენ შევძლებთ შევქმნათ რუქის ფაილი რამდენიმე დაწკაპუნებით. გაშვება DBF მეთაური პროფესიონალი, დააწკაპუნეთ ფაილი -> ახალიდა შექმენით ა DBFფაილი. იმ შემთხვევაში, თუ RSS XMLფაილი, სტრუქტურა ასეთია:

დააწკაპუნეთ კარგი. The DBFშეიქმნება ფაილი და ახლა ის შეიძლება გამოვიყენოთ შედეგად ფაილად ჩვენი იმპორტისთვის XMLპროცესი. თქვენ შეგიძლიათ გამოიყენოთ ნებისმიერი ხელმისაწვდომი ველის ტიპი: პერსონაჟი, მთელი რიცხვი, რიცხვითი, თარიღიდა ა.შ.

შედეგად ფაილზე დაფუძნებული რუქის ფაილის შესაქმნელად დააწკაპუნეთ ექსპორტის სტრუქტურახელსაწყოს ღილაკი (იხილეთ სურათი ზემოთ). როდესაც Save დიალოგი იხსნება, აირჩიეთ გზა და ფაილის სახელი და შემდეგ შეინახეთ სტრუქტურა როგორც a DBFფაილი.

XML ტეგების DBF ველებთან შესაბამისობა

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

Გააღე DBFფაილი, რომელიც ახლახან შეინახეთ. დააწკაპუნეთ ფაილი -> სტრუქტურადა დაამატეთ ახალი ველი სახელწოდებით" xmltagname"-ის პერსონაჟიტიპი. თუ გსურთ, შეგიძლიათ დაამატოთ მეტი ველი რუკა-ფაილში. მაგალითად, მოდით "დავამატოთ ველი სახელად" კომენტარი".დააწკაპუნეთ კარგიცვლილებების შესანახად.

ახლა შეავსეთ ახლის ყველა მწკრივი" xmltagname"ველი ერთად XMLკვანძების გზა (გამოყოფილი " -> "), რომელიც უნდა იყოს ჩასმული შესაბამის ველში DBFფაილი:

ეს ნიშნავს, რომ ღირებულება XMLკვანძი<სათაური> დაბუდებული<არხი> კვანძი, რომელიც მოთავსებულია ზედა დონეზე<rss>, ჩასმული იქნება " სათაური"ველი; XMLტეგი" rss -> არხი -> აღწერა"ჩასმული იქნება" აღწერის"ველი და ასე შემდეგ.

გამოყენების შემთხვევაში" -attr" რუკა-ფაილის პარამეტრი, ბილიკები უნდა შეიცავდეს შესაბამის ატრიბუტებსაც, მაგ.: " rss version="2.0" -> არხი -> სათაური".

ყურადღება მიაქციეთ " ელემენტის_აღმომ"ველი XMLტეგი" rss -> არხი -> ელემენტი -> აღწერა" შეიცავს CDATA განყოფილებათან HTMLმარკირება. ასე რომ, მისი ტეგის გზა უნდა დასრულდეს " #cdata-სექცია"სტრიქონი.

ბოლო რიგი, რომელიც ხედავთ ზემოთ მოცემულ სურათზე არის ე.წ. მწკრივი-ტეგითეგის ეს გზა საშუალებას იძლევა DBF მეთაურირომ იცოდეთ რომელი XMLტეგი უნდა იყოს გამოყენებული, როგორც ახალი მწკრივი შედეგად DBFფაილი. ჩვენს შემთხვევაში, ეს არის " rss -> არხი -> ელემენტი".

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

კარგი, ეს ყველაფერია. ახლა ჩვენ შეგვიძლია იმპორტის გაშვება XMLრომ DBFთავად. შეასრულეთ შემდეგი ბრძანება ბრძანების ხაზიდან, ან ა BATფაილი:

dbfcommander.exe -icx "D:\xml\rss.xml" "D:\dbf\" "D:\map-file.dbf"

შედეგად, ჩვენ მივიღებთ ახალ ფაილს. D:\dbf\rss.dbf"რომელიც შეიცავს იმპორტირებულს XMLმონაცემები:

თქვენ შეგიძლიათ ჩამოტვირთოთ ყველა ფაილი, რომელიც გამოიყენება ამ კონვერტაციაში.

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

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

მასპინძლობს http://www.allbest.ru/

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

ინჟინერიისა და ტექნოლოგიების ინსტიტუტი

საინფორმაციო ტექნოლოგიებისა და საწარმოო პროცესების ავტომატური კონტროლის დეპარტამენტი

დასკვნითი საკვალიფიკაციო სამუშაოები

მიმართულებით 230100 "კომპიუტერული მეცნიერება და კომპიუტერული ტექნიკა"

თემა: "მონაცემთა ბაზების პროგრამა-კონვერტორი DBF ფაილებიდან XML ფორმატის ფაილში"

სტუდენტი მაქსიმოვი დიმიტრი ოლეგოვიჩი

ტირასპოლი, 2013 წ

შესავალი

1. საგნობრივი სფეროს კვლევა და ანალიზი

1.1 დავალების აღწერა

1.2 შესწავლილი პრობლემის აქტუალობის დასაბუთება

1.3 მსგავსი პრობლემების გადაჭრის მეთოდების მიმოხილვა

1.4 პრობლემის შესახებ განცხადება, სისტემის მოთხოვნები, მოთხოვნები შეყვანის მონაცემებისა და გამომავალი ფორმების მიმართ

2. პროგრამული პროდუქტის სტრუქტურისა და არქიტექტურის დიზაინი

2.1 განხორციელების მეთოდებისა და საშუალებების არჩევანი, მისი დასაბუთება

2.2 გამოყენებული ალგორითმების აღწერა

2.3 პროგრამული პროდუქტის სტრუქტურა, არქიტექტურა

2.4 ფუნქციონალური დიაგრამა, პროგრამული პროდუქტის ფუნქციური სტრუქტურა

3. პროგრამული პროდუქტის დანერგვა და ტესტირება

3.1 განხორციელების აღწერა

3.2 მომხმარებლის ინტერფეისის აღწერა

3.3 პროგრამული პროდუქტის სანდოობის ტესტირება და შეფასება

3.4 ღირებულების გაანგარიშება

3.5 შრომის დაცვა

დასკვნა

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

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

დანართი

შესავალი

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

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

1) კლასიფიკაცია მონაცემთა მოდელის მიხედვით:

ა) იერარქიული;

ბ) ქსელი;

გ) მიმართებითი;

დ) ობიექტზე და ობიექტზე ორიენტირებული;

ე) ობიექტურ მიმართებითი, ფუნქციური.

2) კლასიფიკაცია მუდმივი შენახვის გარემოს მიხედვით:

ა) მეორად მეხსიერებაში, ანუ ტრადიციულ;

ბ) ოპერატიული მეხსიერებაში;

გ) მესამეულ მეხსიერებაში.

3) კლასიფიკაცია განაწილების ხარისხის მიხედვით:

ა) ცენტრალიზებული, ან კონცენტრირებული;

ბ) განაწილებული.

4) სხვა ტიპის მონაცემთა ბაზა

ა) სივრცითი;

ბ) დროებითი;

გ) სივრცე-დრო;

დ) ციკლური.

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

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

1 . საგნობრივი სფეროს კვლევა და ანალიზი

1.1 დავალების აღწერა

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

1.2 რელევანტურობის დასაბუთება შესწავლილი პრობლემა

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

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

დადებითი მხარე, XML საშუალებას გაძლევთ განახორციელოთ ბევრი რამ, რაც შეიძლება მოიძებნოს ჩვეულებრივ მონაცემთა ბაზებში: შენახვა (XML დოკუმენტები), სქემები (DTD, XML Schema Language), შეკითხვის ენები (XQuery, XPath, XQL, XML - QL, QUILT და ა.შ.), API (SAX, DOM, JDOM) და ა.შ. უარყოფითი მხარეები მოიცავს თანამედროვე მონაცემთა ბაზებში არსებული მრავალი ფუნქციის ნაკლებობას: შენახვის ეკონომია, ინდექსები, უსაფრთხოება, ტრანზაქციები და მონაცემთა მთლიანობა, მრავალ მომხმარებლის წვდომა, ტრიგერები, მოთხოვნები ბევრ დოკუმენტზე და ა.შ.

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

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

მონაცემთა ნაკრების ყველაზე საინტერესო მაგალითები, რომლებშიც მოსახერხებელია XML დოკუმენტის მონაცემთა ბაზად გამოყენება, არის კონტაქტების პერსონალური სია (სახელები, ტელეფონის ნომრები, მისამართები და ა.შ.). თუმცა, დაბალი ღირებულებისა და მონაცემთა ბაზების გამოყენების სიმარტივის გამო, როგორიცაა dBASE და Access, ამ შემთხვევებშიც კი არ არსებობს XML დოკუმენტის მონაცემთა ბაზად გამოყენების საფუძველი. XML-ის ერთადერთი რეალური უპირატესობა ის არის, რომ მონაცემთა ადვილად გადატანა შესაძლებელია ერთი აპლიკაციიდან მეორეში, მაგრამ ეს უპირატესობა არც ისე მნიშვნელოვანია, რადგან მონაცემთა ბაზების XML ფორმატში სერიული ინსტრუმენტები უკვე ფართოდ არის გავრცელებული.

პროგრამული უზრუნველყოფის განვითარება შესაბამისია შემდეგი მიზეზების გამო:

dbf მონაცემთა ბაზის ფორმატი მოძველებულია და არ აკმაყოფილებს თანამედროვე მოთხოვნებს;

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

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

1.3 მსგავსი პრობლემების გადაჭრის მეთოდების მიმოხილვა

„თეთრი ქალაქი“ შესაძლებელს ხდის dbf ფაილების XML ფორმატში გადაყვანას. პროგრამას შეუძლია გადაიყვანოს dBase III, dBase IV, FoxPro, VFP და dBase Level 7 dbf ფაილები.პროგრამას აქვს ბრძანების ხაზის ინტერფეისის მხარდაჭერა. ამრიგად, მისი გაშვება შესაძლებელია .BAT ან .LNK ფაილიდან საჭირო პარამეტრების მითითების შემდეგ ან Windows-ის განრიგის გრაფიკის მიხედვით. ამ პროგრამული პროდუქტის მინუსი არის გამომავალი ფაილის ფორმატის მორგების შეუძლებლობა. აპლიკაციის ძირითადი ფანჯარა ნაჩვენებია სურათზე 1.1.

სურათი 1.1 - პროგრამის მთავარი ფანჯარა "თეთრი ქალაქი"

"DBF Converter" არის მრავალმხრივი, მაგრამ ადვილად გამოსაყენებელი კონვერტაციის პროგრამა. ამ პროგრამას აქვს ოსტატის მსგავსი ინტერფეისი, მაგრამ ასევე შეიძლება გამოყენებულ იქნას როგორც ბრძანების ხაზი ფაილების ჯგუფის დასამუშავებლად. "DBF Converter" მხარს უჭერს მონაცემთა გაცვლის ყველა თანამედროვე ფორმატს, როგორიცაა XML, CSV, TXT, HTML, RTF, PRG და სხვა. დანერგილია DBF ცხრილების SQL სკრიპტად გადაქცევის შესაძლებლობა, რომლის იმპორტირება შესაძლებელია ნებისმიერ SQL მონაცემთა ბაზაში.

მარტივი გარდაქმნების გარდა, "DBF Converter" გაძლევთ საშუალებას მანიპულირება მოახდინოთ მონაცემებით მხოლოდ გარკვეული სვეტების არჩევით და ფილტრების გამოყენებით. გამარტივებული ფილტრაციის წესებისგან განსხვავებით, რომლებიც ჩვეულებრივ გვხვდება სხვა DBF აპლიკაციებში, DBF Converter დინამიურად ქმნის მონაცემთა ბაზის შეყვანის მარტივ ფორმებს. მარტივი ჩანაწერის ნებისმიერ სფეროში მოწინავე ნიღბისა და წესების დაყენების შესაძლებლობა ერთ-ერთი ყველაზე ღირებული ფუნქციაა, რომელიც ხელმისაწვდომია DBF Converter-ში. ამ პროგრამული უზრუნველყოფის მთავარი მინუსი არის მისი ღირებულება $29,95.

აპლიკაციის მთავარი ფანჯარა ნაჩვენებია სურათზე 1.2.

სურათი 1.2 - პროგრამის მთავარი ფანჯარა "DBF Converter"

"DBF View" არის უფასო, კომპაქტური და მოსახერხებელი პროგრამა DBF ფაილებთან მუშაობისთვის. არ საჭიროებს ინსტალაციას, მუშაობს დამატებითი დრაივერებისა და ბიბლიოთეკების გარეშე.

მთავარი უპირატესობა არის უნივერსალურობა, სწრაფი და მოქნილი ხაზოვანი ძიება, რომელიც სიჩქარით აღემატება ბევრ SQL-ს.

Დამატებითი ფუნქციები:

ძიება ნიღბით (ნიღბებით);

მონაცემთა რედაქტირება, ჩანაცვლება, წაშლა, შექმნა, დამატება;

ველების დახარისხება;

მრავალენოვნება და ახალი ლექსიკონების შექმნა;

DBF, TXT, CSV, SQL, XML იმპორტი და ექსპორტი;

გადაკოდირება DOS-ზე, Windows-ზე, ტრანსლიტზე და სხვებზე;

პაროლის გაშვება;

ჩაწერის ისტორია.

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

სურათი 1.3 - პროგრამის მთავარი ფანჯარა "DBF View"

1.4 პრობლემის განცხადება, სისტემის მოთხოვნები, მოთხოვნები გამომავალი მონაცემებისა და გამომავალი ფორმებისთვის

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

შემდეგი ფუნქციები უნდა განხორციელდეს პროგრამულ პროდუქტში:

dbf ფაილების შინაარსის კითხვა;

შაბლონების შექმნა ორიდან ერთ-ერთ რედაქტორში;

შაბლონის რედაქტირება;

dbf ფაილების კონვერტაციის თანმიმდევრობის შერჩევა;

შაბლონების შესრულება;

შეცდომის აღრიცხვა;

პროგრამის შედეგების შენახვა XML ფაილში.

პროგრამა დაწერილია Microsoft Visual Studio 2008-ში და გაშვებას მოითხოვს:

Windows ოჯახის ერთ-ერთი ვერსიის ოპერაციული სისტემა: Windows Vista, Windows 7 ან Windows 8;

Microsoft .NET Framework 4;

Visual FoxPro ODBC დრაივერები.

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

შეყვანის მონაცემები შეიძლება იყოს dBase II, dBase III ან dBase IV ვერსიის dbf ფაილები.

გამომავალი ფაილი უნდა იყოს XML ფორმატის ფაილი ენობრივი ვერსიით 1.x და ნებისმიერი ბრაუზერის მხარდაჭერა.

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

2 . პროგრამული პროდუქტის სტრუქტურა და არქიტექტურა

2.1 განხორციელების მეთოდებისა და საშუალებების არჩევანი, მისი დასაბუთება

პროგრამული პროდუქტის შემუშავებისთვის შეირჩა ინტეგრირებული განვითარების გარემო Microsoft Visual Studio 2008.

Visual Studio 2008 - გამოვიდა 2007 წლის 19 ნოემბერს, .NET Framework 3.5-თან ერთად. ის მიზნად ისახავს Windows Vista ოპერაციული სისტემის აპლიკაციების შექმნას (მაგრამ ასევე მხარს უჭერს XP), Office 2007 და ვებ აპლიკაციებს. მოყვება LINQ, C#-ის ახალი ვერსიები და Visual Basic. სტუდიაში არ იყო Visual J#. მისი ერთ-ერთი უპირატესობა არის სრულიად რუსული ინტერფეისი.

Visual Studio მოიცავს წყაროს კოდის რედაქტორს IntelliSense ტექნოლოგიით და კოდის მარტივი რეფაქტორინგით. ჩაშენებულ გამართვას შეუძლია იმუშაოს როგორც წყაროს დონის, ასევე მანქანური დონის გამართვით. სხვა ჩაშენებული ხელსაწყოები მოიცავს ფორმის რედაქტორს, რომელიც ამარტივებს აპლიკაციის GUI-ს შექმნას, ვებ რედაქტორს, კლასის დიზაინერს და მონაცემთა ბაზის სქემის დიზაინერს. Visual Studio გაძლევთ საშუალებას შექმნათ და დააკავშიროთ მესამე მხარის დანამატები (პლაგინები), რათა გააფართოვოთ ფუნქციონირება თითქმის ყველა დონეზე, წყაროს კოდის ვერსიის კონტროლის სისტემების (როგორიცაა Subversion და Visual SourceSafe) მხარდაჭერის დამატების ჩათვლით, ახალი ხელსაწყოების დამატება (მაგალითად, რედაქტირებისთვის და ვიზუალური კოდის დიზაინისთვის). დომენის სპეციფიკურ პროგრამირების ენებში ან ინსტრუმენტებში პროგრამული უზრუნველყოფის განვითარების პროცესის სხვა ასპექტებისთვის (მაგალითად, Team Explorer კლიენტი Team Foundation სერვერთან მუშაობისთვის).

Visual Studio 2008 C#-ზე დაფუძნებული სამუშაო მაგიდის ყველა ფუნქცია მოიცავს:

ობიექტთა ურთიერთქმედების ენაზე ამოცანების ჩამოყალიბების უნარი;

პროგრამის კოდის მაღალი მოდულარულობა;

მომხმარებელთა სურვილებთან ადაპტაცია;

პროგრამის მრავალჯერადი გამოყენების მაღალი ხარისხი;

დაკავშირებული ბიბლიოთეკების დიდი რაოდენობა.

2. 2 გამოყენებული ალგორითმების აღწერა

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

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

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

ცხრილი 2.1 - შესაძლო აღიარებული სახელმწიფოების სია

სტატუსის ინდექსი	სახელმწიფო	აღწერა
	ცვლადი	ციკლის მრიცხველი
		სამსახურის სიტყვა, რომელიც აღნიშნავს ციკლის დაწყებას
		სერვისის სიტყვა, რომელიც აღნიშნავს მარყუჟის გასასვლელ მდგომარეობას
		ფუნქციური სიტყვა, რომელიც აღნიშნავს, რომ შემდგომი მითითება იქნება ბაზის სვეტებზე
		ფუნქციური სიტყვა, რომელიც აღნიშნავს, რომ შემდგომი მითითება იქნება ბაზის სტრიქონები
	რაოდენობა	ფუნქციური სიტყვა, რომელიც მიუთითებს რიგების ან სვეტების რაოდენობაზე, იმის მიხედვით, თუ რა იყო წინა ზარი
		ფუნქციური სიტყვა, რომელიც აღნიშნავს მისასვლელი სვეტის მონაცემთა ტიპის გამოსავალს
	სახელი	ფუნქციური სიტყვა, რომელიც აღნიშნავს იმ სვეტის სახელწოდებას, რომელსაც მოჰყვება აპელაცია
		სპეციალური სიმბოლოები, რომლებიც გამოყოფს სერვისის სიტყვებს
	= (ტოლი ნიშანი)	სპეციალური სიმბოლო, რომელიც მიუთითებს რა მნიშვნელობა მიენიჭება ცვლადს ციკლის დაწყებისას.
	[ (ღია ფრჩხილი)
	] (დახურეთ ფრჩხილები)	სპეციალური სიმბოლო, რომელიც მიუთითებს კონკრეტულ სვეტზე ან მწკრივზე წვდომის შესახებ
		ნებისმიერი მთელი რიცხვი

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

სურათი 2.1 - შესაძლო გადასვლების სასრული მდგომარეობის მანქანა

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

ნახაზი 2.2 - დაღმავალი გადამწყვეტი უკან დახევით

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

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

სურათი 2.3 - მონაცემთა ბაზის ცხრილის ზოგადი სტრუქტურა

3. განხორციელების სახით აირჩიეს გამოსავალი „სიმართლის ცხრილის“ გამოყენებით. ეს ცხრილი არის ცხრილი n+1 სვეტით და m+1 რიგებით, სადაც n და m არის შეყვანის ცხრილის სვეტებისა და სტრიქონების რაოდენობა. ცხრილის თითოეული უჯრედი ინახავს true ან false მნიშვნელობას. სურათი 2.4 გვიჩვენებს "სიმართლის ცხრილს".

სურათი 2.4 - "სიმართლის ცხრილი"

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

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

ასევე შეიქმნა პირობები:<», «>"", "=", "შეიცავს", "შეესაბამება".

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

სურათი 2.5 - "სიმართლის ცხრილი" გამოყენებული ფილტრებით

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

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

გლობალური - ამ ტიპის ტეგები არ ატარებენ ლოგიკურ დატვირთვას, ისინი უბრალოდ საჭიროა გამოსავლისთვის.

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

2.3 პროგრამული პროდუქტის სტრუქტურა, არქიტექტურა

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

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

კლასების შიდა სტრუქტურის ან სტრუქტურის გარდა, შესაბამისი დიაგრამა მიუთითებს კლასებს შორის ურთიერთობაზე:

ამ აპლიკაციისთვის გამოყოფილია კლასები, რომლებიც აღწერილია ცხრილში 2.2.

ცხრილი 2.2 - პროგრამულ პროდუქტში გამოყენებული კლასების აღწერა

კონვერტორის აპლიკაციის კლასის დიაგრამა ნაჩვენებია ნახაზზე 2.6. დიაგრამიდან ხედავთ, რომ MyCode კლასი არის Template კლასის ცვლადი. Template კლასი შეიცავს შემდეგ ველებს: dt, lv, thisTemplate, mycode, fs, sr, sw, correct, masCode, masPerem, masPeremCount, masSost, masCodeLength. dt არის DataTable ტიპის ცვლადი, რომელიც შეიცავს მონაცემთა ბაზაში შენახულ ინფორმაციას; lv - ListView ტიპის ცვლადი, ინტერფეისის ობიექტი, რომელშიც იწერება შეცდომის შეტყობინებები შაბლონებში; thisTemplate - string ტიპის ცვლადი, რაც ნიშნავს იმ შაბლონის სახელს, რომელიც ამჟამად მუშავდება; mycode - MyCode კლასის მასივი, რომელიც ინახავს ინფორმაციას ამ შაბლონში ნაპოვნი ყველა კოდის ფრაგმენტის შესახებ; fs - FileStream ტიპის ცვლადი, რომელიც განსაზღვრავს რომელ ფაილთან იმუშავებს პროგრამა; sr - StreamReader ტიპის ცვლადი, რომელიც განსაზღვრავს თუ რომელი ფაილიდან წაიკითხება ინფორმაცია; sw არის StreamWriter ტიპის ცვლადი, რომელიც განსაზღვრავს, თუ რომელ ფაილის ინფორმაცია ჩაიწერება; სწორი - bool ტიპის ცვლადი, რომელიც მიუთითებს, არის თუ არა მიმდინარე კოდის ფრაგმენტი სწორად დამუშავებული; masCode - სტრიქონის ტიპის მასივი, რომელიც შეიცავს თარგში ნაპოვნი კოდის ყველა ხაზს; masCodeLength - int ცვლადი, რომელიც მიუთითებს კოდის რამდენი ხაზი იქნა ნაპოვნი შაბლონში; masPerem - სტრიქონის ტიპის ორგანზომილებიანი მასივი, რომელიც შეიცავს შექმნილი ცვლადების სახელს და მნიშვნელობას; masPeremCount - int ტიპის ცვლადი, რომელიც მიუთითებს რამდენი ცვლადი შეიქმნა ამ მომენტში; masSost არის int ტიპის მასივი, რომელიც შეიცავს მანქანის მდგომარეობის სიას კოდის მიმდინარე ხაზისთვის.

კლასი ასევე შეიცავს შემდეგ მეთოდებს: Connect, Search, Analize, Check, ExecuteCode. Connect მეთოდი უკავშირდება შაბლონს მოცემულ გზაზე. ძიების მეთოდი პოულობს კოდის ფრაგმენტებს შაბლონში. ანალიზის მეთოდი განსაზღვრავს მდგომარეობებს კოდის ხაზისთვის. Check მეთოდი რეკურსიულია, ის განსაზღვრავს სტრიქონის ლოგიკურ ვალიდობას. ExecuteCode მეთოდი ახორციელებს მიმდინარე შაბლონს. აღწერილი კლასებისთვის შეგიძლიათ გააკეთოთ კლასის დიაგრამა. სურათი 2.6 არის კლასის დიაგრამა.

სურათი 2.6 - კლასის დიაგრამა

2.4 ფუნქციონალური დიაგრამა, პროგრამული პროდუქტის ფუნქციური დანიშნულება

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

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

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

საბოლოო საკვალიფიკაციო სამუშაოს მეორე თავში შეირჩა განვითარების ინსტრუმენტები, კერძოდ Microsoft Visual Studio 2008, აღწერილი იყო პროგრამული პროდუქტის დანერგვის ძირითადი მეთოდები და აღწერილი იყო მისი სტრუქტურაც. ასევე აღწერილია პროგრამული პროდუქტის ფუნქციური დიაგრამა.

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

განხორციელების მეთოდებისა და საშუალებების არჩევანი, მისი დასაბუთება;

გამოყენებული ალგორითმების აღწერა;

პროგრამული პროდუქტის სტრუქტურა, არქიტექტურა;

ფუნქციონალური დიაგრამა, პროგრამული პროდუქტის ფუნქციური დანიშნულება.

3 . იმპლემენტაციადა ტესტირებაპროგრამული პროდუქტი

3.1 განხორციელების აღწერა

ამ პროგრამული პროდუქტის დანერგვის ერთ-ერთი სირთულე არის ამომცნობი ალგორითმის დაწერა. მთელი ალგორითმი აღწერილია მეთოდებით: Search, Analize, Check, ExecuteCode.

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

საჯარო voidSearch()

boolsign=მცდარი;

ხოლო (!sr.EndOfStream)

თუ ((c != "*") && (ნიშანი == მართალია))

(s += c.ToString();)

თუ ((c == "*") && (ნიშანი == მცდარი))

თუ ((c == "*") && (ნიშანი == მართალია))

masCode = s;

masCodeLength++; )

s += c.ToString(); ))

mycode = ახალი MyCode ;)

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

საჯარო სიცარიელის ანალიზი ()

( string masIdent = ახალი სტრიქონი;

int masIdentLength = 0;

bool ნიშანი = მართალია;

for (int a = 0; a< masCodeLength; a++)

(სწორი=მცდარი;

masIdentLength = 0;

masCode[a] = masCode[a].Trim();

masCode[a] = masCode[a].ToLower();

for (int b = 0; b< masCode[a].Length; b++)

( c = masCode[a][b];

masIdentLength++; )

masIdent = ".";

masIdentLength++;

თუ ((c == "") && (s != ""))

( masIdent = s;

masIdentLength++;

( masIdent = s;

masIdentLength++; )

mycode[a] = new MyCode("", null);

for (int z = 0; z< masIdentLength; z++)

mycode[a].code += masIdent[z] + " ";

masSost = ახალი int;

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

for (int b = 0; b< masIdentLength; b++)

თუ (masIdent[b] == "for")

სხვა თუ (masIdent[b] == "ადრე")

else if (masIdent[b] == "სვეტი")

else if (masIdent[b] == "სტრიქონი")

თუ (Char.IsLetter(masIdent[b]))

( bool f = true;

ამისთვის (int d = 1; d< masIdent[b].Length; d++)

თუ (!Char.IsLetterOrDigit(masIdent[b][d]))

თუ (f == ჭეშმარიტი) masSost[b] = 1; სხვა

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

lv.Items.SubItems.Add("არაღიარებული იდენტიფიკატორი" + masIdent[b]); )) სხვა

lv.Items.SubItems.Add(mycode[a].code);

lv.Items.SubItems.Add("არაღიარებული იდენტიფიკატორი" + masIdent[b]);))

mycode[a] = new MyCode(mycode[a].code, masSost);

შემოწმება (0, masSost, a); )

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

საჯარო void შემოწმება (int a, int s, int indc)

(თუ (masSost[a] == s)

(თუ ((s == 1) && (a == 0))

სწორი=მართალი; ) სხვა

თუ ((s == 2) && (a == 0)) s = 1; სხვა

თუ (((s == 4) || (s == 5)) && (a == 0)) s = 8; სხვა

თუ ((s == 1) && (a == 1)) s = 9; სხვა

თუ ((s == 8) && (a == 1)) s = 6; სხვა

თუ ((s == 10) && (a == 1)) s = 1; სხვა

თუ ((s == 9) && (a == 2)) s = 12; სხვა

თუ ((s == 6) && (a == 2))

(თუ (a == masSost.სიგრძე - 1)

სწორი=მართალი; ) სხვა

თუ (((s == 1) || (s == 12)) && (a == 2)) s = 11; სხვა

თუ ((s == 12) && (a == 3)) s = 3; სხვა

თუ ((s == 11) && (a == 3)) s = 8; სხვა

თუ ((s == 3) && (a == 4)) s = 12; სხვა

თუ ((s == 8) && (a == 4))

(თუ (masSost == 4)

თუ ((s == 6) && (a == 7))

(თუ (a == masSost.სიგრძე - 1)

სწორი=მართალი; )

თუ (((s == 12) || (s == 1)) && (a == 7))

თუ ((s == 11) && (a == 8))

(თუ (a == masSost.სიგრძე - 1)

სწორი=მართალი; )

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

თუ (სწორი == მცდარი)

Check(a, s, indc); ))

თუ ((s == 8) && (a == 1))

Check(a, s, indc); )

თუ ((s == 1) && (a == 2))

შემოწმება (a, s, indc);)

თუ ((s == 1) && (a == 7))

Check(a, s, indc); )

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

თუ (სწორი == მცდარი)

lv.Items.Add(thisTemplate, thisTemplate);

lv.Items.SubItems.Add(masCode);

lv.Items.SubItems.Add("სტრიქონის ლოგიკური მნიშვნელობა ირღვევა");

mycode.correct = false;

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

საჯარო void ExecuteCode (int NCode, bool cikcle, StreamReader sr, StreamWriter sw, int tempF)

ხოლო (!sr.EndOfStream)

c = Convert.ToChar(sr.Read());

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

თუ ((c == ")") && (cikcle == მართალია))

თუ წაკითხული სიმბოლო არ იყო "*", მაშინ ეს ნიშნავს, რომ სიმბოლო არ ეკუთვნის კოდის ბრძანებებს და ის უბრალოდ უნდა იყოს გამომავალი.

თუ წაკითხული სიმბოლო იყო "*", ალგორითმი კითხულობს შემდეგ სიმბოლოს, თუ ეს არის "*", მაშინ ეს ნიშნავს, რომ მომხმარებელს სურდა ამ სიმბოლოს გამომავალი ფაილი.

( c = Convert.ToChar(sr.Read());

თუ შემდეგი სიმბოლო არ იყო "*", მაშინ ეს ნიშნავს, რომ ყველა მომდევნო სიმბოლო "*"-მდე ეხება კოდის ბრძანებებს.

if (mycode.correct == true)

if (mycode.masSost == 1)

( bool შექმნა = ყალბი;

for (int a = 0; a< masPeremCount; a++)

(if (masPerem == mycode.code)

sw.Write(masPerem);

while (sr.Read() != "*")

თუ კოდში მომხმარებელი ცდილობს აჩვენოს ცვლადი, რომელიც ადრე არ იყო დეკლარირებული, მაშინ შეცდომის ჩანაწერი იწერება შეცდომების ჟურნალში და შორს კოდი აღარ სრულდება.

თუ (შექმნა == მცდარი)

( lv.Items.Add(thisTemplate, thisTemplate);

lv.Items.SubItems.Add("არარსებული ცვლადის ჩვენების მცდელობა");

mycode.code = ""; )

while (sr.Read() != "*")

if (mycode.masSost == 4)

(თუ (mycode.masSost == 6)

sw.Write(dt.Columns.Count.ToString());

while (sr.Read() != "*")

if (Convert.ToInt32 (mycode.masValue)< dt.Columns.Count)

(თუ (mycode.masSost == 7)

sw.Write(dt.Columns.masValue)].DataType.Name);

sw.Write(dt.Columns.masValue)].ColumnName);)

თუ მომხმარებელი ცდილობს წვდომას სვეტზე ან მწკრივზე, რომელიც არ არსებობს, მაშინ შესაბამისი შეცდომის ჩანაწერი ემატება შეცდომების ჟურნალს.

lv.Items.Add(thisTemplate, thisTemplate);

lv.Items.SubItems.Add(mycode.code);

mycode.code = ""; )

while (sr.Read() != "*")

( bool შექმნა = ყალბი;

for (int a = 0; a< masPeremCount; a++)

if (Convert.ToInt32 (masPerem)< dt.Columns.Count)

(თუ (mycode.masSost == 13)

sw.Write(dt.Columns)].ColumnName);

sw.Write(dt.Columns)].DataType.Name);

lv.Items.Add(thisTemplate, thisTemplate);

lv.Items.SubItems.Add(mycode.code);

lv.Items.SubItems.Add("ინდექსი საზღვრებს გარეთ");

mycode.code = ""; )

while (sr.Read() != "*")

თუ (შექმნა == მცდარი) (

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

lv.Items.Add(thisTemplate, thisTemplate);

lv.Items.SubItems.Add(mycode.code);

lv.Items.SubItems.Add("არარსებულ ცვლადზე წვდომის მცდელობა");

while (sr.Read() != "*")

if (mycode.masSost == 5)

( int n1 = 0, n2 = 0, nn = 0;

if (mycode.masSost == 6)

( sw.Write(dt.Rows.Count.ToString());

while (sr.Read() != "*")

(თუ (mycode.masSost == 12)

( ( n1 = Convert.ToInt32 (mycode.masValue);

if (mycode.masSost == 12)

( n2 = Convert.ToInt32 (mycode.masValue);

( bool შექმნა = ყალბი;

for (int a = 0; a< masPeremCount; a++)

if (masPerem == mycode.masValue)

n2 = Convert.ToInt32 (masPerem);

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

სხვა ( if (n1 >= dt.rows.Count)

(if (mycode.code != "")

(lv.Items.Add(thisTemplate, thisTemplate);

lv.Items.SubItems.Add(mycode.code);

lv.Items.SubItems.Add("ინდექსი " + n1 + " დიაპაზონის მიღმაა");))

თუ (n2 >= dt.Columns.Count)

(if (mycode.code != "")

( lv.Items.Add(thisTemplate, thisTemplate);

lv.Items.SubItems.Add(mycode.code);

lv.Items.SubItems.Add("ინდექსი " + n2 + " დიაპაზონის მიღმაა"); ))

mycode.code = ""; )

while ((sr.Read() != "*") && (!sr.EndOfStream))

if (mycode.masSost == 2)

masPerem = mycode.masValue;

masPerem = mycode.masValue;

nk = masPeremCount;

masPeremCount++;

if (mycode.masSost == 12)

k = Convert.ToInt32 (mycode.masValue); სხვა

თუ (mycode.masSost == 4) k = dt.Columns.Count;

else k = dt.Rows.Count;

while (sr.Read() != "*") ( )

თუ მომხმარებელმა გამოაცხადა ციკლი და ამის შემდეგ არ მიუთითა მისი დასაწყისი "("-ის დაყენების გარეშე, ეს განიხილება როგორც შეცდომა და ამის შესახებ ჩანაწერი ემატება შეცდომების ჟურნალს.

c = Convert.ToChar(sr.Read());

c = Convert.ToChar(sr.Read());

c = Convert.ToChar(sr.Read());

( lv.Items.Add(thisTemplate, thisTemplate);

lv.Items.SubItems.Add(mycode.code);

lv.Items.SubItems.Add("ციკლის დაწყება არ არის მითითებული");

mycode.correct = false;

NCode ++; ) სხვა (

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

Directory.CreateDirectory("ტემპ");

StreamWriter sw1=new StreamWriter("Temp\\Temp"+tempF.ToString()+".txt", false, Encoding.UTF8);

c = Convert.ToChar(sr.Read());

c = Convert.ToChar(sr.Read()); )

int cycleCount = 0;

ხოლო (c != ")")

if (sr.EndOfStream)

c = Convert.ToChar(sr.Read());

თუ ((c == ")") && (cickleCount != 0))

(cickleCount--;

c = Convert.ToChar(sr.Read()); ))

StreamReader sr1 = new StreamReader("Temp\\Temp" + tempF.ToString() + ".txt", Encoding.UTF8);

int CickleCode = 0;

bool sign2 = false;

ხოლო (!sr1.EndOfStream)

(c = Convert.ToChar(sr1.Read());

თუ ((c != "*") && (ნიშანი2 == მართალია))

(s1 += c.ToString();)

თუ ((c == "*") && (ნიშანი2 == მცდარი))

თუ ((c == "*") && (ნიშანი2 == მართალია))

(ნიშანი 2 = მცდარი;

else s1 += c.ToString(); ))

for (int a = Convert.ToInt32 (mycode.masValue); a< k; a++)

( masPerem = a.ToString();

ExecuteCode(NCode + 1, true, new StreamReader("Temp\\Temp" + tempF.ToString() + ".txt", Encoding.UTF8), sw, tempF);)

მარყუჟის დასრულების შემდეგ, დროებითი ფაილი იშლება და მარყუჟების ბუდეების სიღრმე მცირდება ერთით.

masPerem = "";

masPerem = "";

NCode = CickleCode + 1;

File.Delete("Temp\\Temp" + tempF.ToString() + ".txt");

კონსტრუქტორის გამოყენებით შექმნილ შაბლონებთან მუშაობის ალგორითმი აღწერილია შემდეგი მეთოდებით: Execute, GetTruthTable, ExecuteTag.

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

DataTable truedt=new DataTable();

StreamWriter sw=new StreamWriter(textBox4.Text+"Output file.xml",false,Encoding.UTF8);

for (int a = 0; a<= dt.Columns.Count;a++)

truedt.Columns.Add("",typeof(bool));

for (int a = 0; a<= dt.Rows.Count; a++)

(DataRow dr = truedt.NewRow();

for (int b = 0; b< dr.ItemArray.Length; b++)

truedt.Rows.Add(dr); )

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

ხოლო (! სრული)

( tagind = GetTagIndex(Items);

თუ (მასტაგ.ტიპი == ტიპები.გლობალური || მასტაგ.ტიპი == ტიპები.მთავარი)

if (mastag.type == type.block)

თუ (ერთეულები >= ერთეულების რაოდენობა)

სრული=true; )

თუ ტეგის ტიპი არის გლობალური ან ძირითადი, ტეგის შინაარსი უბრალოდ იწერება ფაილში.

if (mastag.name != "")

sw.WriteLine(items);

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

bool haveRow = false;

ტეგი blocktag = new tag.indF - mastag.indS - 1];

for (int a = mastag.indS + 1, b = 0; a< mastag.indF; a++, b++)

( blocktag[b] = matag;

if (blocktag[b].type ==type. მარტივი)

if (blocktag[b].source == "სტრიქონის ინდექსი" || blocktag[b].source == "უჯრედის შინაარსი")

haveRow = მართალია;)

ამის შემდეგ იქმნება „სიმართლის ცხრილი“ და მასზე ვრცელდება სიაში ნაპოვნი მარტივი ტეგების ყველა პირობა.

truedt=CreateTable(truthdt,dt);

for (int a = 0; a< blocktag.Length; a++)

if (blocktag[a].type ==type. მარტივი)

truedt = GetTruthTable(dt, truedt, blocktag[a]);

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

for (int a = 0; a< dt.Rows.Count; a++)

for (int b = 0; b< dt.Columns.Count; b++)

bool wasEx = ყალბი;

StreamWriter swt = new StreamWriter("temp.txt", false, Encoding.UTF8);

for (int c = 0; c< blocktag.Length; c++)

if (blocktag[c].type ==type.global)

if (blocktag[c].name != "")

swt.WriteLine(items.indS + c + 1]);

if (blocktag[c].name != "")

wasEx=ExecuteTag(dt, truedt, blocktag[c], a, b, swt); )

( StreamReader sr = new StreamReader("temp.txt", Encoding.UTF8);

sw.Write(sr.ReadToEnd());

File.Delete("temp.txt");

( for (int a=0;a

for (int c = 0; c< blocktag.Length; c++)

( if (blocktag[c].type ==type.global)

if (blocktag[c].name != "")

sw.WriteLine(items.indS + c + 1]);

if (blocktag[c].type ==type. მარტივი)

if (blocktag[c].name != "")

ExecuteTag(dt, truedt, blocktag[c], 0, a, sw);

თუ ტეგის ტიპი მარტივია, მაშინ მისთვის იქმნება ახალი „სიმართლის ცხრილი“ და თეგი სრულდება.

if (მასტაგ.ტიპი == ტიპები.მარტივი)

( truedt=CreateTable(truthdt,dt);

DataTable tempdt = GetTruthTable(dt, truedt, mastag);

if (mastag.name!="")

ExecuteTag(dt, tempdt, matag, 0, 0, sw);

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

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

3.2 მომხმარებლის ინტერფეისის აღწერა

პროგრამის მთავარი ფანჯარა დაყოფილია რამდენიმე ნაწილად: „.dbf“, „Templates“, „.xml“ და შეცდომების ჟურნალი. ყველა ნაწილში, ჟურნალის გარდა, არის ელემენტები, რომლებიც პასუხისმგებელნი არიან ფაილების შემცველი დირექტორიების არჩევაზე ან რომლებშიც ფაილები უნდა იყოს შენახული. შეცდომების ჟურნალი წარმოდგენილია სამი სვეტის სიის სახით: "ნიმუში", "სტრიქონი", "შეცდომა". პირველი სვეტი შეიცავს შაბლონის სახელს, რომელშიც აღმოჩენილია შეცდომა. მეორეში, ხაზი, სადაც მოხდა შეცდომა. მესამე, შეცდომის ტიპი.

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

3.1 სურათზე ნაჩვენებია ძირითადი ფორმა - პროგრამის მთავარი ფანჯარა.

სურათი 3.1 - პროგრამის მთავარი ფანჯარა

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

ნახაზი 3.2 გვიჩვენებს დამატებითი პროგრამის ფანჯრის (თარგის რედაქტორი) ხედს.

სურათი 3.2 - შაბლონის რედაქტორის ფანჯარა

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

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

სურათი 3.3 - შაბლონის კონსტრუქტორის ფანჯარა

პროგრამული უზრუნველყოფის მუშაობის შედეგად მიღებული იქნა XML ენის სხვადასხვა ვერსიის XML ფაილები. შეყვანის მონაცემად გამოყენებული იყო dBase II, dBase III და dBase IV ვერსიების dbf ფორმატის მონაცემთა ბაზები. კონვერტირებული ფაილები სწორად გაიხსნა შემდეგი ბრაუზერებით: Internet Explorer 10, Mozilla Firefox 19, Google Chrome ვერსია 27.0.1453.93, Opera 12.15. ბრაუზერების გარდა, ფაილების ნახვა და რედაქტირება შესაძლებელია ნებისმიერი ტექსტური რედაქტორით. მიღებული შედეგების მიხედვით შეიძლება დავასკვნათ, რომ პროგრამის მუშაობისას მიღებული XML ფაილები აკმაყოფილებს მომხმარებლის მოთხოვნებს.

3. 3 პროგრამული პროდუქტის სანდოობის ტესტირება და შეფასება

პროგრამული პროდუქტის ტესტირებისას გამოვლინდა შემდეგი შეცდომები:

მონაცემთა ბაზის ცხრილის უჯრედში ინდექსირების შეცდომა;

მარყუჟის ცვლადის გამომავალი შეცდომა;

შეცდომა, რომელიც ჩნდება, როდესაც მწკრივის ან სვეტის ინდექსი აღემატება მათ რაოდენობას.

1. მონაცემთა ბაზის ცხრილის უჯრედში ინდექსირების შეცდომა. ხდება მაშინ, როდესაც თარგი შეიცავს "*row[x].column[y]*" ფორმის კოდს, სადაც x და y არის რიცხვები ან ცვლადები. პრობლემა მოგვარდა პროგრამის კოდში დამატებითი პირობის დამატებით შაბლონში მსგავსი სტრიქონების დამუშავებისას.

2. მარყუჟის ცვლადის გამომავალი შეცდომა. ჩნდება, როდესაც შაბლონში მითითებულია ფორმის კოდი "*x*", სადაც x არის ცვლადი. პრობლემა მოგვარდა საიდენტიფიკაციო ცხრილის კომპილაციის შეცვლით.

3. შეცდომა, რომელიც ჩნდება, თუ მწკრივის ან სვეტის ინდექსი აღემატება მათ რაოდენობას. ეს ხდება მაშინ, როდესაც შაბლონი შეიცავს კოდს, როგორიცაა "*column[x].name*", სადაც x არის რიცხვი ან ცვლადი, რომლის ღირებულება აღემატება სვეტების რაოდენობას. პრობლემა მოგვარდა ინდექსის მნიშვნელობისა და სტრიქონების ან სვეტების რაოდენობის შედარებით, თუ ინდექსი აღემატება, ამის შესახებ ჩანაწერი ემატება შეცდომების ჟურნალს და პროგრამა აგრძელებს მუშაობას.

3. 4 ღირებულების გაანგარიშება

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

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

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

სადაც K p - კაპიტალის ინვესტიციები დიზაინისთვის; К р - კაპიტალური ინვესტიციები პროექტის განსახორციელებლად.

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

სადაც K m - მასალების ღირებულება; K pr - ძირითადი და დამატებითი ხელფასები სოციალური დაზღვევის გამოქვითვებით ინჟინერიისა და ტექნიკური პერსონალისთვის, რომელიც უშუალოდ მონაწილეობს პროექტის განვითარებაში; K mash - ხარჯები, რომლებიც დაკავშირებულია მანქანის დროის გამოყენებასთან პროგრამის გამართვისთვის; კ გ - მომსახურების გადახდა მესამე პირებისთვის, თუ პროექტი ხორციელდება მესამე მხარის ჩართულობით; K n - საპროექტო განყოფილების ზედნადები ხარჯები. ყველა გამოთვლა განხორციელდება ჩვეულებრივ ერთეულებში (c.u.), რაც შეესაბამება ერთი აშშ დოლარის ღირებულებას პრიდნესტროვის რესპუბლიკურ ბანკში პროგრამული უზრუნველყოფის შემუშავების დროს.

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

ცხრილი 3.1 - მასალების სავარაუდო ღირებულება

მსგავსი დოკუმენტები

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

ნაშრომი, დამატებულია 27/06/2013


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

საკურსო ნაშრომი, დამატებულია 24.06.2013


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

საკურსო ნაშრომი, დამატებულია 17/05/2013


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

ნაშრომი, დამატებულია 28.03.2015


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

რეზიუმე, დამატებულია 03/26/2010


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

ნაშრომი, დამატებულია 25/09/2014


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

საკურსო ნაშრომი, დამატებულია 01/08/2014


wav და mp3 ფაილის ფორმატების მახასიათებლები. გამოყენების შემთხვევების დიაგრამების აგება, გრაფიკული ინტერფეისის და აპლიკაციის არქიტექტურის შემუშავება. პროგრამის მუშაობის ალგორითმების შემუშავება: TrimWavFile მეთოდი, TrimMp3, ChangeVolume, speedUpX1_2, speedDownX1_2.

საკურსო ნაშრომი, დამატებულია 20/12/2013


Total Commander პროგრამასთან მუშაობის მახასიათებლების მიმოხილვა. შექმენით საქაღალდეები, დააკოპირეთ ფაილები ფლეშ დრაივში. კონტექსტური მენიუს დარეკვა. ფაილის სტრუქტურის განმარტება. ფაილების ჯგუფის სახელის გადარქმევა. ფაილების არქივში განთავსება. არქივის რამდენიმე ნაწილად დაყოფა.

ლაბორატორიული სამუშაო, დამატებულია 04/08/2014


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

DBF არის მონაცემთა ბაზის ფაილი, რომელთანაც მუშაობის შესაძლებლობა ადრე იყო ინტეგრირებული Microsoft Office გარემოში. Access და Excel აპლიკაციები მუშაობდა ფორმატით, მოგვიანებით Access ამოიღეს პაკეტიდან და იქცა ცალკე პროგრამად, ხოლო Excel-ში 2007 წლიდან DataBaseFile მხარდაჭერა მნიშვნელოვნად შეზღუდული იყო.

თუ თქვენ არ შეგიძლიათ გახსნათ DBF ფაილი პირდაპირ Excel-ში, ჯერ უნდა დააკონვერტიროთ იგი.

თუმცა, მიუხედავად იმისა, რომ DBF ბევრი მიიჩნევს მოძველებულ ფორმატად, ის მაინც ფართოდ გამოიყენება სპეციალიზებულ პროგრამებში ბიზნესის, დიზაინისა და ინჟინერიის სფეროში. სადაც არ უნდა იმუშაოთ დიდი რაოდენობით ინფორმაციასთან, მათი სტრუქტურირება და დამუშავება, შეკითხვის შესრულება. მაგალითად, 1C Enterprise პროგრამული პაკეტი მთლიანად დაფუძნებულია მონაცემთა ბაზის მართვაზე. და იმის გათვალისწინებით, რომ ბევრი საოფისე დოკუმენტაცია და მონაცემი მიდის Excel-ში, ამ ფორმატებთან ინტეგრირებული მუშაობის საკითხი აქტუალური და მოთხოვნადია.

Excel-ის პრობლემები DBF-თან მუშაობისას

Excel 2003-ში შესაძლებელი იყო DBF-ის გახსნა და რედაქტირება, ასევე XLS დოკუმენტების შენახვა ამ ფორმატში:

1. აირჩიეთ "ფაილი" მენიუს ზოლიდან.
2. შემდეგი, დააჭირეთ "შენახვა როგორც".
3. აირჩიეთ "*.dbf" ჩამოსაშლელი სიიდან.

ᲛᲜᲘᲨᲕᲜᲔᲚᲝᲕᲐᲜᲘ. 2007 წლიდან თქვენ შეგიძლიათ გახსნათ და ნახოთ მონაცემთა ბაზის ფორმატი Excel-ში, მაგრამ თქვენ არ შეგიძლიათ მასში ცვლილებების შეტანა ან .xls დოკუმენტების შენახვა. სტანდარტული პროგრამის ინსტრუმენტები აღარ იძლევა ამ შესაძლებლობას.

თუმცა, აპლიკაციისთვის არის სპეციალური დანამატები, რომლებიც ამატებენ მას ასეთ ფუნქციას. ქსელში სხვადასხვა ფორუმზე, პროგრამისტები აქვეყნებენ თავიანთ განვითარებას, შეგიძლიათ იპოვოთ სხვადასხვა ვარიანტები. ყველაზე პოპულარული დანამატი სახელწოდებით XslToDBF შეგიძლიათ ჩამოტვირთოთ დეველოპერის საიტიდან http://basile-m.narod.ru/xlstodbf/download.html. ჩამოტვირთვა უფასოა, მაგრამ სურვილის შემთხვევაში შეგიძლიათ მხარი დაუჭიროთ პროექტს საფულეზე ან ბარათზე ნებისმიერი თანხის გადარიცხვით.

ინსტალაცია და გამოყენება:

1. ჩამოტვირთეთ არქივი ზემოთ მოცემული საიტიდან.
2. ამოიღეთ XlsToDBF.xla მისგან და შეინახეთ თქვენს კომპიუტერში.
   
3. Excel-ში გადადით მენიუში Microsoft-ის ხატულა ღილაკით მარცხნივ, Options.
   
4. Excel ოფციების ქვეშ აირჩიეთ დანამატები.
5. "მართვა / Excel დანამატების" ხაზში დააწკაპუნეთ "გადასვლა".
   
6. დააწკაპუნეთ Browse-ზე და მიუთითეთ შენახულ XlsToDBF.xla-ზე.
   
7. დანამატების სიაში ჩანაწერი „XLS -> DBF“ უნდა გამოჩნდეს მონიშნული ველით. გაითვალისწინეთ, თუ ის არ არსებობს.
8. ახლა თქვენ შეგიძლიათ შეინახოთ .xls .dbf ფორმატში. ამავე საიტიდან შეგიძლიათ ჩამოტვირთოთ გამოყენების დეტალური ინსტრუქცია. მთავარია სწორად მოამზადოთ ცხრილის მონაცემები.
9. ცხრილის მომზადების შემდეგ აირჩიეთ ნებისმიერი შევსებული უჯრედი და დააჭირეთ Alt და F
10. მაკრო ფანჯარაში, რომელიც იხსნება, ველში ჩაწერეთ XlsToDBF, დიდი მნიშვნელობა არ აქვს.
    
11. დააჭირეთ გაშვებას.
12. თუ თქვენ სწორად მოამზადეთ და დააფორმატეთ მონაცემები, მაშინ მონაცემთა ბაზის ფაილი შეინახება საქაღალდეში, სადაც მდებარეობს ორიგინალური XLS.

თუ არ გსურთ რაიმე შეცვალოთ Office-ში, არ ენდოთ დანამატებს და მესამე მხარის აპლიკაციებს, მაშინ შეგიძლიათ შესთავაზოთ უფრო შრომატევადი გზა XLS ფაილის DBF-ად გადაქცევისთვის:

1. შეიძინეთ და დააინსტალირეთ Microsoft Access.
2. Excel-ში მოამზადეთ და შეინახეთ დოკუმენტი.
   
3. დააჭირეთ ღილაკს "გახსნა" MS Access-ში და აირჩიეთ ფაილი.
   
4. ახლა საჭიროა იმპორტის სწორად კონფიგურაცია.
   
5. დასაწყისისთვის აირჩიეთ ფურცელი. თუ რამდენიმეა, მაინც უნდა გააკეთოთ თითო-თითო.
   
6. თუ ცხრილს აქვს სათაურის მწკრივი, მონიშნეთ შესაბამისი ველი.
   
7. შემდეგი, შეგიძლიათ შეცვალოთ ცხრილის სახელი.
   
8. ახლა დააჭირეთ ღილაკს "გარე მონაცემები".
   
9. დააჭირეთ ღილაკს "ექსპორტი", "Advanced".
   
10. აირჩიეთ dBase ფაილი.
    
11. მიუთითეთ სახელი და შეინახეთ მდებარეობა.

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

კონვერტაცია

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

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

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

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