constructor - C#construtor encadeamento?(Como fazer isso?)




constructor-chaining (8)

O que é o uso de "Cadeia de Construtor"?
Você o usa para chamar um construtor de outro construtor.

Como pode implementar "Constructor Chain"?
Use ": this (yourProperties)" palavra-chave após a definição de construtor. por exemplo:

Class MyBillClass
{
    private DateTime requestDate;
    private int requestCount;

    public MyBillClass()
    {
        /// ===== we naming "a" constructor ===== ///
        requestDate = DateTime.Now;
    }
    public MyBillClass(int inputCount) : this()
    {
        /// ===== we naming "b" constructor ===== ///
        /// ===== This method is "Chained Method" ===== ///
        this.requestCount= inputCount;
    }
}

Por que isso é útil?
Um motivo importante é reduzir a codificação e evitar o código duplicado. como código repetido para inicializar a propriedade Suponha que alguma propriedade na classe deva ser inicializada com um valor específico (em nossa amostra, requestDate). E a classe tem 2 ou mais construtores. Sem "Constructor Chain", você deve repetir o código de inicialização em todos os construtores de classe.

Como isso funciona? (Ou, o que é seqüência de execução em "Constructor Chain")?
no exemplo acima, o método "a" será executado primeiro, e a seqüência de instruções retornará ao método "b". Em outras palavras, o código acima é igual ao abaixo:

Class MyBillClass
{
    private DateTime requestDate;
    private int requestCount;

    public MyBillClass()
    {
        /// ===== we naming "a" constructor ===== ///
        requestDate = DateTime.Now;
    }
    public MyBillClass(int inputCount) : this()
    {
        /// ===== we naming "b" constructor ===== ///
        // ===== This method is "Chained Method" ===== ///

        /// *** --- > Compiler execute "MyBillClass()" first, And then continue instruction sequence from here
        this.requestCount= inputCount;
    }
}

Eu sei que esta é supostamente uma pergunta super simples, mas eu tenho lutado com o conceito há algum tempo. Minha pergunta é, como você construtores de cadeia em c #? Eu estou na minha primeira aula de OOP, então estou apenas aprendendo. Eu não entendo como o encadeamento de construtores funciona ou como implementá-lo, ou até mesmo porque é melhor do que apenas fazer construtores sem encadeamento.

Eu apreciaria alguns exemplos com uma explicação.

Então, como fazer isso? Eu sei com dois que vai:

public SomeClass this: {0}

public SomeClass
{
    someVariable = 0
} 

Mas como você faz isso com três, quatro e assim por diante?

Mais uma vez, sei que esta é uma questão de iniciante, mas estou lutando para entender isso e não sei por quê.


Você está perguntando sobre isso?

  public class VariantDate {
    public int day;
    public int month;
    public int year;

    public VariantDate(int day) : this(day, 1) {}

    public VariantDate(int day, int month) : this(day, month,1900){}

    public VariantDate(int day, int month, int year){
    this.day=day;
    this.month=month;
    this.year=year;
    }

}

Eu só quero trazer um ponto válido para qualquer um procurando por isso. Se você pretende trabalhar com versões .NET antes do 4.0 (VS2010), saiba que você precisa criar cadeias de construtor, como mostrado acima.

No entanto, se você estiver hospedado em 4.0, tenho boas notícias. Agora você pode ter um único construtor com argumentos opcionais! Vou simplificar o exemplo da classe Foo:

class Foo {
  private int id;
  private string name;

  public Foo(int id = 0, string name = "") {
    this.id = id;
    this.name = name;
  }
}

class Main() {
  // Foo Int:
  Foo myFooOne = new Foo(12);
  // Foo String:
  Foo myFooTwo = new Foo(name:"Timothy");
  // Foo Both:
  Foo myFooThree = new Foo(13, name:"Monkey");
}

Quando você implementa o construtor, você pode usar os argumentos opcionais desde que os padrões foram definidos.

Espero que tenham gostado desta lição! Eu simplesmente não posso acreditar que os desenvolvedores estão reclamando sobre o encadeamento de construções e não serem capazes de usar argumentos opcionais padrão desde 2004/2005! Agora, demorou tanto tempo no mundo do desenvolvimento, que os desenvolvedores têm medo de usá-lo porque ele não será compatível com versões anteriores.


Há outro ponto importante no encadeamento de construtores: order. Por quê? Digamos que você tenha um objeto sendo construído em tempo de execução por uma estrutura que espera que seja seu construtor padrão. Se você quer ser capaz de passar valores enquanto ainda tem a capacidade de passar em argumentos construtores quando quiser, isto é extremamente útil.

Eu poderia, por exemplo, ter uma variável de apoio que é definida para um valor padrão pelo meu construtor padrão, mas tem a capacidade de ser substituída.

public class MyClass
{
  private IDependency _myDependency;
  MyClass(){ _myDependency = new DefaultDependency(); }
  MYClass(IMyDependency dependency) : this() {
    _myDependency = dependency; //now our dependency object replaces the defaultDependency
  }
}

Espero que o exemplo a seguir forneça alguma luz sobre o encadeamento de construtores.
meu caso de uso aqui, por exemplo, você está esperando que o usuário passe um diretório para seu construtor, o usuário não sabe qual diretório passar e decide permitir que você designe o diretório padrão. você aumenta e atribui um diretório padrão que você acha que vai funcionar.

BTW, eu usei LINQPad para este exemplo, caso você esteja se perguntando o que * .Dump () é.
Felicidades

void Main()
{

    CtorChaining ctorNoparam = new CtorChaining();
    ctorNoparam.Dump();
    //Result --> BaseDir C:\Program Files (x86)\Default\ 

    CtorChaining ctorOneparam = new CtorChaining("c:\\customDir");
    ctorOneparam.Dump();    
    //Result --> BaseDir c:\customDir 
}

public class CtorChaining
{
    public string BaseDir;
    public static string DefaultDir = @"C:\Program Files (x86)\Default\";


    public CtorChaining(): this(null) {}

    public CtorChaining(string baseDir): this(baseDir, DefaultDir){}

    public CtorChaining(string baseDir, string defaultDir)
    {
        //if baseDir == null, this.BaseDir = @"C:\Program Files (x86)\Default\"
        this.BaseDir = baseDir ?? defaultDir;
    }
}

Você usa a sintaxe padrão (usando this como um método) para escolher a sobrecarga, dentro da classe:

class Foo {
    private int id;
    private string name;
    public Foo() : this(0, "") {
    }
    public Foo(int id, string name) {
        this.id = id;
        this.name = name;
    }
    public Foo(int id) : this(id, "") {
    }
    public Foo(string name) : this(0, name) {
    }
}

então:

Foo a = new Foo(), b = new Foo(456,"def"), c = new Foo(123), d = new Foo("abc");

Note também:

  • você pode encadear para construtores no tipo base(...) usando base(...)
  • você pode colocar um código extra em cada construtor
  • o padrão (se você não especificar nada) é base()

Por "por quê?"

  • redução de código (sempre uma coisa boa)
  • necessário chamar um construtor de base não padrão, por exemplo:

    SomeBaseType(int id) : base(id) {...}

Note que você também pode usar inicializadores de objetos de maneira similar (sem precisar escrever nada):

SomeType x = new SomeType(), y = new SomeType { Key = "abc" },
         z = new SomeType { DoB = DateTime.Today };

Eu tenho uma aula de diário e por isso não estou escrevendo definindo os valores novamente e novamente

public Diary() {
    this.Like = defaultLike;
    this.Dislike = defaultDislike;
}

public Diary(string title, string diary): this()
{
    this.Title = title;
    this.DiaryText = diary;
}

public Diary(string title, string diary, string category): this(title, diary) {
    this.Category = category;
}

public Diary(int id, string title, string diary, string category)
    : this(title, diary, category)
{
    this.DiaryID = id;
}

Histórico da versão do C #:

C # é uma linguagem de programação orientada a objetos simples e poderosa desenvolvida pela Microsoft.

O C # evoluiu muito desde o seu primeiro lançamento em 2002. O C # foi introduzido com o .NET Framework 1.0.

A tabela a seguir lista os recursos importantes introduzidos em cada versão do C #.

E a versão mais recente do C # está disponível em versões c # .





c# constructor constructor-chaining