Ereditarietà nella domanda C #: i metodi interni prevalenti sono possibili?

È ansible sovrascrivere il comportamento di un metodo interno?

using System; class TestClass { public string Name { get { return this.ProtectedMethod(); } } protected string ProtectedMethod() { return InternalMethod(); } string InternalMethod() { return "TestClass::InternalMethod()"; } } class OverrideClassProgram : TestClass { // try to override the internal method ? (doesn't work) string InternalMethod() { return "OverrideClassProgram::InternalMethod()"; } static int Main(string[] args) { // TestClass::InternalMethod() Console.WriteLine(new TestClass().Name); // TestClass::InternalMethod() ?? are we just screwed? Console.WriteLine(new OverrideClassProgram().Name); return (int)Console.ReadKey().Key; } } 

Penso che tu abbia qualcosa di confuso qui. C’è una vera parola chiave “interna”, è questo che vuoi?

 internal string InternalMethod() { return "TestClass::InternalMethod()"; } 

Ma penso che quello che stai davvero cercando sia la parola chiave “virtuale”. Questo ti permette di fare un override: Parent Class

 protected virtual string InternalMethod() { return "TestClass::InternalMethod()"; } 

Classe bambino

 protected override string InternalMethod() { return "TestProgram::InternalMethod()"; } 

L’utilizzo della parola chiave “new” è valido, ma reimplement completamente il metodo. Cioè rompe il polimorfismo.

Modifica: ecco un link .

In Java tutto è virtuale a meno che non sia statico / finale. In C # devi dichiarare esplicitamente un metodo di istanza come virtuale e quindi quel metodo non può essere privato. Questo articolo spiega perché.

Di default tutti i membri di una class sono privati, quindi se non si fornisce un modificatore di accesso (diverso dal privato ovviamente) il metodo InternalMethod () nell’esempio è privato e non può essere virtuale e quindi non può essere sovrascritto.

È necessario modificare il suo modificatore di accesso e contrassegnarlo come virtuale e nella class figlio è necessario sovrascriverlo affinché il codice funzioni nel modo desiderato.

Questo potrebbe non rispondere alla tua domanda, ma solo per aggiungere un centesimo.

Internal indica che tipi o membri sono accessibili solo all’interno di file nello stesso assembly. Sono pubblici per l’assemblea ma hanno un accesso leggermente inferiore al public in tempo reale.

Modificatori di accesso MSDN,

Un uso comune dell’accesso interno è lo sviluppo basato sui componenti poiché consente a un gruppo di componenti di cooperare in modo privato senza essere esposto al resto del codice dell’applicazione. Ad esempio, un framework per la creazione di interfacce utente grafiche potrebbe fornire classi di controllo e di modulo che cooperano utilizzando membri con accesso interno. Poiché questi membri sono interni, non sono esposti al codice che utilizza il framework

Prova a usare la parola chiave override … la nuova parola chiave è chiamare un constuctor di class

Certo, è ansible, ma per sovrascrivere un metodo, il metodo deve essere virtual o abstract , come qualsiasi altra visibilità.

 class Base { internal virtual void Foo() { Console.WriteLine("Foo from Base"); } } class Derived : Base { internal override void Foo() { Console.WriteLine("Foo from Derived"); } } 

Quando si utilizza la new parola chiave, si chiama metodo nascosto , che non è la stessa cosa. Se scrivo questo:

 class Base { internal void Foo() { Console.WriteLine("Foo from Base"); } } class Derived : Base { internal new void Foo() { Console.WriteLine("Foo from Derived"); } } static void Main() { Base b = new Derived(); b.Foo(); } 

Quindi eseguirà il metodo Base Foo , non Derived . In altre parole stamperà Foo from Base . Nel primo caso, avrebbe comunque eseguito il metodo Derived e stampato Foo from Derived .