重写继承的方法时，应避免显式类型铸造 [英] Avoid explicit type casting when overriding inherited methods

问题描述

我有一个抽象基类，还实现了特定的接口

 公共接口IMovable< TEntity，T> 
，其中TEntity：类
，其中T：结构
 {
 TEntity移动（IMover< T> moverProvider）; 
} 
 
公共抽象类的动物：IMovable<动物，INT> 
 {
 ... 
 
公共虚拟动物移动（IMover< INT> moverProvider）
 {
 //使用提供先行者$ B $进行运动b} 
} 
  

然后我就继承类其中一些必须重写接口的实现方法。基类

 公共类蛇：动物
 {
 ... 
 
公众覆盖动物移动（IMover< INT> moverProvider）
 {
 //执行不同的运动
} 
} 
  

我的接口方法返回同一个对象实例它的移动，这样以后我可以使用的链接的还是直接在<$ C $的东西C>收益语句，而无需使用额外的变量。

  //我不，如果方法想要这个将是无效的类型化
变种S = GetMySnake（）; 
 s.Move（供应商）; 
返回小号; 
 
 //我不希望这两种，如果在所有可能的
回报（蛇）GetMySnake（）移动（供应商）。 
 
 //我只是希望这个
返回GetMySnake（）移动（供应商）。 
  

问题

正如你所看到的我的例子我在覆盖子类收益类的基类来代替跑步类。这可能需要我投的结果，我想避免。

我如何定义我的接口和实现，使我的改写将返回实际类型？执行的实例

 公共蛇移动（IMover< INT> moverProvider）{} 
  

解决方案

我建议改变接口方法的返回类型为无效和移动链接行为的扩展方法，你可以得到真正的类型目标的如

 公共接口IMovable< ; TEntity，T> 
，其中TEntity：类
，其中T：结构
 {
无效通过MoveTo（IMover< T> moverProvider）; 
} 
 
公共抽象类的动物：IMovable<动物，INT> 
 {
公共虚拟无效通过MoveTo（IMover< INT>发）{} 
} 
 
公共静态类AnimalExtensions 
 {
公共静态TAnimal移动< TAnimal>（这TAnimal动物，IMover< INT>发）其中TAnimal：动物，IMovable< TAnimal，INT> 
 {
 animal.MoveTo（发）; 
返回动物; 
} 
} 
  

请注意，你可以让移动分机，如果您需要更广泛地应用更通用的：

 公共静态TEntity移动< TEntity ，T>（这TEntity实体，IMover< T>发）其中TEntity：IMovable< TEntity，T>其中T：结构
 {
 entity.MoveTo（发）; 
返回实体; 
} 
  

I have a base abstract class that also implements a particular interface.

public interface IMovable<TEntity, T>
    where TEntity: class
    where T: struct
{
    TEntity Move(IMover<T> moverProvider);
}

public abstract class Animal : IMovable<Animal, int>
{
    ...

    public virtual Animal Move(IMover<int> moverProvider)
    {
        // performs movement using provided mover
    }
}

Then I have inherited classes some of which have to override interface implementation methods of the base class.

public class Snake : Animal
{
    ...

    public override Animal Move(IMover<int> moverProvider)
    {
        // perform different movement
    }
}

My interface methods return the same object instance after it's moved so I can use chaining or do something directly in return statement without using additional variables.

// I don't want this if methods would be void typed
var s = GetMySnake();
s.Move(provider);
return s;

// I don't want this either if at all possible
return (Snake)GetMySnake().Move(provider);

// I simply want this
return GetMySnake().Move(provider);

Question

As you can see in my example my overrides in child class returns base class type instead of running class. This may require me to cast results, which I'd like to avoid.

How can I define my interface and implementations so that my overrides will return the actual type of the executing instance?

public Snake Move(IMover<int> moverProvider) {}

解决方案

I suggest changing the return type of the interface method to void and moving the chaining behaviour to an extension method where you can get the real type of the target e.g.

public interface IMovable<TEntity, T>
    where TEntity : class
    where T : struct
{
    void MoveTo(IMover<T> moverProvider);
}

public abstract class Animal : IMovable<Animal, int>
{
    public virtual void MoveTo(IMover<int> mover) { }
}

public static class AnimalExtensions
{
    public static TAnimal Move<TAnimal>(this TAnimal animal, IMover<int> mover) where TAnimal : Animal, IMovable<TAnimal, int>
    {
        animal.MoveTo(mover);
        return animal;
    }
}

Note you can make the Move extension more generic if you need it to apply more generally:

public static TEntity Move<TEntity, T>(this TEntity entity, IMover<T> mover) where TEntity : IMovable<TEntity, T> where T : struct
{
    entity.MoveTo(mover);
    return entity;
}

这篇关于重写继承的方法时，应避免显式类型铸造的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！