Come posso impedire che un costruttore di base venga chiamato da un erede in C #?

Question

Ho una classe base (scritta male) che voglio racchiudere in un oggetto proxy. La classe base è simile alla seguente:

public class BaseClass : SomeOtherBase 
{
   public BaseClass() {}

   public BaseClass(int someValue) {}

   //...more code, not important here
}

e, il mio proxy è simile a:

public BaseClassProxy : BaseClass
{
  public BaseClassProxy(bool fakeOut){}
}

Senza " fakeOut " costruttore, il costruttore di base dovrebbe essere chiamato. Tuttavia, con esso, mi aspettavo che non fosse chiamato. In entrambi i casi, o ho bisogno di un modo per non chiamare alcun costruttore di classe base, o un altro modo per delegare efficacemente questa classe (malvagia).

Answer 1

Se non si chiama esplicitamente alcun costruttore nella classe base, il costruttore senza parametri verrà chiamato implicitamente. Non c'è modo di aggirarlo, non è possibile creare un'istanza di una classe senza che venga chiamato un costruttore.

Answer 2

C'è un modo per creare un oggetto senza chiamare qualsiasi costruttori di istanze.

Prima di procedere, assicurati di voler farlo in questo modo. Il 99% delle volte questa è la soluzione sbagliata.

Ecco come lo fai:

FormatterServices.GetUninitializedObject(typeof(MyClass));

Chiamalo al posto del costruttore dell'oggetto. Creerà e restituirà un'istanza senza chiamare costruttori o inizializzatori di campo.

Quando si deserializza un oggetto in WCF, utilizza questo metodo per creare l'oggetto. Quando ciò accade, i costruttori e persino gli inizializzatori di campo non vengono eseguiti.

Answer 3

È necessario chiamare almeno 1 ctor. L'unico modo per aggirarlo è il contenimento. Avere la classe dentro o fare riferimento all'altra classe.

Answer 4

Se quello che vuoi è non chiamare uno dei due costruttori della classe base, non è possibile farlo.

I costruttori della classe C # devono chiamare i costruttori della classe base. Se non lo chiami esplicitamente, base () è implicito . Nel tuo esempio, se non specifichi quale costruttore della classe base chiamare, è lo stesso di:

public BaseClassProxy : BaseClass
{
    public BaseClassProxy() : base() { }
}

Se si preferisce utilizzare l'altro costruttore della classe base, è possibile utilizzare:

public BaseClassProxy : BaseClass
{
    public BaseClassProxy() : base(someIntValue) { }
}

Ad ogni modo, uno dei due verrà chiamato, esplicitamente o implicitamente.

Answer 5

Non credo che tu possa andare in giro chiamando il costruttore. Ma potresti fare qualcosa del genere:

public class BaseClass : SomeOtherBase 
{
   public BaseClass() {}

   protected virtual void Setup()
   {
   }
}

public BaseClassProxy : BaseClass
{
   bool _fakeOut;
   protected BaseClassProxy(bool fakeOut)
   {
        _fakeOut = fakeOut;
        Setup();
   }

   public override void Setup()
   {
       if(_fakeOut)
       {
            base.Setup();
       }
       //Your other constructor code
   }
} 

Answer 6

Quando si crea un oggetto BaseClassProxy, è NECESSARIO creare un'istanza della sua classe base, quindi è necessario chiamare il costruttore della classe base, quello che si può fare è scegliere quale chiamare, come:

public BaseClassProxy (bool fakeOut) : base (10) {}

Per chiamare il secondo costruttore anziché il primo

Answer 7

Temo che non sia il costruttore di chiamate base non sia un'opzione.

Answer 8

Ho finito per fare qualcosa del genere:

public class BaseClassProxy : BaseClass 
{
   public BaseClass BaseClass { get; private set; }

   public virtual int MethodINeedToOverride(){}
   public virtual string PropertyINeedToOverride() { get; protected set; }
}

Questo mi ha fatto aggirare alcune delle cattive pratiche della classe base.

Answer 9

i costruttori sono pubblici per natura. non usare un costruttore e usarne un altro per la costruzione e renderlo privato. Quindi si creerebbe un'istanza senza parametri e si chiamerebbe quella funzione per costruire l'istanza dell'oggetto.

Answer 10

Va bene, ecco una brutta soluzione al problema di una classe che eredita i costruttori di un'altra classe che non volevo permettere ad alcuni di loro di funzionare. Speravo di evitare di usare questo nella mia classe ma eccolo qui:

Ecco il mio costruttore di classi:

public MyClass();
{
   throw new Exception("Error: Must call constructor with parameters.");
}

OK ora sei stato avvisato che era brutto. Nessuna lamentela, per favore!

Volevo forzare almeno i parametri minimi dal mio costruttore principale senza che consentisse al costruttore di base ereditato senza parametri.

Credo anche che se si crea un costruttore e non si inserisce: base () dopo che non chiamerà il costruttore della classe base. E se si creano costruttori per tutti quelli nella classe base e fornire gli stessi parametri esatti per loro nella classe principale, che non passerà attraverso. Ma questo può essere noioso se hai molti costruttori nella classe base!