මයික්‍රොසොෆ්ට් ඔෆිස් ස්ථාපනය නොකර C # හි එක්සෙල් (.XLS සහ .XLSX) ගොනුවක් නිර්මාණය කරන්නේ කෙසේද?

කේතය ක්‍රියාත්මක වන යන්ත්‍රයේ එක්සෙල් ස්ථාපනය කිරීම අවශ්‍ය නොවී සී # සමඟ එක්සෙල් පැතුරුම්පතක් නිර්මාණය කරන්නේ කෙසේද?

ඔබට ExcelLibrary නමින් පුස්තකාලයක් භාවිතා කළ හැකිය. එය ගූගල් කේතයේ පළ කර ඇති නිදහස්, විවෘත මූලාශ්‍ර පුස්තකාලයකි:

එක්සෙල් පුස්තකාලය

මෙය ඔබ ඉහත සඳහන් කළ PHP ExcelWriter හි වරායක් ලෙස පෙනේ. එය තවමත් නව .xlsx ආකෘතියට ලියන්නේ නැත, නමුත් ඔවුන් එම ක්‍රියාකාරීත්වය ඇතුලත් කිරීමට කටයුතු කරමින් සිටී.

එය ඉතා සරල, කුඩා හා භාවිතා කිරීමට පහසුය. ප්ලස් එයට ඩේටාසෙට් හෙල්පර් ඇති අතර එය එක්සෙල් දත්ත සමඟ පහසුවෙන් වැඩ කිරීමට ඩේටාසෙට් සහ ඩේටා ටේබල් භාවිතා කිරීමට ඉඩ දෙයි.

එක්සෙල් පුස්තකාලය තවමත් ක්‍රියාත්මක වන්නේ පැරණි එක්සෙල් ආකෘතිය (.xls ගොනු) සඳහා පමණක් බව පෙනේ, නමුත් අනාගතයේදී නව 2007/2010 ආකෘති සඳහා සහය එක් කරයි.

ඔබ ද භාවිතා කළ හැකිය EPPlus එක්සෙල් 2007/2010 ආකෘතිය ගොනු (.xlsx ගොනු) සඳහා පමණක් ක්රියා කරන,. ද තිබෙන NPOI සමඟ කටයුතු කරන.

අදහස් දැක්වීම්වල සඳහන් පරිදි එක් එක් පුස්තකාලය සමඟ දන්නා දෝෂ කිහිපයක් තිබේ. සියල්ලට ම, කාලය ගත වන විට EPPlus හොඳම තේරීම බව පෙනේ. එය වඩාත් ක්‍රියාශීලීව යාවත්කාලීන කර ලේඛනගත කර ඇති බව පෙනේ.

පහත දැක්වෙන පරිදි සටහන් කර ඇති පරිදි, EPPlus හට Pivot Tables සඳහා සහය ඇති අතර ExcelLibrary හට යම් සහයක් තිබිය හැකිය ( ExcelLibrary හි Pivot table issue )

ඉක්මන් යොමු කිරීම සඳහා සබැඳි කිහිපයක් මෙන්න:
ExcelLibrary - GNU Lesser GPL
EPPlus - GNU (LGPL) - තවදුරටත් නඩත්තු
නොකරන EPPlus 5 - පොලිෆෝම් වාණිජ නොවන - 2020 මැයි මස ආරම්භ වන
NPOI - Apache බලපත්‍රය

ExcelLibrary සඳහා උදාහරණ කේත කිහිපයක් මෙන්න:

මෙන්න දත්ත සමුදායකින් දත්ත ගෙන එයින් වැඩපොතක් නිර්මාණය කිරීමේ උදාහරණයකි. එක්සෙල් පුස්තකාල කේතය පතුලේ ඇති තනි පේළිය බව සලකන්න:

//Create the data set and table
DataSet ds = new DataSet("New_DataSet");
DataTable dt = new DataTable("New_DataTable");

//Set the locale for each
ds.Locale = System.Threading.Thread.CurrentThread.CurrentCulture;
dt.Locale = System.Threading.Thread.CurrentThread.CurrentCulture;

//Open a DB connection (in this example with OleDB)
OleDbConnection con = new OleDbConnection(dbConnectionString);
con.Open();

//Create a query and fill the data table with the data from the DB
string sql = "SELECT Whatever FROM MyDBTable;";
OleDbCommand cmd = new OleDbCommand(sql, con);
OleDbDataAdapter adptr = new OleDbDataAdapter();

adptr.SelectCommand = cmd;
adptr.Fill(dt);
con.Close();

//Add the table to the data set
ds.Tables.Add(dt);

//Here's the easy part. Create the Excel worksheet from the data set
ExcelLibrary.DataSetHelper.CreateWorkbook("MyExcelFile.xls", ds);

එක්සෙල් ගොනුව සෑදීම එතරම් පහසුය. ඔබට එක්සෙල් ලිපිගොනු අතින් නිර්මාණය කළ හැකිය, නමුත් ඉහත ක්‍රියාකාරිත්වය මගේ සිතට තදින්ම කාවැදුණි.

ඔබ xlsx ආකෘතිය ගැන සතුටු වන්නේ නම්, මගේ GitHub ව්‍යාපෘතිය වන EPPlus උත්සාහ කරන්න . එය එක්සෙල් පැකේජයේ ප්‍රභවයෙන් ආරම්භ වූ නමුත් අද එය සම්පුර්ණයෙන්ම නැවත ලිවීමකි. එය පරාස, සෛල මෝස්තර, ප්‍රස්ථාර, හැඩ, පින්තූර, නම් කළ පරාස, ඔටෝ ෆිල්ටර් සහ තවත් බොහෝ දේ සඳහා සහය දක්වයි.

මයික්‍රොසොෆ්ට් ඔෆිස් සඳහා විවෘත එක්ස්එම්එල් එස්ඩීකේ 2.0 භාවිතා කිරීම ගැන කුමක් කිව හැකිද?

ප්‍රතිලාභ කිහිපයක්:

• කාර්යාලය ස්ථාපනය කිරීම අවශ්‍ය නොවේ
• මයික්‍රොසොෆ්ට් විසින් සාදන ලදී = යහපත් MSDN ප්‍රලේඛනය
• ව්යාපෘතියේ භාවිතා කිරීමට එක් .නෙට් ඩීඑල්
• SDK, diff, validator, වැනි බොහෝ මෙවලම් සමඟ පැමිණේ

සබැඳි:

• ගිතූබ්
• ප්‍රධාන එම්එස්ඩීඑන් ගොඩබෑම
• "මම කොහොමද ..." ආරම්භක පිටුව
• එස්ඩීකේ නිවේදනය කරන එම්.එස්.ඩී.එන් බ්‍රයන්_ජෝන්ස්
• blogs.MSDN brian_jones විස්තර කරන්නේ SDK විශාල ලිපිගොනු බිඳ වැටීමකින් තොරව හැසිරවීමයි (DOM ක්‍රමය මෙන් නොව)

මම පහත සඳහන් විවෘත මූලාශ්‍ර ව්‍යාපෘති සාර්ථකව භාවිතා කර ඇත්තෙමි.

• OOXML ආකෘති සඳහා ExcelPackage (Office 2007)

• .XLS ආකෘතිය සඳහා NPOI (Office 2003). NPOI 2.0 (බීටා) ද XLSX සඳහා සහය දක්වයි.

මගේ බ්ලොග් සටහන් දෙස බලන්න:

සී # හි එක්සෙල් පැතුරුම්පත් .XLS සහ .XLSX නිර්මාණය කිරීම

එක්සෙල් වගුව සහ ගතික සටහන සමඟ NPOI

එක්සෙල් ලිපිගොනු නිර්මාණය කිරීමට සහ හැසිරවීමට ඔබට OLEDB භාවිතා කළ හැකිය. මෙය පරීක්ෂා කරන්න: OLEDB භාවිතා කරමින් එක්සෙල් කියවීම සහ ලිවීම .

සාමාන්‍ය උදාහරණය:

using (OleDbConnection conn = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\\temp\\test.xls;Extended Properties='Excel 8.0;HDR=Yes'"))
{
  conn.Open();
  OleDbCommand cmd = new OleDbCommand("CREATE TABLE [Sheet1] ([Column1] string, [Column2] string)", conn);
  cmd.ExecuteNonQuery();
}

සංස්කරණය කරන්න - තවත් සබැඳි කිහිපයක්:

• හේයි, ස්ක්‍රිප්ටින් ගයි! එක්සෙල් භාවිතා නොකර එක්සෙල් වෙතින් කියවිය හැක්කේ කෙසේද?
• දෘශ්‍ය මූලික .නෙට් සමඟ එක්සෙල් වැඩපොතක වාර්තා ලබා ගැනීමට සහ වෙනස් කිරීමට ADO.NET භාවිතා කරන්නේ කෙසේද?
• ADO.NET C # DbProviderFactory භාවිතා කරමින් එක්සෙල් පැතුරුම්පත් කියවීම සහ ලිවීම

.NET සඳහා වන වාණිජ විසඳුම වන SpreadsheetGear එය කරනු ඇත.

ඔබට සජීවී ASP.NET (C # සහ VB) සාම්පල මෙතැනින් දැකගත හැකි අතර ඇගයීමේ අනුවාදයක් මෙතැනින් බාගන්න .

වියාචනය: මා සතුව පැතුරුම්පත් ගියර් එල්එල්සී ඇත

මා භාවිතා කළ විකල්ප කිහිපයක්:

එක්ස්එල්එස්එක්ස් අත්‍යවශ්‍ය දෙයක් නම් : එක්සෙල් පැකේජය හොඳ ආරම්භයක් වන නමුත් සංවර්ධකයා ඒ මත වැඩ කිරීමෙන් ඉවත් වූ විට මිය ගියේය. එක්ස්එම්එල් එතැනින් තෝරාගෙන විශේෂාංග කිහිපයක් එකතු කළේය. එක්ස්එම්එල් නරක විකල්පයක් නොවේ, මම තවමත් නිෂ්පාදන වෙබ් අඩවි කිහිපයක එය භාවිතා කරමි.

මගේ නව ව්යාපෘති සඳහා, නමුත්, මම භාවිතා කරනවා NPOI , එම .NET වරාය Apache POI . NPOI 2.0 (ඇල්ෆා) ද XLSX සඳහා සහය දක්වයි.

අතිශයින්ම සැහැල්ලු විකල්පයක් වන්නේ HTML වගු භාවිතා කිරීමයි. ගොනුවක හිස, ශරීරය සහ වගු ටැග් නිර්මාණය කර එය .xls දිගුවක් සහිත ගොනුවක් ලෙස සුරකින්න. සූත්‍ර ඇතුළුව ප්‍රතිදානය හැඩගස්වා ගැනීමට ඔබට භාවිතා කළ හැකි Microsoft විශේෂිත ගුණාංග ඇත.

ඔබ මෙය වෙබ් යෙදුමක කේතනය නොකරන බව මට වැටහී ඇත, නමුත් මෙන්න HTML වගුවක් හරහා එක්සෙල් ගොනුවක සංයුතිය පිළිබඳ උදාහරණයකි . ඔබ කොන්සෝල යෙදුමක්, ඩෙස්ක්ටොප් යෙදුමක් හෝ සේවාවක් කේත කරන්නේ නම් මෙම තාක්ෂණය භාවිතා කළ හැකිය.

ඔබ එක්සෙල් 2007/2010 ගොනු නිර්මාණය කරන්නේ නම් මෙම විවෘත කේත ව්‍යාපෘතිය උත්සාහ කර බලන්න: https://github.com/closedxml/closedxml

XML ලේඛනවල කරදර සමඟ කටයුතු නොකර ලිපිගොනු (VBA හා සමාන) හැසිරවීමට එය වස්තු නැඹුරු ක්‍රමයක් සපයයි. C # සහ Visual Basic (VB) වැනි ඕනෑම .NET භාෂාවකට එය භාවිතා කළ හැකිය.

එක්සෙල් යෙදුමකින් තොරව එක්සෙල් 2007/2010 ගොනු නිර්මාණය කිරීමට ClosedXML ඔබට ඉඩ දෙයි. සාමාන්‍ය උදාහරණය වන්නේ වෙබ් සේවාදායකයක එක්සෙල් වාර්තා නිර්මාණය කිරීමයි:

var workbook = new XLWorkbook();
var worksheet = workbook.Worksheets.Add("Sample Sheet");
worksheet.Cell("A1").Value = "Hello World!";
workbook.SaveAs("HelloWorld.xlsx");

ඔබට ExcelXmlWriter භාවිතා කළ හැකිය .

එය හොඳින් ක්‍රියාත්මක වේ.

ඔබට ඇත්ත වශයෙන්ම C # හි ඇති අන්තර් පංති පරීක්ෂා කිරීමට අවශ්‍ය විය හැකිය (උදා: Microsoft.Office.Interop.Excelඔබ පවසන්නේ OLE නැත (මෙය එසේ නොවේ), නමුත් අන්තර් පංති භාවිතා කිරීම ඉතා පහසුය. C # ප්‍රලේඛනය මෙතැනින් බලන්න (එක්සෙල් සඳහා අන්තර් ක්‍රියාකාරීත්වය ආරම්භ වේ C # PDF හි 1072 පිටුව).

ඔබ ඒවා අත්හදා බැලුවේ නැත්නම් ඔබ පුදුමයට පත් විය හැකිය.

කරුණාකර මේ පිළිබඳව මයික්‍රොසොෆ්ට් ස්ථාවරය ගැන අනතුරු අඟවන්න :

මයික්‍රොසොෆ්ට් දැනට නිර්දේශ කර නැති අතර සහාය නොදක්වයි, කිසිදු අවධානයට ලක් නොවූ, අන්තර්ක්‍රියාකාරී නොවන සේවාදායක යෙදුමකින් හෝ සංරචකයකින් (ඒඑස්පී, ඒඑස්පී. හෝ මෙම පරිසරය තුළ කාර්යාලය ක්‍රියාත්මක වන විට අවහිර වීම.

මෙන්න සම්පූර්ණයෙන්ම නොමිලේ C # පුස්තකාලයක්, එය ඔබට DataSet, DataTableහෝ List<>අව්‍යාජ එක්සෙල් 2007 .xlsx ගොනුවකට අපනයනය කිරීමට ඉඩ සලසයි , OpenXML පුස්තකාල භාවිතා කරමින්:

http://mikesknowledgebase.com/pages/CSharp/ExportToExcel.htm

සම්පූර්ණ මූලාශ්‍ර කේතය ලබා දී ඇත - නොමිලේ - උපදෙස් සමඟ, සහ නිරූපණ යෙදුමක්.

ඔබගේ යෙදුමට මෙම පන්තිය එක් කිරීමෙන් පසුව, ඔබට එක් කේත පේළියකින් ඔබේ දත්ත කට්ටලය එක්සෙල් වෙත අපනයනය කළ හැකිය:

CreateExcelFile.CreateExcelDocument(myDataSet, "C:\\Sample.xlsx");

එය ඊට වඩා සරල නොවේ ...

ඔබේ සේවාදායකයේ එක්සෙල් සිටීම පවා අවශ්‍ය නොවේ.

XML පැතුරුම්පත් 2003 ආකෘතිය භාවිතයෙන් ඔබේ ගොනු සෑදීම ගැන සලකා බැලිය හැකිය. මෙය මනාව ලේඛනගත කළ යෝජනා ක්‍රමයක් භාවිතා කරන සරල XML ආකෘතියකි .

ඔබට GemBox.Sreadsheet දෙස බැලීමට අවශ්‍ය විය හැකිය .

ඔවුන් සතුව සියලු අංගයන්ගෙන් යුත් නිදහස් අනුවාදයක් ඇති නමුත් එය ඔබේ අවශ්‍යතාවයට යටත් වන්නේ නම් පත්රයකට පේළි 150 ක් සහ වැඩපොතකට තහඩු 5 කට සීමා වේ.

මට තවම එය භාවිතා කිරීමට අවශ්‍යතාවයක් නොතිබුණි, නමුත් සිත්ගන්නා සුළුය.

සමමුහුර්ත කිරීම අත්‍යවශ්‍ය XlsIO හට මෙය කළ හැකිය. එයට මයික්‍රොසොෆ්ට් කාර්යාලය මත යැපීමක් නොමැති අතර විවිධ වේදිකා සඳහා නිශ්චිත සහයෝගයක් ද ඇත.

• ASP.NET
• ASP.NET MVC
• යූ.ඩබ්ලිව්.පී
• Xamarin
• WPF සහ වින්ඩෝස් ආකෘති
• වින්ඩෝස් සර්විස් සහ කණ්ඩායම් පදනම් කරගත් මෙහෙයුම්

කේත නියැදිය:

//Creates a new instance for ExcelEngine.
ExcelEngine excelEngine = new ExcelEngine();
//Loads or open an existing workbook through Open method of IWorkbooks
IWorkbook workbook = excelEngine.Excel.Workbooks.Open(fileName);
//To-Do some manipulation|
//To-Do some manipulation
//Set the version of the workbook.
workbook.Version = ExcelVersion.Excel2013;
//Save the workbook in file system as xlsx format
workbook.SaveAs(outputFileName);

ඔබ සුදුසුකම් ලැබුවහොත් (ඇ.ඩො. මිලියනයකට වඩා අඩු ආදායමක්) ප්‍රජා බලපත්‍ර වැඩසටහන හරහා මුළු පාලන කට්ටලයම නොමිලේ ලබා ගත හැකිය . සටහන: මම සමමුහුර්තකරණය සඳහා වැඩ කරමි.

හොඳින්,

ඔබට Aspose වැනි තෙවන පාර්ශවීය පුස්තකාලයක් ද භාවිතා කළ හැකිය .

මෙම පුස්තකාලයට ඔබේ පරිගණකයේ එක්සෙල් ස්ථාපනය කිරීම අවශ්‍ය නොවන වාසියක් ඇත.

OpenXML යනු සේවාදායකයේ MS Excel ස්ථාපනය කිරීමෙන් වළක්වා ගත හැකි හොඳ විකල්පයකි. මයික්‍රොසොෆ්ට් විසින් සපයන ලද විවෘත XML SDK 2.0 පැකේජයක් තුළ විවෘත XML පැකේජ සහ යටින් පවතින විවෘත XML ක්‍රමලේඛන අංග හැසිරවීමේ කාර්යය සරල කරයි. විවෘත එක්ස්එම්එල් යෙදුම් ක්‍රමලේඛ අතුරුමුහුණත (ඒපීඅයි) විවෘත එක්ස්එම්එල් පැකේජ මත සංවර්ධකයින් විසින් ඉටු කරනු ලබන බොහෝ පොදු කාර්යයන් ආවරණය කරයි.

මෙය පරීක්ෂා කරන්න OpenXML: විකල්පය සේවාදායකයේ MS Excel ස්ථාපනය කිරීමෙන් වළකින්න

විවිධ ඔෆිස් 2003 එක්ස්එම්එල් පුස්තකාල කුඩා එක්සෙල් ලිපිගොනු සඳහා ඉතා හොඳින් ක්‍රියා කරයි. කෙසේ වෙතත්, XML ආකෘතියෙන් සුරකින ලද විශාල වැඩපොතක විශාලත්වය ගැටලුවක් බව මට පෙනේ. උදාහරණයක් ලෙස, මා සමඟ වැඩ කරන වැඩපොතක් නව (සහ වඩාත් තදින් ඇසුරුම් කර ඇති) 40MB වනු ඇත. XLSX ආකෘතිය 360MB XML ගොනුවක් බවට පත්වේ.

මගේ පර්යේෂණය මා ගෙන ඇති තාක් දුරට, පැරණි ද්විමය ගොනු ආකෘති වලට ප්‍රතිදානය කිරීමට ඉඩ දෙන වාණිජ පැකේජ දෙකක් තිබේ. අර තියෙන්නේ:

• මැණික් පෙට්ටිය
• සංරචක එක් එක්සෙල්

මේ දෙකම ලාභදායී නොවේ (පිළිවෙලින් 500USD සහ 800USD, මම හිතන්නේ). නමුත් දෙකම එක්සෙල් වලින් ස්වාධීනව ක්‍රියා කරයි.

මට කුතුහලයක් ඇති වන්නේ OpenOffice.org වැනි දේ සඳහා වන එක්සෙල් ප්‍රතිදාන මොඩියුලයයි. මම හිතන්නේ ඒවා ජාවා සිට .නෙට් වෙත ගෙන යා හැකිද යන්නයි.

XML පැතුරුම්පත් ජනනය කිරීම ගැන මම එකඟ වෙමි, C # 3 සඳහා එය කරන්නේ කෙසේද යන්න පිළිබඳ උදාහරණයක් මෙන්න (සෑම කෙනෙක්ම VB 9: P හි බ්ලොග් කර ඇත) http://www.aaron-powell.com/linq-to-xml-to- විශිෂ්ටයි

මම මෑතකදී FlexCel.NET භාවිතා කර ඇති අතර එය විශිෂ්ට පුස්තකාලයක් බව මට පෙනී ගියේය! බොහෝ මෘදුකාංග නිෂ්පාදන ගැන මම එසේ නොකියමි. මෙහි සම්පූර්ණ විකුණුම් තලය ලබා දීමෙන් පලක් නැත, ඔබට ඔවුන්ගේ වෙබ් අඩවියේ ඇති සියලුම අංග කියවිය හැකිය.

එය වාණිජ නිෂ්පාදනයක් වන නමුත් ඔබ එය මිලදී ගන්නේ නම් සම්පූර්ණ ප්‍රභවය ඔබට ලැබේ. එබැවින් ඔබට සැබවින්ම අවශ්‍ය නම් එය ඔබේ එක්රැස්වීමට සම්පාදනය කළ හැකි යැයි මම සිතමි. එසේ නොමැති නම් එය xcopy සඳහා එක් අමතර එකලස් කිරීමක් පමණි - වින්‍යාස කිරීමක් හෝ ස්ථාපනය කිරීමක් හෝ එවැනි කිසිවක් නැත.

.NET රාමුව, තෙවන පාර්ශවීය පුස්තකාල නොමැතිව මෙය කිරීමට ඔබට ක්‍රමයක් සොයා ගත හැකි යැයි මම නොසිතමි. පැහැදිලිවම, ඒ සඳහා සහයෝගය ලබා දී නොමැති අතර OLE ස්වයංක්‍රීයකරණය යනු වේදනාකාරී ලෝකයකි.

System.IO.StreamWriter භාවිතා කරමින් එක්සෙල් වස්තුව භාවිතා නොකර විශිෂ්ට ලෙස දත්ත සමුදාය අපනයනය කිරීම සඳහා මම සරල කේතයක් ලියා ඇත.

පහත දැක්වෙන්නේ දත්ත කට්ටලයේ සියලුම වගු කියවා ඒවා එකින් එක තහඩු වලට ලියන කේතයයි. මම මේ ලිපියෙන් උදව් ගත්තා .

public static void exportToExcel(DataSet source, string fileName)
{
        const string endExcelXML = "</Workbook>";
        const string startExcelXML = "<xml version>\r\n<Workbook " +
                 "xmlns=\"urn:schemas-microsoft-com:office:spreadsheet\"\r\n" +
                 " xmlns:o=\"urn:schemas-microsoft-com:office:office\"\r\n " +
                 "xmlns:x=\"urn:schemas-    microsoft-com:office:" +
                 "excel\"\r\n xmlns:ss=\"urn:schemas-microsoft-com:" +
                 "office:spreadsheet\">\r\n <Styles>\r\n " +
                 "<Style ss:ID=\"Default\" ss:Name=\"Normal\">\r\n " +
                 "<Alignment ss:Vertical=\"Bottom\"/>\r\n <Borders/>" +
                 "\r\n <Font/>\r\n <Interior/>\r\n <NumberFormat/>" +
                 "\r\n <Protection/>\r\n </Style>\r\n " +
                 "<Style ss:ID=\"BoldColumn\">\r\n <Font " +
                 "x:Family=\"Swiss\" ss:Bold=\"1\"/>\r\n </Style>\r\n " +
                 "<Style     ss:ID=\"StringLiteral\">\r\n <NumberFormat" +
                 " ss:Format=\"@\"/>\r\n </Style>\r\n <Style " +
                 "ss:ID=\"Decimal\">\r\n <NumberFormat " +
                 "ss:Format=\"0.0000\"/>\r\n </Style>\r\n " +
                 "<Style ss:ID=\"Integer\">\r\n <NumberFormat " +
                 "ss:Format=\"0\"/>\r\n </Style>\r\n <Style " +
                 "ss:ID=\"DateLiteral\">\r\n <NumberFormat " +
                 "ss:Format=\"mm/dd/yyyy;@\"/>\r\n </Style>\r\n " +
                 "</Styles>\r\n ";
        System.IO.StreamWriter excelDoc = null;
        excelDoc = new System.IO.StreamWriter(fileName);

        int sheetCount = 1;
        excelDoc.Write(startExcelXML);
        foreach (DataTable table in source.Tables)
        {
            int rowCount = 0;
            excelDoc.Write("<Worksheet ss:Name=\"" + table.TableName + "\">");
            excelDoc.Write("<Table>");
            excelDoc.Write("<Row>");
            for (int x = 0; x < table.Columns.Count; x++)
            {
                excelDoc.Write("<Cell ss:StyleID=\"BoldColumn\"><Data ss:Type=\"String\">");
                excelDoc.Write(table.Columns[x].ColumnName);
                excelDoc.Write("</Data></Cell>");
            }
            excelDoc.Write("</Row>");
            foreach (DataRow x in table.Rows)
            {
                rowCount++;
                //if the number of rows is > 64000 create a new page to continue output
                if (rowCount == 64000)
                {
                    rowCount = 0;
                    sheetCount++;
                    excelDoc.Write("</Table>");
                    excelDoc.Write(" </Worksheet>");
                    excelDoc.Write("<Worksheet ss:Name=\"" + table.TableName + "\">");
                    excelDoc.Write("<Table>");
                }
                excelDoc.Write("<Row>"); //ID=" + rowCount + "
                for (int y = 0; y < table.Columns.Count; y++)
                {
                    System.Type rowType;
                    rowType = x[y].GetType();
                    switch (rowType.ToString())
                    {
                        case "System.String":
                            string XMLstring = x[y].ToString();
                            XMLstring = XMLstring.Trim();
                            XMLstring = XMLstring.Replace("&", "&");
                            XMLstring = XMLstring.Replace(">", ">");
                            XMLstring = XMLstring.Replace("<", "<");
                            excelDoc.Write("<Cell ss:StyleID=\"StringLiteral\">" +
                                           "<Data ss:Type=\"String\">");
                            excelDoc.Write(XMLstring);
                            excelDoc.Write("</Data></Cell>");
                            break;
                        case "System.DateTime":
                            //Excel has a specific Date Format of YYYY-MM-DD followed by  
                            //the letter 'T' then hh:mm:sss.lll Example 2005-01-31T24:01:21.000
                            //The Following Code puts the date stored in XMLDate 
                            //to the format above
                            DateTime XMLDate = (DateTime)x[y];
                            string XMLDatetoString = ""; //Excel Converted Date
                            XMLDatetoString = XMLDate.Year.ToString() +
                                 "-" +
                                 (XMLDate.Month < 10 ? "0" +
                                 XMLDate.Month.ToString() : XMLDate.Month.ToString()) +
                                 "-" +
                                 (XMLDate.Day < 10 ? "0" +
                                 XMLDate.Day.ToString() : XMLDate.Day.ToString()) +
                                 "T" +
                                 (XMLDate.Hour < 10 ? "0" +
                                 XMLDate.Hour.ToString() : XMLDate.Hour.ToString()) +
                                 ":" +
                                 (XMLDate.Minute < 10 ? "0" +
                                 XMLDate.Minute.ToString() : XMLDate.Minute.ToString()) +
                                 ":" +
                                 (XMLDate.Second < 10 ? "0" +
                                 XMLDate.Second.ToString() : XMLDate.Second.ToString()) +
                                 ".000";
                            excelDoc.Write("<Cell ss:StyleID=\"DateLiteral\">" +
                                         "<Data ss:Type=\"DateTime\">");
                            excelDoc.Write(XMLDatetoString);
                            excelDoc.Write("</Data></Cell>");
                            break;
                        case "System.Boolean":
                            excelDoc.Write("<Cell ss:StyleID=\"StringLiteral\">" +
                                        "<Data ss:Type=\"String\">");
                            excelDoc.Write(x[y].ToString());
                            excelDoc.Write("</Data></Cell>");
                            break;
                        case "System.Int16":
                        case "System.Int32":
                        case "System.Int64":
                        case "System.Byte":
                            excelDoc.Write("<Cell ss:StyleID=\"Integer\">" +
                                    "<Data ss:Type=\"Number\">");
                            excelDoc.Write(x[y].ToString());
                            excelDoc.Write("</Data></Cell>");
                            break;
                        case "System.Decimal":
                        case "System.Double":
                            excelDoc.Write("<Cell ss:StyleID=\"Decimal\">" +
                                  "<Data ss:Type=\"Number\">");
                            excelDoc.Write(x[y].ToString());
                            excelDoc.Write("</Data></Cell>");
                            break;
                        case "System.DBNull":
                            excelDoc.Write("<Cell ss:StyleID=\"StringLiteral\">" +
                                  "<Data ss:Type=\"String\">");
                            excelDoc.Write("");
                            excelDoc.Write("</Data></Cell>");
                            break;
                        default:
                            throw (new Exception(rowType.ToString() + " not handled."));
                    }
                }
                excelDoc.Write("</Row>");
            }
            excelDoc.Write("</Table>");
            excelDoc.Write(" </Worksheet>");
            sheetCount++;
        }


        excelDoc.Write(endExcelXML);
        excelDoc.Close();
    }

ඔබගේ ගැටළුව කෙලින්ම ආමන්ත්‍රණය කරන තෙවන පාර්ශවීය විසඳුමකට තවත් යොමු කිරීමක් එක් කිරීමට අවශ්‍යය: http://www.officewriter.com

(වියාචනය: මම වැඩ කරන්නේ OfficeWriter නිපදවන සොෆ්ට්ආර්ටිසන්ස් සඳහායි)

IKVM + POI

නැත්නම්, ඔබට ඉන්ටර්පොප් භාවිතා කළ හැකිය ...

නියැදි කේතය සමඟ සම්පුර්ණ කළ LINQ සිට XML දක්වා එය කළ හැකි ක්‍රමයක් මෙන්න:

එක්ස්එම්එල් වෙත ලින්ක් සමඟ එක්සෙල් දත්ත ඉක්මනින් ආනයනය කර අපනයනය කරන්න

ඔබට නම් අවකාශයන් ආනයනය කිරීමට සිදු වන බැවින් එය ටිකක් සංකීර්ණයි, නමුත් එය බාහිර පරායත්තතාවයන් වළක්වා ගැනීමට ඉඩ සලසයි.

.

මයික්‍රොසොෆ්ට් එක්සෙල් ස්ථාපනය කිරීමට අවශ්‍ය නොවන සමහර තෙවන පාර්ශවීය කොටස් වෙළෙන්දෝ ඉන්ෆ්‍රැජිස්ටික්ස් හෝ සමමුහුර්තකරණය වැනි ඉතා හොඳ එක්සෙල් අපනයන හැකියාවන් සපයයි.

මෙම වෙළෙන්දෝ උසස් UI ජාලක සංරචක ද සපයන හෙයින්, ඔබේ යෙදුමේ පරිශීලක අතුරුමුහුණතෙහි ජාලකයක වර්තමාන තත්වය අනුකරණය කිරීමට එක්සෙල් අපනයනයක ශෛලිය හා පිරිසැලසුම ඔබට අවශ්‍ය නම් මෙම සංරචක විශේෂයෙන් පහසුය.

ඔබගේ අපනයනය අපනයනය කළ යුතු දත්ත අවධාරණය කරමින් සහ UI සමඟ කිසිදු සම්බන්ධයක් නොමැතිව සේවාදායක පැත්ත ක්‍රියාත්මක කිරීමට අදහස් කරන්නේ නම්, මම නොමිලේ විවෘත මූලාශ්‍ර විකල්පයන්ගෙන් එකක් (උදා: ExcelLibrary) සඳහා යන්නෙමි.

මයික්‍රොසොෆ්ට් ඔෆිස් කට්ටලයේ සේවාදායක පාර්ශවීය ස්වයංක්‍රීයකරණය භාවිතා කිරීමට උත්සාහ කළ ව්‍යාපෘති සමඟ මම මීට පෙර සම්බන්ධ වී සිටිමි. මෙම අත්දැකීම මත පදනම්ව මම එම ප්‍රවේශයට එරෙහිව තරයේ නිර්දේශ කරමි.

public class GridViewExportUtil
{
    public static void Export(string fileName, GridView gv)
    {
        HttpContext.Current.Response.Clear();
        HttpContext.Current.Response.AddHeader(
            "content-disposition", string.Format("attachment; filename={0}", fileName));
        HttpContext.Current.Response.ContentType = "application/ms-excel";

        using (StringWriter sw = new StringWriter())
        {
            using (HtmlTextWriter htw = new HtmlTextWriter(sw))
            {
                //  Create a form to contain the grid
                Table table = new Table();

                //  add the header row to the table
                if (gv.HeaderRow != null)
                {
                    GridViewExportUtil.PrepareControlForExport(gv.HeaderRow);
                    table.Rows.Add(gv.HeaderRow);
                }

                //  add each of the data rows to the table
                foreach (GridViewRow row in gv.Rows)
                {
                    GridViewExportUtil.PrepareControlForExport(row);
                    table.Rows.Add(row);
                }

                //  add the footer row to the table
                if (gv.FooterRow != null)
                {
                    GridViewExportUtil.PrepareControlForExport(gv.FooterRow);
                    table.Rows.Add(gv.FooterRow);
                }

                //  render the table into the htmlwriter
                table.RenderControl(htw);

                //  render the htmlwriter into the response
                HttpContext.Current.Response.Write(sw.ToString());
                HttpContext.Current.Response.End();
            }
        }
    }

    /// <summary>
    /// Replace any of the contained controls with literals
    /// </summary>
    /// <param name="control"></param>
    private static void PrepareControlForExport(Control control)
    {
        for (int i = 0; i < control.Controls.Count; i++)
        {
            Control current = control.Controls[i];
            if (current is LinkButton)
            {
                control.Controls.Remove(current);
                control.Controls.AddAt(i, new LiteralControl((current as LinkButton).Text));
            }
            else if (current is ImageButton)
            {
                control.Controls.Remove(current);
                control.Controls.AddAt(i, new LiteralControl((current as ImageButton).AlternateText));
            }
            else if (current is HyperLink)
            {
                control.Controls.Remove(current);
                control.Controls.AddAt(i, new LiteralControl((current as HyperLink).Text));
            }
            else if (current is DropDownList)
            {
                control.Controls.Remove(current);
                control.Controls.AddAt(i, new LiteralControl((current as DropDownList).SelectedItem.Text));
            }
            else if (current is CheckBox)
            {
                control.Controls.Remove(current);
                control.Controls.AddAt(i, new LiteralControl((current as CheckBox).Checked ? "True" : "False"));
            }

            if (current.HasControls())
            {
                GridViewExportUtil.PrepareControlForExport(current);
            }
        }
    }
}

හායි මෙම විසඳුම වන්නේ ඔබේ ජාලක දර්ශනය ඔබේ එක්සෙල් ගොනුවට අපනයනය කිරීමයි

මෙම පුස්තකාලය භාවිතයෙන් ඔබට මනාව හැඩගස්වන ලද එක්සෙල් ගොනු සෑදිය හැකිය: http://officehelper.codeplex.com/documentation
පහත නියැදිය බලන්න:

using (ExcelHelper helper = new ExcelHelper(TEMPLATE_FILE_NAME, GENERATED_FILE_NAME))
{
    helper.Direction = ExcelHelper.DirectionType.TOP_TO_DOWN;
    helper.CurrentSheetName = "Sheet1";
    helper.CurrentPosition = new CellRef("C3");

    //the template xlsx should contains the named range "header"; use the command "insert"/"name".
    helper.InsertRange("header");

    //the template xlsx should contains the named range "sample1";
    //inside this range you should have cells with these values:
    //<name> , <value> and <comment>, which will be replaced by the values from the getSample()
    CellRangeTemplate sample1 = helper.CreateCellRangeTemplate("sample1", new List<string> {"name", "value", "comment"}); 
    helper.InsertRange(sample1, getSample());

    //you could use here other named ranges to insert new cells and call InsertRange as many times you want, 
    //it will be copied one after another;
    //even you can change direction or the current cell/sheet before you insert

    //typically you put all your "template ranges" (the names) on the same sheet and then you just delete it
    helper.DeleteSheet("Sheet3");
}        

නියැදිය මේ ආකාරයට පෙනේ:

private IEnumerable<List<object>> getSample()
{
    var random = new Random();

    for (int loop = 0; loop < 3000; loop++)
    {
        yield return new List<object> {"test", DateTime.Now.AddDays(random.NextDouble()*100 - 50), loop};
    }
}

C # වෙතින් එක්සෙල් ගොනුවක් සෑදීමට ඇති සරලම හා වේගවත්ම ක්‍රමය වන්නේ විවෘත XML Produc ලදායිතා මෙවලම භාවිතා කිරීමයි. විවෘත XML tivity ලදායිතා මෙවලම විවෘත XML SDK ස්ථාපනය සමඟ පැමිණේ. මෙවලම ඕනෑම එක්සෙල් ගොනුවක් සී # කේතයට හරවයි. C # කේතය පසුව එම ගොනුව නැවත උත්පාදනය කිරීමට භාවිතා කළ හැකිය.

සම්බන්ධ ක්‍රියාවලිය පිළිබඳ දළ විශ්ලේෂණයක් නම්:

1. මෙවලම සමඟ විවෘත XML SDK ස්ථාපනය කරන්න.
2. අපේක්ෂිත පෙනුමෙන් නවතම එක්සෙල් සේවාදායකයා භාවිතා කරමින් එක්සෙල් ගොනුවක් සාදන්න. එය නම් කරන්න DesiredLook.xlsx.
3. මෙවලම විවෘත DesiredLook.xlsxකර ඉහළින් ඇති පරාවර්තන කේත බොත්තම ක්ලික් කරන්න.
4. ඔබගේ ගොනුව සඳහා C # කේතය මෙවලමෙහි දකුණු කවුළුව තුළ ජනනය වේ. මෙය ඔබේ C # විසඳුමට එකතු කර අපේක්ෂිත පෙනුමෙන් ගොනු ජනනය කරන්න.

ප්‍රසාද දීමනාවක් ලෙස, මෙම ක්‍රමය ඕනෑම වර්ඩ් සහ පවර්පොයින්ට් ගොනු සඳහා ක්‍රියා කරයි. C # සංවර්ධකයා ලෙස, ඔබ ඔබේ අවශ්‍යතාවන්ට සරිලන පරිදි කේතයේ වෙනස්කම් සිදු කරනු ඇත.

මම ගිතබ් මත සරල WPF යෙදුමක් නිර්මාණය කර ඇති අතර එය වින්ඩෝස් මත ක්‍රියාත්මක වේ. GeneratedClassඔබට ජනනය කළ කේතය ඇලවිය හැකි ස්ථාන දරණ පන්තියක් ඇත. ඔබ ගොනුවේ එක් අනුවාදයක් ආපසු ගියහොත්, එය මෙවැනි එක්සෙල් ගොනුවක් ජනනය කරනු ඇත:

C # හි සමහර ප්‍රයෝජනවත් එක්සෙල් ස්වයංක්‍රීයකරණය ඔබට පහත සබැඳියෙන් සොයාගත හැකිය.

http://csharp.net-informations.com/excel/csharp-excel-tutorial.htm

බෝල්ටන්.

එක්සෙල් ගොනු නිර්මාණය කරන්නේ කෙසේදැයි සාම්පල දෙස බලන්න.

C # සහ VB.NET හි උදාහරණ ඇත

එය XSL XSLX සහ CSV Excel ගොනු කළමනාකරණය කරයි.

http://www.devtriogroup.com/ExcelJetcell/Samples