🏄 ⛹🏽 🧛🏿 Cls को xlsx और xml में C # में बदलें 🔋 📤 🔜

इस लेख में मैं xls को xml दस्तावेज़ों में बदलने के संभावित तरीकों में से एक के बारे में बात करने की कोशिश करूँगा ।

प्रत्यक्ष रूप से, मेरा काम कुछ इस तरह दिखता था:

दिया हुआ:

समाधान खोजने और लागू करने के लिए 1-2 दिन का समय
समाधान यथासंभव मुक्त होना चाहिए।
जिस फ़ाइल को संसाधित किया जाना चाहिए उसकी अनुमानित संरचना, आकार और सामग्री ज्ञात है, जो दस्तावेज़ से ग्राफ़, चार्ट और अन्य मध्यस्थों को पढ़ने की आवश्यकता को समाप्त करती है।
इंटरॉप का उपयोग , साथ ही साथ अन्य पुस्तकालयों, जिनके लिए कार्यालय की स्थापना की आवश्यकता नहीं हो सकती है, क्योंकि यह सर्वर पर एक अतिरिक्त भार बनाता है और कार्यालय सूट की अतिरिक्त स्थापना की आवश्यकता नहीं है।

मुझे कहना होगा कि यह कार्य किसी भी तरह से आसान नहीं है, और इसे हल करने के लिए, जैसा कि नए कार्यालय प्रारूपों (डॉक्स और xlsx) के साथ किया गया था , निम्नलिखित कारणों से विफल होंगे:

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

stackoverflow, , , .Net , xls xlsx, xlsx .

, Microsoft, , , , . , , ( ), , , . , , , , , !

Tony Qu , . , .Net, ( .Net doc).
, , , : NPOI - , . , , .

, , , xls xlsx, , .

nuget NPOI ( nuget : Tony Qu, netcore — . , , ):

XlsToXlsx public MemoryStream Convert(Stream sourceStream):

public MemoryStream Convert(Stream sourceStream)
{
//  xls
var source = new HSSFWorkbook(sourceStream);
//     xlsx
var destination = new XSSFWorkbook();
//    xls    xlsx
for (int i = 0; i < source.NumberOfSheets; i++)
{
    var xssfSheet = (XSSFSheet)destination.CreateSheet(source.GetSheetAt(i).SheetName);
    var hssfSheet = (HSSFSheet)source.GetSheetAt(i);
    CopyStyles(hssfSheet, xssfSheet);
    CopySheet(hssfSheet, xssfSheet);
}
//   
using (var ms = new MemoryStream())
{
    destination.Write(ms);
    return ms;
}
}

, . , , (, , ).
xls NPOI HSSFWorkbook, , .
xlsx XSSFWorkbook.
, xls xlsx. , . , xssfSheet HSSFSheet.
, , .
MemoryStream

,

private void CopyStyles(HSSFSheet from, XSSFSheet to)
{
    for (short i = 0; i <= from.Workbook.NumberOfFonts; i++)
    {
        CopyFont(to.Workbook.CreateFont(), from.Workbook.GetFontAt(i));
    }

    for (short i = 0; i < from.Workbook.NumCellStyles; i++)
    {
        CopyStyle(to.Workbook.CreateCellStyle(), from.Workbook.GetCellStyleAt(i), to.Workbook, from.Workbook);
    }
}

, , , , .

void CopyFont(IFont toFront, IFont fontFrom)

private void CopyFont(IFont toFront, IFont fontFrom)
{
    toFront.Boldweight = fontFrom.Boldweight;
    toFront.Charset = fontFrom.Charset;
    toFront.Color = fontFrom.Color;
    toFront.FontHeightInPoints = fontFrom.FontHeightInPoints;
    toFront.FontName = fontFrom.FontName;
    toFront.IsBold = fontFrom.IsBold;
    toFront.IsItalic = fontFrom.IsItalic;
    toFront.IsStrikeout = fontFrom.IsStrikeout;
}

, , — .
:

private void CopyStyle(ICellStyle toCellStyle, ICellStyle fromCellStyle, IWorkbook toWorkbook, IWorkbook fromWorkbook)
{
    toCellStyle.Alignment = fromCellStyle.Alignment;
    toCellStyle.BorderBottom = fromCellStyle.BorderBottom;
    toCellStyle.BorderDiagonal = fromCellStyle.BorderDiagonal;
    toCellStyle.BorderDiagonalColor = fromCellStyle.BorderDiagonalColor;
    toCellStyle.BorderDiagonalLineStyle = fromCellStyle.BorderDiagonalLineStyle;
    toCellStyle.BorderLeft = fromCellStyle.BorderLeft;
    toCellStyle.BorderRight = fromCellStyle.BorderRight;
    toCellStyle.BorderTop = fromCellStyle.BorderTop;
    toCellStyle.BottomBorderColor = fromCellStyle.BottomBorderColor;
    toCellStyle.DataFormat = fromCellStyle.DataFormat;
    toCellStyle.FillBackgroundColor = fromCellStyle.FillBackgroundColor;
    toCellStyle.FillForegroundColor = fromCellStyle.FillForegroundColor;
    toCellStyle.FillPattern = fromCellStyle.FillPattern;
    toCellStyle.Indention = fromCellStyle.Indention;
    toCellStyle.IsHidden = fromCellStyle.IsHidden;
    toCellStyle.IsLocked = fromCellStyle.IsLocked;
    toCellStyle.LeftBorderColor = fromCellStyle.LeftBorderColor;
    toCellStyle.RightBorderColor = fromCellStyle.RightBorderColor;
    toCellStyle.Rotation = fromCellStyle.Rotation;
    toCellStyle.ShrinkToFit = fromCellStyle.ShrinkToFit;
    toCellStyle.TopBorderColor = fromCellStyle.TopBorderColor;
    toCellStyle.VerticalAlignment = fromCellStyle.VerticalAlignment;
    toCellStyle.WrapText = fromCellStyle.WrapText;
    toCellStyle.SetFont(toWorkbook.GetFontAt((short)(fromCellStyle.GetFont(fromWorkbook).Index + 1)));
}

, , . , , SetFont, .

xls xlsx

xls xlsx.

private void CopySheet(HSSFSheet source, XSSFSheet destination)
{
    var maxColumnNum = 0;
    var mergedRegions = new List<CellRangeAddress>();
    for (int i = source.FirstRowNum; i <= source.LastRowNum; i++)
    {
        var srcRow = (HSSFRow)source.GetRow(i);
        var destRow = (XSSFRow)destination.CreateRow(i);
        if (srcRow != null)
        {
            CopyRow(source, destination, srcRow, destRow, mergedRegions);
            //      
            if (srcRow.LastCellNum > maxColumnNum)
            {
                maxColumnNum = srcRow.LastCellNum;
            }
        }
    }
    //     
    for (int i = 0; i <= maxColumnNum; i++)
    {
        destination.SetColumnWidth(i, source.GetColumnWidth(i));
    }
}

CopyRow(source, destination, srcRow, destRow, mergedRegions) — . , CopySheet . , (, xls xlsx ).

void CopyRow(HSSFSheet srcSheet, XSSFSheet destSheet, HSSFRow srcRow, XSSFRow destRow, List<CellRangeAddress> mergedRegions):

private void CopyRow(HSSFSheet srcSheet, XSSFSheet destSheet, HSSFRow srcRow, XSSFRow destRow, List<CellRangeAddress> mergedRegions)
{
    //   
    destRow.Height = srcRow.Height;
    for (int j = srcRow.FirstCellNum; srcRow.LastCellNum >= 0 && j <= srcRow.LastCellNum; j++)
    {
        var oldCell = (HSSFCell)srcRow.GetCell(j);
        var newCell = (XSSFCell)destRow.GetCell(j);
        if (oldCell != null)
        {
            //      
            if (newCell == null)
            {
                newCell = (XSSFCell)destRow.CreateCell(j);
            }
            CopyCell(oldCell, newCell);
            //     
            //        
            var mergedRegion = GetMergedRegion(srcSheet, srcRow.RowNum,
                    (short)oldCell.ColumnIndex);
            //    
            if (mergedRegion != null)
            {
                //          
                var newMergedRegion = new CellRangeAddress(mergedRegion.FirstRow,
                        mergedRegion.LastRow, mergedRegion.FirstColumn, mergedRegion.LastColumn);
                //   ,         
                if (IsNewMergedRegion(newMergedRegion, mergedRegions))
                {
                    mergedRegions.Add(newMergedRegion);
                    destSheet.AddMergedRegion(newMergedRegion);
                }
            }
        }
    }
}

-, "" xls "" xlsx
-, , . , , , .

private void CopyCell(HSSFCell oldCell, XSSFCell newCell)
{
    CopyCellStyle(oldCell, newCell);
    CopyCellValue(oldCell, newCell);
}

-, :

private void CopyCellStyle(HSSFCell oldCell, XSSFCell newCell)
{
if (oldCell.CellStyle == null)
    return;
newCell.CellStyle = newCell.Sheet.Workbook.GetCellStyleAt((short)(oldCell.CellStyle.Index + 1));
}

-, :

void CopyCellValue(HSSFCell oldCell, XSSFCell newCell)
{
switch (oldCell.CellType)
{
    case CellType.String:
        newCell.SetCellValue(oldCell.StringCellValue);
        break;
    case CellType.Numeric:
        newCell.SetCellValue(oldCell.NumericCellValue);
        break;
    case CellType.Blank:
        newCell.SetCellType(CellType.Blank);
        break;
    case CellType.Boolean:
        newCell.SetCellValue(oldCell.BooleanCellValue);
        break;
    case CellType.Error:
        newCell.SetCellErrorValue(oldCell.ErrorCellValue);
        break;
    case CellType.Formula:
        newCell.SetCellFormula(oldCell.CellFormula);
        break;
    default:
        break;
}
}

, , (, ).

, .
, CellRangeAddress GetMergedRegion(HSSFSheet sheet, int rowNum, short cellNum) bool IsNewMergedRegion(CellRangeAddress newMergedRegion, List<CellRangeAddress> mergedRegions):

CellRangeAddress GetMergedRegion(HSSFSheet sheet, int rowNum, short cellNum)
{
for (var i = 0; i < sheet.NumMergedRegions; i++)
{
    var merged = sheet.GetMergedRegion(i);
    if (merged.IsInRange(rowNum, cellNum))
    {
        return merged;
    }
}
return null;
}

, , , - . , , . , null.

bool IsNewMergedRegion(CellRangeAddress newMergedRegion,List<CellRangeAddress> mergedRegions)
{
    return !mergedRegions.Any(r =>
    r.FirstColumn == newMergedRegion.FirstColumn &&
    r.LastColumn == newMergedRegion.LastColumn &&
    r.FirstRow == newMergedRegion.FirstRow &&
    r.LastRow == newMergedRegion.LastRow);
}

, , . , 4- ( , ).

xls xlsx .

, stackoverflow, xlsx xls, stackoverflow.

public void ConvertToXlsxFile(MemoryStream stream, string path)
{
var result = Convert(stream);
using (FileStream fs = new FileStream(path, FileMode.OpenOrCreate))
{
    fs.Write(result.ToArray());
}
}

public void ConvertToXlsxFile(string xlsPath, string destPath)
{
MemoryStream result;
using (FileStream fs = new FileStream(xlsPath, FileMode.Open))
{
    result = Convert(fs);
}
using (FileStream fs = new FileStream(destPath, FileMode.OpenOrCreate))
{
    fs.Write(result.ToArray());
}
}

, , xml:

public class XlsToXml : IConvertable
{
public string Convert(Stream stream)
{
    XlsToXlsx excelConvert = new XlsToXlsx();
    Stream str = excelConvert.Convert(stream);
    XlsxToXml converter = new XlsToXml();
    return converter.Convert(str);
}
public string ConvertByFile(string path)
{
    using (FileStream fs = File.OpenRead(path))
    {
        return Convert(fs);
    }
}
}

, XlsxToXml, xlsx xml, .

Cls को xlsx और xml में C # में बदलें

,

xls xlsx

More articles: