Կառուցող (նախագծման ձևանմուշ)

Կառուցող նախագծման ձևանմուշը ծրագրային ապահովման ստեղծող ձևանմուշ է։ Ի տարբերություն աբստրակտ ֆաբրիկա և ֆաբրիկային մեթոդ նախագծման ձևանմուշների, որոնք ներառում են պոլիմորֆիզմ, կառուցող ձևանմուշը փորձում է գտնել կոնստրուկտորի տելեսկոպիկ անտիմոդելի լուծում։ Կոնստրուկտորի տելեսկոպիկ անտիմոդելն առաջանում է, երբ կոնստրուկտորի պարամետրերի կոմբինացիայի մեծացումը բերում է կոնստրուկտորների ցանկի էքսպոնենտալ մեծացման։ Բազմաթիվ կոնստրուկտորներ օգտագործելու փոխարեն կառուցող ձևանմուշն օգտագործում է այլ օբյեկտ՝ որպես կառուցող, որը ինիցիալիզացիայի պահին քայլ առ քայլ ստանում է ամեն մի պարամետրը, իսկ այնուհետև անմիջապես վերադարձնում է ստացված և կառուցված օբյեկտը։

Կառուցող ձևանմուշը ևս մի այլ առավելություն ունի։ Այն կարող է օգտագործվել այն օբյեկտների համար, ովքեր ունեն հարթ տվյալներ (html կոդ, SQL կանչեր, X.509 սերտեֆիկատներ...), այսինքն տվյալներ, որոնք հնարավոր չէ հեշտությամբ վերախմբագրել։ Այս տիպի տվյալները չեն կարող փոփոխվել քայլ առ քայլ, այլ պետք է փոխվեն միանգամից։ Նմանատիպ օբյեկտ ստեղծելու լավագույն մեթոդը հանդիսանում է կառուցող դասի կիրառությունը։

Կառուցողը հաճախ ստեղծում է կազմող։ Հաճախ դիզայնի նախագիծը սկսում են ֆաբրիկային մեթոդն օգտագործելով (ավելի բարդ, բազմացող ենթադասերով) և Աբստրակտ ֆաբրիկա, Նախատիպ մոդելների օգտագործմամբ, որտեղ որ առավել ճկունություն է պահանջվում։ Երբեմն ստեղծման մոդելները լրացնում են միմյանց. Կառուցողը կարող է օգտագործել ուրիշ մոդելներից մեկը ստեղծվող կոմպոնենտների իրականացման համար։ Կառուցողները լավ թեկնածու են հանդիսանում fluent interface-ի համար։

Ընդհանուր հասկացողություններ 
 Client - հայցող
 Instance - նմուշ
 Implementation - իրականացում
 Product - արգասիք

Նկարագրություն 
Կառուցող ձևանմուշի նպատակը բարդ օբյեկտի կառուցման առանձնացումն է նրա իրականացումից։ Այս գործողության միջոցով միևնույն կառուցող պրոցեսը կարող է հանդես գալ տարբեր ներկայացումներով։

Կառուցվածք 

Builder
Աբստրակտ ինտերֆեյս օբյեկտ ստեղծելու համար։

Concrete Builder
Ներկայացնում է Builder-ի իրականացումը։ Սա օբյեկտ է, որը հնարավորություն ունի ստեղծել նոր օբյեկտներ։

Պսեվդոկոդ 
Մենք ունենք Car դաս։ Խնդիրը նրանումն է, որ Car-ն ունի բազմաթիվ տարբերակներ։ Յուրաքանչյուր տարբերակի համակցություննները դասի համար վերածվում է կոնստրուկտուրների մեծ քանակի։ Այսպիսով մենք ստեղծում ենք կառուցող CarBuilder դասը։ Մենք քայլ առ քայլ կոդն ուղարկում ենք CarBuilder-ին, իսկ այնուհետև ունենում ենք Car-ի վերջնական ճիշտ տարբերակով տեսքը։

 class Car is
   Can have GPS, trip computer and various numbers of seats. Can be a city car, a sports car, or a cabriolet.
 
 class CarBuilder is
   method getResult() is
       output:  a Car with the right options
     Construct and return the car.
 
   method setSeats(number) is
       input:  the number of seats the car may have.
     Tell the builder the number of seats.
 
   method setCityCar() is
     Make the builder remember that the car is a city car.
 
   method setCabriolet() is
     Make the builder remember that the car is a cabriolet.
 
   method setSportsCar() is
     Make the builder remember that the car is a sports car.
 
   method setTripComputer() is
     Make the builder remember that the car has a trip computer.
 
   method unsetTripComputer() is
     Make the builder remember that the car does not have a trip computer.
 
   method setGPS() is
     Make the builder remember that the car has a global positioning system.
 
   method unsetGPS() is
     Make the builder remember that the car does not have a global positioning system.
 
 Construct a CarBuilder called carBuilder
 carBuilder.setSeats(2)
 carBuilder.setSportsCar()
 carBuilder.setTripComputer()
 carBuilder.unsetGPS()
 car := carBuilder.getResult()

Օրինակ C# լեզվով 
Այս նախագծման ձևանմուշը ստեղծում է օբյեկտ ինտերֆեյսի վրա հիմնվելով, բայց և թույլ է տալիս ենթադասին որոշել, թե ինչ նմուշից այն պետք է ստեղծվի։ Մեթոդը նաև ավելի շատ է վերահսկում ստեղծման պրոցեսը։ Կառուցող ձևանմուշի համար կա Ղեկավար հասկացություն։ Ղեկավարը փաստացի ստեղծում է օբյեկտ և դրանից հետո մի քանի խնդիր () է թողարկում։

//IVSR: Builder Pattern
    public interface IBuilder
    {
        string RunBuilderTask1();
        string RunBuilderTask2();
    }

    public class Builder1 : IBuilder
    {

        #region IBuilder Members

        public string RunBuilderTask1()
        {
            throw new ApplicationException("Task1");
        }

        public string RunBuilderTask2()
        {
            throw new ApplicationException("Task2");
        }

        #endregion
    }

    public class Builder2 : IBuilder
    {
        #region IBuilder Members

        public string RunBuilderTask1()
        {
            return "Task3";
        }

        public string RunBuilderTask2()
        {
            return "Task4";
        }

        #endregion
    }

    public class Director
    {
        public IBuilder CreateBuilder(int type)
        {
            IBuilder builder = null;
            if (type == 1)
                builder = new Builder1();
            else
                builder = new Builder2();
            builder.RunBuilderTask1();
            builder.RunBuilderTask2();
            return builder;
        }
    }
Կառուցող ձևանմուշի դեպքում Ղեկավարն իրականում օգտագործում է CreateBuilder-ը, որպեսզի նոր օրինակներ կառուցի։ Այսպիսով, քանի որ Builderը փաստացի ստեղծվել է, մենք կարող ենք կանչել մի քանի խնդիրներ ()։

Ծանոթագրություններ 

Ծրագրավորում