উত্তর:
আপনার ব্যক্তিগত নির্মাণকারীর প্রয়োজন হতে পারে এমন কয়েকটি কারণ:
finalশ্রেণী স্তর স্থাপন করতে হবে। প্রাইভেট কনস্ট্রাক্টর রাখা এই কারণে বেশ বেহুদা।
final। স্ট্রিং ক্লাসের জন্য সান এটি করেছিল এবং এপিআইয়ের যুক্তিসঙ্গত অংশ যা প্রসারিত করা উচিত নয়।
একটি প্রাইভেট কনস্ট্রাক্টর সরবরাহ করে আপনি ক্লাসের উদাহরণগুলি এই খুব বর্গ বাদে অন্য কোনও জায়গায় তৈরি হওয়া থেকে বিরত রাখেন। এই ধরনের কন্সট্রাক্টর সরবরাহের জন্য বেশ কয়েকটি ব্যবহারের কেস রয়েছে।
উ: আপনার শ্রেণীর উদাহরণগুলি একটি staticপদ্ধতিতে তৈরি করা হয়েছে । staticপদ্ধতি তারপর হিসেবে ঘোষণা করা হয় public।
class MyClass()
{
private:
MyClass() { }
public:
static MyClass * CreateInstance() { return new MyClass(); }
};
বি। আপনার ক্লাসটি একটি সিঙ্গলটন । এর অর্থ, প্রোগ্রামে আপনার শ্রেণীর একের বেশি উদাহরণ উপস্থিত নেই।
class MyClass()
{
private:
MyClass() { }
public:
MyClass & Instance()
{
static MyClass * aGlobalInst = new MyClass();
return *aGlobalInst;
}
};
সি। (কেবলমাত্র আসন্ন সি ++ 0x মানের ক্ষেত্রে প্রযোজ্য) আপনার বেশ কয়েকটি কনস্ট্রাক্টর রয়েছে। তাদের মধ্যে কিছু ঘোষণা করা হয় public, অন্যরা private। কোডের আকার হ্রাস করার জন্য, পাবলিক কনস্ট্রাক্টররা 'কল' বেসরকারী কন্সট্রাক্টররা ঘুরেফিরে সমস্ত কাজ করে। আপনার publicকনস্ট্রাক্টরগুলিকে ডেলিগেটিং কনস্ট্রাক্টর বলা হয় :
class MyClass
{
public:
MyClass() : MyClass(2010, 1, 1) { }
private:
MyClass(int theYear, int theMonth, int theDay) { /* do real work */ }
};
D. আপনি অবজেক্ট অনুলিপি সীমাবদ্ধ করতে চান (উদাহরণস্বরূপ, শেয়ার্ড রিসোর্স ব্যবহারের কারণে):
class MyClass
{
SharedResource * myResource;
private:
MyClass(const MyClass & theOriginal) { }
};
E. আপনার ক্লাসটি একটি ইউটিলিটি ক্লাস । তার মানে, এটিতে কেবল staticসদস্য রয়েছে । এই ক্ষেত্রে, প্রোগ্রামে কোনও বস্তুর উদাহরণ তৈরি করা আবশ্যক।
একটি "পিছনের দরজা" রেখে যা অন্য বন্ধু শ্রেণি / ফাংশনটিকে ব্যবহারকারীর জন্য নিষিদ্ধ উপায়ে একটি অবজেক্ট তৈরি করতে দেয়। একটি উদাহরণ যা মনে আসে তা হ'ল একটি পুনরুক্তি (সি ++) তৈরির ধারক হবে:
Iterator Container::begin() { return Iterator(this->beginPtr_); }
// Iterator(pointer_type p) constructor is private,
// and Container is a friend of Iterator.
friendএটি সুনির্দিষ্টভাবে ব্যবহার করতে পারে না — এবং এটির একটি খারাপ ধারণা এমন অনেকগুলি ক্ষেত্রে রয়েছে। দুঃখের বিষয়, বার্তাটি খুব ভালভাবে গ্রহণ করা হয়েছে, এবং অনেক বিকাশকারী কখনই ভাষাটি এতটা ভালভাবে শিখতে পারে না যে মাঝে মধ্যে ব্যবহার friendকেবলমাত্র গ্রহণযোগ্য নয়, তবে তার চেয়ে বেশি পছন্দযোগ্য । আপনার উদাহরণটি ঠিক এরকম একটি ঘটনা ছিল। ইচ্ছাকৃত দৃ strong় মিলন কোনও অপরাধ নয়, এটি একটি ডিজাইনের সিদ্ধান্ত।
প্রত্যেকে সিঙ্গেলটন জিনিসটির উপর আটকে আছে, বাহ!
অন্য জিনিস:
এটি এমন একটি কনস্ট্রাক্টরের পক্ষে খুব কার্যকর হতে পারে যাতে প্রচলিত কোড থাকে; 'এটি (...)' ব্যবহার করে অন্যান্য কনস্ট্রাক্টর দ্বারা বেসরকারী কনস্ট্রাক্টরদের ডাকা যেতে পারে; স্বরলিপি। একটি প্রাইভেট (বা সুরক্ষিত) কনস্ট্রাক্টরে সাধারণ সূচনা কোড তৈরি করে আপনি স্পষ্টভাবে পরিষ্কার করে দিচ্ছেন যে এটি কেবল নির্মাণের সময় ডাকা হয়, এটি কেবল কোনও পদ্ধতি যদি না হয় তবে:
public class Point {
public Point() {
this(0,0); // call common constructor
}
private Point(int x,int y) {
m_x = x; m_y = y;
}
};
কিছু উদাহরণ রয়েছে যেখানে আপনি পাবলিক কনস্ট্রাক্টর ব্যবহার করতে নাও চান; উদাহরণস্বরূপ, যদি আপনি একটি একক ক্লাস চান।
আপনি যদি তৃতীয় পক্ষের দ্বারা ব্যবহৃত একটি অ্যাসেম্বলি লিখছেন তবে এমন অনেকগুলি অভ্যন্তরীণ শ্রেণি থাকতে পারে যা আপনি কেবল আপনার সমাবেশ দ্বারা তৈরি করতে চান এবং আপনার সমাবেশের ব্যবহারকারীদের দ্বারা তাত্ক্ষণিকভাবে না বসানো যেতে পারে।
এটি নিশ্চিত করে যে আপনার (ব্যক্তিগত নির্মাণকারী সহ শ্রেণি) কনট্রাক্টরকে কীভাবে ডাকা হয় তা নিয়ন্ত্রণ করে।
উদাহরণ: কারখানার স্ট্যাটিক ফ্যাক্টরি পদ্ধতিটি বস্তুগুলিকে ফেরত দিতে পারে কারণ কারখানার পদ্ধতি তাদের বরাদ্দ দেওয়ার জন্য পছন্দ করে (উদাহরণস্বরূপ সিঙ্গলটন কারখানার মতো)।
কেবলমাত্র নির্দিষ্ট শ্রেণি দ্বারা সুরক্ষার জন্য (সুরক্ষার কারণে) আমাদের প্রাইভেট কনস্ট্রাক্টর থাকতে পারে।
সি ++ উদাহরণ:
class ClientClass;
class SecureClass
{
private:
SecureClass(); // Constructor is private.
friend class ClientClass; // All methods in
//ClientClass have access to private
// & protected methods of SecureClass.
};
class ClientClass
{
public:
ClientClass();
SecureClass* CreateSecureClass()
{
return (new SecureClass()); // we can access
// constructor of
// SecureClass as
// ClientClass is friend
// of SecureClass.
}
};
দ্রষ্টব্য: দ্রষ্টব্য: কেবল ক্লায়েন্টক্লাস (যেহেতু এটি সিকিউর ক্লাসের বন্ধু) সিকিউর ক্লাসের কনস্ট্রাক্টরকে কল করতে পারে।
এখানে বেসরকারী নির্মাণকারীর কয়েকটি ব্যবহার রয়েছে:
আমি আপনার কাছ থেকে একই প্রশ্ন সম্বোধন করে একটি প্রশ্ন দেখেছি।
কেবলমাত্র যদি আপনি অন্যকে দৃষ্টান্ত তৈরি করতে না চান, তবে কনডাক্টরটিকে একটি সীমিত সুযোগের মধ্যে রাখুন। ব্যবহারিক প্রয়োগ (উদাহরণস্বরূপ) হ'ল সিঙ্গলটন প্যাটার্ন।
আপনি করা উচিত নয় কন্সট্রাকটর ব্যাক্তিগত করা হবে। সময়কাল। এটিকে সুরক্ষিত করুন, যাতে আপনার প্রয়োজন হলে ক্লাসটি বাড়িয়ে দিতে পারেন।
সম্পাদনা: আমি যে পাশে আছি তা কতই না নিম্নমুখী হলেও তা আমি দাঁড়িয়ে আছি। আপনি কোডটিতে ভবিষ্যতের বিকাশের সম্ভাবনা কেটে ফেলছেন। যদি অন্য ব্যবহারকারী বা প্রোগ্রামাররা সত্যই ক্লাসটি প্রসারিত করার জন্য দৃ determined়প্রতিজ্ঞ হয়, তবে তারা কেবল নির্মাতাকে উত্স বা বাইকোডে সুরক্ষিতভাবে পরিবর্তন করবে। তাদের জীবনকে আরও শক্ত করার জন্য আপনি কিছু করতে পারেন নি। আপনার নির্মাণকারীর মন্তব্যে একটি সতর্কতা অন্তর্ভুক্ত করুন এবং এটি এ ছেড়ে দিন।
যদি এটি কোনও ইউটিলিটি শ্রেণি হয় তবে সহজ, আরও সঠিক এবং আরও মার্জিত সমাধান হ'ল এক্সটেনশন রোধ করতে পুরো শ্রেণিকে "স্থিতিশীল চূড়ান্ত" চিহ্নিত করা। কেবল কনস্ট্রাক্টরকে ব্যক্তিগত হিসাবে চিহ্নিত করার জন্য এটি কোনও ভাল কাজ করে না; সত্যিকার অর্থে নির্ধারিত ব্যবহারকারী সর্বদা কনস্ট্রাক্টর পেতে প্রতিবিম্ব ব্যবহার করতে পারেন।
protected
কন্সট্রাক্টরের একটি ভাল ব্যবহার হ'ল স্ট্যাটিক ফ্যাক্টরি পদ্ধতিগুলি ব্যবহারের জন্য জোর করে চাপানো, যা আপনাকে ইনস্ট্যান্টেশন বা পুলের সীমাবদ্ধ করতে এবং ব্যয়বহুল সংস্থানসমূহ (ডিবি সংযোগগুলি, দেশীয় সংস্থানগুলি) পুনরায় ব্যবহার করতে দেয়।কনস্ট্রাক্টর কোনও কাজের জন্য ব্যক্তিগত যেমন আপনার যখন সিঙ্গলটন প্রয়োগ করতে হবে বা শ্রেণীর অবজেক্টের সংখ্যা সীমাবদ্ধ করতে হবে। উদাহরণস্বরূপ সিঙ্গলটন বাস্তবায়নে আমাদের কনস্ট্রাক্টরকে বেসরকারী করতে হবে
#include<iostream>
using namespace std;
class singletonClass
{
static int i;
static singletonClass* instance;
public:
static singletonClass* createInstance()
{
if(i==0)
{
instance =new singletonClass;
i=1;
}
return instance;
}
void test()
{
cout<<"successfully created instance";
}
};
int singletonClass::i=0;
singletonClass* singletonClass::instance=NULL;
int main()
{
singletonClass *temp=singletonClass::createInstance();//////return instance!!!
temp->test();
}
আবার আপনি যদি 10 অবধি অবজেক্ট তৈরির সীমাবদ্ধ করতে চান তবে নীচেরটি ব্যবহার করুন
#include<iostream>
using namespace std;
class singletonClass
{
static int i;
static singletonClass* instance;
public:
static singletonClass* createInstance()
{
if(i<10)
{
instance =new singletonClass;
i++;
cout<<"created";
}
return instance;
}
};
int singletonClass::i=0;
singletonClass* singletonClass::instance=NULL;
int main()
{
singletonClass *temp=singletonClass::createInstance();//return an instance
singletonClass *temp1=singletonClass::createInstance();///return another instance
}
ধন্যবাদ
আপনার একাধিক কনস্ট্রাক্টর থাকতে পারে। সি ++ একটি ডিফল্ট কনস্ট্রাক্টর এবং একটি ডিফল্ট অনুলিপি নির্মাণকারীর সরবরাহ করে যদি আপনি কোনও স্পষ্টভাবে সরবরাহ না করেন। ধরুন আপনার কাছে এমন একটি শ্রেণি রয়েছে যা কেবলমাত্র কিছু প্যারামিটারাইজড কনস্ট্রাক্টর ব্যবহার করে নির্মিত যেতে পারে। হতে পারে এটি ভেরিয়েবলের সূচনা করে। যদি কোনও ব্যবহারকারী এই নির্মাতা ব্যতীত এই শ্রেণিটি ব্যবহার করে তবে তারা সমস্যার কোনও শেষ করতে পারে না। একটি ভাল সাধারণ নিয়ম: যদি ডিফল্ট বাস্তবায়ন বৈধ না হয় তবে ডিফল্ট এবং অনুলিপি নির্মাণকারী উভয়কেই বেসরকারী করুন এবং কোনও প্রয়োগ সরবরাহ করবেন না:
class C
{
public:
C(int x);
private:
C();
C(const C &);
};
বৈধ নয় এমন ডিফল্ট কনস্ট্রাক্টরগুলির সাথে ব্যবহারকারীদের অবজেক্টটি ব্যবহার থেকে বিরত রাখতে সংকলকটি ব্যবহার করুন।
কার্যকর জাভা থেকে উদ্ধৃতি দিয়ে , আপনার কাছে প্রাইভেট কনস্ট্রাক্টরের সাথে একটি ক্লাস থাকতে পারে একটি ইউটিলিটি ক্লাস যা ধ্রুবককে সংজ্ঞায়িত করে (স্থিতিশীল চূড়ান্ত ক্ষেত্র হিসাবে)।
( সম্পাদনা: মন্তব্য অনুসারে এটি এমন কিছু যা কেবল জাভার ক্ষেত্রে প্রযোজ্য হতে পারে, অন্য কোনও OO ভাষায় এই নির্মাণটি প্রযোজ্য / প্রয়োজন হয় কিনা তা আমি অসচেতন (সি ++ বলুন))
নীচের মত একটি উদাহরণ:
public class Constants {
private Contants():
public static final int ADDRESS_UNIT = 32;
...
}
EDIT_1 : আবার, নীচে ব্যাখ্যা জাভায় প্রযোজ্য: (এবং কার্যকর জাভা বইটি থেকে উল্লেখ করে )
নীচের মত ইউটিলিটি ক্লাসের একটি ইনস্ট্যান্টেশন ক্ষতিকারক না হলেও এটি কোনও উদ্দেশ্য করে না কারণ সেগুলি তাত্ক্ষণিকভাবে নকশাকৃত করার জন্য ডিজাইন করা হয়নি।
উদাহরণস্বরূপ, বলুন ক্লাস কনস্ট্যান্টদের জন্য কোনও ব্যক্তিগত কনস্ট্রাক্টর নেই। নীচের মতো একটি কোড অংশ বৈধ তবে কনস্ট্যান্ট শ্রেণীর ব্যবহারকারীর উদ্দেশ্য সম্পর্কে ভাল বোঝা যায় না
unit = (this.length)/new Constants().ADDRESS_UNIT;
মত কোডের বিপরীতে
unit = (this.length)/Constants.ADDRESS_UNIT;
এছাড়াও আমি মনে করি যে কোনও প্রাইভেট কনস্ট্রাক্টর কনস্ট্যান্টস ( ডিজাইন ) শ্রেণির ডিজাইনারের অভিপ্রায়টি আরও ভালভাবে জানায় ।
জাভা একটি ডিফল্ট প্যারামিটারলেস পাবলিক কনস্ট্রাক্টর সরবরাহ করে যদি কোনও কনস্ট্রাক্টর সরবরাহ না করা হয় এবং যদি আপনার উদ্দেশ্য ইনস্ট্যান্টেশন রোধ করা হয় তবে একটি প্রাইভেট কনস্ট্রাক্টর প্রয়োজন।
কেউ শীর্ষ স্তরের শ্রেণীর স্থিতিশীল চিহ্নিত করতে পারে না এবং এমনকি একটি চূড়ান্ত শ্রেণি ইনস্ট্যান্ট করা যায়।
ইউটিলিটি ক্লাসে ব্যক্তিগত নির্মাণকারী থাকতে পারে। ক্লাসগুলির ব্যবহারকারীরা এই ক্লাসগুলি ইনস্ট্যান্ট করতে সক্ষম হবেন না:
public final class UtilityClass {
private UtilityClass() {}
public static utilityMethod1() {
...
}
}
অন্যতম গুরুত্বপূর্ণ ব্যবহার হ'ল সিঙ্গলটন ক্লাসে
class Person
{
private Person()
{
//Its private, Hense cannot be Instantiated
}
public static Person GetInstance()
{
//return new instance of Person
// In here I will be able to access private constructor
}
};
এটিও উপযুক্ত, যদি আপনার শ্রেণিতে কেবল স্থির পদ্ধতি থাকে। অর্থ্যাৎ আপনার ক্লাসটি ইনস্ট্যান্ট করার দরকার নেই কারও
এটি সত্যই একটি স্পষ্ট কারণ: আপনি একটি বস্তু তৈরি করতে চান, তবে এটি নির্মাণের মধ্যে (ইন্টারফেসের শর্তে) এটি করা ব্যবহারিক নয়।
Factoryউদাহরণস্বরূপ বেশ সুস্পষ্ট, আমাকে প্রকট দিন Named Constructorবাগ্ধারা।
বলুন আমার একটি ক্লাস রয়েছে Complexযা একটি জটিল সংখ্যার প্রতিনিধিত্ব করতে পারে।
class Complex { public: Complex(double,double); .... };
প্রশ্নটি হল: নির্মাতা কি বাস্তব এবং কল্পিত অংশগুলি প্রত্যাশা করে, বা এটি আদর্শ এবং কোণ (পোলার স্থানাঙ্ক) প্রত্যাশা করে?
ইন্টারফেসটিকে আরও সহজ করার জন্য আমি এটি পরিবর্তন করতে পারি:
class Complex
{
public:
static Complex Regular(double, double = 0.0f);
static Complex Polar(double, double = 0.0f);
private:
Complex(double, double);
}; // class Complex
এটিকে Named Constructorআইডিয়ম বলা হয় : ক্লাসটি কেবল স্ক্র্যাচ থেকে স্পষ্ট করে বলা যেতে পারে যে আমরা কোন নির্মাণকারীর ব্যবহার করতে চাই।
এটি অনেকগুলি নির্মাণ পদ্ধতির একটি বিশেষ ক্ষেত্রে। নকশা নিদর্শন বিল্ড বস্তু উপায়ে একটি ভাল নম্বর প্রদান: Builder, Factory, Abstract Factory, ... এবং একটি প্রাইভেট কন্সট্রাকটর নিশ্চিত করবে যে ব্যবহারকারী সঠিকভাবে সীমাবদ্ধ।
সুপরিচিত ব্যবহারগুলি ছাড়াও ...
মেথড অবজেক্ট প্যাটার্নটি বাস্তবায়নের জন্য , আমি এর সংক্ষিপ্তসারটি করব:
"প্রাইভেট কনস্ট্রাক্টর, পাবলিক স্ট্যাটিক পদ্ধতি"
"বাস্তবায়নের জন্য অবজেক্ট, ইন্টারফেসের জন্য ফাংশন"
যদি আপনি কোনও অবজেক্টটি ব্যবহার করে কোনও ফাংশন বাস্তবায়ন করতে চান এবং কোনও এক-অফ গণনা (কোনও পদ্ধতি কল দ্বারা) করার বাইরে বস্তুটি কার্যকর না হয় তবে আপনার কাছে একটি থ্রোওয়ে অবজেক্ট রয়েছে । আপনি এই সাধারণ অ্যান্টি-প্যাটার্নটিকে প্রতিরোধ করে একটি স্থির পদ্ধতিতে অবজেক্ট তৈরি এবং পদ্ধতি কলকে সজ্জিত করতে পারেন:
z = new A(x,y).call();
... এটি একটি (নেমস্পিড) ফাংশন কল দিয়ে প্রতিস্থাপন করা:
z = A.f(x,y);
কলকারীটিকে কখনই জানতে বা যত্নের প্রয়োজন হয় না যে আপনি কোনও অভ্যন্তরীণ অভ্যন্তরীণভাবে ব্যবহার করছেন, একটি ক্লিনার ইন্টারফেস প্রদান করছেন এবং অবজেক্টটি থেকে আবর্জনা আটকাচ্ছেন বা অবজেক্টটির ভুল ব্যবহার করবেন না।
উদাহরণস্বরূপ, যদি আপনি পদ্ধতি জুড়ে একটি গণনার ভেঙ্গে করতে চান তাহলে foo, barএবং zorkএবং ফাংশন আউট, আপনি এটি বাস্তবায়ন হতে পারে নিম্নরূপ অনেক মান পাস না করেও ভাগ অবস্থায় উদাহরণস্বরূপ:
class A {
public static Z f(x, y) {
A a = new A(x, y);
a.foo();
a.bar();
return a.zork();
}
private A(X x, Y y) { /* ... */ };
}
এই পদ্ধতি অবজেক্ট প্যাটার্নটি স্মার্টটাক সেরা অনুশীলন প্যাটার্নস , কেন্ট বেক, পৃষ্ঠা 34–37 এ দেওয়া হয়েছে, যেখানে এটি একটি রিফ্যাক্টরিং প্যাটার্নের শেষ ধাপ, শেষ:
- আসল পদ্ধতিটিকে এমন একটি দিয়ে প্রতিস্থাপন করুন যা নতুন পদ্ধতির উদাহরণ তৈরি করে, মূল পদ্ধতির পরামিতিগুলি এবং রিসিভার দিয়ে নির্মিত এবং "গণনা" আহ্বান করে।
এটি এখানে অন্যান্য উদাহরণগুলির তুলনায় উল্লেখযোগ্যভাবে পৃথক: শ্রেণিটি অস্থায়ী (কোনও ইউটিলিটি শ্রেণীর বিপরীতে), তবে উদাহরণগুলি ব্যক্তিগত (একক কারখানার মতো কারখানার পদ্ধতিগুলির বিপরীতে), এবং স্ট্যাকের উপরে বাঁচতে পারে, যেহেতু তারা কখনও পালায় না।
এই প্যাটার্নটি বোতলস-আপ ওওপি-তে খুব দরকারী, যেখানে নিম্ন-স্তরের বাস্তবায়নকে সহজ করার জন্য অবজেক্টগুলি ব্যবহৃত হয়, তবে বাহ্যিকভাবে বাহ্যিকভাবে উন্মুক্ত হয় না এবং প্রায়শই উপস্থাপিত হয় এবং উচ্চ-স্তরের ইন্টারফেসের সাথে শুরু হয় শীর্ষ-ওওপি-র সাথে বৈপরীত্য হয়।
কখনও কখনও কার্যকর হয় যদি আপনি কখন এবং কখন (এবং কত) কোনও বস্তুর উদাহরণ তৈরি করতে চান তা নিয়ন্ত্রণ করতে চান।
অন্যদের মধ্যে, নিদর্শনগুলিতে ব্যবহৃত:
Singleton pattern
Builder pattern
প্রাইভেট কনস্ট্রাক্টর ব্যবহারের ক্ষেত্রে ডোমেন-চালিত ডিজাইনের মুখোমুখি পাঠযোগ্যতা / রক্ষণাবেক্ষণযোগ্যতা বৃদ্ধি করা যেতে পারে। "মাইক্রোসফ্ট। নেট - এন্টারপ্রাইজের আর্কিটেকিং অ্যাপ্লিকেশন, দ্বিতীয় সংস্করণ" থেকে:
var request = new OrderRequest(1234);
উদ্ধৃতি, "এখানে দুটি সমস্যা রয়েছে First প্রথমত, কোডটি দেখার সময়, কেউ কী চলছে তা খুব কমই অনুমান করতে পারে Order অর্ডার রিকোয়েস্টের একটি উদাহরণ তৈরি করা হচ্ছে, তবে কেন এবং কোন ডেটা ব্যবহার করছে? 1234 কি? এটি দ্বিতীয় সমস্যাটির দিকে নিয়ে যায়: আপনি সীমাবদ্ধ প্রসঙ্গের সর্বব্যাপী ভাষা লঙ্ঘন করছেন The ভাষা সম্ভবত এর মতো কিছু বলে: গ্রাহক একটি আদেশের অনুরোধ জারি করতে পারে এবং একটি ক্রয় আইডি নির্দিষ্ট করার অনুমতি দেওয়া হয় that's যদি এটি হয় তবে একটি নতুন অর্ডাররুইকস্ট উদাহরণটি পাওয়ার আরও ভাল উপায় এখানে রয়েছে here : "
var request = OrderRequest.CreateForCustomer(1234);
কোথায়
private OrderRequest() { ... }
public OrderRequest CreateForCustomer (int customerId)
{
var request = new OrderRequest();
...
return request;
}
আমি এটি প্রতিটি একক শ্রেণীর জন্য সমর্থন করছি না, তবে উপরের ডিডিডি দৃশ্যের জন্য আমি মনে করি যে কোনও নতুন অবজেক্টের সরাসরি সৃষ্টি রোধ করার জন্য এটি সঠিকভাবে বোধ করা যায়।