[C#] Default implementatie voor virtual method override

[ThaLaw]

Ik heb een classlibrary die door andere ontwikkelaars moet worden gebruikt.
Een aantal classes hebben virtual methods die ze zelf kunnen overriden.
Nou wil ik dat als ze override en dan methodname intypen, dat een default of voorbeeld implementatie al voor ze wordt klaargezet.

Hetzelfde gedrag als je nu in VS2005 bijvoorbeeld override Equals intypt, dan geeft Intellisense je de volgende implementatie al:

public override bool Equals(object obj)
{
return base.Equals(obj);
}

Hoe krijg ik zoiets voor elkaar voor mijn eigen classes?

[cowgirl]

Wil je een specifieke implementatie of, zoals in het voorbeeld, alleen een aanroep van de base. Dat tweede gebeurt volgens mij nl. standaard (werkt in elk geval bij mij en ik kan me niet herinneren daar iets speciaals voor gedaan te hebben). Of het eerste mogelijk is weet ik niet.

[ThaLaw]

Nee het gaat mij echt om een stukje voorbeeldcode.

[cspare]

Dat idee van Equals heeft te maken met code snippets. Ik heb er nooit zelf mee gewerkt, maar je kan ook zelf code snippets maken. Je zou eens kunnen kijken bij de Code Snippets Manager (In het Tools menu)

[ThaLaw]

Denk eigenlijk dat ik het veerkeerd aanpak / uitleg.

Wat ik eigenlijk wil is dat ik gebruikers een interface opleg (ze moeten 1 bepaalde method implementeren) en daarnaast zit er ook nog 1 stukje verplichte code in...

bijv.

abstract class Master
{
public static Object Masterinit(Object o)
{ ... some shared init code...}
}

class MyClass : Master
{
private static Object MyOwnObject;

public static void Init()
{ // Verplichte regel:
Masterinit(MyOwnObject);
}
}

Snap je wat ik bedoel?
P.s. Als deze code rijp is voor de Daily-WTF mag je het ook zeggen

[Zr40]

Als je verplicht initialisatiecode wil uitvoeren, plaats deze dan in de constructor.

[cowgirl]

Maar als die regel verplicht is, waarom die dan niet in je baseclass en via de base.method aanroepen? Dan maak je gewoon gebruik van de standaard intellisense. Je krijgt dan de volgende code:

C#:

abstract class Master
{
   public static virtual void Init()
   { ... some shared init code...}
}

class MyClass : Master
{
   private static Object MyOwnObject;

   public static void Init()
   { // Verplichte regel:
      base.Init()
   }
}

[Woy]

Dan zou je het toch zo moeten doen.

C#:

abstact class Master
{
    public object MasterInit(Object o){...}

    public virtual void Init(){ MasterInit(o);...}

    public void DoSomething()
    {
        if( !init )
             throw new ApplicationException( "Object not initialized yet" );
    }
}

Als een applicatie dan jouw methode override dan is die er ook verantwoordelijk voor om de base aan te roepen of om alle functionaliteit ( Het aanroepen van de master init ) te doen.

[ThaLaw]

Ja, daar is het eigenlijk allemaal mee beginnen.

Het gaat om een static class, dus ik had netjes een static constructor, dat zou moeten werken. En dat deed het niet. Waarschijnlijk heeft dat te maken met dat ik hier werk met het .Net Micro Framework. De static constructor werd 'misschien' wel uitgevoerd, maar dat ging dan buiten de debugger om. Bovendien werkt het dan nog steeds niet.

Vandaar mijn zoektocht naar alternatieven...

[Woy]

Als het echt belangrijk is dat het altijd aangeroepen wordt kun je ook nog zoiets doen

C#:

class Master
{
      private void MasterInit(){....}
      public void Init()
      {
           MasterInit();
           OnInit();
      }

      public virtual void OnInit()
      {
          ....
      }
}

De code gebruikt dan altijd Init maar de gebruikende class moet de OnInit overriden. Op deze manier kan de gebruikende class wel functionaliteit toevoegen maar is het niet mogenlijk om functionaliteit van de Master class over te slaan ( Mits natuurlijk de Init wel aangeroepen wordt ).

[whoami]

In de constructor moet je nooit virtuele methods aanroepen .... tenzij je perfect weet welke implementaties in welke volgorde worden aangeroepen etc...

Topicstarter:
Als je van een class een method 'overridable' wil maken, maar er ook altijd zeker wil van zijn dat een bepaald stuk code altijd wordt aangeroepen, dan design je gewoon je class als volgt:

code:

abstract class  MyBase
{
    public  SomeMethod()
    {
         ThisFunctionIsAlwaysExecuted();
         SomeMethodCore();
    }

    protected abstract SomeMethodCore();
}

Bij het inheriten van deze class, is de ontwikkelaar altijd verplicth om SomeMethodCore te overriden / implementeren. Diegene die de class gebruikt kan niet rechtstreeks SomeMethodCore aanroepen (aangezien die protected is), maar moet altijd SomeMethod aanroepen. In die method voer je het stuk code uit dat verplicht is, en roep je daarna de overriden SomeMethodCore op.

[Woy]

Zoals whoami het doet om de SomeMethodCore protected te maken is natuurlijk nog wat netter idd. Het al dan niet abstract maken van de method hangt natuurlijk van de nood af om de methode perse te implementeren.

edit:
Ik zie nou overigens dat je het over static classes hebt. Dan heeft het geheel weinig met overerving te maken en denk ik dat er mischien wat fout zit in je design.

Static dingen kun je nou eenmaal niet overerven.

[ Voor 71% gewijzigd door Woy op 09-05-2007 10:27 ]

[whoami]

overerven van een static class ? Dat lijkt me raar ...

[ThaLaw]

Het klopt dat ik wat zit te rommelen hier en daar.

Ik ben afgeweken van het originele plan, omdat het allemaal niet werkte.
De achterliggende gedachte is nog complexer, dat heeft temaken met de ExtendedWeakReference class binnen het .Net Micro Framework.
Ik moet objecten in flash geheugen houden als er geen strong reference meer is enz.
Dat luistert allemaal erg nauw met het maken van static of niet static objecten, tel daar bij op dat ik nog vrij onervaren ben in C# en je hebt een recept voor complete chaos.

De post van whoami klinkt veelbelovend, ik had even niet in de gaten dat wanneer je een virtual method aanroept in een constructor van een baseclass, dat deze dan de overriden method uitvoert. Dit zou kunnen werken...

[whoami]

Het aanroepen van een virtual method in een constructor is niet bepaald een best-practice, en kan soms tot ongewenste resultaten leiden.

[barfieldmv]

ThaLaw schreef op woensdag 09 mei 2007 @ 10:30:
Het klopt dat ik wat zit te rommelen hier en daar.

Ik ben afgeweken van het originele plan, omdat het allemaal niet werkte.
De achterliggende gedachte is nog complexer, dat heeft temaken met de ExtendedWeakReference class binnen het .Net Micro Framework.
Ik moet objecten in flash geheugen houden als er geen strong reference meer is enz.
Dat luistert allemaal erg nauw met het maken van static of niet static objecten, tel daar bij op dat ik nog vrij onervaren ben in C# en je hebt een recept voor complete chaos.

De post van whoami klinkt veelbelovend, ik had even niet in de gaten dat wanneer je een virtual method aanroept in een constructor van een baseclass, dat deze dan de overriden method uitvoert. Dit zou kunnen werken...

Ik had op een gegeven moment hetzelfde probleem.

Een methode die na overerving een andere implementatie bevatte, maar hij moest nog wel een blok code uitvoeren voordat die methode werd gestart en dat wist de child class niet. Mijn oplossing was het:

code:

void Start()
{
basicStart()
OverridenStart()
}

De gebruiker kan dan de overriden start abstract maken terwijl de functie gestart moest worden met een andere functie aanroep (start)