Liste de classes héritées

Version imprimable

Bonjour à tous,

Je me retrouve bloqué sur un problème tout bête alors je viens vous demander votre aide. :aie:
J'ai les classes ci-dessous :
Code:

1 2 3 public abstract class Action: IEquatable<Action>{} public class Action_CharacterOperator : Action{} public class Action_SpellCaster : Action{}
J'ai dans une autre classe un tableau d'Action

Code:

private Action[] Actions = new Action[39];

Dans ce tableau j'ai des Action_CharacterOperator et Action_SpellCaster. Mais pas d'Action car c'est une classe abstraite.

Dans chacune de mes classes filles, j'ai une fonction executeAction() avec des paramètres différents.

Mon problème est que lors de l'appel de cette fonction depuis mon tableau j'ai une erreur car la classe mère n'a pas de déclaration pour cette fonction.

Code:

Actions[1].executeAction(); // ERROR

Comment faire pour pouvoir appeler cette fonction executeAction() depuis mon tableau d'Action? :oops:

J'ai beau réfléchir je ne vois pas comment faire.
En sachant que chaque déclaration de cette fonction sont différentes, j'ai un appel du genre
Code:

1 2 if(currentAction.GetType() == typeof(Action_CharacterOperator)) { currentAction.executeAction(this._characterOperator, keyState); } // ERROR else if(currentAction.GetType() == typeof(Action_CharacterControler)) {currentAction.executeAction(this, keyState); } // ERROR
Est-ce qu'il y a un concept de POO qui m'échappe ?

D'avance merci pour vos retour.

29/08/2018, 19h34
Mat.M

on manque de code; as-tu fait les bonnes déclarations dans la déclaration de la classe abstraite notamment ?
Voir ici et ici notamment

Alors pour que vous visualisiez mieux, voici mon code. Je ne vous donne que les déclarations car le contenu n'a aucune importance dans notre problème actuel ;)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public abstract class Action: IEquatable<Action> {
	//_____ PROTECTED PROPERTIES _____________________________________________
	protected Object _pressedDownAction;
	protected Object _heldAction;
	protected Object _releasedAction;
 
	//_____ ACCESSEURS _______________________________________________________	
	public Object PressedDownAction {}
	public Object HeldAction {}	
	public Object ReleasedAction {}
 
	//_____ METHODES _________________________________________________________
	public override int GetHashCode () {}
	public override bool Equals (object obj) {}
	public bool Equals (Action otherAction) {}
	public static bool operator == (Action left, Action right) {}
	public static bool operator != (Action left, Action right) {}
 
}
 
public class Action_CharacterOperator : Action {	
	//_____ PRIVATE PROPERTIES ___________________________________________________
	CharacterOperator.PossibleActions _targetAction;	
 
	//_____ CONSTRUCTEURS ______________________________________________________
	public Action_CharacterOperator (CharacterOperator.PossibleActions tragetAction, bool pressedDownValue = true) {}
 
	//_____ METHODES ____________________________________________________________
	public bool executeAction (CharacterOperator characterOperator, InputAdvanced.KeyState keyState) {}
}
 
public class Action_CharacterControler : Action {	
	//_____ PRIVATE PROPERTIES ___________________________________________________
	CharacterControler.PossibleActions _targetAction;	
 
	//_____ CONSTRUCTEURS ______________________________________________________
	public Action_CharacterControler (CharacterControler.PossibleActions tragetAction, bool pressedDownValue = true) {}
 
	//_____ METHODES ____________________________________________________________
	public bool executeAction (CharacterControler characterControler, InputAdvanced.KeyState keyState) {}
}

Ensuite dans une autre classe j'appelle ces classes comme suit :

Code:

1
2
3
4
5
6
7
8
9
private Action[] Actions = new Action[39];
Actions[1] = new Action_CharacterOperator(CharacterOperator.PossibleActions.MovingForward);
Actions[2] = new Action_CharacterControler(CharacterControler.PossibleActions.LockCursorByInput);
// ...
 
// Et plus tard dans le code
currentAction = Actions[i];
if(currentAction.GetType() == typeof(Action_CharacterOperator)) { currentAction.executeAction(this._characterOperator, keyState); } // ERROR
else if(currentAction.GetType() == typeof(Action_CharacterControler)) {currentAction.executeAction(this, keyState); } // ERROR

J'espère que c'est plus claire :mrgreen:

30/08/2018, 11h12
WaterTwelve21
Bonjour ,

Et pourquoi la classe mère n'a pas de déclaration pour executeAction() ?
Sans déclaration dans la classe mère, tu va devoir caster l'élément en classe fille pour pouvoir l'appelée.

Pourquoi ne pas déclarer la méthode en virtual dans la classe mère, pour ensuite être en override dans les classes filles
Code:

1 2 3 // classe Action public virtual bool ExecuteAction() //classe filles public override bool ExecuteAction() { // du code }
Bon code,
30/08/2018, 11h25
tribaleur

On peut faire un déclaration override avec des signatures différentes sur des fonctions ?
Il me semblait qu'il fallait que la fonction virtuel et la fonction override devait avoir les mêmes paramètres. :aie:

Je vais tester ça de suite.

Ha oups en effet ! on ne peut pas , j'avais pas vu la différence sur la signature (elle est subtile :aie:) .

Le cast reste une option:
Code:

1 2 if(currentAction is Action_CharacterOperator)) { ((Action_CharacterOperator)currentAction).executeAction(this._characterOperator, keyState); } else if(currentAction is Action_CharacterControler)) {((Action_CharacterControler)currentAction).executeAction(this, keyState); }

30/08/2018, 11h46
tribaleur

En effet les virtual à besoin d'une signature identique. Pareil pour le abstract que j'avais testé déjà au cas où.

Pour le cast j'avais essayé mais je n'avais pas pensé à mettre des parenthèses autour de currentAction. :aie:
Du coup le cast fonctionne et c'est parfait !

Merci. :king:

Bonjour,

A partir du moment où la signature de la méthode dans les classes filles est différente, il n'est pas possible d'utiliser le polymorphisme pour appeler la bonne méthode. Ce qui est tout à fait logique !

Il ne reste que le cast. A noter que depuis C# 7.2, il est possible d'écrire :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 switch (action) { case Action_CharacterOperator actionOperator: actionOperator.actionExecute(...); break; case Action_CharacterControler actionController: actionController.actionExecute(...); default: // Cast non géré break; } }
L'avantage est double :

d'une part, la syntaxe est plus fluide (bon, c'est subjectif, je le concède :mouarf:) ;
d'autre part, la possibilité de récupérer facilement le cas où aucun cast n'est dispo (ne rien faire, lever une exception, etc... on fait ce que l'on veut). Autrement, il faut utiliser des if en cascade ou introduire une variable pour arriver à la même finalité.

30/08/2018, 15h30
tribaleur

Et bin je ne savait pas qu'on pouvait utiliser le switch case sur la type de la variable comme ça.

J'en prend note car en effet c'est très pratique.
Je suis moi même d'accord avec tes deux arguments. Le premier nécessite cependant de connaitre cette possible syntaxe ;)

Merci pour l'info en tous cas.
30/08/2018, 16h26
François DORIN

Citation:

Envoyé par tribaleur

Et bin je ne savait pas qu'on pouvait utiliser le switch case sur la type de la variable comme ça.

Attention, c'est très récent et a été introduit avec C# 7.2 l'année dernière seulement !
31/08/2018, 10h55
tribaleur

Vus que je travaille avec Unity, mais la dernière version, je vais vérifier la version de c# associée.

Vus que je n'ai aucune contrainte de version, je vais essayer tant qu'à faire de développer avec la dernière version de c# ;)

Merci pour la précision cependant.