Didn’t find what you were looking for?
Mesaj simgesi
Altbilgi içeriğine atla
  1. Iron Software
  2. IronXL Blogu
  3. IronXL Kullanımı
  4. Excel'i İhraç Etmek için Interop
IRONXL KULLANARAK

Interop ve IronXL'i Kullanarak C# Dilinde DataTable'ı Excel'e Nasıl Aktarılır

Curtis Chau
Curtis Chau
Güncellendi:

.NET Geliştiricileri için DataTable'yi Excel'e İhraç Etmenin Önemi Nedir?

Verilerin bir veritabanından veya uygulamadan bir Excel dosyasına dışa aktarılması, bilgileri etkin bir şekilde analiz etmek, görselleştirmek ve paylaşmak zorunda olan organizasyonlar için temel bir gerekliliktir. Excel dosyaları, son kullanıcıların verilerle etkileşimde bulunmasını ve yorumlamasını kolaylaştıran kullanıcı dostu arayüzleri ile yaygın olarak tanınır. Geliştiriciler, veri kümelerini .xlsx formatına dönüştürerek verinin, alıcının teknik bilgisi ne olursa olsun erişilebilir ve iyi yapılandırılmış kalmasını sağlar.

.NET geliştiricileri için iki yaygın yaklaşım mevcuttur: Microsoft Office Interop ve IronXL gibi özel Excel kütüphaneleri. Bu kılavuz, hem yöntemle, çalışan C# kodu örnekleriyle birlikte yürütüyor, ödünleşmelerini karşılaştırıyor ve hangi yaklaşımın üretim uygulamaları için mantıklı olduğu üzerine açıklıyor.

Interop ve IronXL Arasındaki Temel Farklılıklar Nelerdir?

Koda dalmadan önce, bu iki yaklaşım arasındaki temel farkların anlaşılması, herhangi bir proje için doğru seçimi formüle etmeye yardımcı olur. Karşılaştırma, teknik mimari, dağıtım gereksinimleri ve DataTable-veri Excel ihracat senaryolarında çalışma deneyimini kapsar.

C# için Excel Dışarı Aktarımında Microsoft Office Interop ve IronXL Karşılaştırması
Özellik Microsoft Office Interop IronXL
Office Kurulumu Gerekli Evet -- Microsoft Excel kurulu olmalı Hayır -- bağımsız kütüphane
Sunucu-Tarafı Destek Microsoft tarafından önerilmiyor Tamamen destekleniyor
Platform Desteği Sadece Windows Windows, Linux, macOS, Azure
.NET Core / .NET 5+ Desteği Sınırlı Tam destek (.NET 6, 7, 8, 9, 10)
Kaynak Yönetimi COM nesne temizliği gerektirir Standart .NET temizliği
Kurulum Yöntemi COM referansı + Office kurulum NuGet paketi
İş Parçacığı Modeli Tek iş parçacıklı konut (STA) İş parçacığı güvenli operasyonlar
Büyük Veri Tabloları Bellek yoğun işlemler Etkin dosya tabanlı yaklaşım
Desteklenen Dosya Formatları XLSX, XLS, CSV XLSX, XLS, CSV, JSON, XML
Lisanslama Office lisansı gerektirir Ticari lisans mevcut

Mimari fark temeldir: Excel Interop, Microsoft Excel uygulamasını COM aracılığıyla otomatikleştirir, oysa IronXL herhangi bir harici işlem başlatmadan Excel dosya formatlarını doğrudan okur ve yazar. Bu farklılık, hafıza kullanımından dağıtım karmaşıklığına kadar her şeyi etkiler.

Excel Dışa Aktarımı İçin IronXL Nasıl Kurulur?

IronXL'ın kurulumu sadece birkaç saniye sürer ve NuGet üzerinden yapılır. Ek bir yazılım, Office kurulumu veya sistem yapılandırması gerekmez. Kütüphane, Windows, Linux ve macOS dahil, Azure App Services, Azure Fonksiyonları ve konteyner örnekleri üzerinde kurulumdan hemen sonra çalışır.

NuGet Paket Yöneticisi Konsolu'nu açın ve şunu çalıştırın:

Install-Package IronXL.Excel

IronXL, .NET Framework 4.6.2+ ve modern .NET sürümlerinin tümünü .NET 10'a kadar destekler. Kurulumdan sonra, dosyanızın üstüne using IronXL; ekleyin ve dışa aktarmaya hazırsınız.

Interop Kullanarak C# ile DataTable'ı Excel'e Nasıl Aktarırsınız?

Geleneksel yaklaşım, Excel'i doğrudan otomatikleştirmek için Microsoft.Office.Interop.Excel ad alanını kullanır. Bu yöntem, kodun çalıştığı makinede Microsoft Excel yüklü olmasını gerektirir.

Interop için Gereksinimler

Interop'u kullanmadan önce, emin olun ki:

  1. Microsoft Excel, geliştirme ve dağıtım makinelerinde yüklüdür.
  2. Visual Studio'da "Microsoft Excel Nesne Kütüphanesi"ne bir COM referansı eklenmiştir.
  3. Projenize Microsoft.Office.Interop.Excel ad alanı dahil edilmiştir.

Interop İhracat Kodu

Aşağıdaki kod, en üst düzey ifadelerle C#'da Microsoft Office Interop kullanarak bir DataTable'yi Excel dosyasına nasıl dışa aktaracağınızı göstermektedir:

using Microsoft.Office.Interop.Excel;
using System.Data;
using System.Runtime.InteropServices;

// Create a sample DataTable with employee data
DataTable dt = new DataTable("Employees");
dt.Columns.Add("EmployeeID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));
dt.Columns.Add("Salary", typeof(decimal));

dt.Rows.Add(1, "John Smith", "Engineering", 75000);
dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
dt.Rows.Add(3, "Michael Chen", "Finance", 70000);
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

// Initialize Excel Application object
Application excelApp = new Application
{
    Visible = false,
    DisplayAlerts = false
};

Workbook workbook = excelApp.Workbooks.Add();
Worksheet worksheet = (Worksheet)workbook.ActiveSheet;

try
{
    // Write column headers to the first row
    for (int i = 0; i < dt.Columns.Count; i++)
    {
        worksheet.Cells[1, i + 1] = dt.Columns[i].ColumnName;
    }

    // Write data rows starting from row 2
    for (int i = 0; i < dt.Rows.Count; i++)
    {
        for (int j = 0; j < dt.Columns.Count; j++)
        {
            worksheet.Cells[i + 2, j + 1] = dt.Rows[i][j].ToString();
        }
    }

    string filePath = @"C:\Reports\EmployeeReport_Interop.xlsx";
    workbook.SaveAs(filePath);
    Console.WriteLine("Excel file created using Interop.");
}
catch (Exception ex)
{
    Console.WriteLine("Error: " + ex.Message);
}
finally
{
    // Always release COM objects to prevent orphaned Excel processes
    workbook.Close();
    excelApp.Quit();
    Marshal.ReleaseComObject(worksheet);
    Marshal.ReleaseComObject(workbook);
    Marshal.ReleaseComObject(excelApp);
}
using Microsoft.Office.Interop.Excel;
using System.Data;
using System.Runtime.InteropServices;

// Create a sample DataTable with employee data
DataTable dt = new DataTable("Employees");
dt.Columns.Add("EmployeeID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));
dt.Columns.Add("Salary", typeof(decimal));

dt.Rows.Add(1, "John Smith", "Engineering", 75000);
dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
dt.Rows.Add(3, "Michael Chen", "Finance", 70000);
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

// Initialize Excel Application object
Application excelApp = new Application
{
    Visible = false,
    DisplayAlerts = false
};

Workbook workbook = excelApp.Workbooks.Add();
Worksheet worksheet = (Worksheet)workbook.ActiveSheet;

try
{
    // Write column headers to the first row
    for (int i = 0; i < dt.Columns.Count; i++)
    {
        worksheet.Cells[1, i + 1] = dt.Columns[i].ColumnName;
    }

    // Write data rows starting from row 2
    for (int i = 0; i < dt.Rows.Count; i++)
    {
        for (int j = 0; j < dt.Columns.Count; j++)
        {
            worksheet.Cells[i + 2, j + 1] = dt.Rows[i][j].ToString();
        }
    }

    string filePath = @"C:\Reports\EmployeeReport_Interop.xlsx";
    workbook.SaveAs(filePath);
    Console.WriteLine("Excel file created using Interop.");
}
catch (Exception ex)
{
    Console.WriteLine("Error: " + ex.Message);
}
finally
{
    // Always release COM objects to prevent orphaned Excel processes
    workbook.Close();
    excelApp.Quit();
    Marshal.ReleaseComObject(worksheet);
    Marshal.ReleaseComObject(workbook);
    Marshal.ReleaseComObject(excelApp);
}
Imports Microsoft.Office.Interop.Excel
Imports System.Data
Imports System.Runtime.InteropServices

' Create a sample DataTable with employee data
Dim dt As New DataTable("Employees")
dt.Columns.Add("EmployeeID", GetType(Integer))
dt.Columns.Add("Name", GetType(String))
dt.Columns.Add("Department", GetType(String))
dt.Columns.Add("Salary", GetType(Decimal))

dt.Rows.Add(1, "John Smith", "Engineering", 75000)
dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000)
dt.Rows.Add(3, "Michael Chen", "Finance", 70000)
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000)

' Initialize Excel Application object
Dim excelApp As New Application With {
    .Visible = False,
    .DisplayAlerts = False
}

Dim workbook As Workbook = excelApp.Workbooks.Add()
Dim worksheet As Worksheet = CType(workbook.ActiveSheet, Worksheet)

Try
    ' Write column headers to the first row
    For i As Integer = 0 To dt.Columns.Count - 1
        worksheet.Cells(1, i + 1) = dt.Columns(i).ColumnName
    Next

    ' Write data rows starting from row 2
    For i As Integer = 0 To dt.Rows.Count - 1
        For j As Integer = 0 To dt.Columns.Count - 1
            worksheet.Cells(i + 2, j + 1) = dt.Rows(i)(j).ToString()
        Next
    Next

    Dim filePath As String = "C:\Reports\EmployeeReport_Interop.xlsx"
    workbook.SaveAs(filePath)
    Console.WriteLine("Excel file created using Interop.")
Catch ex As Exception
    Console.WriteLine("Error: " & ex.Message)
Finally
    ' Always release COM objects to prevent orphaned Excel processes
    workbook.Close()
    excelApp.Quit()
    Marshal.ReleaseComObject(worksheet)
    Marshal.ReleaseComObject(workbook)
    Marshal.ReleaseComObject(excelApp)
End Try
$vbLabelText   $csharpLabel

Application nesnesi, Excel işleminin kendisini temsil eder. Visible = false ayarlanarak Excel'in işlem sırasında ekranda açılması engellenir, bu da arka plan işlemleri için önemlidir. DisplayAlerts = false ayarı, otomatik iş akışlarını kesintiye uğratacak iletişim kutularını bastırır.

finally bloğu isteğe bağlı değildir -- her COM nesnesini açıkça Marshal.ReleaseComObject kullanarak serbest bırakmak zorundadır. Bu adımı atlamak, Görev Yöneticisi'nde yetim Excel süreçlerini bırakır ve belleği tüketir, sonunda sunucunun istikrarını bozar. Bu temizleme deseni, web uygulamaları ve hizmetler için Interop'u uygun olmayan bir hale getiren ünlü bir sıkıntı noktasıdır.

IronXL Kullanarak DataTable'yi Excel'e Nasıl İhraç Ederiz?

IronXL herhangi bir Office kurulumu olmadan çalışan modern bir alternatif sunar. Kütüphane Excel dosyalarını doğrudan okur ve yazar, bu da onu sunucu ortamları, bulut dağıtımları ve çapraz platform uygulamaları için ideal hale getirir. Daha fazla API detayı için tam IronXL belgelerine bakın.

IronXL İhracat Kodu

Aşağıdaki kod, en üst düzey ifadelerle IronXL kütüphanesini kullanarak bir DataTable'yi Excel dosyasına nasıl dönüştüreceğinizi göstermektedir:

using IronXL;
using System.Data;

// Create a sample DataTable
DataTable dt = new DataTable("Employees");
dt.Columns.Add("EmployeeID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));
dt.Columns.Add("Salary", typeof(decimal));

dt.Rows.Add(1, "John Smith", "Engineering", 75000);
dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
dt.Rows.Add(3, "Michael Chen", "Finance", 70000);
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

// Create a new Excel workbook
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Employees");

// Write column headers to row 0
for (int i = 0; i < dt.Columns.Count; i++)
{
    sheet.SetCellValue(0, i, dt.Columns[i].ColumnName);
}

// Export DataTable rows to Excel cells
for (int i = 0; i < dt.Rows.Count; i++)
{
    for (int j = 0; j < dt.Columns.Count; j++)
    {
        sheet.SetCellValue(i + 1, j, dt.Rows[i][j]);
    }
}

string filePath = @"C:\Reports\EmployeeReport_IronXL.xlsx";
workbook.SaveAs(filePath);
Console.WriteLine("Excel file created using IronXL.");
using IronXL;
using System.Data;

// Create a sample DataTable
DataTable dt = new DataTable("Employees");
dt.Columns.Add("EmployeeID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));
dt.Columns.Add("Salary", typeof(decimal));

dt.Rows.Add(1, "John Smith", "Engineering", 75000);
dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
dt.Rows.Add(3, "Michael Chen", "Finance", 70000);
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

// Create a new Excel workbook
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Employees");

// Write column headers to row 0
for (int i = 0; i < dt.Columns.Count; i++)
{
    sheet.SetCellValue(0, i, dt.Columns[i].ColumnName);
}

// Export DataTable rows to Excel cells
for (int i = 0; i < dt.Rows.Count; i++)
{
    for (int j = 0; j < dt.Columns.Count; j++)
    {
        sheet.SetCellValue(i + 1, j, dt.Rows[i][j]);
    }
}

string filePath = @"C:\Reports\EmployeeReport_IronXL.xlsx";
workbook.SaveAs(filePath);
Console.WriteLine("Excel file created using IronXL.");
Imports IronXL
Imports System.Data

' Create a sample DataTable
Dim dt As New DataTable("Employees")
dt.Columns.Add("EmployeeID", GetType(Integer))
dt.Columns.Add("Name", GetType(String))
dt.Columns.Add("Department", GetType(String))
dt.Columns.Add("Salary", GetType(Decimal))

dt.Rows.Add(1, "John Smith", "Engineering", 75000)
dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000)
dt.Rows.Add(3, "Michael Chen", "Finance", 70000)
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000)

' Create a new Excel workbook
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Employees")

' Write column headers to row 0
For i As Integer = 0 To dt.Columns.Count - 1
    sheet.SetCellValue(0, i, dt.Columns(i).ColumnName)
Next

' Export DataTable rows to Excel cells
For i As Integer = 0 To dt.Rows.Count - 1
    For j As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(i + 1, j, dt.Rows(i)(j))
    Next
Next

Dim filePath As String = "C:\Reports\EmployeeReport_IronXL.xlsx"
workbook.SaveAs(filePath)
Console.WriteLine("Excel file created using IronXL.")
$vbLabelText   $csharpLabel

IronXL yaklaşımı benzer bir mantıksal yapıyı takip eder ancak daha temiz bir sözdizimi ve COM karmaşıklığı olmadan. WorkBook.Create metodu, belirtilen formatta yeni bir çalışma kitabı başlatır -- ExcelFileFormat.XLSX, Excel 2007 ve sonrası ile uyumlu modern Office Open XML dosyaları üretir. Kütüphane ayrıca eski sistemler için XLS'i de destekler.

SetCellValue, standart .NET konvansiyonlarına uygun 0 bazlı indeksler kullanır, bu da indeks sistemleri arasında dönüştürme yaparken yaygın olarak oluşan bir eksik hatalarını azaltır. Metod, tür dönüşümünü otomatik olarak ele alır: tamsayı, string, ondalık ve DateTime değerleri uygun Excel hücre tipleri ile yazılır.

Temizlik kodunun tamamen yokluğuna dikkat edin. IronXL nesneleri, çöp toplayıcının otomatik olarak işlediği standart .NET yönetilen nesneleridir. Yetim süreçler veya yönetilecek COM referans sayma riski yoktur.

DataTable'ı C#'ta Excel'e Dışa Aktarma Interop vs IronXL: Resim 1 - Excel Çıktısı

DataTable'ı C#'ta Excel'e Dışa Aktarma Interop vs IronXL: Resim 2 - Konsol Çıktısı

Çalışma kitabı oluşturma hakkında daha fazla ayrıntı için bkz. IronXL çalışma kitabı oluşturma kılavuzu.

Yeniden Kullanılabilir Bir Aktarma Yöntemini Nasıl Oluşturabilirsiniz?

Üretim uygulamaları, genellikle herhangi bir DataTable'yi Excel dosyasına dışa aktarabilecek yeniden kullanılabilir bir yönteme ihtiyaç duyar. Aşağıdaki örnek, dışa aktarma mantığını kapsayan, null değerleri ele alan ve çıkış dizinini mevcut değilse otomatik olarak oluşturan bir yardımcının nasıl çalıştığını göstermektedir. Daha fazla model için IronXL örnekler sayfasını inceleyin.

Yeniden Kullanılabilir IronXL Aktarma Yardımcısı

using IronXL;
using IronXL.Styles;
using System;
using System.Data;
using System.IO;

// --- ExcelExporter helper ---

bool ExportToExcel(DataTable dt, string filePath)
{
    if (dt == null || dt.Rows.Count == 0)
        return false;

    try
    {
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet sheet = workbook.CreateWorkSheet(dt.TableName ?? "Sheet1");

        // Bold headers in the first row
        for (int i = 0; i < dt.Columns.Count; i++)
        {
            var cell = sheet.GetCellAt(0, i);
            cell.Value = dt.Columns[i].ColumnName;
            cell.Style.Font.Bold = true;
        }

        // Data rows
        for (int i = 0; i < dt.Rows.Count; i++)
        {
            for (int j = 0; j < dt.Columns.Count; j++)
            {
                var value = dt.Rows[i][j];
                sheet.SetCellValue(
                    i + 1, j,
                    (value == DBNull.Value || value == null) ? "" : value
                );
            }
        }

        FileInfo fileInfo = new FileInfo(filePath);
        if (!fileInfo.Directory!.Exists)
            fileInfo.Directory.Create();

        workbook.SaveAs(filePath);
        return true;
    }
    catch (Exception ex)
    {
        Console.WriteLine("Export failed: " + ex.Message);
        return false;
    }
}

// --- Usage ---

DataTable employees = new DataTable("Employees");
employees.Columns.Add("EmployeeID", typeof(int));
employees.Columns.Add("Name", typeof(string));
employees.Columns.Add("Department", typeof(string));
employees.Rows.Add(1, "John Smith", "Engineering");
employees.Rows.Add(2, "Sarah Johnson", "Marketing");

bool success = ExportToExcel(employees, @"C:\Reports\Export.xlsx");
Console.WriteLine(success ? "Export completed." : "Export failed.");
using IronXL;
using IronXL.Styles;
using System;
using System.Data;
using System.IO;

// --- ExcelExporter helper ---

bool ExportToExcel(DataTable dt, string filePath)
{
    if (dt == null || dt.Rows.Count == 0)
        return false;

    try
    {
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet sheet = workbook.CreateWorkSheet(dt.TableName ?? "Sheet1");

        // Bold headers in the first row
        for (int i = 0; i < dt.Columns.Count; i++)
        {
            var cell = sheet.GetCellAt(0, i);
            cell.Value = dt.Columns[i].ColumnName;
            cell.Style.Font.Bold = true;
        }

        // Data rows
        for (int i = 0; i < dt.Rows.Count; i++)
        {
            for (int j = 0; j < dt.Columns.Count; j++)
            {
                var value = dt.Rows[i][j];
                sheet.SetCellValue(
                    i + 1, j,
                    (value == DBNull.Value || value == null) ? "" : value
                );
            }
        }

        FileInfo fileInfo = new FileInfo(filePath);
        if (!fileInfo.Directory!.Exists)
            fileInfo.Directory.Create();

        workbook.SaveAs(filePath);
        return true;
    }
    catch (Exception ex)
    {
        Console.WriteLine("Export failed: " + ex.Message);
        return false;
    }
}

// --- Usage ---

DataTable employees = new DataTable("Employees");
employees.Columns.Add("EmployeeID", typeof(int));
employees.Columns.Add("Name", typeof(string));
employees.Columns.Add("Department", typeof(string));
employees.Rows.Add(1, "John Smith", "Engineering");
employees.Rows.Add(2, "Sarah Johnson", "Marketing");

bool success = ExportToExcel(employees, @"C:\Reports\Export.xlsx");
Console.WriteLine(success ? "Export completed." : "Export failed.");
Imports IronXL
Imports IronXL.Styles
Imports System
Imports System.Data
Imports System.IO

' --- ExcelExporter helper ---

Function ExportToExcel(dt As DataTable, filePath As String) As Boolean
    If dt Is Nothing OrElse dt.Rows.Count = 0 Then
        Return False
    End If

    Try
        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        Dim sheet As WorkSheet = workbook.CreateWorkSheet(If(dt.TableName, "Sheet1"))

        ' Bold headers in the first row
        For i As Integer = 0 To dt.Columns.Count - 1
            Dim cell = sheet.GetCellAt(0, i)
            cell.Value = dt.Columns(i).ColumnName
            cell.Style.Font.Bold = True
        Next

        ' Data rows
        For i As Integer = 0 To dt.Rows.Count - 1
            For j As Integer = 0 To dt.Columns.Count - 1
                Dim value = dt.Rows(i)(j)
                sheet.SetCellValue(i + 1, j, If(value Is DBNull.Value OrElse value Is Nothing, "", value))
            Next
        Next

        Dim fileInfo As New FileInfo(filePath)
        If Not fileInfo.Directory.Exists Then
            fileInfo.Directory.Create()
        End If

        workbook.SaveAs(filePath)
        Return True
    Catch ex As Exception
        Console.WriteLine("Export failed: " & ex.Message)
        Return False
    End Try
End Function

' --- Usage ---

Dim employees As New DataTable("Employees")
employees.Columns.Add("EmployeeID", GetType(Integer))
employees.Columns.Add("Name", GetType(String))
employees.Columns.Add("Department", GetType(String))
employees.Rows.Add(1, "John Smith", "Engineering")
employees.Rows.Add(2, "Sarah Johnson", "Marketing")

Dim success As Boolean = ExportToExcel(employees, "C:\Reports\Export.xlsx")
Console.WriteLine(If(success, "Export completed.", "Export failed."))
$vbLabelText   $csharpLabel

ExportToExcel yardımcısı herhangi bir DataTable ve bir dosya yolu dizesini kabul eder, eğer dışa aktarma başarısız olursa veya tablo boşsa false döner. Eksik değerleri hücreleri yazmadan önce DBNull.Value kontrol ederek zarif bir şekilde ele alır. Dizin oluşturma adımı, yeni ortamlar için dağıtım yaparken yaygın üretim sorunlarından biri olan yeni klasör yollarına planlı dışa aktarmaları kesintiye uğratmaktan DirectoryNotFoundException ile korur.

Kalın başlıklar, ek ayarlara ihtiyaç duymadan profesyonel görünümlü bir çıkış üreten cell.Style.Font.Bold = true kullanılarak uygulanır. Desen genişletmesi kolaydır: arka plan renkleri, sınırlar veya sütun genişliği otomatik ayarlamayı ekleyerek kuruluşunuzun raporlama standartlarına uygun hale getirin.

Büyük veri kümeleri ile çalışmak için IronXL performans kılavuzu, bellek tahsisini minimize eden toplu yazma stratejilerini kapsar. Kütüphane ayrıca bir DataSet -- ilgili DataTable nesnelerinin koleksiyonu -- tek bir çalışma kitabında birden çok yaprağa dışa aktarmayı da destekler, bu çok sayfalı raporlar için yararlıdır.

Her İki Yaklaşım Hücre Biçimlendirmesini Nasıl Ele Alır?

Profesyonel Excel aktarımları genellikle biçimlendirme gerektirir: kalın başlıklar, renkli hücreler, sınırlar ve sayı formatları. Her iki kütüphane de stillendirmeyi destekler, ancak uygulama anlamında kelime fazlalığı ve güvenilirlik açısından önemli ölçüde farklılık gösterir.

IronXL ile Biçimlendirme

using IronXL;
using IronXL.Styles;
using System.Data;

DataTable dt = new DataTable("Sales");
dt.Columns.Add("Product", typeof(string));
dt.Columns.Add("Revenue", typeof(decimal));
dt.Rows.Add("Widget A", 15000.50m);
dt.Rows.Add("Widget B", 22500.75m);

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Sales");

// Write headers with light blue background and bold font
for (int i = 0; i < dt.Columns.Count; i++)
{
    var cell = sheet.GetCellAt(0, i);
    cell.Value = dt.Columns[i].ColumnName;
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#ADD8E6");
    cell.Style.BottomBorder.SetColor("#000000");
    cell.Style.BottomBorder.Type = BorderType.Thin;
}

// Write data rows
for (int i = 0; i < dt.Rows.Count; i++)
{
    for (int j = 0; j < dt.Columns.Count; j++)
    {
        sheet.SetCellValue(i + 1, j, dt.Rows[i][j]);
    }
}

workbook.SaveAs(@"C:\Reports\FormattedReport_IronXL.xlsx");
Console.WriteLine("Formatted Excel file created.");
using IronXL;
using IronXL.Styles;
using System.Data;

DataTable dt = new DataTable("Sales");
dt.Columns.Add("Product", typeof(string));
dt.Columns.Add("Revenue", typeof(decimal));
dt.Rows.Add("Widget A", 15000.50m);
dt.Rows.Add("Widget B", 22500.75m);

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Sales");

// Write headers with light blue background and bold font
for (int i = 0; i < dt.Columns.Count; i++)
{
    var cell = sheet.GetCellAt(0, i);
    cell.Value = dt.Columns[i].ColumnName;
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#ADD8E6");
    cell.Style.BottomBorder.SetColor("#000000");
    cell.Style.BottomBorder.Type = BorderType.Thin;
}

// Write data rows
for (int i = 0; i < dt.Rows.Count; i++)
{
    for (int j = 0; j < dt.Columns.Count; j++)
    {
        sheet.SetCellValue(i + 1, j, dt.Rows[i][j]);
    }
}

workbook.SaveAs(@"C:\Reports\FormattedReport_IronXL.xlsx");
Console.WriteLine("Formatted Excel file created.");
Imports IronXL
Imports IronXL.Styles
Imports System.Data

Dim dt As New DataTable("Sales")
dt.Columns.Add("Product", GetType(String))
dt.Columns.Add("Revenue", GetType(Decimal))
dt.Rows.Add("Widget A", 15000.50D)
dt.Rows.Add("Widget B", 22500.75D)

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Sales")

' Write headers with light blue background and bold font
For i As Integer = 0 To dt.Columns.Count - 1
    Dim cell = sheet.GetCellAt(0, i)
    cell.Value = dt.Columns(i).ColumnName
    cell.Style.Font.Bold = True
    cell.Style.SetBackgroundColor("#ADD8E6")
    cell.Style.BottomBorder.SetColor("#000000")
    cell.Style.BottomBorder.Type = BorderType.Thin
Next

' Write data rows
For i As Integer = 0 To dt.Rows.Count - 1
    For j As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(i + 1, j, dt.Rows(i)(j))
    Next
Next

workbook.SaveAs("C:\Reports\FormattedReport_IronXL.xlsx")
Console.WriteLine("Formatted Excel file created.")
$vbLabelText   $csharpLabel

IronXL'in stillendirme API'si temiz bir nesne modeli kullanır. Renk değerleri, yaygın kurumsal markalama ile örtüşmesini sağlayan #ADD8E6 (açık mavi) gibi standart hex kodlarını kabul eder, böylece renk sistemleri arasında dönüştürme yapmadan kolayca uyumlaştırılabilir. BorderType.Thin ve BorderType.Thick, numaralandırma aramalarına ihtiyaç duymadan standart sınır senaryolarını kapsar.

DataTable'ı C#'ta Excel'e Dışa Aktarma Interop vs IronXL: Resim 3 - IronXL Çıktısıyla Biçimlendirme

Sayı formatları, koşullu biçimlendirme ve hücre birleştirme dahil tüm stillendirme seçenekleri için bkz. IronXL hücre stillendirme kılavuzu ve sınır ve hizalama dokümantasyonu.

Interop Biçimlendirme Karmaşıklığı

Interop eşdeğeri, bireysel Range nesnelerine erişir ve Font.Bold, Interior.Color ve Borders.LineStyle gibi özellikleri ayarlar. Her özellik erişimi bir COM süreçler arası çağrı olup, bu da ek yük ekler ve Excel yanıtsız hale gelirse istisnalarla karşılaşma olasılığını artırır. Renk değerleri System.Drawing.ColorTranslator.ToOle dönüşümü gerektirir ve her stil bloğu standart COM temizleme zinciri ile takip edilmelidir -- en az üç Marshal.ReleaseComObject çağrısı gerektirir.

Bu kelime fazlalığı, büyük çalışma sayfalarında koşullu biçimlendirme, sütun genişlikleri veya sayı formatları uygularken problemli hale gelir. IronXL, aynı senaryoları daha az kod satırıyla ve bir çökme sonrasında Excel süreçlerini çalışır durumda bırakma riski olmadan ele alır.

.NET İçin Excel Aktarma İçin En İyi Uygulamalar Nelerdir?

Aktarım rutinlerinde tutarlı uygulamalar izlemek hataları azaltır, bakım kolaylığını artırır ve kodunuzun test edilmesi ve dağıtılması kolaylaşır.

Adlandırma ve Yol Kuralları

Dışa aktarılan dosyalar için tutarlı bir adlandırma sözleşmesi kullanın: {ReportName}_{Timestamp}.xlsx. Tahmin edilebilir dosya adları, otomatik temizleme ve arşivlemeyi kolaylaştırır. Çıkış dizinini, yolları sabitlemek yerine uygulama konfigürasyonunda saklayın -- bu, yeni ortamlara dağıtım yaparken DirectoryNotFoundException önler.

Hata Yönetimi

Tüm aktarım mantığını try-catch bloklarına sarın ve hatayı teşhis etmek için yeterli bağlamla istisnaları kaydedin. Zamanlanmış aktarımlar için, bir istisna atmak yerine bir sonuç nesnesi döndürmeyi düşünün, böylece çağıran hizmet çökmeden tekrar deneyebilir veya operatörleri uyarabilir. Yukarıdaki ExportToExcel yardımcısı, bu düzeni bool dönüş değeri ile göstermektedir.

Büyük Veri Kümeleri ile Çalışma

50.000'den fazla satıra sahip veri kümeleri için, bellek baskısını önlemek için verileri gruplar halinde aktarın. IronXL, aşamalı yazıları destekler ve OpenXML SDK çok büyük dosyalar için düşük seviye akış sağlar. Interop'u büyük veri kümeleri için tamamen önleyin -- bellek içi modeli, büyük ölçekte önemli yavaşlamalara neden olur.

Çapraz Platform Dağıtımı

Uygulama Linux veya macOS üzerinde çalışıyorsa -- örneğin Docker konteynerlerinde veya Azure Linux Uygulama Hizmetlerinde -- IronXL tek uygulanabilir seçenektir. Interop, Excel COM sunucusuna bağımlı olduğundan Windows dışındaki sistemlerde çalışmaz. .NET çapraz platform dağıtım kılavuzunu kullanarak tüm bağımlılıkların hedef çalışma zamanında mevcut olduğunu doğrulayın.

Test Etme

Aktarım mantığı için birim testleri, çıktı dosyasının varlığını, beklenen satır sayısını ve doğru sütun adlarının kullanıldığını doğrulamalıdır. IronXL'nin WorkBook.Load metodu, Excel'i başlatmadan testlerde dışa aktarılan dosyaları yeniden okumayı kolaylaştırır. Örnekler için bkz. IronXL okuma kılavuzu.

Her Yaklaşımı Ne Zaman Seçmelisiniz?

Doğru tercih, projenin özel gereksinimlerine, dağıtım ortamına ve uzun vadeli bakım hususlarına bağlıdır.

Microsoft Office Excel Interop'u seçin:

  • Halihazırda Interop'a dayanan eski sistemlerde çalışırken ve geçiş mümkün değilse.
  • Makrolar, pivot tabloları veya grafik otomasyonu gibi gelişmiş Excel özellikleri tam Excel uygulama nesne modelini gerektiriyorsa.
  • Kullanıcıların Microsoft Excel yüklü olduğu masaüstü uygulamaları oluştururken ve uygulama etkileşimli olarak çalışıyorsa.
  • Dağıtım ortamı tamamen kontrol altında, yalnızca Windows'ta ve Office lisansları zaten mevcut durumda ise.
  • Karmaşık gömülü formüller veya VBA kodu içeren mevcut Excel şablonlarını otomatikleştirirken.

IronXL'u seçin:

  • Excel dosya aktarımları üreten web uygulamaları, REST API'leri veya arka plan servisleri oluştururken.
  • Azure App Services, AWS Lambda veya Docker konteynerleri gibi bulut ortamlarına dağıtırken.
  • Windows, Linux veya macOS dağıtımları için çapraz platform desteğe ihtiyaç duyuyorsanız.
  • Interop desteği sınırlı olan .NET Framework 4.6.2+ veya modern .NET sürümleriyle çalışırken.
  • COM temizleme endişeleri olmadan güvenilir kaynak yönetimine ihtiyaç duyuyorsanız.
  • Üretim sunucularında Office lisans bağımlılıklarını önlemek istiyorsanız.
  • İzole edilmiş Excel dosya üretimi gerektiren çok kiracılı uygulamalar oluştururken.
  • COM süreçler arası iletişimin getirdiği maliyet olmaksızın büyük veri kümelerini verimli bir şekilde işlerken.
  • XLSX, XLS, CSV, JSON ve XML gibi birden fazla formata dışa aktarıma ihtiyaç duyulduğunda.

IronXL öğreticilerini diğer senaryolar için keşfedin, örneğin mevcut Excel dosyalarını okuma, formüllerle çalışma ve birden fazla çalışma sayfasını yönetme.

Sonraki Adımlarınız Neler?

Bir DataTable'yi Excel dosyasına dışa aktarmak, iş verilerini işleyen .NET uygulamaları için temel bir gerekliliktir. Kaynak bir veritabanı sorgusu, birden çok ilişkili tablo içeren bir DataSet veya dinamik olarak oluşturulmuş bir hafıza içi koleksiyon olsun, doğru kütüphane seçimi dağıtım esnekliği ve uzun vadeli sürdürülebilirliği belirler.

Microsoft Office Excel Interop yıllardır geliştiricilere hizmet vermektedir, ancak Office kurulumu bağımlılığı, COM karmaşıklığı, desteklenmeyen sunucu senaryoları ve kaynak yönetim zorlukları, modern uygulama geliştirme için giderek daha az pratik hale geldikçe sorun oluşturur.

IronXL, bu sınırlamaları ele alan daha temiz bir alternatif sunar. Basit bir NuGet kurulumu, Windows, Linux ve macOS'u kapsayan çapraz platform desteği ve .NET geleneklerini takip eden basit API'ları ile, Excel Interop çözümlerini etkileyen dağıtım baş ağrıları ve kaynak yönetimi tuzaklarını ortadan kaldırır.

Başlamak için, IronXL'yi NuGet üzerinden yükleyin, yukarıdaki kod örneklerinden birini kopyalayın ve test DataTable'dan hızlı bir dışa aktarma yapın. IronXL hızlı başlangıç kılavuzu en yaygın senaryoları birkaç dakika içinde kapsar. Üretime hazır olduğunuzda, IronXL lisanslama sayfasını inceleyin ve ekip büyüklüğünüze ve dağıtım modelinize uygun seçeneği bulun. Daha fazla keşif için, kapsamlı IronXL API referansını ve topluluk örnekleri için IronXL GitHub deposunu keşfedin.

Sıkça Sorulan Sorular

C#'da DataTable'ları aktarırken IronXL'nin Excel Interop'a göre birincil avantajı nedir?

IronXL, DataTable'ları Excel'e aktarmanın daha basit ve verimli bir yolunu sunar, sunucuda Excel kurulu olmasını gerektirmeden.

IronXL, Excel'e büyük DataTable'ları aktarırken yönetebilir mi?

Evet, IronXL, performans için optimize edilmiştir ve büyük DataTable'ları yönetebilir, Excel dosyalarına hızlı ve güvenilir aktarım sağlar.

Veri aktarmak için IronXL kullanmak için Microsoft Excel'in kurulu olması gerekiyor mu?

Hayır, IronXL, kurulum gerektirmez, bu da sunucu tarafı uygulamalar için idealdir.

IronXL, Interop'a kıyasla DataTable'ları aktarma sürecini nasıl basitleştirir?

IronXL, Interop ile ilişkili karmaşık kurulum ve bağımlılıkları ortadan kaldırarak DataTable'ları aktarmak için doğrudan bir API sunar.

IronXL, DataTable'ları Excel'e aktarmak için .NET core ile uyumlu mu?

Evet, IronXL, .NET Core ile tamamen uyumludur, böylece çapraz platform uygulamalarında DataTable'ları Excel'e aktarabilirsiniz.

IronXL hangi dosya formatlarına DataTable'ları aktarabilir?

IronXL, çeşitli Excel dosya formatlarına, örneğin XLSX, XLS ve CSV'ye DataTable'ları aktarabilir.

IronXL, Excel sayfalarının stil ve formatlamasını destekliyor mu?

Evet, IronXL, DataTable'lardan profesyonel görünüşlü Excel sayfaları oluşturmanıza olanak tanıyan gelişmiş stil ve formatlama seçeneklerini destekler.

IronXL'yi C#'da Excel ile ilgili görevleri otomatikleştirmek için kullanabilir miyim?

Evet, IronXL, DataTable'ları aktarma gibi geniş bir Excel ile ilgili görev yelpazesini otomatikleştirmek için kullanılabilir.

IronXL'ye yeni başlayan geliştiriciler için bir öğrenme eğrisi var mı?

IronXL, sezgisel ve öğrenmesi kolay olacak şekilde tasarlanmıştır, geliştiricilerin hızlıca başlamasına yardım etmek için kapsamlı belgeler ve örnekler sunar.

IronXL'yi ticari bir projede kullanmak için lisanslama seçenekleri nelerdir?

IronXL, ticari kullanım için süresiz ve abonelik lisans seçenekleri dahil farklı proje ihtiyaçlarına uygun çeşitli lisanslama seçenekleri sunar.

Curtis Chau
Curtis Chau
  Mühendislik ekibiyle şimdi sohbet edin
Teknik Yazar

Curtis Chau, Bilgisayar Bilimleri alanında Lisans Derecesine (Carleton Üniversitesi) sahip ve Node.js, TypeScript, JavaScript ve React konularında uzmanlaşmış ön uç geliştirmeyle ilgileniyor. Sezgisel ve estetik açıdan hoş kullanıcı arayüzleri oluşturma tutkunu, Curtis modern çerçevelerle çalışmayı ve iyi yapı...

Daha Fazla Oku

İlgili Makaleler

30 günlük deneme → Tam ürün. Sınırsız. Kart gerektirmez. Ücretsiz Denemeye Başlayın

Iron Destek Ekibi

Haftada 5 gün, 24 saat çevrimiçiyiz.
Sohbet
E-posta
Beni Ara