C#实现抽象类方法:我必须进行强制转换

本文关键字：转换 抽象 实现 抽象类 类方法 | 更新日期: 2023-09-27 18:20:11

我有两个类：

public abstract class Loop : Events
{ }
public class SimpleLoop : Loop
{
    public Sound sound;
    public SimpleLoop simple;
}

我有一个带有抽象方法的抽象类：

public abstract class AbstractParser
{
    public abstract Loop ParseLoop();
}

还有另一个类，它扩展了前一个类并实现了抽象方法：

public class Parser2 : AbstractParser
{
    public override Loop ParseLoop()
    {
        //not important stuff
        simpleLoop.simple = (SimpleLoop) ParseLoop();
        return simpleLoop;
    }
}

现在，我的问题是：有一种方法可以避免simpleLoop.simple = (SimpleLoop) ParseLoop()内部的铸造？

显然我没有完全上课，所以不要问自己这一团糟的目的是什么：D谢谢你的帮助！

C#实现抽象类方法:我必须进行强制转换

public class Parser2 : AbstractParser
{
    public override Loop ParseLoop()
    {
        return ParseLoopImplementation();
    }
    private SimpleLoop ParseLoopImplementation()
    {
        //not important stuff
        simpleLoop.simple = ParseLoopImplementation();
        return simpleLoop;
    }
}

注意。您的代码将产生StackOverflowException，因为它在所有路径上都是递归的。

试试这个：

public class SimpleLoopParser<T> : AbstractParser<T>
{
    protected override T ParseLoopImplementation()
    {
        simpleLoop.simple = //parse here;
        return simpleLoop;
    }
}
public abstract class AbstractParser <T>
{
    public override T ParseLoop()
    {
        return ParseLoopImplementation();
    }
    protected abstract Loop ParseLoopImplementation();
}

这样称呼：

SimpleLoop simpleLoopParsed = new SimpleLoopParser<SimpleLoop>().ParseLoop();
相关文章：