C#'da Excel Pivot Tablosu Nasıl Oluşturulur?
C# ile Excel pivot tabloları oluşturmak, Microsoft Office kurulumu gerektiren Office Interop veya bağımsız çalışan modern kütüphanelerle mümkündür. IronXL, üstün dağıtım esnekliği ve çapraz platform desteği sunarak DevOps ortamlarında çalışmalar sağlar.
Pivot tabloları programatik olarak oluşturmak, ya Office bağımlılıkları ile C# Interop gerektirir ya da bağımsız çalışan IronXL gibi modern kütüphaneler gerektirir. Bu eğitim, geliştiricilerin özellikle Docker konteynerlerine veya Azure ve AWS gibi bulut ortamlarına dağıtım yaparken giderek daha fazla IronXL'i neden geleneksel Interop yöntemlerine tercih ettiklerini vurgulayarak her iki yaklaşımı da gösterir.
Bu makalede, pivot tabloları ve grupları otomatik analiz ve hata yönetimi ile nasıl düzenleyeceğimizi, oluşturacağımızı, tasarlayacağımızı ve hesaplayacağımızı öğreneceğiz - tüm bunlar, dağıtım basitliğini sağlayarak DevOps mühendislerinin ihtiyaç duyduğu şekilde gerçekleşir.
Excel Pivot Tablosu Nedir?
Pivot tablosu, Excel'in en güçlü araçlarından biridir. .NET uygulamalarında veri analizi için vazgeçilmez kılan geniş veri setlerini özetlemenin kolay bir yoludur. Pivot tablolar, sayısal verileri kolayca görüntülemenizi, anlamanızı ve analiz etmenizi sağlar. Bunlar yalnızca Excel'de değil, aynı zamanda Google Sheets, Apple Numbers ve CSV Dışa Aktarımlarında da mevcuttur. Verileri genel olarak görme çözümü sunarlar - kişilerin bilgilerini anlamlı bir şekilde görmelerine izin veren bir veri konsolu gibi hareket ederler.
Konteynırlı uygulamalar için, pivot tabloları programatik olarak oluşturmak, Docker imajlarınıza Excel kurulumlarını ekleme ihtiyacını ortadan kaldırarak, konteyner boyutunu ve dağıtım karmaşıklığını önemli ölçüde azaltır. Bu yaklaşım, modern CI/CD boru hatları ve konteynır dağıtım stratejileri ile mükemmel bir uyum sağlar.
Gelin, bir pivot tablo yapmanın yanlış yolunu inceleyelim, ardından C# ile doğru yolu öğrenelim:
C# Interop Kullanarak Excel Tablosunda Pivot Tablosu Nasıl Oluşturulur?
C# Excel Interop, Excel'in pivot tablo işlevselliğine COM otomasyonu ile doğrudan erişim sağlar. İşte C#'de pivot tablolar oluşturmak için araç arayan birçok geliştiricinin karşılaştığı geleneksel yaklaşım:
Bu Yaklaşım .NET'te Neden Demode Olarak Kabul Ediliyor?
using Excel = Microsoft.Office.Interop.Excel;
using System.Runtime.InteropServices;
// Create Excel application instance
Excel.Application xlApp = new Excel.Application();
Excel.Workbook xlWorkbook = xlApp.Workbooks.Open(@"C:\Data\SalesData.xlsx");
Excel.Worksheet xlSheet = (Excel.Worksheet)xlWorkbook.Sheets[1];
Excel.Worksheet xlPivotSheet = (Excel.Worksheet)xlWorkbook.Sheets.Add();
// Define data range for pivot table
Excel.Range dataRange = xlSheet.UsedRange;
// Row area and column area
// Create pivot cache and pivot table
Excel.PivotCache pivotCache = xlWorkbook.PivotCaches().Create(
Excel.XlPivotTableSourceType.xlDatabase,
dataRange,
Type.Missing);
Excel.PivotTable pivotTable = pivotCache.CreatePivotTable(
xlPivotSheet.Cells[3, 1],
"SalesPivot",
Type.Missing,
Type.Missing); // fields by field
// Configure pivot table fields
Excel.PivotField productField = (Excel.PivotField)pivotTable.PivotFields("Product");
productField.Orientation = Excel.XlPivotFieldOrientation.xlRowField;
productField.Position = 1;
Excel.PivotField regionField = (Excel.PivotField)pivotTable.PivotFields("Region");
regionField.Orientation = Excel.XlPivotFieldOrientation.xlColumnField;
regionField.Position = 1;
Excel.PivotField salesField = (Excel.PivotField)pivotTable.PivotFields("Sales");
pivotTable.AddDataField(salesField, "Sum of Sales", Excel.XlConsolidationFunction.xlSum);
// Save and cleanup
xlWorkbook.SaveAs(@"C:\Data\PivotReport.xlsx");
xlWorkbook.Close();
xlApp.Quit();
// Release COM objects to prevent memory leaks
Marshal.ReleaseComObject(pivotTable);
Marshal.ReleaseComObject(pivotCache);
Marshal.ReleaseComObject(xlPivotSheet);
Marshal.ReleaseComObject(xlSheet);
Marshal.ReleaseComObject(xlWorkbook);
Marshal.ReleaseComObject(xlApp);using Excel = Microsoft.Office.Interop.Excel;
using System.Runtime.InteropServices;
// Create Excel application instance
Excel.Application xlApp = new Excel.Application();
Excel.Workbook xlWorkbook = xlApp.Workbooks.Open(@"C:\Data\SalesData.xlsx");
Excel.Worksheet xlSheet = (Excel.Worksheet)xlWorkbook.Sheets[1];
Excel.Worksheet xlPivotSheet = (Excel.Worksheet)xlWorkbook.Sheets.Add();
// Define data range for pivot table
Excel.Range dataRange = xlSheet.UsedRange;
// Row area and column area
// Create pivot cache and pivot table
Excel.PivotCache pivotCache = xlWorkbook.PivotCaches().Create(
Excel.XlPivotTableSourceType.xlDatabase,
dataRange,
Type.Missing);
Excel.PivotTable pivotTable = pivotCache.CreatePivotTable(
xlPivotSheet.Cells[3, 1],
"SalesPivot",
Type.Missing,
Type.Missing); // fields by field
// Configure pivot table fields
Excel.PivotField productField = (Excel.PivotField)pivotTable.PivotFields("Product");
productField.Orientation = Excel.XlPivotFieldOrientation.xlRowField;
productField.Position = 1;
Excel.PivotField regionField = (Excel.PivotField)pivotTable.PivotFields("Region");
regionField.Orientation = Excel.XlPivotFieldOrientation.xlColumnField;
regionField.Position = 1;
Excel.PivotField salesField = (Excel.PivotField)pivotTable.PivotFields("Sales");
pivotTable.AddDataField(salesField, "Sum of Sales", Excel.XlConsolidationFunction.xlSum);
// Save and cleanup
xlWorkbook.SaveAs(@"C:\Data\PivotReport.xlsx");
xlWorkbook.Close();
xlApp.Quit();
// Release COM objects to prevent memory leaks
Marshal.ReleaseComObject(pivotTable);
Marshal.ReleaseComObject(pivotCache);
Marshal.ReleaseComObject(xlPivotSheet);
Marshal.ReleaseComObject(xlSheet);
Marshal.ReleaseComObject(xlWorkbook);
Marshal.ReleaseComObject(xlApp);Imports Excel = Microsoft.Office.Interop.Excel
Imports System.Runtime.InteropServices
' Create Excel application instance
Dim xlApp As New Excel.Application()
Dim xlWorkbook As Excel.Workbook = xlApp.Workbooks.Open("C:\Data\SalesData.xlsx")
Dim xlSheet As Excel.Worksheet = CType(xlWorkbook.Sheets(1), Excel.Worksheet)
Dim xlPivotSheet As Excel.Worksheet = CType(xlWorkbook.Sheets.Add(), Excel.Worksheet)
' Define data range for pivot table
Dim dataRange As Excel.Range = xlSheet.UsedRange
' Create pivot cache and pivot table
Dim pivotCache As Excel.PivotCache = xlWorkbook.PivotCaches().Create(Excel.XlPivotTableSourceType.xlDatabase, dataRange, Type.Missing)
Dim pivotTable As Excel.PivotTable = pivotCache.CreatePivotTable(xlPivotSheet.Cells(3, 1), "SalesPivot", Type.Missing, Type.Missing)
' Configure pivot table fields
Dim productField As Excel.PivotField = CType(pivotTable.PivotFields("Product"), Excel.PivotField)
productField.Orientation = Excel.XlPivotFieldOrientation.xlRowField
productField.Position = 1
Dim regionField As Excel.PivotField = CType(pivotTable.PivotFields("Region"), Excel.PivotField)
regionField.Orientation = Excel.XlPivotFieldOrientation.xlColumnField
regionField.Position = 1
Dim salesField As Excel.PivotField = CType(pivotTable.PivotFields("Sales"), Excel.PivotField)
pivotTable.AddDataField(salesField, "Sum of Sales", Excel.XlConsolidationFunction.xlSum)
' Save and cleanup
xlWorkbook.SaveAs("C:\Data\PivotReport.xlsx")
xlWorkbook.Close()
xlApp.Quit()
' Release COM objects to prevent memory leaks
Marshal.ReleaseComObject(pivotTable)
Marshal.ReleaseComObject(pivotCache)
Marshal.ReleaseComObject(xlPivotSheet)
Marshal.ReleaseComObject(xlSheet)
Marshal.ReleaseComObject(xlWorkbook)
Marshal.ReleaseComObject(xlApp)Bu Interop örneği, sıralar olarak Ürün, sütunlar olarak Bölge ve veri alanında Toplam Satış ile özgün bir Excel pivot tablosu oluşturur. İşlevsel olsa da, bu yaklaşım Microsoft Office kurulumu ve dikkatli COM nesne yönetimi gerektirir. Microsoft belgeleri, bu yaklaşımın neden modern olmadığını açıklar. DevOps perspektifinden bakıldığında, bu yaklaşımın önemli sorunları bulunmaktadır çünkü etkili bir şekilde konteynerleştirilemez - Microsoft Office'i bir Linux Docker konteynerine kuramazsınız veya sunucusuz ortamlarına dağıtamazsınız.
C# Interop Hangi Problemleri Oluşturur?
Interop yaklaşımı, modern DevOps uygulamaları ve bulut yerel dağıtımları için uygun olmayan çeşitli önemli zorluklar sunar.
Maalesef Stack Overflow ve diğer programlama siteleri, 2000'lerin başlarındaki konularla zaman içinde kilitlendikleri için bunu önermeye devam ediyor.
Dağıtım Bağımlılıkları: Kaynak kodu çalıştıran her makineye, üretim sunucuları dahil olmak üzere, Microsoft Office kurulumunu gerektirir. Bu, lisanslama maliyetlerini ve dağıtım karmaşıklığını artırır.
Bellek Yönetimi: COM nesneleri, Marshal.ReleaseComObject() kullanılarak açıkça serbest bırakılmalıdır. Bir nesneyi bile kaçırmak, Excel süreçlerinin bellekte takılmasına neden olur, Stack Overflow'da genişçe belgelenmiştir. Pivot önbelleği düşünün.
Platform Sınırlamaları: Bu çözüm yalnızca Windows üzerinde Office yüklü iken çalışır. Son derece yavaş olabilir ve bellek sızıntılarına neden olabilir. Linux, macOS, Docker konteynerleri veya Azure Functions gibi bulut platformları için destek yok. Bu durum, dağıtım seçeneklerini ciddi şekilde kısıtlar ve modern konteyner orkestrasyon platformlarının kullanılmasına engel olur.
Performans Sorunları: Excel uygulama örneklerini başlatmak yavaş ve kaynak yoğundur, özellikle sunucu tarafı işleme için.
Sürüm Uyumluluğu: Farklı Office sürümleri, ortamlar arasında uyumsuzluk sorunlarına neden olan farklı COM arayüzlerine sahip olabilir.
IronXL, Interop Olmadan Pivot Tabloyu Programlamayla Nasıl Oluşturur?
IronXL, pivot tablo oluşturmayı, yönetilen kod kullanarak, COM bağımlılıklarını ortadan kaldırarak farklı bir şekilde ele alır. Yerel Excel pivot tabloları oluşturmamakla birlikte, kapsayıcı tabanlı dağıtımlar ve bulut-yerli mimariler için mükemmel olan güçlü toplama yetenekleri sağlar. Kütüphanenin performans iyileştirmeleri, 40 kat hız artışı ve 19,5 GB'den 1 GB'ın altına düşen bellek kullanımı içerir, bu da onu kaynak sınırlı konteyner ortamları için ideal hale getirir.
Bu Yaklaşımı XLSX veya XLS Dosyaları İçin Modern Yapan Nedir?
using IronXL;
using System.Linq;
using System.Data; // Keep this namespace
using static System.Data.DataTableExtensions; // Use 'using static' for DataTableExtensions
class Program
{
static void Main(string[] args)
{
// Load Excel file - no Office required
WorkBook workbook = WorkBook.Load("SalesData.xlsx");
WorkSheet dataSheet = workbook.WorkSheets[0];
// Convert to DataTable for powerful manipulation
var dataTable = dataSheet.ToDataTable(true); // true = use first row as column headers
// Create pivot-style aggregation using LINQ
var pivotData = dataTable.AsEnumerable()
.GroupBy(row => new {
Product = row["Product"].ToString(),
Region = row["Region"].ToString()
}) //range
.Select(g => new {
Product = g.Key.Product,
Region = g.Key.Region,
TotalSales = g.Sum(row => Convert.ToDecimal(row["Sales"])),
AverageSale = g.Average(row => Convert.ToDecimal(row["Sales"])),
Count = g.Count()
});
// Create pivot report worksheet
WorkSheet pivotSheet = workbook.CreateWorkSheet("PivotReport");
// Build cross-tabulation structure
var products = pivotData.Select(p => p.Product).Distinct().OrderBy(p => p);
var regions = pivotData.Select(p => p.Region).Distinct().OrderBy(r => r);
// Create headers
pivotSheet["A1"].Value = "Product/Region";
int col = 2;
foreach (var region in regions)
{
pivotSheet[$"{(char)('A' + col - 1)}1"].Value = region; // string
col++;
}
// Populate pivot data
int row = 2;
foreach (var product in products)
{
pivotSheet[$"A{row}"].Value = product;
col = 2;
foreach (var region in regions)
{
var sales = pivotData
.Where(p => p.Product == product && p.Region == region)
.Select(p => p.TotalSales)
.FirstOrDefault();
pivotSheet[$"{(char)('A' + col - 1)}{row}"].Value = sales;
col++;
}
row++;
}
// Add totals using Excel formulas
pivotSheet[$"A{row}"].Value = "Total"; // grand totals
for (int c = 2; c <= regions.Count() + 1; c++)
{
pivotSheet[$"{(char)('A' + c - 1)}{row}"].Formula = $"=SUM({(char)('A' + c - 1)}2:{(char)('A' + c - 1)}{row - 1})";
}
// Proceeding to apply formatting
var dataRange = pivotSheet[$"B2:{(char)('A' + regions.Count())}{row}"];
dataRange.FormatString = "$#,##0.00";
workbook.SaveAs("PivotReport.xlsx");
}
}using IronXL;
using System.Linq;
using System.Data; // Keep this namespace
using static System.Data.DataTableExtensions; // Use 'using static' for DataTableExtensions
class Program
{
static void Main(string[] args)
{
// Load Excel file - no Office required
WorkBook workbook = WorkBook.Load("SalesData.xlsx");
WorkSheet dataSheet = workbook.WorkSheets[0];
// Convert to DataTable for powerful manipulation
var dataTable = dataSheet.ToDataTable(true); // true = use first row as column headers
// Create pivot-style aggregation using LINQ
var pivotData = dataTable.AsEnumerable()
.GroupBy(row => new {
Product = row["Product"].ToString(),
Region = row["Region"].ToString()
}) //range
.Select(g => new {
Product = g.Key.Product,
Region = g.Key.Region,
TotalSales = g.Sum(row => Convert.ToDecimal(row["Sales"])),
AverageSale = g.Average(row => Convert.ToDecimal(row["Sales"])),
Count = g.Count()
});
// Create pivot report worksheet
WorkSheet pivotSheet = workbook.CreateWorkSheet("PivotReport");
// Build cross-tabulation structure
var products = pivotData.Select(p => p.Product).Distinct().OrderBy(p => p);
var regions = pivotData.Select(p => p.Region).Distinct().OrderBy(r => r);
// Create headers
pivotSheet["A1"].Value = "Product/Region";
int col = 2;
foreach (var region in regions)
{
pivotSheet[$"{(char)('A' + col - 1)}1"].Value = region; // string
col++;
}
// Populate pivot data
int row = 2;
foreach (var product in products)
{
pivotSheet[$"A{row}"].Value = product;
col = 2;
foreach (var region in regions)
{
var sales = pivotData
.Where(p => p.Product == product && p.Region == region)
.Select(p => p.TotalSales)
.FirstOrDefault();
pivotSheet[$"{(char)('A' + col - 1)}{row}"].Value = sales;
col++;
}
row++;
}
// Add totals using Excel formulas
pivotSheet[$"A{row}"].Value = "Total"; // grand totals
for (int c = 2; c <= regions.Count() + 1; c++)
{
pivotSheet[$"{(char)('A' + c - 1)}{row}"].Formula = $"=SUM({(char)('A' + c - 1)}2:{(char)('A' + c - 1)}{row - 1})";
}
// Proceeding to apply formatting
var dataRange = pivotSheet[$"B2:{(char)('A' + regions.Count())}{row}"];
dataRange.FormatString = "$#,##0.00";
workbook.SaveAs("PivotReport.xlsx");
}
}Imports IronXL
Imports System.Linq
Imports System.Data ' Keep this namespace
Imports static System.Data.DataTableExtensions ' Use 'using static' for DataTableExtensions
Module Program
Sub Main(args As String())
' Load Excel file - no Office required
Dim workbook As WorkBook = WorkBook.Load("SalesData.xlsx")
Dim dataSheet As WorkSheet = workbook.WorkSheets(0)
' Convert to DataTable for powerful manipulation
Dim dataTable = dataSheet.ToDataTable(True) ' true = use first row as column headers
' Create pivot-style aggregation using LINQ
Dim pivotData = dataTable.AsEnumerable() _
.GroupBy(Function(row) New With {
Key .Product = row("Product").ToString(),
Key .Region = row("Region").ToString()
}) _
.Select(Function(g) New With {
Key .Product = g.Key.Product,
Key .Region = g.Key.Region,
Key .TotalSales = g.Sum(Function(row) Convert.ToDecimal(row("Sales"))),
Key .AverageSale = g.Average(Function(row) Convert.ToDecimal(row("Sales"))),
Key .Count = g.Count()
})
' Create pivot report worksheet
Dim pivotSheet As WorkSheet = workbook.CreateWorkSheet("PivotReport")
' Build cross-tabulation structure
Dim products = pivotData.Select(Function(p) p.Product).Distinct().OrderBy(Function(p) p)
Dim regions = pivotData.Select(Function(p) p.Region).Distinct().OrderBy(Function(r) r)
' Create headers
pivotSheet("A1").Value = "Product/Region"
Dim col As Integer = 2
For Each region In regions
pivotSheet($"{ChrW(AscW("A"c) + col - 1)}1").Value = region ' string
col += 1
Next
' Populate pivot data
Dim row As Integer = 2
For Each product In products
pivotSheet($"A{row}").Value = product
col = 2
For Each region In regions
Dim sales = pivotData _
.Where(Function(p) p.Product = product AndAlso p.Region = region) _
.Select(Function(p) p.TotalSales) _
.FirstOrDefault()
pivotSheet($"{ChrW(AscW("A"c) + col - 1)}{row}").Value = sales
col += 1
Next
row += 1
Next
' Add totals using Excel formulas
pivotSheet($"A{row}").Value = "Total" ' grand totals
For c As Integer = 2 To regions.Count() + 1
pivotSheet($"{ChrW(AscW("A"c) + c - 1)}{row}").Formula = $"=SUM({ChrW(AscW("A"c) + c - 1)}2:{ChrW(AscW("A"c) + c - 1)}{row - 1})"
Next
' Proceeding to apply formatting
Dim dataRange = pivotSheet($"B2:{ChrW(AscW("A"c) + regions.Count())}{row}")
dataRange.FormatString = "$#,##0.00"
workbook.SaveAs("PivotReport.xlsx")
End Sub
End ModuleKapsayıcı dostu bir şekilde pivot tabloları böyle oluşturuyorsunuz. Bu yaklaşım, Docker konteynerlerinde, Kubernetes podlarında ve dış bağımlılıklar gerektirmeyen sunucusuz işlevlerde sorunsuz çalışır. Tüm uygulama, .NET'in desteklediği her yerde çalışabilecek hafif bir kapsayıcı görüntüsüne paketlenebilir.
Pivot Tablo Çıktısı Nasıl Görünür?
Çıktı, IronXL'nin ham satış verilerini Excel kurulumu gerektirmeden yapılandırılmış bir pivot raporuna nasıl dönüştürdüğünü gösterir, bu da onu CI/CD hatlarında otomatik raporlama için mükemmel yapar.
IronXL Formülleri ile Dinamik Özetler Nasıl Oluşturulur?
Pivot tablo yenileme işlevine benzer dinamik güncellemeler gerektiren senaryolar için IronXL, Excel'in yerleşik formüllerinden yararlanabilir. Bu yaklaşım tercih edilebilir - veriniz çok daha modern ve şık bir şekilde ele alınır. Kod, destekle iletişime geçmeye veya kullanım kılavuzlarını okumaya ihtiyaç duymadan kolayca anlaşılır ve kurulabilir. Bu yaklaşım, otomatik olarak güncellenen formül tabanlı hesaplamalar'a ihtiyaç duyduğunuz kapsayıcı ortamlarında özellikle değerlidir.
Formül Tabanlı Özetler Nasıl Otomatik Güncellenir?
// Load the workbook
WorkBook workbook = WorkBook.Load(inputPath);
// Rename the first worksheet so formulas reference correctly
WorkSheet dataSheet = workbook.WorkSheets[0];
dataSheet.Name = "DataSheet";
// Convert worksheet to DataTable
DataTable dataTable = dataSheet.ToDataTable(true);
// Create new summary worksheet
WorkSheet summarySheet = workbook.CreateWorkSheet("DynamicSummary");
// Get unique product-region combinations
var uniqueCombos = dataTable.AsEnumerable()
.Select(row => new {
Product = row["Product"].ToString(),
Region = row["Region"].ToString()
})
.Distinct()
.OrderBy(x => x.Product)
.ThenBy(x => x.Region);
// Add header row
summarySheet["A1"].Value = "Product";
summarySheet["B1"].Value = "Region";
summarySheet["C1"].Value = "Total Sales";
summarySheet["D1"].Value = "Count";
// Populate rows with formulas
int rowIndex = 2;
foreach (var combo in uniqueCombos)
{
summarySheet[$"A{rowIndex}"].Value = combo.Product;
summarySheet[$"B{rowIndex}"].Value = combo.Region;
// Adjust column references if your Sales column is C (not D)
summarySheet[$"C{rowIndex}"].Formula =
$"=SUMIFS(DataSheet!C:C,DataSheet!A:A,\"{combo.Product}\",DataSheet!B:B,\"{combo.Region}\")";
summarySheet[$"D{rowIndex}"].Formula =
$"=COUNTIFS(DataSheet!A:A,\"{combo.Product}\",DataSheet!B:B,\"{combo.Region}\")";
rowIndex++;
}
// Optional: add total row
summarySheet[$"A{rowIndex}"].Value = "Total";
summarySheet[$"C{rowIndex}"].Formula = $"=SUM(C2:C{rowIndex - 1})";
summarySheet[$"D{rowIndex}"].Formula = $"=SUM(D2:D{rowIndex - 1})";
// Save output file
workbook.SaveAs(outputPath); //filename// Load the workbook
WorkBook workbook = WorkBook.Load(inputPath);
// Rename the first worksheet so formulas reference correctly
WorkSheet dataSheet = workbook.WorkSheets[0];
dataSheet.Name = "DataSheet";
// Convert worksheet to DataTable
DataTable dataTable = dataSheet.ToDataTable(true);
// Create new summary worksheet
WorkSheet summarySheet = workbook.CreateWorkSheet("DynamicSummary");
// Get unique product-region combinations
var uniqueCombos = dataTable.AsEnumerable()
.Select(row => new {
Product = row["Product"].ToString(),
Region = row["Region"].ToString()
})
.Distinct()
.OrderBy(x => x.Product)
.ThenBy(x => x.Region);
// Add header row
summarySheet["A1"].Value = "Product";
summarySheet["B1"].Value = "Region";
summarySheet["C1"].Value = "Total Sales";
summarySheet["D1"].Value = "Count";
// Populate rows with formulas
int rowIndex = 2;
foreach (var combo in uniqueCombos)
{
summarySheet[$"A{rowIndex}"].Value = combo.Product;
summarySheet[$"B{rowIndex}"].Value = combo.Region;
// Adjust column references if your Sales column is C (not D)
summarySheet[$"C{rowIndex}"].Formula =
$"=SUMIFS(DataSheet!C:C,DataSheet!A:A,\"{combo.Product}\",DataSheet!B:B,\"{combo.Region}\")";
summarySheet[$"D{rowIndex}"].Formula =
$"=COUNTIFS(DataSheet!A:A,\"{combo.Product}\",DataSheet!B:B,\"{combo.Region}\")";
rowIndex++;
}
// Optional: add total row
summarySheet[$"A{rowIndex}"].Value = "Total";
summarySheet[$"C{rowIndex}"].Formula = $"=SUM(C2:C{rowIndex - 1})";
summarySheet[$"D{rowIndex}"].Formula = $"=SUM(D2:D{rowIndex - 1})";
// Save output file
workbook.SaveAs(outputPath); //filenameImports System.Data
Imports System.Linq
' Load the workbook
Dim workbook As WorkBook = WorkBook.Load(inputPath)
' Rename the first worksheet so formulas reference correctly
Dim dataSheet As WorkSheet = workbook.WorkSheets(0)
dataSheet.Name = "DataSheet"
' Convert worksheet to DataTable
Dim dataTable As DataTable = dataSheet.ToDataTable(True)
' Create new summary worksheet
Dim summarySheet As WorkSheet = workbook.CreateWorkSheet("DynamicSummary")
' Get unique product-region combinations
Dim uniqueCombos = dataTable.AsEnumerable() _
.Select(Function(row) New With {
.Product = row("Product").ToString(),
.Region = row("Region").ToString()
}) _
.Distinct() _
.OrderBy(Function(x) x.Product) _
.ThenBy(Function(x) x.Region)
' Add header row
summarySheet("A1").Value = "Product"
summarySheet("B1").Value = "Region"
summarySheet("C1").Value = "Total Sales"
summarySheet("D1").Value = "Count"
' Populate rows with formulas
Dim rowIndex As Integer = 2
For Each combo In uniqueCombos
summarySheet($"A{rowIndex}").Value = combo.Product
summarySheet($"B{rowIndex}").Value = combo.Region
' Adjust column references if your Sales column is C (not D)
summarySheet($"C{rowIndex}").Formula = $"=SUMIFS(DataSheet!C:C,DataSheet!A:A,""{combo.Product}"",DataSheet!B:B,""{combo.Region}"")"
summarySheet($"D{rowIndex}").Formula = $"=COUNTIFS(DataSheet!A:A,""{combo.Product}"",DataSheet!B:B,""{combo.Region}"")"
rowIndex += 1
Next
' Optional: add total row
summarySheet($"A{rowIndex}").Value = "Total"
summarySheet($"C{rowIndex}").Formula = $"=SUM(C2:C{rowIndex - 1})"
summarySheet($"D{rowIndex}").Formula = $"=SUM(D2:D{rowIndex - 1})"
' Save output file
workbook.SaveAs(outputPath) ' filenameBu formüller, pivot tablo yenileme davranışına benzer şekilde ancak Interop bağımlılıkları olmadan canlı veri bağlantılarını korur ve veri sayfası değiştiğinde otomatik olarak güncellenir. Bu yaklaşım, harici bağımlılıklara ihtiyaç duymadan dinamik raporlar oluşturması gereken kapsayıcı mikro hizmetler için idealdir.
Dinamik Özetlerden Ne Sonuçlar Bekleyebilirsiniz?
Bu kodu, önceki örnekten Excel dosyasına uygularsak, bu çıktıyı elde ederiz:
Dinamik özet yaklaşımı, kaynak veriler değiştiğinde otomatik olarak güncellenen gerçek zamanlı hesaplamalar sağlar, bu da otomatik raporlama hatları için uygundur. Bu, zamanlanmış pivot tablo yenileme ihtiyacını ortadan kaldırır ve .NET MAUI ve Blazor uygulamalarında sorunsuz çalışır.
C# Interop ve Pivot Tablolar için IronXL Nasıl Karşılaştırılır?
|
Boyut |
C# Interop |
IronXL |
|---|---|---|
|
Ofis Gerekli |
Evet - Tam kurulum |
Hayır - Bağımsız kütüphane |
|
Platform Desteği |
Sadece Windows |
Windows, Linux, macOS, Docker |
|
Hafıza Yönetimi |
Manuel COM temizliği gerekli |
Otomatik .NET çöp koleksiyonu |
|
Dağıtım |
Karmaşık - Ofis lisanslama |
Basit - Tek DLL |
|
Performans |
Yavaş - Excel işlem başlatma |
Hızlı - Bellek içi hesaplamalar |
|
Bulut Uyumlu |
Hayır - Azure sınırlamaları |
Evet - Azure Functions desteği |
|
Yerel Pivot Tablolar |
Evet |
Hayır - Toplama alternatifleri |
|
Geliştirme Hızı |
Yavaş - COM karmaşıklığı |
Hızlı - Sezgisel API |
|
Konteyner Desteği |
Hayır - Ofis kapsayıcı haline getirilemez |
Evet - Docker uyumlu |
|
Sağlık Kontrolleri |
Zor - COM işlem izleme |
Kolay - Standart .NET izleme |
DevOps perspektifinden bakıldığında, IronXL'nin mimarisi, modern dağıtım senaryoları için önemli avantajlar sağlar. Kütüphanenin, harici bağımlılıkları olmadan konteynerlerde çalışabilmesi, hızlı dağılan ve verimli şekilde ölçeklendirilebilen hafif Docker görüntüleri oluşturmanızı sağlar. Sağlık kontrolleri standart .NET kalıpları kullanılarak uygulanabilir ve kütüphanenin güvenlik özellikleri DigiCert sertifikasyonu ve COM arayüzlerinin olmamasıyla saldırı vektörlerini azaltır.
Hangi Yaklaşımı Seçmelisiniz?
C# Interop Ne Zaman Kullanılmalıdır?
C# Interop seçin şu durumlarda:
- Yerel Excel pivot tablo nesneleri kesinlikle gerekliyse
- Yalnızca Windows üzerinde Ofis her yerde yüklüyken çalışıyorsanız
- Yalnızca yönettiğiniz masaüstü sistemlerine dağılım yapıyorsanız
- Mevcut eski kod Interop'a bağımlıysa
- Eski .NET Framework sürümlerini kullanıyorsanız
- Kapsayıcıya taşınma veya buluta geçiş planınız yoksa
Ne Zaman IronXL Daha İyi Sonuçlar Sağlar?
IronXL seçin şu durumlarda:
- Sunuculara veya bulut ortamlarına (Azure, AWS) dağılım yapıyorsanız
- Kapsayıcılarda çalışan çapraz platform uygulamalar oluşturuyorsanız
- Daha iyi performans için 40 kat hız artışı gerektiriyorsa
- Ofis lisanslama maliyetlerinden ve dağıtım karmaşıklığından kaçınıyorsanız
- Basit kod ile lisans anahtarı yönetimi gerekiyorsa
- Mac, iOS, Android ve Linux sistemlerini destekliyorsanız
- Modern .NET Core ve .NET 5-10'da çalışıyorsanız
- Programatik olarak pivot tablo alanlarını yapılandırıyorsanız
- Çeşitli formatlara aktaran mikro hizmetler oluşturuyorsanız
- CI/CD hatlarında otomatik raporlama uyguluyorsanız
- Konteyner orkestrasyon için sağlık kontrol uç noktaları oluşturuyorsanız
- Farklı elektronik tablo formatları arasında dönüştürme yapıyorsanız
C#'ta Pivot Tablolar Oluşturma Hakkında Neler Öğrendik?
C# Excel Interop yerel pivot tablolar oluşturabilirken, dağıtım sınırlamaları ve karmaşıklığı, özellikle kapsayıcı ortamlarında modern uygulamalar için giderek daha pratik olmayan hale getiriyor. IronXL, analytik yetenekleri koruyarak Office bağımlılıklarını ortadan kaldıran, veri toplama ve formül tabanlı özetler aracılığıyla güçlü alternatifler sunar.
Interop kullanmadan pivot tabloları geliştirmek için alternatif arayan geliştiriciler ve DevOps mühendisleri için, IronXL, tüm platformlarda çalışan, COM sorunlarını önleyen ve dağıtımı basitleştiren üstün bir yol sunar. Yerel pivot nesnelerinin olmamasının karşılığı, daha fazla esneklik, daha iyi performans ve Ofis lisanslama gerekliliklerinin ortadan kaldırılması ile dengelenir. DevOps ekipleri için en önemlisi, IronXL, containerize dağıtımlar, otomatik ölçekleme ve modern CI/CD hatlarına sorunsuz entegrasyon ile gerçek bir kod olarak altyapı sağlar.
Kütüphanenin kapsamlı özellik seti, koşullu biçimlendirme, hücre stili, formül desteği ve veri doğrulama içerir ve modern .NET uygulamalarında Excel otomasyonu için tam bir çözüm sunar. CSV dosyalarıyla çalışıyor, çalışma sayfalarını yönetiyor veya karmaşık veri dönüşümleri uyguluyor olun, IronXL, dağıtım dostu bir API sunar.
Excel otomasyonunuzu modernize etmeye ve modern C# ile pivot tablo kodu oluşturmaya hazır mısınız?
IronXL, NuGet Paket Yöneticisi aracılığıyla C# uygulamalarınıza saniyeler içinde uygulanabilir. Ücretsiz deneme sürümünü deneyin ve üretim uygulamalarınızdaki Interop bağımlılıklarını ortadan kaldırarak kapsayıcı dağıtımlarınızı basitleştirin.
Sıkça Sorulan Sorular
Excel'de pivot tablo nedir?
Excel'de bir pivot tablo, verileri özetlemek, analiz etmek, keşfetmek ve sunmak için kullanılan güçlü bir araçtır. Kullanıcıların sütunları satırlara ve tam tersine dönüştürmesine olanak tanır, böylece dinamik veri analizi sağlar.
C#'da Excel pivot tabloları oluşturmak için neden IronXL kullanmalıyım?
IronXL, Office Interop'a bağlı kalmadan C#'da Excel pivot tabloları oluşturmanıza olanak tanır ve böylece Excel kurulumlarına gerek kalmaz, bağımlılıkları azaltır ve modern, verimli bir tercih haline gelir.
IronXL, C# Interop ile Excel operasyonları için nasıl kıyaslanır?
IronXL, Office kurulumlarını gerektiren C# Interop'a göre daha akıcı ve bağımsız bir yaklaşım sunar. IronXL, pivot tabloları ve diğer Excel işlemlerini Interop karmaşıklığı olmadan basitleştirir.
Excel kurulu olmadan pivot tablolar oluşturabilir miyim?
Evet, IronXL kullanarak, Microsoft Office'ten bağımsız olarak çalıştığı için Excel kurulu olmadan C# uygulamalarınızda pivot tablolar oluşturabilirsiniz.
IronXL, büyük veri kümeleri için uygun mu?
IronXL, büyük veri kümelerini verimli bir şekilde yönetmek için tasarlanmıştır ve sağlam veri işleme ve pivot tablo oluşturma gerektiren uygulamalar için uygundur.
Geleneksel yöntemlere göre IronXL kullanmanın avantajları nelerdir?
IronXL, Excel kurulumlarına ihtiyaç duymaksızın, kullanım kolaylığı, esneklik ve karmaşık veri işlemleri için destek sunarak geleneksel yöntemlere kıyasla modern, bağımsız bir alternatif sunar.
Pivot tablolar için IronXL kullanmak için VBA öğrenmem gerek mi?
Hayır, IronXL, pivot tabloları oluşturmak ve yönetmek için doğrudan C# içinde çalışmanıza olanak tanır, VBA veya diğer Excel'e özel programlama dillerini öğrenme gereğini ortadan kaldırır.
Ücretsiz Başlayın
Ücretsiz Başlayın
Ücretsiz Canlı Demo Rezervasyonu
