Mengapa kita membutuhkan pola desain pabrik abstrak?

Sebagian besar definisi mengatakan:

Pabrik abstrak menyediakan antarmuka untuk membuat keluarga objek terkait tanpa menentukan kelas konkretnya

Apa gunanya Pola Pabrik Abstrak karena kita dapat mencapai tugas melalui pembuatan objek kelas beton itu sendiri. Mengapa kita memiliki metode pabrik yang membuat objek kelas Beton?

Tolong berikan saya contoh kehidupan nyata di mana saya harus menerapkan pola abstractFactory?

Abstrak Pabrik adalah pola desain yang sangat sentral untuk Dependency Injection (DI). Berikut daftar pertanyaan Stack Overflow dimana penerapan Pabrik Abstrak telah diterima sebagai solusinya.

Sejauh pemahaman saya, pertanyaan-pertanyaan ini mewakili keprihatinan atau masalah nyata yang orang-orang miliki, sehingga Anda dapat memulai dengan beberapa contoh kehidupan nyata:

• Apakah ada pola untuk menginisialisasi objek yang dibuat melalui wadah DI
• Tidak dapat menggabungkan Pabrik / DI
• Injeksi Ketergantungan WCF dan pabrik abstrak
• Cara mengatur IoC ketika kelas kunci membutuhkan Sesi (atau variabel khusus konteks lainnya)
• Bagaimana cara mengatasi tipe berdasarkan nilai konfigurasi pengguna akhir?
• Pola Strategi dan Injeksi Ketergantungan menggunakan Unity
• Pola pabrik abstrak di atas IoC?
• Apakah ini cara yang benar untuk menggunakan dan menguji kelas yang menggunakan pola pabrik?
• DDD Book, Eric Evans: Tolong jelaskan apa yang dimaksud dengan "PABRIK harus disarikan ke jenis yang diinginkan daripada kelas konkret yang dibuat."
• DI wadah, pabrik, atau baru untuk benda fana?
• Bagaimana cara membuat instance pengujian unit?
• Apa strategi terbaik untuk Injeksi Ketergantungan Input Pengguna?

Contoh kehidupan nyata untuk penggunaan pola Pabrik Abstrak menyediakan akses data ke dua sumber data yang berbeda. Asumsikan aplikasi Anda mendukung penyimpanan data yang berbeda. (misalnya Database SQL dan file XML). Anda memiliki dua antarmuka akses data yang berbeda, misalnya IReadableStoredan IWritableStoremenentukan metode umum yang diharapkan oleh aplikasi Anda, apa pun jenis sumber data yang digunakan.

Jenis sumber data mana yang harus digunakan tidak boleh mengubah cara kode klien mengambil kelas akses datanya. Anda AbstractDataAccessFactorytahu jenis sumber data dikonfigurasi dan menyediakan beton pabrik untuk kode klien, yaitu SqlDataAccessFactoryatau XmlDataAccessFactory. Pabrik beton ini dapat membuat implementasi beton, misalnya SqlReadableStoredan SqlWriteableStore.

The DbProviderFactory di .NET Framework adalah contoh dari pola ini.

Jika saya memahami Anda dengan benar - pertanyaannya adalah, mengapa kita memiliki metode Pabrik dan pola pabrik abstrak. Anda memerlukan pabrik abstrak ketika kelas polimorfik yang berbeda memiliki prosedur pembuatan contoh yang berbeda. Dan Anda ingin beberapa modul membuat instance dan menggunakannya, tanpa mengetahui detail inisialisasi objek apa pun. Misalnya - Anda ingin membuat objek Java dengan melakukan beberapa perhitungan. Tetapi beberapa di antaranya adalah bagian dari aplikasi, sementara bytecode lainnya harus dibaca dari DB. Di sisi lain - mengapa kita membutuhkan metode pabrik? Setuju, pabrik abstrak itu tumpang tindih. Tetapi dalam beberapa kasus - jauh lebih sedikit kode untuk ditulis, memiliki lebih sedikit kelas dan antarmuka membuat sistem lebih mudah untuk dipahami.

Apa gunanya Pola Pabrik Abstrak karena kita dapat mencapai tugas melalui pembuatan objek kelas beton itu sendiri. Mengapa kita memiliki metode pabrik yang membuat objek kelas Beton?

Dengan tidak adanya Pabrik Abstrak , Klien perlu mengetahui detail kelas beton. Kopling ketat ini telah dilepas dengan Pabrik Abstrak .

Sekarang Metode Pabrik memperlihatkan kontrak, yang harus digunakan klien. Anda dapat menambahkan lebih banyak produk ke pabrik Anda dengan menambahkan produk baru, yang menerapkan antarmuka yang diekspos oleh Metode Pabrik.

Lihat pertanyaan SE terkait ini untuk pemahaman yang lebih baik:

Apa perbedaan mendasar antara Pabrik dan Pola Pabrik Abstrak?

Maksud:

Menyediakan antarmuka untuk membuat keluarga objek terkait atau dependen tanpa menentukan kelas konkretnya.

Anda dapat memahami maksud, Struktur, Checklist dan Aturan praktis dari Abstrak Pabrik pola dari ini sourcemaking artikel.

Daftar Periksa:

1. Putuskan apakah kemandirian platform dan layanan kreasi adalah sumber kesulitan saat ini.
2. Petakan matriks platform versus produk .
3. Tentukan antarmuka pabrik yang terdiri dari metode pabrik per produk.
4. Tentukan kelas turunan pabrik untuk setiap platform yang merangkum semua referensi ke operator baru.
5. The klien harus pensiun semua referensi baru, dan menggunakan metode pabrik untuk membuat produk benda.

Pabrik Abstrak sangat bagus untuk mendukung banyak platform sambil menjaga basis kode Anda tetap bersatu. Misalkan Anda memiliki program Qt atau GTK + atau .NET / Mono besar yang ingin Anda jalankan di Windows, Linux, dan OSX. Tetapi Anda memiliki fitur yang diimplementasikan dengan cara berbeda pada setiap platform (mungkin melalui API kernel32 atau fitur POSIX).

public abstract class Feature
{
    public abstract int PlatformSpecificValue { get; }

    public static Feature PlatformFeature
    {
        get
        {
            string platform;
            // do platform detection here
            if (platform == "Win32")
                return new Win32Feature();
            if (platform == "POSIX")
                return new POSIXFeature();
        }
    }

    // platform overrides omitted
}

Dengan Pabrik Abstrak ini, UI Anda tidak perlu mengetahui apa pun tentang platform saat ini.

Feature feature = Feature.PlatformFeature;
Console.WriteLine(feature.PlatformSpecificValue);

Jika melihat pola desainnya, hampir semuanya bisa dibuat mubazir. Tetapi pola apa yang berarti pendekatan yang umum digunakan untuk solusi untuk jenis masalah yang serupa. Pola desain memberi Anda pendekatan atau solusi tingkat desain untuk serangkaian masalah desain yang serupa. Menggunakan pola desain membantu Anda memecahkan masalah Anda dan karenanya menghasilkan lebih cepat.

mudah, membayangkan bahwa Anda memiliki kode yang bekerja dengan abstraksi, Anda harus membuat abstraksi dan bukan kelas konkret.

Anda harus selalu bekerja melawan abstraksi karena Anda dapat memodifikasi kode dengan lebih baik.

Ini adalah contoh yang bagus: http://en.wikipedia.org/wiki/Abstract_factory_pattern#C.23

Saya menemukan pola Pabrik Abstrak berlebihan.

Pertama-tama, itu tidak terjadi bahwa sering bahwa Anda memiliki satu set saling terkait jenis yang ingin Anda instantiate.

Kedua, tingkat tipuan (abstraksi) yang disediakan oleh antarmuka biasanya mencukupi saat bekerja dengan injeksi ketergantungan.

Contoh tipikal WindowsGui vs MacGui vs ... di mana Anda akan memiliki WindowsButton, MacButton, WindowsScrollBar, MacScrollbar, dll. Seringkali lebih mudah diterapkan dengan menentukan Tombol konkret , Scrollbars, dll. Menggunakan pola Pengunjung dan / atau Interpreter untuk menyediakan perilaku sebenarnya.

Saya rasa ada tempat untuk pola pabrik abstrak daripada pola pabrik sederhana di tempat-tempat di mana contoh Anda sangat rumit, terlalu rumit dan jelek untuk satu pabrik dan terlalu rumit untuk dipahami UI ..

Katakanlah ini adalah merek TYPE_A bukan kelas tunggal .. katakanlah ada keluarga dari 100 jenis kelas yang serupa dari Tipe-A dan Anda perlu membuat instance satu objek darinya. Bayangkan ada detail info canggih yang diperlukan untuk membuat objek yang benar dari merek dari banyak jenis objek yang serupa, dan dalam entitas objek ini Anda perlu mengetahui dengan tepat parameter mana yang harus disetel dan cara menyetelnya.

Di pabrik khusus untuk merek ini kami akan meminta mereka untuk membedakan dan mendapatkan objek yang tepat untuk dipakai dan juga bagaimana cara membuatnya. kita akan tahu bahwa menurut masukan dari internet (katakanlah warna apa yang tersedia di toko online), dan dari aplikasi dan layanan lain yang berjalan di latar belakang (parameter UI tidak menyadarinya).

Dan mungkin besok kita akan memiliki keluarga lain katakanlah type_B dan type_C untuk dipakai. Jadi UI akan memiliki "jika lain" untuk mengetahui apakah pengguna menginginkan "type_A", "type_B" atau "type_C" - tetapi kelas pabrik akan memutuskan dengan tepat kelas mana dari jenis (dari keluarga) yang akan dibangun, dan bagaimana menyetelnya - nilai apa yang harus disetel ke parameternya, atau untuk dikirim ke kontraktornya. Semua ini - menurut banyak parameter yang tidak disadari UI. Semua ini terlalu berlebihan untuk satu kelas pabrik.

Contoh kehidupan nyata disediakan di namespace System.Data.Common yang memiliki kelas dasar abstrak yang mencakup DbConnection, DbCommand, dan DbDataAdapter dan dibagikan oleh penyedia data .NET Framework, seperti System.Data.SqlClient dan System.Data.OracleClient yang mana memungkinkan pengembang untuk menulis kode akses data generik yang tidak bergantung pada penyedia data tertentu.

Kelas DbProviderFactories menyediakan metode statis untuk membuat instance DbProviderFactory. Instance kemudian mengembalikan objek yang diketik dengan kuat berdasarkan informasi penyedia dan string koneksi yang diberikan pada waktu proses.

Contoh:

 DataTable allProvidersTable = DbProviderFactories.GetFactoryClasses();

        /* Getting SqlClient family members */
        DbProviderFactory dbProviderFactory = DbProviderFactories.GetFactory("System.Data.SqlClient");
        DbCommand dbCommand = dbProviderFactory.CreateCommand();
        DbConnection dbConnection = dbProviderFactory.CreateConnection();
        DbDataAdapter dbDataAdapter = dbProviderFactory.CreateDataAdapter();

        SqlClientFactory sqlClientFactory = (SqlClientFactory)dbProviderFactory;
        SqlConnection sqlConnection = (SqlConnection)dbConnection;
        SqlCommand sqlCommand = (SqlCommand) dbCommand;
        SqlDataAdapter sqlDataAdapter = (SqlDataAdapter) dbDataAdapter;

        /* Getting OracleClient family members*/
        dbProviderFactory = DbProviderFactories.GetFactory("System.Data.OracleClient");
        dbCommand = dbProviderFactory.CreateCommand();
        dbConnection = dbProviderFactory.CreateConnection();
        dbDataAdapter = dbProviderFactory.CreateDataAdapter();

        OracleClientFactory oracleClientFactory = (OracleClientFactory)dbProviderFactory;
        OracleConnection oracleConnection = (OracleConnection)dbConnection;
        OracleCommand oracleCommand = (OracleCommand)dbCommand;
        OracleDataAdapter oracleDataAdapter = (OracleDataAdapter)dbDataAdapter;

Contoh-2

Arsitektur Solusi Kode

Instans pabrik beton disediakan menggunakan metode Pabrik statis seperti di bawah ini

public  class FurnitureProviderFactory
{
    public static IFurnitureFactory GetFactory(string furnitureType)
    {
        if (furnitureType == "Wood")
        {
            return new WoodenFurnitureFactory();
        }
        if (furnitureType == "Plastic")
        {
            return new PlasticFurnitureFactory();
        }
        throw new Exception("Undefined Furniture");
    }
}

Untuk menjawab pertanyaan Anda secara langsung, Anda mungkin bisa lolos tanpa menggunakan pola desain seperti itu.

Namun perlu diingat, bahwa sebagian besar proyek di dunia nyata berkembang dan Anda ingin memberikan semacam ekstensibilitas agar proyek Anda tahan di masa depan.

Dari pengalaman saya sendiri, sebagian besar waktu, Pabrik diimplementasikan dan seiring pertumbuhan proyek itu berubah menjadi pola desain yang lebih kompleks seperti Pabrik Abstrak.

Ini semua tentang ketergantungan. Jika Anda tidak peduli dengan kopling dan dependensi yang ketat, maka Anda tidak memerlukan pabrik abstrak. Tapi itu akan menjadi masalah segera setelah Anda menulis aplikasi yang membutuhkan pemeliharaan.

Katakanlah Anda membuat a.jar, dan orang lain menggunakan toples Anda dan ingin menggunakan objek konkret baru dalam kode Anda. Jika Anda tidak menggunakan pabrik abstrak, dia harus mengubah kode Anda atau menimpa kode Anda. Tetapi jika Anda menggunakan pabrik abstrak, maka dia dapat menyediakan pabrik dan memberikan kode Anda dan semuanya baik-baik saja.

Versi refined: Pertimbangkan skenario di bawah ini: Orang lain menulis kerangka kerja. Kerangka kerja ini menggunakan pabrik abstrak dan beberapa pabrik beton untuk membuat banyak objek pada saat berjalan. Jadi Anda dapat dengan mudah mendaftarkan pabrik Anda sendiri ke kerangka kerja yang ada dan membuat objek Anda sendiri. Kerangka tertutup untuk modifikasi dan masih mudah diperluas karena pola pabrik yang abstrak.

Pola ini sangat berguna ketika klien tidak tahu persis tipe apa yang akan dibuat. Sebagai contoh, misalkan Showroom yang secara eksklusif menjual ponsel mendapat pertanyaan untuk ponsel pintar buatan Samsung. Di sini kita tidak tahu persis jenis objek yang akan dibuat (dengan asumsi semua informasi untuk telepon dibungkus dalam bentuk objek konkret). Tapi kami tahu bahwa kami sedang mencari ponsel pintar yang diproduksi oleh Samsung. Informasi ini sebenarnya dapat digunakan jika desain kami memiliki implementasi pabrik Abstrak.

Memahami dan Menerapkan Pola Pabrik Abstrak di C #