C# generische Funktion für überladene Methoden

Question

Ich habe zwei Methoden, FollowForce() und AvoidForce(), die überladen sind, um entweder ein NavObject oder ein GameObject zu akzeptieren. Gibt es eine Möglichkeit, die Funktion Follow() zu vereinfachen, um beide Typen zu akzeptieren?

public void Follow(NavObject target){ 
     if(isFollowing){Body.AddForce(FollowForce(target));} 
     if(isAvoiding){Body.AddForce(AvoidForce(target));} 
    } 

public void Follow(GameObject target){ 
     if(isFollowing){Body.AddForce(FollowForce(target));} 
     if(isAvoiding){Body.AddForce(AvoidForce(target));} 
    } 

ich folgendes versucht, bekam aber cannot convert 'T' expression to type 'NavObject':

public void Follow <T>(T target){ 
     if(isFollowing){Body.AddForce(FollowForce(target));} 
     if(isAvoiding){Body.AddForce(AvoidForce(target));} 
    } 

Answer 1

Ihre FollowForce und AvoidForce Funktionen, die target als Parameter akzeptieren muss auch Typ "T"

Answer 2

Wenn Ihre Objekte Aktie akzeptieren Funktionalität sollten Sie eine abstrakte Basisklasse oder eine Schnittstelle TrackedObject einführen und diese in Ihrem NavObject und GameObject erweitern. Sie können dann schreiben Sie die folgenden

public void Follow(TrackedObject target){ 
    if(isFollowing){Body.AddForce(FollowForce(target));} 
    if(isAvoiding){Body.AddForce(AvoidForce(target));} 
} 

Ihre statischen Funktionen Parameter von FollowForce und AvoidForce müssen dann auch TrackedObject

Answer 3

Potenziell vom Typ sein, Sie brauchen nicht einmal Generics mit dieser verwenden. Sie könnten auch eine Schnittstelle für Ihre NavObject und GameObject implementieren, die alle Eigenschaften/Methoden enthält, die innerhalb Ihrer FollowForce und AddForce Methoden benötigt werden.

public void Follow(IHaveForce target) 
{ 
    if (isFollowing) 
    { 
     Body.AddForce(FollowForce(target)); 
    } 
    if (isAvoiding) 
    { 
     Body.AddForce(AvoidForce(target)); 
    } 
} 

dann Ihre anderen Methoden müssten wie folgt aufgebaut werden:

public Force FollowForce(IHaveForce target) 
{ 
    // Do your work... 
} 

public Force AvoidForce(IHaveForce target) 
{ 
    // Do your work... 
} 

Der einzige Grund, warum Sie benötigen würde Generics zu verwenden wäre, wenn Sie während des gleichen Typs erzwingen möchten. In dem von Ihnen bereitgestellten Minimalszenario scheint es nicht so zu sein, dass Sie das brauchen. Wenn Sie Generics trotzdem verwenden möchten, können Sie auch Ihren generischen Typ IHaveForce implementieren lassen.