Come posso creare un file Excel (.XLS e .XLSX) in C # senza installare Microsoft Office? [chiuso]
https://stackoverflow.com/questions/151005
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Come posso creare un foglio di calcolo Excel con C # senza richiedere l'installazione di Excel sul computer che esegue il codice?
Soluzione
Puoi usare una libreria chiamata ExcelLibrary. È una libreria open source gratuita pubblicata su Google Code:
Questa sembra essere una porta di ExcelWriter PHP che hai menzionato sopra. Non scriverà ancora nel nuovo formato .xlsx, ma stanno lavorando per aggiungere quella funzionalità in.
È molto semplice, piccolo e facile da usare. Inoltre ha un DataSetHelper che ti consente di utilizzare DataSet e DataTables per lavorare facilmente con i dati di Excel.
ExcelLibrary sembra funzionare ancora solo per il vecchio formato Excel (file .xls), ma potrebbe aggiungere supporto in futuro per i nuovi formati 2007/2010.
Puoi anche utilizzare EPPlus , che funziona solo con file in formato Excel 2007/2010 (file .xlsx ). C'è anche NPOI che funziona con entrambi.
Esistono alcuni bug noti in ciascuna libreria, come indicato nei commenti. Nel complesso, EPPlus sembra essere la scelta migliore col passare del tempo. Sembra essere anche attivamente aggiornato e documentato.
Inoltre, come notato da @ & # 1040; & # 1088; & # 1090; & # 1105; & # 1084; & # 1062; & # 1072 ; # 1088 &; # 1080 &; # 1086 &; # 1085 &; # 1086 &; & # 1074; di seguito, EPPlus supporta le tabelle pivot e ExcelLibrary potrebbe avere un po 'di supporto ( Problema della tabella pivot in ExcelLibrary )
Ecco un paio di link per una rapida consultazione:
ExcelLibrary - GNU Lesser GPL
EPPlus - GNU Lesser General Public License (LGPL)
NPOI - Licenza Apache
Ecco alcuni esempi di codice per ExcelLibrary:
Ecco un esempio che prende i dati da un database e ne crea una cartella di lavoro. Si noti che il codice ExcelLibrary è la riga singola in fondo:
//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);
La creazione del file Excel è semplice. Puoi anche creare manualmente file Excel, ma la funzionalità di cui sopra è ciò che mi ha davvero colpito.
Altri suggerimenti
Se sei soddisfatto del formato xlsx, prova il mio progetto GitHub, EPPlus . È iniziato con l'origine di ExcelPackage, ma oggi è una riscrittura totale. Supporta intervalli, stili di celle, grafici, forme, immagini, intervalli denominati, filtro automatico e molte altre cose.
Ho usato con successo i seguenti progetti open source:
-
ExcelPackage per formati OOXML (Office 2007)
-
NPOI per il formato .XLS (Office 2003). NPOI 2.0 (Beta) supporta anche XLSX.
Dai un'occhiata ai miei post sul blog:
E che dire dell'utilizzo di Open XML SDK 2.0 per Microsoft Office?
Alcuni vantaggi:
- Non richiede Office installato
- Prodotta da Microsoft = documentazione MSDN decente
- Solo una dll .Net da utilizzare nel progetto
- SDK viene fornito con molti strumenti come diff, validator, ecc
Link:
- Scarica SDK
- Atterraggio MSDN principale
- " Come posso .. . " pagina iniziale
- blogs.MSDN brian_jones che annuncia SDK
- blogs.MSDN brian_jones che descrive SDK che gestisce file di grandi dimensioni senza arresti anomali (a differenza del metodo DOM)
Puoi usare OLEDB per creare e manipolare file Excel. Controlla questo: Lettura e scrittura di Excel tramite OLEDB .
Esempio tipico:
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();
}
MODIFICA - Alcuni altri collegamenti:
La soluzione commerciale SpreadsheetGear per .NET lo farà.
Puoi vedere campioni ASP.NET in tempo reale (C # e VB) qui e scaricare un versione di valutazione qui .
Disclaimer: possiedo SpreadsheetGear LLC
Alcune opzioni che ho usato:
Se XLSX è un must: ExcelPackage è un buon inizio ma è morto quando lo sviluppatore smettere di lavorarci su. ExML ha raccolto da lì e ha aggiunto alcune funzionalità. ExML non è una cattiva opzione, la sto ancora usando in un paio di siti Web di produzione .
Per tutti i miei nuovi progetti, tuttavia, sto utilizzando NPOI , la porta .NET di POI di Apache . NPOI 2.0 (Alpha) supporta anche XLSX.
Un'opzione estremamente leggera potrebbe essere l'uso di tabelle HTML. Basta creare tag head, body e table in un file e salvarlo come file con estensione .xls. Esistono attributi specifici di Microsoft che è possibile utilizzare per definire l'output, comprese le formule.
Mi rendo conto che potresti non codificarlo in un'applicazione web, ma ecco un esempio della composizione di un file Excel tramite una tabella HTML. Questa tecnica potrebbe essere utilizzata se stavi codificando un'app console, un'app desktop o un servizio.
Puoi utilizzare ExcelXmlWriter .
Funziona bene.
Se stai creando file Excel 2007/2010, prova questo progetto open source: https: // github. com / ClosedXML / ClosedXML
Fornisce un modo orientato agli oggetti per manipolare i file (simile a VBA) senza occuparsi delle seccature dei documenti XML. Può essere usato da qualsiasi linguaggio .NET come C # e Visual Basic (VB).
ClosedXML ti consente di creare file Excel 2007/2010 senza Excel applicazione. L'esempio tipico è la creazione di report Excel su un Web server:
var workbook = new XLWorkbook(); var worksheet = workbook.Worksheets.Add("Sample Sheet"); worksheet.Cell("A1").Value = "Hello World!"; workbook.SaveAs("HelloWorld.xlsx");
In realtà potresti voler controllare le classi di interoperabilità . Non dici OLE (cosa che non è), ma le classi di interoperabilità sono molto facili da usare.
Potresti essere colpito se non li hai provati.
Si prega di essere avvisati di Microsoft posizione su questo:
Microsoft attualmente non consiglia e non supporta, Automazione di applicazioni Microsoft Office da qualsiasi incustodito, applicazione o componente client non interattivo (incluso ASP, ASP.NET, DCOM e NT Services), perché Office potrebbe presentare instabilità comportamento e / o deadlock quando Office viene eseguito in questo ambiente.
Ecco una libreria C # completamente gratuita, che ti consente di esportare da un DataSet, DataTable o List<> in un vero file .xlsx di Excel 2007, usando le librerie OpenXML:
http://mikesknowledgebase.com/pages/CSharp/ExportToExcel.htm
Il codice sorgente completo viene fornito - gratuitamente - insieme alle istruzioni e un'applicazione demo.
Dopo aver aggiunto questa classe alla tua applicazione, puoi esportare il tuo DataSet in Excel in una sola riga di codice:
CreateExcelFile.CreateExcelDocument(myDataSet, "C:\\Sample.xlsx");
Non è molto più semplice di così ...
E non richiede nemmeno che Excel sia presente sul tuo server.
Puoi prendere in considerazione la creazione di file utilizzando il formato XML Spreadsheet 2003 . Questo è un semplice formato XML che utilizza un schema ben documentato .
Potresti dare un'occhiata a GemBox.Spreadsheet .
Hanno una versione gratuita con tutte le funzionalità ma limitata a 150 righe per foglio e 5 fogli per cartella di lavoro, se ciò rientra nelle tue esigenze.
Non ho ancora avuto bisogno di usarlo da solo, ma sembra interessante.
Syncfusion Essential XlsIO può farlo. Non ha dipendenze da Microsoft Office e ha anche un supporto specifico per piattaforme diverse.
- ASP.NET
- ASP.NET MVC
- UWP
- Xamarin
- WPF e Windows Form
- Servizio Windows e operazioni basate su batch
Esempio di codice:
//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);
L'intera suite di controlli è disponibile gratuitamente tramite il programma licenza della community se sei idoneo ( meno di 1 milione di dollari di entrate). Nota: lavoro per Syncfusion.
Bene,
puoi anche utilizzare una libreria di terze parti come Aspose .
Questa libreria ha il vantaggio che non richiede l'installazione di Excel sul tuo computer, il che sarebbe l'ideale nel tuo caso.
Le varie librerie XML di Office 2003 sono disponibili abbastanza bene per file Excel di piccole dimensioni. Tuttavia, trovo che la dimensione pura di una grande cartella di lavoro salvata nel formato XML sia un problema. Ad esempio, una cartella di lavoro con cui lavoro sarebbe 40 MB nel nuovo (e certamente più stretto pacchetto) formato XLSX diventa un file XML da 360 MB.
Per quanto mi ha portato la mia ricerca, ci sono due pacchetti commerciali che consentono l'output nei formati di file binari più vecchi. Sono:
Né sono economici (500USD e 800USD rispettivamente, penso). ma entrambi funzionano indipendentemente da Excel stesso.
Ciò di cui sarei curioso è il modulo di output di Excel per artisti del calibro di OpenOffice.org. Mi chiedo se possano essere portati da Java a .Net.
OpenXML è anche una buona alternativa che aiuta a evitare l'installazione di MS Excel su Server. Open XML SDK 2.0 fornito da Microsoft semplifica il compito di manipolare i pacchetti Open XML e gli elementi dello schema Open XML sottostanti all'interno di un pacchetto. L'API (Application Programming Interface) Open XML incapsula molte attività comuni che gli sviluppatori eseguono sui pacchetti Open XML.
Dai un'occhiata a OpenXML: Alternativa che aiuta a evitare l'installazione di MS Excel sul server
Sono d'accordo sulla generazione di fogli di calcolo XML, ecco un esempio su come farlo per C # 3 (tutti ne parlano solo in VB 9: P) http://www.aaron-powell.com/linq-to-xml-to-excel
Di recente ho usato FlexCel.NET e l'ho trovata un'ottima biblioteca! Non lo dico per troppi prodotti software. Inutile dare qui l'intera presentazione delle vendite, puoi leggere tutte le funzionalità sul loro sito Web.
È un prodotto commerciale, ma se lo acquisti ottieni la fonte completa. Quindi suppongo che potresti compilarlo nel tuo assemblaggio se lo desideri davvero. Altrimenti è solo un ulteriore assemblaggio di xcopy: nessuna configurazione o installazione o qualcosa del genere.
Non credo che troverai alcun modo per farlo senza librerie di terze parti poiché .NET Framework, ovviamente, non ha il supporto integrato per esso e l'automazione OLE è solo un intero mondo di dolore.
Voglio solo aggiungere un altro riferimento a una soluzione di terze parti che risolva direttamente il tuo problema: http://www.officewriter.com
(Dichiarazione di non responsabilità: lavoro per SoftArtisans, la società che produce OfficeWriter)
Ho scritto un codice semplice per esportare il set di dati in Excel senza utilizzare l'oggetto Excel utilizzando System.IO.StreamWriter.
Di seguito è riportato il codice che leggerà tutte le tabelle dal set di dati e le scriverà sui fogli uno per uno. Ho preso aiuto da questo articolo .
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();
}
Ecco un modo per farlo con LINQ to XML, completo di codice di esempio:
Importa ed esporta rapidamente i dati di Excel con LINQ in XML
È un po 'complesso, poiché devi importare spazi dei nomi e così via, ma ti consente di evitare dipendenze esterne.
(Inoltre, ovviamente, è VB .NET, non C #, ma puoi sempre isolare le cose di VB .NET nel suo progetto per usare XML Literals e fare tutto il resto in C #.)
Alcuni fornitori di componenti di terze parti come Infragistics o Syncfusion offrono ottime capacità di esportazione Excel che non richiedono l'installazione di Microsoft Excel.
Poiché questi fornitori forniscono anche componenti avanzati della griglia dell'interfaccia utente, questi componenti sono particolarmente utili se si desidera che lo stile e il layout di un'esportazione excel imitino lo stato corrente di una griglia nell'interfaccia utente dell'applicazione.
Se la tua esportazione deve essere eseguita sul lato server con enfasi sui dati da esportare e senza alcun collegamento all'interfaccia utente, sceglierei una delle opzioni open source gratuite (ad esempio ExcelLibrary).
In precedenza sono stato coinvolto in progetti che hanno tentato di utilizzare l'automazione lato server nella suite di Microsoft Office. Sulla base di questa esperienza, raccomanderei fortemente questo approccio.
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);
}
}
}
}
Salve, questa soluzione consiste nell'esportare la visualizzazione della griglia nel file Excel che potrebbe aiutarti
Puoi creare file Excel ben formattati usando questa libreria:
http://officehelper.codeplex.com/documentation
Vedi l'esempio seguente:
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");
}
dove esempio è simile a questo:
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};
}
}
Il modo più semplice e veloce per creare un file Excel da C # è utilizzare lo Strumento di produttività Open XML. Lo strumento di produttività Open XML viene fornito con l'installazione dell'SDK Open XML. Lo strumento esegue il reverse engineering di qualsiasi file Excel in codice C #. Il codice C # può quindi essere utilizzato per rigenerare quel file.
Una panoramica del processo in questione è:
- Installa Open XML SDK con lo strumento.
- Crea un file Excel usando l'ultimo client Excel con l'aspetto desiderato. Denominalo
DesiredLook.xlsx. - Con lo strumento aperto
GeneratedClasse fai clic sul pulsante Rifletti codice nella parte superiore.
- Il codice C # per il tuo file verrà generato nel riquadro destro dello strumento. Aggiungi questo alla tua soluzione C # e genera file con l'aspetto desiderato.
Come bonus, questo metodo funziona con qualsiasi file Word e PowerPoint. Come sviluppatore C #, apporterai quindi modifiche al codice per adattarlo alle tue esigenze.
Ho sviluppato una semplice app WPF su github che verrà eseguita su Windows a questo scopo. Esiste una classe segnaposto chiamata <=> in cui è possibile incollare il codice generato. Se torni indietro di una versione del file, verrà generato un file Excel come questo:
Qualche utile automazione di Excel in C #, puoi trovare dal seguente link.
http://csharp.net-informations.com/excel/ csharp-excel-tutorial.htm
Bolton.
Guarda esempi su come creare file Excel.
Ci sono esempi in C # e VB.NET
Gestisce i file XSL XSLX e CSV Excel.
