Comment avoir une méthode abstraite retourne un type abstrait avec des implémentations concrètes?

Question

J'ai trois classes qui retourneront chacune un résultat légèrement différent.

// interfact to a king 
public interface IKing{ 
    public Result Get(); 
} 

// main abstract class 
public abstract class King:IKing{ 
    public abstract Result Get(); 
} 

// main abstract result 
public abstract class Result{ 
    public int Type {get;set;} 
} 

// KingA result 
public class ResultA:Result{ 
    ... 
} 

// KingB result 
public class ResultB:Result{ 
    ... 
} 

// concrete implementations 
public class KingA:King{ 
    public override ResultA Get(){ 
    return new ResultA; 
    } 
} 

public class KingB:King{ 
    public override ResultB Get(){ 
    return new ResultB 
    } 
} 

Cela ne fonctionnera pas depuis la King méthode surchargée de Get attend la classe Result et n'acceptera pas ses enfants ResultA et ResultB.

Y a-t-il une meilleure approche que je peux prendre?

Answer 1

L'approche habituelle consiste à utiliser des génériques.

public interface IKing<T> where T:Result{ 
    T Get(); 
} 

public class King<T> : IKing<T> 
    public abstract T Get(); 
} 

public class KingA : King<ResultB> { 
    public override ResultA Get(){ 
     return new ResultA(); 
    } 
} 

public class KingB : King<ResultB> { 
    public override ResultB Get(){ 
     return new ResultB(); 
    } 
} 

Édition: syntaxe fixe.

Answer 2

Vous devriez être en mesure de jeter explicitement ResultA et ResultB comme Result dans les implémentations de Get (je suppose que ce que les « réalisations concrètes » sont destinées à être).

Answer 3

Cela vous aidera si vous utilisez du code qui compile. Vos «implémentations concrètes» sont fausses, on dirait que vous avez mélangé les concepts de classe et de méthode. Il n'y a pas de problème de conception ici. Par exemple:

public class KingA : King { 
    public override Result Get() { 
     return new ResultA(); 
    } 
} 

Answer 4

Je pense qu'il ya une certaine confusion de syntaxe ici - si je saisis bien votre intention, cela fonctionne très bien:

// interface to a king 
public interface IKing 
{ 
    Result Get(); 
} 

// main abstract class 
public abstract class King : IKing 
{ 
    public abstract Result Get(); 
} 

// main abstract result 
public abstract class Result 
{ 
    private int _Type; 
    public int Type { get { return _Type; } set { _Type = value; } } 
} 

// KingA result 
public class ResultA : Result 
{ 

} 

// KingB result 
public class ResultB : Result 
{ 

} 

// concrete implementations 
public class KingA : King 
{ 
    public override Result Get() 
    { 
     return new ResultA(); 
    } 
} 

public class KingB : King 
{ 
    public override Result Get() 
    { 
     return new ResultB(); 
    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     IKing ka = new KingA(); 
     IKing kb = new KingB(); 

     Result ra = ka.Get(); 
     Result rb = kb.Get(); 

     if (ra is ResultA) 
     { 
      Console.WriteLine("A ok!"); 
     } 

     if (rb is ResultB) 
     { 
      Console.WriteLine("B ok!"); 
     } 
    } 
} 

(modifié pour le formatage)