Abstract Factory Tasarım Deseni ve Uygulama Örneği
Abstract Factory tasarım deseni, creational yani nesne oluşturma odaklı tasarım kalıpları arasında yer alan önemli bir yazılım tasarım desenidir.
Bu desenin temel amacı, birbiriyle ilişkili veya benzer temaya sahip nesne ailelerini, somut sınıflarını doğrudan belirtmeden oluşturmaktır. Böylece istemci kod, hangi somut sınıfın üretildiğini bilmeden yalnızca ortak arayüzler üzerinden çalışır.
Abstract Factory deseni özellikle bir sistemde aynı aileye ait farklı nesnelerin birlikte kullanılması gerektiğinde ve bu nesne aileleri arasında kolayca geçiş yapılmak istendiğinde oldukça faydalıdır. Bu yapı sayesinde nesne oluşturma süreci soyutlanır, bağımlılıklar azalır ve sistem daha esnek hale gelir.
ABSTRACT FACTORY TASARIM DESENİ NEDİR?
Abstract Factory, ilişkili nesnelerin oluşturulmasını merkezi bir fabrika yapısı üzerinden yöneten bir tasarım desenidir. Bu desen, istemci kodun doğrudan somut sınıflara bağımlı olmasını engeller.
Bu yaklaşımda istemci kod yalnızca fabrika arayüzünü ve ürün arayüzlerini bilir. Hangi somut nesnenin oluşturulacağı ise ilgili factory sınıfı tarafından belirlenir.
Bu sayede sistemde yeni bir ürün ailesi veya yeni bir nesne türü eklendiğinde, mevcut istemci kodu büyük ölçüde değişmeden kalır. Bu da kodun genişletilebilirliğini ve bakım kolaylığını artırır.
SENARYO: FİNANSAL RAPORLAMA SİSTEMİ
Bu örnekte, farklı finansal raporlar üreten bir sistem üzerinden Abstract Factory tasarım desenini inceleyeceğiz.
Sistemde gelir tablosu ve nakit akış tablosu gibi farklı finansal rapor türleri bulunmaktadır. Her rapor türü farklı veri yapılarıyla çalışır ancak rapor üretme ve raporu görüntüleme gibi ortak davranışlara sahiptir.
Bu nedenle her rapor türünü ortak bir arayüz altında yönetmek ve ilgili rapor nesnelerini factory sınıfları aracılığıyla oluşturmak mantıklı bir yaklaşımdır.
PROBLEM
Finansal raporlama sistemlerinde farklı rapor türleri için farklı sınıflar ve farklı veri modelleri kullanılabilir. Örneğin gelir tablosu net satış, satılan malın maliyeti ve brüt kâr gibi alanlara sahipken, nakit akış tablosu operasyonel faaliyetler, yatırım faaliyetleri ve finansman faaliyetleri gibi farklı alanlara sahip olabilir.
Eğer istemci kod doğrudan bu somut rapor sınıflarını oluşturursa, sistem zamanla bu sınıflara sıkı sıkıya bağlı hale gelir. Yeni bir rapor türü eklendiğinde veya mevcut rapor üretim süreci değiştiğinde istemci kodda da değişiklik yapılması gerekebilir.
Bu durum kodun bakımını zorlaştırır, test edilebilirliği azaltır ve sistemin genişletilmesini daha riskli hale getirir.
ÇÖZÜM
Abstract Factory deseni ile rapor oluşturma süreci soyutlanır. İstemci kod, somut rapor sınıflarını doğrudan oluşturmak yerine bir factory arayüzü üzerinden rapor nesnesi talep eder.
Bu yapıda her rapor türü için bir factory sınıfı bulunur. Örneğin gelir tablosu raporu için IncomeStatementFactory, nakit akış tablosu raporu için ise CashFlowStatementFactory kullanılabilir.
Bu sayede istemci kod, rapor nesnesinin nasıl oluşturulduğunu bilmeden yalnızca ortak arayüzler üzerinden rapor üretme ve görüntüleme işlemlerini gerçekleştirebilir.
SINIFLAR
İlk olarak finansal raporların kullanacağı veri modellerini tanımlıyoruz. Bu örnekte gelir tablosu için IncomeTable, nakit akış tablosu için ise CashFlowTable sınıfları oluşturulmuştur.
IncomeTable sınıfı, gelir tablosunda kullanılacak temel finansal verileri içerir.
public class IncomeTable
{
public decimal NetSales { get; set; }
public decimal CostOfGoodsSold { get; set; }
public decimal GrossProfit { get; set; }
}
CashFlowTable sınıfı ise nakit akış tablosunda kullanılacak finansal verileri temsil eder.
public class CashFlowTable
{
public decimal OperatingActivities { get; set; }
public decimal InvestingActivities { get; set; }
public decimal FinancingActivities { get; set; }
public decimal NetIncreaseInCash { get; set; }
public decimal CashAtBeginningOfPeriod { get; set; }
public decimal CashAtEndOfPeriod { get; set; }
}
IFINANCIALREPORT ARAYÜZÜ
Şimdi tüm finansal raporların uyması gereken ortak bir arayüz tanımlıyoruz. IFinancialReport<T> arayüzü, rapor üretme ve raporu görüntüleme işlemlerini standart hale getirir.
Buradaki T generic tipi, her raporun kendi veri modeliyle çalışabilmesini sağlar. Örneğin gelir tablosu IncomeTable ile, nakit akış tablosu ise CashFlowTable ile çalışabilir.
/// <summary>
/// Defines a generic interface for financial reports,
/// allowing for report generation and display.
/// The type parameter T represents the data structure used for report generation.
/// </summary>
public interface IFinancialReport<T>
{
/// <summary>
/// Asynchronously generates a report based on the provided export data.
/// Returns a boolean indicating success or failure.
/// </summary>
/// <param name="ExportData">The export data of type T used to generate the report.</param>
/// <returns>A task representing the asynchronous operation, containing a boolean result.</returns>
Task<bool> GenerateReport(T ExportData);
/// <summary>
/// Asynchronously displays the report content.
/// </summary>
/// <returns>A task representing the asynchronous operation.</returns>
Task DisplayReport();
}
IREPORTFACTORY ARAYÜZÜ
Rapor nesnelerinin oluşturulmasını soyutlamak için IReportFactory<T> arayüzünü tanımlıyoruz.
Bu arayüz, ilgili veri tipine uygun bir finansal rapor nesnesi oluşturur. Böylece istemci kod, rapor nesnesinin hangi somut sınıftan üretildiğini bilmeden sadece factory üzerinden rapor oluşturabilir.
/// <summary>
/// Defines a factory interface for creating financial report instances.
/// This interface supports the Abstract Factory design pattern.
/// </summary>
public interface IReportFactory<T>
{
/// <summary>
/// Creates an instance of a financial report that handles data of type T.
/// </summary>
/// <returns>An instance of IFinancialReport<T>.</returns>
IFinancialReport<T> CreateReport();
}
CASH FLOW STATEMENT SINIFI
CashFlowStatement sınıfı, nakit akış tablosu raporunu temsil eder. Bu sınıf IFinancialReport<CashFlowTable> arayüzünü uygular.
GenerateReport metodu, verilen CashFlowTable verisine göre rapor oluşturma sürecini temsil eder. Bu örnekte Excel dosyası oluşturma işlemi simüle edilmiştir.
/// <summary>
/// Concrete implementation of IFinancialReport<T> for cash flow statements.
/// Handles the creation and display of cash flow reports using the CashFlowTable type.
/// </summary>
public class CashFlowStatement : IFinancialReport<CashFlowTable>
{
/// <summary>
/// Asynchronously displays the generated cash flow report.
/// </summary>
/// <returns>A task representing the asynchronous display operation.</returns>
public async Task DisplayReport()
{
Console.WriteLine("Displaying Report Cash Flow Result On the Page");
await Task.CompletedTask;
}
/// <summary>
/// Asynchronously generates a cash flow report based on provided CashFlowTable data.
/// </summary>
/// <param name="cashFlow">The cash flow data used to generate the report.</param>
/// <returns>A task representing the asynchronous report generation operation, containing a boolean result.</returns>
public async Task<bool> GenerateReport(CashFlowTable cashFlow)
{
try
{
await Task.Run(() =>
{
using (var workbook = new XLWorkbook())
{
// Simulation for creation cash flow excel report
workbook.SaveAs("CashFlowStatement.xlsx");
}
});
}
catch (Exception exception)
{
// Logging should be implemented here to handle the exception
return false;
}
return true;
}
}
INCOME STATEMENT SINIFI
IncomeStatement sınıfı, gelir tablosu raporunu temsil eder. Bu sınıf IFinancialReport<IncomeTable> arayüzünü uygular.
Bu sınıf içerisinde gelir tablosu raporunun oluşturulması ve görüntülenmesi ile ilgili işlemler yer alır. Gerçek bir uygulamada bu yapı Excel, PDF veya farklı bir rapor formatı oluşturmak için genişletilebilir.
/// <summary>
/// Concrete implementation of IFinancialReport<T> for income statements.
/// Handles the creation and display of income statements using the IncomeTable type.
/// </summary>
public class IncomeStatement : IFinancialReport<IncomeTable>
{
/// <summary>
/// Asynchronously displays the generated income statement report.
/// </summary>
/// <returns>A task representing the asynchronous display operation.</returns>
public async Task DisplayReport()
{
Console.WriteLine("Displaying Report Income Result On the Page");
await Task.CompletedTask;
}
/// <summary>
/// Asynchronously generates an income statement report based on provided IncomeTable data.
/// </summary>
/// <param name="table">The income data used to generate the report.</param>
/// <returns>A task representing the asynchronous report generation operation, containing a boolean result.</returns>
public async Task<bool> GenerateReport(IncomeTable table)
{
try
{
await Task.Run(() =>
{
using (var workbook = new XLWorkbook())
{
// Simulation for creation income statement excel report
workbook.SaveAs("IncomeStatement.xlsx");
}
});
}
catch (Exception exception)
{
// Logging can be implemented here to handle the exception
return false;
}
return true;
}
}
CASH FLOW STATEMENT FACTORY
Şimdi nakit akış tablosu raporunu oluşturacak factory sınıfını tanımlıyoruz. CashFlowStatementFactory, IReportFactory<CashFlowTable> arayüzünü uygular.
Bu factory sınıfı, nakit akış tablosu için uygun olan CashFlowStatement nesnesini oluşturur ve geriye IFinancialReport<CashFlowTable> tipinde döndürür.
/// <summary>
/// Concrete factory for creating instances of CashFlowStatement reports.
/// Implements the IReportFactory<T> interface for the CashFlowTable data type.
/// </summary>
public class CashFlowStatementFactory : IReportFactory<CashFlowTable>
{
/// <summary>
/// Creates and returns an instance of CashFlowStatement.
/// </summary>
/// <returns>An instance of CashFlowStatement which is a concrete implementation of IFinancialReport<CashFlowTable>.</returns>
public IFinancialReport<CashFlowTable> CreateReport()
{
return new CashFlowStatement();
}
}
INCOME STATEMENT FACTORY
IncomeStatementFactory sınıfı, gelir tablosu raporu oluşturmak için kullanılır. Bu sınıf IReportFactory<IncomeTable> arayüzünü uygular.
Factory metodu çağrıldığında geriye IncomeStatement nesnesi döndürülür. Ancak istemci kod bu somut sınıfla doğrudan çalışmaz, onu IFinancialReport<IncomeTable> arayüzü üzerinden kullanır.
/// <summary>
/// Concrete factory for creating instances of IncomeStatement reports.
/// Implements the IReportFactory<T> interface for the IncomeTable data type.
/// </summary>
public class IncomeStatementFactory : IReportFactory<IncomeTable>
{
/// <summary>
/// Creates and returns an instance of IncomeStatement.
/// </summary>
/// <returns>An instance of IncomeStatement which is a concrete implementation of IFinancialReport<IncomeTable>.</returns>
public IFinancialReport<IncomeTable> CreateReport()
{
return new IncomeStatement();
}
}
ABSTRACT FACTORY NASIL UYGULANIR?
Programın kullanım bölümünde öncelikle gelir tablosu ve nakit akış tablosu için örnek veri modelleri oluşturulur.
Daha sonra her rapor türü için ilgili factory sınıfı kullanılır. Factory sınıfı üzerinden rapor nesnesi oluşturulur ve rapor üretme ile görüntüleme işlemleri gerçekleştirilir.
var incomeTable = new IncomeTable
{
NetSales = 150000,
CostOfGoodsSold = 50000,
GrossProfit = 100000
};
var cashFlow = new CashFlowTable
{
OperatingActivities = 50000m,
InvestingActivities = -20000m,
FinancingActivities = 30000m,
CashAtBeginningOfPeriod = 10000m
};
IReportFactory<IncomeTable> factoryForIncome = new IncomeStatementFactory();
IFinancialReport<IncomeTable> reportForIncome = factoryForIncome.CreateReport();
await reportForIncome.GenerateReport(incomeTable);
await reportForIncome.DisplayReport();
IReportFactory<CashFlowTable> factoryForCashFlow = new CashFlowStatementFactory();
IFinancialReport<CashFlowTable> reportForCashFlow = factoryForCashFlow.CreateReport();
await reportForCashFlow.GenerateReport(cashFlow);
await reportForCashFlow.DisplayReport();
ABSTRACT FACTORY TASARIM DESENİNİN AVANTAJLARI
Esneklik ve Ölçeklenebilirlik
Yeni rapor türleri sisteme kolayca eklenebilir. Örneğin ileride bilanço raporu, gider raporu veya farklı bir finansal rapor türü eklenmek istenirse, yeni veri modeli, yeni rapor sınıfı ve yeni factory sınıfı oluşturularak sistem genişletilebilir.
Azaltılmış Bağımlılıklar
İstemci kod, somut rapor sınıflarına doğrudan bağımlı değildir. Rapor oluşturma işlemi factory sınıfları üzerinden yürütüldüğü için bağımlılıklar daha kontrollü hale gelir.
Test Edilebilirlik
Nesne oluşturma sürecinin soyutlanması, birim testlerin daha kolay yazılmasını sağlar. Testlerde gerçek rapor sınıfları yerine mock veya fake implementasyonlar kullanılabilir.
Bakım Kolaylığı
Rapor üretim süreçlerinde bir değişiklik gerektiğinde, ilgili rapor sınıfı veya factory sınıfı üzerinde düzenleme yapılabilir. Bu sayede uygulamanın diğer bölümlerine minimum etkiyle değişiklik yapılmış olur.
Ortak Sözleşme Kullanımı
Tüm rapor sınıfları ortak bir arayüzü uyguladığı için sistem genelinde standart bir kullanım sağlanır. Bu da kodun okunabilirliğini ve sürdürülebilirliğini artırır.
SONUÇ
Abstract Factory tasarım deseni, birbiriyle ilişkili nesne ailelerinin oluşturulmasını soyutlamak için kullanılan güçlü bir tasarım desenidir.
Bu örnekte finansal raporlama sistemi üzerinden gelir tablosu ve nakit akış tablosu raporlarını ele aldık. Her rapor türü kendi veri modeliyle çalışırken, ortak IFinancialReport<T> arayüzü sayesinde standart bir kullanım yapısı elde edildi.
Rapor nesnelerinin oluşturulması ise IReportFactory<T> arayüzü ve somut factory sınıfları aracılığıyla yönetildi. Böylece istemci kod, somut rapor sınıflarına doğrudan bağımlı olmadan rapor üretme ve görüntüleme işlemlerini gerçekleştirebildi.
Bu yaklaşım, özellikle farklı nesne ailelerinin birlikte yönetildiği, genişletilebilir ve sürdürülebilir sistemler geliştirmek için oldukça kullanışlıdır. Finansal raporlama, UI tema üretimi, platform bağımlı servisler ve farklı entegrasyon katmanları gibi birçok senaryoda Abstract Factory deseni etkili bir çözüm sunar.
```
