overload - how to instance a class in c#




Chame um construtor de outro (6)

Antes do corpo do construtor, use:

: base (parameters)

: this (parameters)

Exemplo:

public class People: User
{
   public People (int EmpID) : base (EmpID)
   {
      // Add more statements here.
   }
}

Eu tenho dois construtores que alimentam valores para campos readonly.

class Sample
{
    public Sample(string theIntAsString)
    {
        int i = int.Parse(theIntAsString);

        _intField = i;
    }

    public Sample(int theInt)
    {
        _intField = theInt;
    }


    public int IntProperty
    {
        get { return _intField; }
    }
    private readonly int _intField;

}

Um construtor recebe os valores diretamente e o outro faz alguns cálculos e obtém os valores, depois define os campos.

Ora aqui está o truque:

  1. Eu não quero duplicar o código de configuração. Neste caso, apenas um campo é definido, mas é claro que pode haver mais de um.
  2. Para tornar os campos readonly, eu preciso configurá-los a partir do construtor, então não posso "extrair" o código compartilhado para uma função de utilitário.
  3. Eu não sei como chamar um construtor de outro.

Alguma ideia?


Aqui está um exemplo que chama outro construtor e, em seguida, verifica a propriedade que ele definiu.

    public SomeClass(int i)
    {
        I = i;
    }

    public SomeClass(SomeOtherClass soc)
        : this(soc.J)
    {
        if (I==0)
        {
            I = DoSomethingHere();
        }
    }

Eu estou melhorando a resposta do supercat. Eu acho que o seguinte também pode ser feito:

class Sample
{
    private readonly int _intField;
    public int IntProperty
    {
        get { return _intField; }
    }

    void setupStuff(ref int intField, int newValue)
    {
        //Do some stuff here based upon the necessary initialized variables.
        intField = newValue;
    }

    public Sample(string theIntAsString, bool? doStuff = true)
    {
        //Initialization of some necessary variables.
        //==========================================
        int i = int.Parse(theIntAsString);
        // ................
        // .......................
        //==========================================

        if (!doStuff.HasValue || doStuff.Value == true)
           setupStuff(ref _intField,i);
    }

    public Sample(int theInt): this(theInt, false) //"false" param to avoid setupStuff() being called two times
    {
        setupStuff(ref _intField, theInt);
    }
}

Quando você herda uma classe de uma classe base, você pode invocar o construtor da classe base instanciando a classe derivada

class sample
{
    public int x;

    public sample(int value)
    {
        x = value;
    }
}

class der : sample
{
    public int a;
    public int b;

    public der(int value1,int value2) : base(50)
    {
        a = value1;
        b = value2;
    }
}

class run 
{
    public static void Main(string[] args)
    {
        der obj = new der(10,20);

        System.Console.WriteLine(obj.x);
        System.Console.WriteLine(obj.a);
        System.Console.WriteLine(obj.b);
    }
}

A saída do programa de amostra é

50 10 20

Você também pode usar this palavra-chave para invocar um construtor de outro construtor

class sample
{
    public int x;

    public sample(int value) 
    {
        x = value;
    }

    public sample(sample obj) : this(obj.x) 
    {
    }
}

class run
{
    public static void Main(string[] args) 
    {
        sample s = new sample(20);
        sample ss = new sample(s);

        System.Console.WriteLine(ss.x);
    }
}

A saída deste programa de amostra é

20


Sim, você pode chamar outro método antes da base de chamadas ou isso!

public class MyException : Exception
{
    public MyException(int number) : base(ConvertToString(number)) 
    {
    }

    private static string ConvertToString(int number) 
    { 
      return number.toString()
    }

}

Encadeamento de construtores, ou seja, você pode usar "Base" para É um relacionamento e "Este" você pode usar para a mesma classe, quando quiser chamar vários Construtores em uma única chamada.

  class BaseClass
{
    public BaseClass():this(10)
    {
    }
    public BaseClass(int val)
    {
    }
}
    class Program
    {
        static void Main(string[] args)
        {
            new BaseClass();
            ReadLine();
        }
    }




constructor