Microsoft Office를 설치하지 않고 C #에서 Excel (.XLS 및 .XLSX) 파일을 만들려면 어떻게합니까?

코드를 실행하는 컴퓨터에 Excel을 설치하지 않고도 C #으로 Excel 스프레드 시트를 만들려면 어떻게해야합니까?

ExcelLibrary라는 라이브러리를 사용할 수 있습니다. Google 코드에 게시 된 무료 오픈 소스 라이브러리입니다.

엑셀 라이브러리

이것은 위에서 언급 한 PHP ExcelWriter의 포트 인 것 같습니다. 아직 새로운 .xlsx 형식으로 쓰지는 않지만 해당 기능을 추가하기 위해 노력하고 있습니다.

매우 간단하고 작으며 사용하기 쉽습니다. 또한 DataSets와 DataTables를 사용하여 Excel 데이터로 쉽게 작업 할 수있는 DataSetHelper가 있습니다.

ExcelLibrary는 여전히 이전 Excel 형식 (.xls 파일)에서만 작동하는 것으로 보이지만 향후 2007/2010 형식에 대한 지원이 추가 될 수 있습니다.

EPPlus 는 Excel 2007/2010 형식 파일 (.xlsx 파일)에만 사용할 수 있습니다 . 둘 다 작동하는 NPOI 도 있습니다 .

주석에 명시된 바와 같이 각 라이브러리에는 몇 가지 알려진 버그가 있습니다. 시간이 지남에 따라 EPPlus가 최선의 선택 인 것 같습니다. 더 적극적으로 업데이트되고 문서화 된 것 같습니다.

또한 아래의 @ АртёмЦарионов에서 알 수 있듯이 EPPlus는 피벗 테이블을 지원하며 ExcelLibrary는 일부 지원을 제공 할 수 있습니다 ( ExcelLibrary의 피벗 테이블 문제 )

다음은 빠른 참조를위한 몇 가지 링크입니다.
ExcelLibrary - GNU Lesser GPL
EPPlus - GNU Lesser General Public License (LGPL)
NPOI - Apache License

다음은 ExcelLibrary의 예제 코드입니다.

다음은 데이터베이스에서 데이터를 가져 와서 통합 문서를 만드는 예입니다. 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);

Excel 파일을 만드는 것은 그렇게 쉽습니다. Excel 파일을 수동으로 만들 수도 있지만 위의 기능이 정말 인상적입니다.

xlsx 형식에 만족한다면 GitHub 프로젝트 인 EPPlus를 사용해보십시오 . ExcelPackage의 소스로 시작했지만 오늘은 완전히 다시 작성되었습니다. 범위, 셀 스타일, 차트, 도형, 그림, 명명 된 범위, 자동 필터 및 기타 여러 기능을 지원합니다.

그리고 Microsoft Office 용 Open XML SDK 2.0을 사용하는 것은 어떻습니까?

몇 가지 장점 :

• Office를 설치할 필요가 없습니다
• Microsoft에서 만든 = 괜찮은 MSDN 설명서
• 프로젝트에서 사용할 하나의 .Net dll
• SDK에는 diff, validator 등과 같은 많은 도구가 제공됩니다.

연결:

• 깃 허브
• 주요 MSDN 랜딩
• "어떻게 ..."스타터 페이지
• blogs.MSDN brian_jones 발표 SDK
• blogs.MSDN brian_jones (DOM 방식과 달리) 크래시없이 큰 파일을 처리하는 SDK를 설명

나는 다음과 같은 오픈 소스 프로젝트를 성공적으로 사용했습니다.

• OOXML 형식 용 ExcelPackage (Office 2007)

• .XLS 형식의 NPOI (Office 2003). NPOI 2.0 (베타)도 XLSX를 지원합니다.

내 블로그 게시물을 살펴보십시오.

C #에서 Excel 스프레드 시트 .XLS 및 .XLSX 작성

Excel 테이블 및 동적 차트가 포함 된 NPOI

OLEDB를 사용하여 Excel 파일을 만들고 조작 할 수 있습니다. 이것을 확인하십시오 : OLEDB를 사용하여 Excel 읽기 및 쓰기 .

전형적인 예 :

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();
}

편집-더 많은 링크 :

• 스크립팅 가이! Excel을 사용하지 않고 어떻게 Excel에서 읽을 수 있습니까?
• Visual Basic .NET을 사용하여 ADO.NET을 사용하여 Excel 통합 문서에서 레코드를 검색하고 수정하는 방법
• ADO.NET C # DbProviderFactory를 사용하여 Excel 스프레드 시트 읽기 및 쓰기

상용 솔루션 인 SpreadsheetGear for .NET이이 를 수행 할 것입니다.

라이브 ASP.NET (C # 및 VB) 샘플은 여기 에서보고 평가판은 여기 에서 다운로드 할 수 있습니다 .

면책 조항 : SpreadsheetGear LLC를 소유하고 있습니다

내가 사용한 몇 가지 옵션 :

XLSX가 필수 인 경우 : ExcelPackage 는 좋은 시작이지만 개발자가 작업을 종료하면 종료됩니다. ExML이 거기에서 집어 들고 몇 가지 기능이 추가되었습니다. ExML 은 나쁜 옵션이 아닙니다. 저는 여전히 두 개의 프로덕션 웹 사이트에서 사용하고 있습니다.

그러나 모든 새 프로젝트 에는 Apache POI 의 .NET 포트 인 NPOI 를 사용하고 있습니다. NPOI 2.0 (Alpha) 은 XLSX도 지원합니다.

매우 가벼운 옵션은 HTML 테이블을 사용하는 것입니다. 파일에 head, body 및 table 태그를 만들고 확장자가 .xls 인 파일로 저장하면됩니다. 수식을 포함하여 출력의 스타일을 지정하는 데 사용할 수있는 Microsoft 특정 특성이 있습니다.

웹 응용 프로그램 에서이 코드를 코딩하지 않을 수도 있지만 HTML 테이블을 통한 Excel 파일 구성의 예 는 다음과 같습니다. 콘솔 앱, 데스크톱 앱 또는 서비스를 코딩하는 경우이 기술을 사용할 수 있습니다.

Excel 2007/2010 파일을 만드는 경우이 오픈 소스 프로젝트에 다음을 시도하십시오. https://github.com/closedxml/closedxml

XML 문서의 번거 로움을 처리하지 않고도 파일을 조작 할 수있는 객체 지향 방식을 제공합니다 (VBA와 유사). C # 및 VB (Visual Basic)와 같은 모든 .NET 언어에서 사용할 수 있습니다.

ClosedXML을 사용하면 Excel 응용 프로그램없이 Excel 2007/2010 파일을 만들 수 있습니다. 일반적인 예는 웹 서버에서 Excel 보고서를 작성하는 것입니다.

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

ExcelXmlWriter 를 사용할 수 있습니다 .

잘 작동합니다.

실제로 C #에서 사용할 수있는 interop 클래스를 확인하고 싶을 수 있습니다 (예 : Microsoft.Office.Interop.ExcelOLE (이것은 아닙니다)라고 말하지만 interop 클래스는 매우 사용하기 쉽습니다.) 여기 에서 C # 설명서를 확인하십시오 (Interop for Excel은 C # PDF 1072 페이지 참조).

당신이 그들을 시도하지 않은 경우 당신은 감동받을 수 있습니다.

이에 대한 Microsoft의 입장 에 대해 경고 하십시오 :

Microsoft는 현재 비대화 형 비대화 형 클라이언트 응용 프로그램 또는 구성 요소 (ASP, ASP.NET, DCOM 및 NT 서비스 포함)의 Microsoft Office 응용 프로그램 자동화를 권장하지 않으며 지원하지 않습니다. 이 환경에서 Office를 실행할 때 교착 상태가 발생합니다.

OpenXML 라이브러리를 사용하여 완전 무료 C # 라이브러리를 사용하면 DataSet, DataTable또는 List<>Excel 2007 .xlsx 파일로 내보낼 수 있습니다 .

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

전체 소스 코드는 지침 및 데모 응용 프로그램과 함께 무료로 제공됩니다.

이 클래스를 응용 프로그램에 추가 한 후 한 줄의 코드로 DataSet을 Excel로 내보낼 수 있습니다.

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

그것보다 훨씬 간단하지는 않습니다 ...

그리고 서버에 Excel이 없어도됩니다.

XML 스프레드 시트 2003 형식을 사용하여 파일을 만드는 것을 고려할 수 있습니다 . 잘 문서화 된 스키마를 사용하는 간단한 XML 형식 입니다.

GemBox.Spreadsheet를 살펴 보십시오 .

모든 기능을 갖춘 무료 버전이지만 필요에 따라 시트 당 150 행 및 통합 문서 당 5 시트로 제한됩니다.

아직 직접 사용할 필요는 없었지만 흥미로워 보입니다.

Syncfusion Essential XlsIO가이 를 수행 할 수 있습니다. Microsoft 사무실에 의존하지 않으며 다른 플랫폼에 대한 특정 지원도 있습니다.

• ASP.NET
• ASP.NET MVC
• UWP
• 사 마린
• WPF 및 Windows Forms
• Windows 서비스 및 배치 기반 작업

코드 샘플 :

//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);

자격이있는 경우 (100 만 달러 미만의 수입) 커뮤니티 라이센스 프로그램을 통해 전체 제어 제품군을 무료로 사용할 수 있습니다 . 참고 : 나는 Syncfusion을 위해 일합니다.

잘,

Aspose 와 같은 타사 라이브러리를 사용할 수도 있습니다 .

이 라이브러리는 컴퓨터에 Excel을 설치할 필요가 없으므로 사용자에게 이상적인 이점이 있습니다.

OpenXML은 또한 서버에 MS Excel을 설치하지 않는 좋은 대안입니다. Microsoft에서 제공하는 Open XML SDK 2.0은 Open XML 패키지와 패키지 내의 기본 Open XML 스키마 요소를 조작하는 작업을 단순화합니다. Open XML API (응용 프로그래밍 인터페이스)는 개발자가 Open XML 패키지에서 수행하는 많은 일반적인 작업을 캡슐화합니다.

이 체크 아웃 예약 대체 서버에서 MS Excel을 설치하지 마십시오 도움 :의 OpenXML을

다양한 Office 2003 XML 라이브러리는 작은 Excel 파일에 적합합니다. 그러나 XML 형식으로 저장된 큰 통합 문서의 크기가 문제인 것으로 나타났습니다. 예를 들어, 내가 작업하는 통합 문서는 새로운 (그리고 더 엄격하게 압축 된) XLSX 형식에서 40MB가 360MB XML 파일이됩니다.

내 연구에 따르면 오래된 바이너리 파일 형식으로 출력 할 수있는 두 가지 상용 패키지가 있습니다. 그들은:

• 보석 함
• ComponentOne Excel

저렴하지도 않습니다 (각각 500USD와 800USD라고 생각합니다). 그러나 둘 다 Excel 자체와 독립적으로 작동합니다.

궁금한 점은 OpenOffice.org와 비슷한 Excel 출력 모듈입니다. Java에서 .Net으로 이식 할 수 있는지 궁금합니다.

XML 스프레드 시트 생성에 동의합니다. 다음은 C # 3 (VB 9 : P의 블로그 만 해당)에 대해 수행하는 방법에 대한 예입니다. http://www.aaron-powell.com/linq-to-xml-to- 뛰어나다

최근에 FlexCel.NET을 사용 했습니다. 훌륭한 라이브러리라는 것을 알았습니다! 너무 많은 소프트웨어 제품에 대해서는 말하지 않습니다. 여기에 전체 판매 피치를 줄 필요가 없습니다. 웹 사이트의 모든 기능을 읽을 수 있습니다.

상용 제품이지만 구매하면 전체 소스를 얻을 수 있습니다. 따라서 원하는 경우 어셈블리로 컴파일 할 수 있다고 가정합니다. 그렇지 않으면 xcopy에 대한 하나의 추가 어셈블리 일뿐입니다-구성이나 설치가 필요하지 않습니다.

.NET 프레임 워크로서 타사 라이브러리가 없으면이 작업을 수행 할 수있는 방법을 찾지 못할 것이라고 생각합니다.

System.IO.StreamWriter를 사용하여 Excel 객체를 사용하지 않고 데이터 세트를 Excel로 내보내는 간단한 코드를 작성했습니다.

아래는 데이터 세트에서 모든 테이블을 읽고 하나씩 시트에 쓰는 코드입니다. 나는 이 기사 에서 도움을 받았다 .

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를 만드는 회사 인 SoftArtisans에서 일합니다)

IKVM + POI

또는 Interop을 사용할 수 있습니다 ...

LINQ to XML을 사용하여 샘플 코드를 완성하는 방법은 다음과 같습니다.

LINQ to XML을 사용하여 Excel 데이터를 빠르게 가져 오기 및 내보내기

네임 스페이스 등을 가져와야하기 때문에 약간 복잡하지만 외부 종속성을 피할 수 있습니다.

(물론 C #이 아닌 VB .NET이지만 XML 리터럴을 사용하기 위해 항상 자체 프로젝트에서 VB .NET 항목을 분리하고 C #에서 다른 모든 작업을 수행 할 수 있습니다.)

Infragistics 또는 Syncfusion과 같은 일부 타사 구성 요소 공급 업체는 Microsoft Excel을 설치하지 않아도되는 우수한 Excel 내보내기 기능을 제공합니다.

이러한 공급 업체는 고급 UI 그리드 구성 요소도 제공하므로 응용 프로그램의 사용자 인터페이스에서 그리드의 현재 상태를 모방하기 위해 Excel 내보내기의 스타일과 레이아웃을 원하는 경우 특히 유용합니다.

내보낼 데이터를 강조하고 UI에 링크하지 않고 서버 측에서 내보내기를 수행하려는 경우 무료 오픈 소스 옵션 중 하나 (예 : ExcelLibrary)를 사용합니다.

이전에 Microsoft Office 제품군에서 서버 쪽 자동화를 사용하려는 프로젝트에 참여했습니다. 이 경험을 바탕으로 나는 그 접근법에 반대하는 것이 좋습니다.

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);
            }
        }
    }
}

안녕하세요이 솔루션은 그리드보기를 Excel 파일로 내보내는 데 도움이 될 수 있습니다.

이 라이브러리를 사용하여 멋진 형식의 Excel 파일을 만들 수 있습니다. 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 #에서 Excel 파일을 만드는 가장 간단하고 빠른 방법은 Open XML Productivity Tool을 사용하는 것입니다. Open XML Productivity Tool은 Open XML SDK 설치와 함께 제공됩니다. 이 도구는 Excel 파일을 C # 코드로 리버스 엔지니어링합니다. 그런 다음 C # 코드를 사용하여 해당 파일을 다시 생성 할 수 있습니다.

관련된 프로세스의 개요는 다음과 같습니다.

1. 도구를 사용하여 Open XML SDK를 설치하십시오.
2. 원하는 모양으로 최신 Excel 클라이언트를 사용하여 Excel 파일을 작성하십시오. 이름을 지정하십시오 DesiredLook.xlsx.
3. 도구를 연 상태 DesiredLook.xlsx에서 상단 근처의 코드 반영 버튼을 클릭하십시오.
4. 파일의 C # 코드가 도구의 오른쪽 창에 생성됩니다. 이것을 C # 솔루션에 추가하고 원하는 모양으로 파일을 생성하십시오.

보너스로이 방법은 모든 Word 및 PowerPoint 파일에서 작동합니다. C # 개발자는 필요에 따라 코드를 변경합니다.

이 목적으로 Windows에서 실행될 github 에서 간단한 WPF 앱을 개발했습니다 . GeneratedClass생성 된 코드를 붙여 넣을 수 있는 자리 표시 자 클래스 가 있습니다. 한 버전의 파일로 돌아 가면 다음과 같이 Excel 파일이 생성됩니다.

C #에서 유용한 Excel 자동화는 다음 링크에서 찾을 수 있습니다.

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

볼튼.

Excel 파일을 작성하는 방법에 대한 샘플을보십시오.

C # 및 VB.NET에 예가 있습니다.

XSL XSLX 및 CSV Excel 파일을 관리합니다.

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