a_sahayam_811572

 Profile Answers by a_sahayam_811572 Questions by a_sahayam_811572

• Aug 26th, 2007

 

Public constructors are used to instantiate and initialize the fields during object instantiation.

Private constructors are used to restrict the instatiation of object using 'new' operator. This type of constructors are mainly used for creating singleton object.

Static constructors are used when initializing class variables (static variables).

PeterVH

• Aug 19th, 2011

 

Public constructors = free for all to use
private contructors = If there is danger in the contruction you use a factory pattern or static singleton pattern so that the class can assume responsability and lessen the risks involved
static contructor = Is called once, and in theory you don't know when (well, at least for you make the first instance). Use this for fixed values.

Code
    public partial class Form4 : Form


    {


        public Form4() { InitializeComponent(); }


 


        private void button1_Click(object sender, EventArgs e)


        {


            Debug.WriteLine("Starting the function");


            Debug.WriteLine(Example.MeaningOfLife);


            var toTest = new Example();


            Debug.WriteLine("in my testinstance, IsHiddenInitialized = " + toTest.IsHiddenInitialized());


 


            // guess not, now for the real deal


            var realDeal = Example.GiveInstance("supersecret");


            Debug.WriteLine("in my real deal, IsHiddenInitialized = " + realDeal.IsHiddenInitialized());


 


            /*


             * output = 


             * Starting the function


             * Static constructor is called


             * 5


             * in my testinstance, IsHiddenInitialized = False


             * I am a nerd


             * in my real deal, IsHiddenInitialized = True


             * */


        }


    }


 


    public class Example


    {


        public static readonly int MeaningOfLife;


        private readonly TopSecretObject _hidden;


 


        public bool IsHiddenInitialized()


        {


            return _hidden != null;


        }


 


        /// <summary>


        /// Default public contructor for testing purposes


        /// </summary>


        public Example()


        {


            // Setup some harmless test values


        }


 


        /// <summary>


        /// private constructor that does dangerous stuff and should be called only fron inside


        /// this class, where the class itself can make sure nothing goes bad


        /// </summary>


        /// <param name="keepThisHidden">A secret to keep</param>


        private Example(string keepThisHidden)


        {


            _hidden = new TopSecretObject(keepThisHidden);


        }


 


        /// <summary>


        /// Static constructor to make sure the meaning of life is known


        /// </summary>


        static Example()


        {


            MeaningOfLife = 42;


            Debug.WriteLine("Static constructor is called");


        }


 


        public static Example GiveInstance(string secretPassword)


        {


            return secretPassword == "supersecret" ? 


                new Example("I am a nerd") : null;


        }


    }


 


    public class TopSecretObject


    {


        public TopSecretObject(string secretPassword)


        {


            Debug.WriteLine(secretPassword);


        }


    }

md.shahidkamal

 Profile Answers by md.shahidkamal 

• Aug 22nd, 2011

 

Constructor are used for creating an object and returning a reference of the object.
so whenever we write
class1 obj=new class1();

Public Constructor
The new Class1() is actually calling a public zero param constructor of class and instance is created.


Private Constructor
And if we mark the constructor as private we wont be able to write
class1 obj=new Class1()
hence the object of class1 cannot be created.
this type of construction is required when we are working with signleton pattern (Design Pattern)

Static Constructor
When we want our static data should be initiallize only one and first time we use
static constructor.
The Static constructor is called only once when the class or any of its derived is loaded in
clr before calling any instance constructor.

Obiageligeorge

 Profile Answers by Obiageligeorge 

• Aug 23rd, 2011

 

A public constructor is accessible anywhere in the application
A private constructor is restricted to the class within the application
Static constructor give access to the data without necessarily creating an object class