Dependency Injection İle Factory Method Design Pattern Sentezi

Merhaba,

Dependency Injection yaklaşımı ile Factory Method Design Pattern arasında bir bütünlük sağlayarak bir proje üzerinde beraber nasıl bir tasarım gerçekleştirebiliriz? sorusuna cevap vermeye çalışacağız.

Bu iki konu üzerinde detaylı durmayacağım. Lakin kısaca özetleyecek olursak eğer Dependency Injection, projedeki bağımlılık entegrasyonlarını soyutlamak üzerine profesyonel maksatlı bir yaklaşım sergilememizi sağlarken, Factory Method Design Pattern ise birbirleriyle ilişkisel nesneleri üretirken alternatif bir yol sunmaktaydı.

Şuanda bu içerikte yapmak istediğimiz olay ise bu iki yaklaşımı uygulayabileceğimiz örnek bir proje gerçekleştirmektir.

Örnek projeyi makalenin sonunda indirebilirsiniz. Senaryo çok basit olduğu için bir film projesinde örneklendirme amaçlı çalışacağımızı söylemenin yeterli olduğunu düşünüyorum…

Hadi başlayalım…
Öncelikle Factory Method Design Pattern’i uygulayabilmek için ilgili soyut sınıfı oluşturuyorum.

    abstract class FilmAbs
    {
        public abstract string FilmAdi();
        public abstract bool Oynat();
        public abstract bool Sat();
        public abstract bool VarMi();
        public abstract int Stok { get; }
    }

Ürünleri(filmleri) oluşturuyorum ve FilmAbs isimli soyut sınıfımızdan miras alıyorum. Doğal olarak ilgili abstract sınıf içerisindeki abstract elemanları ürünlerime uyguluyorum.

    class AFilm : FilmAbs
    {
        public override int Stok
        {
            get
            {
                return 23;
            }
        }

        public override string FilmAdi()
        {
            Console.WriteLine("A Film");
            return "A Film";
        }

        public override bool Oynat()
        {
            Console.WriteLine("A Film Oynatılıyor...");
            return true;
        }

        public override bool Sat()
        {
            Console.WriteLine("A Film Satılmıştır...");
            return true;
        }

        public override bool VarMi()
        {
            Console.WriteLine($"A Film'den {Stok} kadar var...");
            return true;
        }
    }

    class BFilm : FilmAbs
    {
        public override int Stok
        {
            get
            {
                return 44;
            }
        }

        public override string FilmAdi()
        {
            Console.WriteLine("B Film");
            return "B Film";
        }

        public override bool Oynat()
        {
            Console.WriteLine("B Film Oynatılıyor...");
            return true;
        }

        public override bool Sat()
        {
            Console.WriteLine("B Film Satılmıştır...");
            return true;
        }

        public override bool VarMi()
        {
            Console.WriteLine($"B Film'den {Stok} kadar var...");
            return true;
        }
    }

    class CFilm : FilmAbs
    {
        public override int Stok
        {
            get
            {
                return 414;
            }
        }

        public override string FilmAdi()
        {
            Console.WriteLine("C Film");
            return "C Film";
        }

        public override bool Oynat()
        {
            Console.WriteLine("C Film Oynatılıyor...");
            return true;
        }

        public override bool Sat()
        {
            Console.WriteLine("C Film Satılmıştır...");
            return true;
        }

        public override bool VarMi()
        {
            Console.WriteLine($"C Film'den {Stok} kadar var...");
            return true;
        }
    }

Ardından Creater sınıfımı oluşturarak Factory Design Pattern çalışmamı tamamlamış oluyorum.

    enum FilmTipleri
    {
        AFilm,
        BFilm,
        CFilm
    }

    class Creater
    {
        public FilmAbs FactoryMethod(FilmTipleri FilmTipi)
        {
            FilmAbs film = null;

            switch (FilmTipi)
            {
                case FilmTipleri.AFilm:
                    film = new AFilm();
                    break;
                case FilmTipleri.BFilm:
                    film = new BFilm();
                    break;
                case FilmTipleri.CFilm:
                    film = new CFilm();
                    break;
            }

            return film;
        }
    }

Şimdide film satıcı sınıfımı Dependency Injection yaklaşımıyla oluşturuyorum. Aşağıdaki çalışmada Constructor Injection(Constructor Based Dependecy Injection) kullanılmıştır. Dikkat ederseniz eğer Factory Method D. P. sonucu üretilecek olan “FilmAbs” nesnesini “FilmSatici” nesnesi içerisinde Dependency Injection’ı soyutlamış bir biçimde referans olarak almaktadır.

    class FilmSatici
    {
        FilmAbs film;
        public FilmSatici(FilmAbs film)
        {
            this.film = film;
        }

        public void Sat()
        {
            if (film.VarMi())
                film.Sat();
        }
    }

DI ile Factory D. P. yaklaşımlarını beraber kullandığımız tasarımımız bitmiştir. Tasarıyı aşağıdaki gibi kullanabilmekteyiz.

        static void Main(string[] args)
        {
            //Factory Method Design Pattern
            Creater Uretici = new Creater();
            //Dependency Injection
            FilmSatici Satici = new FilmSatici(Uretici.FactoryMethod(FilmTipleri.CFilm));
            Satici.Sat();

            Console.Read();
        }

Bu içeriğimizde sadece projeyi paylaşmayı düşünmekteydim. Velhasıl yukarıda yapılan çalışmayı özetlemeye çalıştım.

Projeyi buradan indirebilir, göz atarak daha net bir şekilde şemayı kafanızda oturtabilirsiniz…

İyi çalışmalar…