👨🏻‍💻 ☔️ 👲🏽 C # में टेक्स्ट डॉक्युमेंट्स को xml में बदलें 🍱 👩🏿‍🤝‍👩🏼 👖

हाल ही में, मुझे कार्यालय दस्तावेज़ों ( डॉक, xlsx, rtf , doc, xls, odt और ods ) से पाठ प्राप्त करने की आवश्यकता से निपटना पड़ा । टास्क को आगे पार्सिंग के लिए सबसे सुविधाजनक संरचना के साथ कचरा के बिना xml प्रारूप में प्रस्तुत करने की आवश्यकता से कार्य जटिल था।

इंटरोप का उपयोग करने का निर्णय कई तरह से अतिरेक के कारण तुरंत दूर हो गया, और सर्वर पर एमएस कार्यालय स्थापित करने की आवश्यकता भी हुई । नतीजतन, एक समाधान पाया गया और एक आंतरिक परियोजना पर लागू किया गया। हालाँकि, खोज इतनी जटिल थी और सामान्य रूप से सुलभ मैनुअल की कमी के कारण तुच्छ नहीं थी, जो मैंने अपने खाली समय में एक पुस्तकालय लिखने का फैसला किया था जो निर्दिष्ट समस्या को हल करेगा, और लिखने के लिए एक तरह का निर्देश भी बनाएगा ताकि डेवलपर्स पढ़ें वह कम से कम सतही रूप से इस मुद्दे को समझने में सक्षम थी।

पाया समाधान के विवरण के लिए आगे बढ़ने से पहले, मैं सुझाव देता हूं कि आप अपने आप को कुछ निष्कर्षों से परिचित करें जो मेरे शोध के परिणामस्वरूप किए गए थे:

.Net प्लेटफ़ॉर्म के लिए, सभी सूचीबद्ध प्रारूपों के साथ काम करने के लिए कोई तैयार समाधान नहीं है, जो हमें कुछ स्थानों पर हमारे समाधान को बनाने के लिए मजबूर करेगा।
नेटवर्क पर Microsoft OpenXML के साथ काम करने पर एक अच्छा मैनुअल खोजने की कोशिश न करें: इस पुस्तकालय से निपटने के लिए आपको बहुत लाल-आंखों वाला, स्टैकऑवरफ़्लो धूम्रपान करना होगा और डीबगर के साथ खेलना होगा।
हाँ, मैं अभी भी ड्रैगन को वश में करने में कामयाब रहा।

मुझे तुरंत कहना होगा कि पुस्तकालय अभी तैयार नहीं है, लेकिन यह सक्रिय रूप से लिखा जा रहा है (जितना खाली समय की अनुमति है)। यह माना जाता है कि प्रत्येक प्रारूप के लिए अलग-अलग पोस्ट लिखी जाएंगी और समानांतर में, उनके प्रकाशन के साथ-साथ, गीथब पर रिपॉजिटरी को अपडेट किया जाएगा, जहां से स्रोतों को प्राप्त करना संभव होगा।

Xlsx और docx के साथ काम करें

.xlsx

, , , docx xlsx zip-, xml. , : zip . , : \xl\worksheets.

excel , , - , :

, , , ( <f>) ( <v>). , shared sharedStrings.xml, \xl.
: .

, -, IConvertable:

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;

namespace ConverterToXml.Converters
{
    interface IConvertable
    {
        string Convert(Stream stream);
        string ConvertByFile(String path);

    }
}

, : string Convert(Stream stream) ( , - ), string ConvertByFile(String path) .

XlsxToXml, IConvertable Nuget DocumentFormat.OpenXml ( , 2.10.0).

string SpreadsheetProcess(Stream memStream), string Convert(Stream stream).

        public string Convert(Stream memStream)
        {
            return SpreadsheetProcess(memStream);
        }

, *string SpreadsheetProcess(Stream memStream)*:

string SpreadsheetProcess(Stream memStream)
        {
            using (SpreadsheetDocument doc = SpreadsheetDocument.Open(memStream, false))
            {
                memStream.Position = 0;
                StringBuilder sb = new StringBuilder(1000);
                sb.Append("<?xml version=\"1.0\"?><documents><document>");
                SharedStringTable sharedStringTable = doc.WorkbookPart.SharedStringTablePart.SharedStringTable; 
                int sheetIndex = 0;
                foreach (WorksheetPart worksheetPart in doc.WorkbookPart.WorksheetParts)
                {
                    WorkSheetProcess(sb, sharedStringTable, worksheetPart, doc, sheetIndex);
                    sheetIndex++;
                }
                sb.Append(@"</document></documents>");
                return sb.ToString();
            }
        }

, string SpreadsheetProcess(Stream memStream) :

using excel . xlsx DocumentFormat.OpenXml SpreadsheetDocument.
StringBuilder sb ( 1000 . StringBuilder , . , , .
shared ( ). , SpreadsheetDocument :
SharedStringTable sharedStringTable = doc.WorkbookPart.SharedStringTablePart.SharedStringTable.

foreach (WorksheetPart worksheetPart in doc.WorkbookPart.WorksheetParts)
            {
                WorkSheetProcess(sb, sharedStringTable, worksheetPart, doc, sheetIndex);
                sheetIndex++;
            }

WorkSheetProcess(sb, sharedStringTable, worksheetPart, doc, sheetIndex);:

private void WorkSheetProcess(StringBuilder sb, SharedStringTable sharedStringTable, WorksheetPart worksheetPart, SpreadsheetDocument doc,
        int sheetIndex)
    {
        string sheetName = doc.WorkbookPart.Workbook.Descendants<Sheet>().ElementAt(sheetIndex).Name.ToString();
        sb.Append($"<sheet name=\"{sheetName}\">");
        foreach (SheetData sheetData in worksheetPart.Worksheet.Elements<SheetData>())
        {
            if (sheetData.HasChildren)
            {
                foreach (Row row in sheetData.Elements<Row>())
                {
                    RowProcess(row, sb, sharedStringTable);
                }
            }
        }
        sb.Append($"</sheet>");
    }

, :
string sheetName = doc.WorkbookPart.Workbook.Descendants<Sheet>().ElementAt(sheetIndex).Name.ToString();
, , . , . , , shift+F9( ), doc( )->WorkbookPart->Workbook Descendants(), Sheet. , ( ). :

foreach , . sheetData - , , RowProcess:

foreach (SheetData sheetData in worksheetPart.Worksheet.Elements<SheetData>())
        {
            if (sheetData.HasChildren)
            {
                foreach (Row row in sheetData.Elements<Row>())
                {
                    RowProcess(row, sb, sharedStringTable);
                }
            }
        }

void RowProcess(Row row, StringBuilder sb, SharedStringTable sharedStringTable) :

void RowProcess(Row row, StringBuilder sb, SharedStringTable sharedStringTable)
    {
        sb.Append("<row>");
        foreach (Cell cell in row.Elements<Cell>())
        {
            string cellValue = string.Empty;
            sb.Append("<cell>");
            if (cell.CellFormula != null)
            {
                cellValue = cell.CellValue.InnerText;
                sb.Append(cellValue);
                sb.Append("</cell>");
                continue;
            }
            cellValue = cell.InnerText;
            if (cell.DataType != null && cell.DataType == CellValues.SharedString)
            {
                sb.Append(sharedStringTable.ElementAt(Int32.Parse(cellValue)).InnerText);
            }
            else
            {
                sb.Append(cellValue);
            }
            sb.Append("</cell>");
        }
        sb.Append("</row>");
    }

foreach (Cell cell in row.Elements<Cell>()) :

if (cell.CellFormula != null)
            {
                cellValue = cell.CellValue.InnerText;
                sb.Append(cellValue);
                sb.Append("</cell>");
                continue;
            }

, , (cellValue = cell.CellValue.InnerText;) .
, , shared: , :

if (cell.DataType != null && cell.DataType == CellValues.SharedString)
            {
                sb.Append(sharedStringTable.ElementAt(Int32.Parse(cellValue)).InnerText);
            }

, .

.docx

, word excel-.
, , , , , , . , , .., , , , - , , .

, . zip . . word document. , , , , . , : - .

, w:t, w:r, w:p. , docx, . : , w:numPr, (w:ilvl) id , (w:numId).

, , , , ( , ), , id , , .
, , :

, . w:tr () w:tc().

इससे पहले कि आप कोडिंग शुरू करें, मैं एक बहुत ही महत्वपूर्ण बारीकियों पर ध्यान देना चाहता हूं (हाँ, जैसा कि पेटका और वासिली इवानोविच के बारे में मजाक में)। जब पार्सिंग सूची, विशेष रूप से जब यह नेस्टेड सूचियों की बात आती है, तो एक स्थिति उत्पन्न हो सकती है जब सूची आइटम को किसी प्रकार के पाठ, छवि, या किसी अन्य चीज के सम्मिलन द्वारा अलग किया जाता है। फिर सवाल उठता है कि हम सूची का समापन टैग कब लगाते हैं? मेरा सुझाव, बैसाखी और साइकिल भवन की महक, एक शब्दकोश जोड़ने के लिए नीचे आता है, जिनमें से कुंजी सूचियों की आईडी होगी, और मूल्य पैराग्राफ की आईडी के अनुरूप होगा (हाँ, यह दस्तावेज़ में प्रत्येक पैराग्राफ की अपनी विशिष्ट आईडी है), जो एक सूची में अंतिम भी है। शायद यह काफी कठिन लिखा है, लेकिन मुझे लगता है कि जब आप कार्यान्वयन को देखते हैं, तो यह कुछ हद तक स्पष्ट हो जाएगा:

public string Convert(Stream memStream)
{
    Dictionary<int, string> listEl = new Dictionary<int, string>();
    string xml = string.Empty;
    memStream.Position = 0;
    using (WordprocessingDocument doc = WordprocessingDocument.Open(memStream, false))
    {
        StringBuilder sb = new StringBuilder(1000); 
        sb.Append("<?xml version=\"1.0\"?><documents><document>");
        Body docBody = doc.MainDocumentPart.Document.Body;
        CreateDictList(listEl, docBody);
        foreach (var element in docBody.ChildElements)
        {
            string type = element.GetType().ToString();
            try
            {
                switch (type)
                {
                    case "DocumentFormat.OpenXml.Wordprocessing.Paragraph":
                        if (element.GetFirstChild<ParagraphProperties>() != null)
                        {
                            if (element.GetFirstChild<ParagraphProperties>().GetFirstChild<NumberingProperties>().GetFirstChild<NumberingId>().Val != CurrentListID)
                            {
                                CurrentListID = element.GetFirstChild<ParagraphProperties>().GetFirstChild<NumberingProperties>().GetFirstChild<NumberingId>().Val;
                                sb.Append($"<li id=\"{CurrentListID}\">");
                                InList = true;
                                ListParagraph(sb, (Paragraph)element);
                            }
                            else
                            {
                                ListParagraph(sb, (Paragraph)element);
                            }
                            if (listEl.ContainsValue(((Paragraph)element).ParagraphId.Value))
                            {
                                sb.Append($"</li id=\"{element.GetFirstChild<ParagraphProperties>().GetFirstChild<NumberingProperties>().GetFirstChild<NumberingId>().Val}\">");
                            }
                            continue;
                        }
                        else
                        {
                            SimpleParagraph(sb, (Paragraph)element);
                            continue;
                        }
                    case "DocumentFormat.OpenXml.Wordprocessing.Table":
                        Table(sb, (Table)element);
                        continue;
                }
            }
            catch (Exception e)
            {
                continue;
            }
        }
        sb.Append(@"</document></documents>");
        xml = sb.ToString();
    }
    return xml;
}

Dictionary<int, string> listEl = new Dictionary<int, string>(); — .
using (WordprocessingDocument doc = WordprocessingDocument.Open(memStream, false)) — doc WordprocessingDocument, word, ( , OpenXML) .
StringBuilder sb = new StringBuilder(1000); — xml.
Body docBody = doc.MainDocumentPart.Document.Body; — ,

CreateDictList(listEl, docBody);, foreach , :

void CreateDictList(Dictionary<int, string> listEl, Body docBody)
{
foreach(var el in docBody.ChildElements)
{
    if(el.GetFirstChild<ParagraphProperties>() != null)
    {
        int key = el.GetFirstChild<ParagraphProperties>().GetFirstChild<NumberingProperties>().GetFirstChild<NumberingId>().Val;
        listEl[key] = ((DocumentFormat.OpenXml.Wordprocessing.Paragraph)el).ParagraphId.Value;
    }
}
}

GetFirstChild<ParagraphProperties>().GetFirstChild<NumberingProperties>().GetFirstChild<NumberingId>().Val; — ( https://docs.microsoft.com/ru-ru/office/open-xml/open-xml-sdk ), . , , , )

, , foreach . : . , , . , (, ) , . , . :

string type = element.GetType().ToString();
               try
{
switch (type)
{
    case "DocumentFormat.OpenXml.Wordprocessing.Paragraph":

        if (element.GetFirstChild<ParagraphProperties>() != null) //  /  
        {
            if (element.GetFirstChild<ParagraphProperties>().GetFirstChild<NumberingProperties>().GetFirstChild<NumberingId>().Val != CurrentListID)
            {
                CurrentListID = element.GetFirstChild<ParagraphProperties>().GetFirstChild<NumberingProperties>().GetFirstChild<NumberingId>().Val;
                sb.Append($"<li id=\"{CurrentListID}\">");
                InList = true;
                ListParagraph(sb, (Paragraph)element);
            }
            else //  
            {
                ListParagraph(sb, (Paragraph)element);
            }
            if (listEl.ContainsValue(((Paragraph)element).ParagraphId.Value))
            {
                sb.Append($"</li id=\"{element.GetFirstChild<ParagraphProperties>().GetFirstChild<NumberingProperties>().GetFirstChild<NumberingId>().Val}\">");
            }
            continue;
        }
        else //  
        {
            SimpleParagraph(sb, (Paragraph)element);
            continue;
        }
    case "DocumentFormat.OpenXml.Wordprocessing.Table":

        Table(sb, (Table)element);
        continue;
}
}

try-catch , - , switch-case ( , , ). , - , .

, ListParagraph(sb, (Paragraph)element); :

void ListParagraph(StringBuilder sb, Paragraph p)
{
//  
var level = p.GetFirstChild<ParagraphProperties>().GetFirstChild<NumberingProperties>().GetFirstChild<NumberingLevelReference>().Val;
// id 
var id = p.GetFirstChild<ParagraphProperties>().GetFirstChild<NumberingProperties>().GetFirstChild<NumberingId>().Val;
sb.Append($"<ul id=\"{id}\" level=\"{level}\"><p>{p.InnerText}</p></ul id=\"{id}\" level=\"{level}\">");
}

<ul>, id .

, , SimpleParagraph(sb, (Paragraph)element);:

void SimpleParagraph(StringBuilder sb, Paragraph p)
{
sb.Append($"<p>{p.InnerText}</p>");
}

, <p>

तालिका विधि में संसाधित होती है Table(sb, (Table)element);:
```
void Table(StringBuilder sb, Table table)
{
sb.Append("<table>");
foreach (var row in table.Elements<TableRow>())
{
sb.Append("<row>");
foreach (var cell in row.Elements<TableCell>())
{
sb.Append($"<cell>{cell.InnerText}</cell>");
}
sb.Append("</row>");
}
sb.Append("</table>");}
```
ऐसे तत्व का प्रसंस्करण काफी तुच्छ है: हम लाइनों को पढ़ते हैं, उन्हें कोशिकाओं में तोड़ते हैं, कोशिकाओं से मान लेते हैं, उन्हें टैग में लपेटते हैं <cell>, जिसे हम टैग में पैक करते हैं <row>और यह सब अंदर डालते हैं <table>।

इस पर, मैं कार्य को डॉक्स और xlsx प्रारूप के दस्तावेजों के लिए हल के रूप में विचार करने का प्रस्ताव करता हूं।

स्रोत कोड को लिंक पर रिपॉजिटरी में देखा जा सकता है

Rtf रूपांतरण लेख

C # में टेक्स्ट डॉक्युमेंट्स को xml में बदलें

Xlsx और docx के साथ काम करें

.xlsx

.docx

More articles: