Como faço para criar um arquivo do Excel (XLSX .XLS e) em C # sem instalar o Microsoft Office? [fechadas]
https://stackoverflow.com/questions/151005
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Como posso criar uma planilha do Excel com C # sem a necessidade de Excel para ser instalado na máquina que está executando o código?
Solução
Você pode usar uma biblioteca chamada ExcelLibrary. É, uma biblioteca livre de código aberto publicado no Google Code:
Este parece ser um port do PHP ExcelWriter que você mencionou acima. Não vai escrever para o novo formato .xlsx ainda, mas eles estão trabalhando para adicionar essa funcionalidade no.
É muito simples, pequeno e fácil de usar. Além disso, ele tem um DataSetHelper que permite usar DataSets e DataTables para trabalhar facilmente com dados do Excel.
ExcelLibrary parece ainda só funcionam para o formato Excel mais velhos (arquivos .xls), mas pode ser a adição de suporte no futuro para novos formatos 2007/2010.
Você também pode usar EPPlus , que funciona apenas para Excel 2007/2010 arquivos de formato (arquivos .xlsx ). Há também NPOI que trabalha com ambos.
Existem alguns bugs conhecidos com cada biblioteca como observado nos comentários. Ao todo, EPPlus parece ser a melhor escolha como o tempo passa. Parece ser mais ativamente atualizado e documentado bem.
Além disso, como observado por @ ????????????? abaixo, EPPlus tem suporte para tabelas dinâmicas e ExcelLibrary pode ter algum apoio ( questão tabela dinâmica no ExcelLibrary )
Aqui estão alguns links para referência rápida:
ExcelLibrary - GNU Lesser GPL
EPPlus - GNU Lesser general Public License (LGPL)
NPOI - Apache License
Aqui um exemplo de código para ExcelLibrary:
Aqui está um exemplo de tomar dados de um banco de dados e criar uma pasta de trabalho a partir dele. Note que o código ExcelLibrary é a única linha na parte inferior:
//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);
Criando o arquivo Excel é tão fácil como isso. Você também pode criar manualmente arquivos do Excel, mas a funcionalidade acima é o que realmente me impressionou.
Outras dicas
Se você está feliz com o formato xlsx, tente meu projeto GitHub, EPPlus . Tudo começou com a fonte de ExcelPackage, mas hoje é uma reescrita total. Ele suporta faixas, estilo de célula, gráficos, formas, imagens, intervalos nomeados, filtro automático e um monte de outras coisas.
Eu tenho usado com sucesso os seguintes projetos de código aberto:
-
ExcelPackage para formatos OOXML (Office 2007)
-
NPOI para o formato .XLS (Office 2003). NPOI 2,0 (Beta) também suporta XLSX.
Dê uma olhada em meus posts:
E o que dizer usando o Open XML SDK 2.0 para Microsoft Office?
Alguns benefícios:
- não requer o Office instalado
- Feito pela documentação MSDN decente Microsoft =
- Apenas um .Net dll para uso no projeto
- SDK vem com muitas ferramentas como diff, validador, etc
Links:
- Baixar SDK
- principal MSDN Landing
- "How Do I ..." página arranque
- brian_jones blogs.MSDN anunciando SDK
- brian_jones blogs.MSDN descrevendo SDK manuseio de grandes arquivos sem deixar de funcionar (ao contrário do método DOM)
Você pode usar OLEDB para criar e manipular arquivos do Excel. Marque esta: Leitura e Escrita Excel usando OLE DB .
Exemplo típico:
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();
}
Editar - Mais alguns links:
A solução comercial, SpreadsheetGear for .NET vai fazê-lo.
Você pode ver ao vivo ASP.NET (C # e VB) amostras aqui e baixar um versão de avaliação aqui .
Disclaimer: eu próprio SpreadsheetGear LLC
A poucas opções que tenho usado:
Se XLSX é uma obrigação: ExcelPackage é um bom começo, mas morreram quando o desenvolvedor parar de trabalhar nele. ExML pegou de lá e acrescentou algumas características. ExML não é uma má opção, ainda estou a usá-lo em um par de sites de produção .
Para todos os meus novos projetos, no entanto, estou usando NPOI , a porta .NET de Apache POI . NPOI 2,0 (alfa) também suporta XLSX.
Uma opção extremamente leve pode ser usar tabelas HTML. Basta criar cabeça, corpo e marcas de tabela em um arquivo e salvá-lo como um arquivo com uma extensão .xls. Existem atributos específicos da Microsoft que você pode usar para estilo de saída, incluindo fórmulas.
Eu percebo que você não pode ser codificação isso em uma aplicação web, mas aqui é um exemplo da composição de um arquivo do Excel através de uma tabela HTML. Esta técnica poderia ser usada se você estivesse de codificação de um console app, app desktop, ou serviço.
Você pode usar ExcelXmlWriter .
Ele funciona muito bem.
Se você estiver criando Excel 2007/2010 arquivos dar a este projeto open source uma tentativa: https: // github. com / closedxml / closedxml
Ele fornece uma maneira orientada a objeto para manipular os arquivos (semelhante ao VBA) sem lidar com as dificuldades de documentos XML. Isso pode ser usado por qualquer linguagem .NET como C # e Visual Basic (VB).
ClosedXML permite criar 2007/2010 arquivos Excel sem o Excel inscrição. O exemplo típico é a criação de relatórios do Excel em um Web servidor:
var workbook = new XLWorkbook(); var worksheet = workbook.Worksheets.Add("Sample Sheet"); worksheet.Cell("A1").Value = "Hello World!"; workbook.SaveAs("HelloWorld.xlsx");
Você realmente pode querer verificar o interoperabilidade aulas . Você diz não OLE (que não é), mas as classes de interoperabilidade são muito fáceis de usar.
Você pode ficar impressionado se você ainda não tentou-los.
Por favor ser avisado da Microsoft de posição sobre esta:
Microsoft atualmente não recomendo, e não suporta, Automação de aplicativos do Microsoft Office a partir de qualquer autônoma, aplicação não interactivo cliente ou componente (incluindo o ASP, ASP.NET, DCOM e serviços NT), porque Office pode apresentar instável comportamento e / ou impasse quando o Office é executado nesse ambiente.
Aqui está uma biblioteca C # totalmente gratuito, que permite exportar a partir de um DataSet, DataTable ou List<> em um arquivo .xlsx Excel 2007 genuína, usando as bibliotecas OpenXML:
http://mikesknowledgebase.com/pages/CSharp/ExportToExcel.htm
O código fonte completo é fornecido - gratuitamente -. Juntamente com as instruções, e uma aplicação de demonstração
Depois de adicionar essa classe para sua aplicação, você pode exportar seu DataSet para o Excel em apenas uma linha de código:
CreateExcelFile.CreateExcelDocument(myDataSet, "C:\\Sample.xlsx");
Ela não fica muito mais simples do que isso ...
E não requer nem mesmo Excel para estar presente no seu servidor.
Você poderia considerar a criação de seus arquivos usando o formato Spreadsheet XML 2003. Este é um formato XML simples usando um bem documentado esquema .
Você pode querer dar uma olhada GemBox.Spreadsheet .
Eles têm uma versão gratuita com todos os recursos, mas limitado a 150 linhas por folha e 5 folhas por livro, se isso cai dentro de suas necessidades.
Eu não tive necessidade de usá-lo mesmo ainda, mas faz olhar interessante.
Syncfusion Essencial XlsIO pode fazer isso. Não tem nenhuma dependência do Microsoft Office e também tem suporte específico para diferentes plataformas.
- ASP.NET
- ASP.NET MVC
- UWP
- Xamarin
- WPF e Windows Forms
- Windows Service e operações em lote com base
Exemplo de código:
//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);
Todo o conjunto de controles está disponível gratuitamente através do comunidade programa de licença se você se qualifica ( menos de 1 milhão de dólares em receita). Nota:. Eu trabalho para Syncfusion
Bem,
Você também pode usar uma biblioteca de terceiros como Aspose .
Esta biblioteca tem o benefício que ele não requer Excel para ser instalado em sua máquina que seria ideal no seu caso.
As várias Office 2003 bibliotecas XML de trabalho disponível muito bem para arquivos do Excel menores. No entanto, acho o tamanho de um grande livro guardado no formato XML a ser um problema. Por exemplo, um trabalho pasta de trabalho eu com isso seria 40MB no novo (e reconhecidamente mais bem embalado) formato XLSX torna-se um arquivo XML 360MB.
Tanto quanto a minha pesquisa me levou, há dois pacotes comerciais que permitem a saída para os formatos de arquivos binários mais antigos. Eles são:
Nem são baratos (500USD e 800USD respectivamente, eu acho). mas ambos independente própria obra de Excel.
O que eu seria curioso é o módulo de saída Excel para os gostos do OpenOffice.org. Eu me pergunto se eles podem ser portados de Java para .Net.
OpenXML é também uma boa alternativa que ajuda a evitar a instalação de MS Excel em server.The Open XML SDK 2.0 fornecido pela Microsoft simplifica a tarefa de manipular pacotes Open XML e os elementos do esquema Open XML subjacentes dentro de um pacote. A Aplicação Open XML Programming Interface (API) encapsula muitas tarefas comuns que os desenvolvedores executar em pacotes de Open XML.
Verifique isto para fora OpenXML: Alternativa que ajuda a evitar a instalação de MS Excel no Server
Eu concordo sobre a geração de planilhas XML, aqui está um exemplo de como fazê-lo para C # 3 (todos apenas blogs sobre o assunto em VB 9: P) http://www.aaron-powell.com/linq-to-xml-to-excel
Eu usei apenas recentemente FlexCel.NET e achei que era ser uma excelente biblioteca! Eu não dizer que sobre muitos produtos de software. Nenhum ponto em dar todo o discurso de vendas aqui, você pode ler todas as características em seu site.
É um produto comercial, mas você começa a fonte completo se você comprá-lo. Então, eu suponho que você poderia compilá-lo em seu conjunto se você realmente queria. Caso contrário, é apenas um extra de montagem para xcopy -. Nenhuma configuração ou instalação ou qualquer coisa assim
Eu não acho que você vai encontrar alguma maneira de fazer isso sem bibliotecas de terceiros como framework .NET, obviamente, não tem suporte embutido para ele e OLE Automation é apenas um mundo de dor.
Apenas deseja adicionar outra referência a uma solução de terceiros que aborda diretamente o problema: http://www.officewriter.com
(Disclaimer: trabalho eu para SoftArtisans, a empresa que faz OfficeWriter)
Eu escrevi um simples código de conjunto de dados de exportação para o Excel sem usar excel objeto usando System.IO.StreamWriter.
Abaixo está o código que irá ler todas as tabelas do conjunto de dados e gravá-los em folhas de um por um. Tomei a ajuda de este artigo .
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();
}
Aqui está uma maneira de fazê-lo com LINQ to XML, completo com código de exemplo:
rapidamente importar e exportar dados do Excel com LINQ to XML
É um pouco complexo, pois você tem que namespaces de importação e assim por diante, mas não deixá-lo a evitar quaisquer dependências externas.
(Além disso, é claro, do VB .NET, C # não, mas você sempre pode isolar o material VB .NET em seu próprio projeto para literais uso de XML, e fazer tudo o resto em C #.)
Alguns 3rd party fornecedores de componentes como Infragistics ou Syncfusion fornecer capacidades de exportação muito bons Excel que não requerem Microsoft Excel para ser instalado.
Uma vez que estes fornecedores também fornecem componentes avançados de grade UI, esses componentes são particularmente útil se você quiser o estilo e layout de uma exportação excel para imitar o estado atual de uma grade na interface do usuário do seu aplicativo.
Se a sua exportação se destina a ser executado do lado do servidor com destaque para os dados a serem exportados e sem ligação com a interface do usuário, em seguida, eu iria para uma das opções gratuitas de código aberto (por exemplo ExcelLibrary).
Eu já havia se envolvido com projetos que tentaram usar a automação do lado do servidor na suíte Microsoft Office. Com base nesta experiência Eu recomendaria fortemente contra essa abordagem.
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);
}
}
}
}
Hi esta solução é exportar a sua visualização em grade ao seu arquivo excel que poderia ajudá-lo
Você pode criar bem formatado arquivos do Excel usando esta biblioteca:
http://officehelper.codeplex.com/documentation
Veja abaixo exemplo:
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");
}
onde olhar amostra assim:
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};
}
}
A maneira mais simples e rápida de criar um ficheiro de Excel de C # é usar a ferramenta de produtividade Open XML. A produtividade da ferramenta Open XML vem com a instalação do Open XML SDK. A ferramenta de engenharia reversa qualquer arquivo de Excel em código C #. O código C # pode então ser usada para re-gerar o arquivo.
Uma visão geral do processo envolvido é:
- Instale o Open XML SDK com a ferramenta.
- Criar um arquivo do Excel usando o cliente mais recente do Excel com aparência desejada. Nomeá-lo
DesiredLook.xlsx. - Com o
DesiredLook.xlsxaberta ferramenta e clique no botão Código perto do topo Reflect.
- O código C # para o seu arquivo será gerado no painel direito da ferramenta. Adicione isto a sua solução C # e gerar arquivos com essa aparência desejada.
Como um bônus, este método funciona para quaisquer arquivos do Word e PowerPoint. Como o desenvolvedor C #, então você vai fazer alterações ao código para atender às suas necessidades.
Eu desenvolvi um href="https://github.com/thomasbtatum/GenerateAnyExcelFileWithCSharp" rel="noreferrer"> aplicativo WPF simples que será executado no Windows para esta finalidade. Há uma classe espaço reservado chamado GeneratedClass onde você pode colar o código gerado. Se você voltar uma versão do arquivo, ele irá gerar um arquivo do Excel como este:
Alguns automação Excel útil em C #, u pode encontrar a partir do seguinte link.
http://csharp.net-informations.com/excel/ csharp-excel-tutorial.htm
Bolton.
Olhe amostras como criar arquivos de Excel.
Há exemplos em C # e VB.NET
Ele gerencia arquivos XSL xslx e CSV Excel.
