继承其通用父类的嵌套类

Question

继承其通用父类的嵌套类

c#visual-studio-2010genericsinheritancenested-class

4

是否有可能实现这样的情况，即A.N通过以下代码从A继承代码？

之所以设置它们这样，是因为我需要多个类从Base<TType>继承，并且Nested : Base<TType>在服务器端仅具有基础部分，而在客户端具有扩展的Nested。这样一来，很容易使用代码，它们之间会共享一些代码。

问题是我必须在里面编写完全相同的代码。

A and A.N  
B and B.N  
C and C.N

我已经通过将嵌套抽象类替换为接口并执行A.N：A，INested来暂时解决了这个问题，但现在我必须再次在所有嵌套类中重写Base<TType>.Nested代码。目前，嵌套类很小且易于管理。

希望这不是一个令人困惑的问题...

public abstract class Base<TType> where TType : class
{
    public TType data;
    internal void CommonCodeForAll() { }
    public abstract void Update();
    public abstract class Nested : Base<TType>
    {
        public abstract void Input();
    }
}

public class A : Base<someClass>
{
    public float Somevariable;

    public void SpecificFunctionToA() { }

    public override void Update()
    {
        // code that gets executed on server & client side that is unique to A
    }

    public class N : A.Nested
    {
        public override void Input()
        {
            if (data.IsReady()) { Somevariable *= 2; }
            SpecificFunctionToA();
        }
    }
}
public class B : Base<anotherClass>
{
    public float Somevariable;
    public int index;
    public int[] Grid;

    public void SomethingElse() { }

    public override void Update()
    {
        // code that gets executed on server & client side that is unique to B
    }

    public class N : B.Nested
    {
        public override void Input()
        {
            if (Grid[index] == -1) { SomethingElse(); }
            data.Somevariable = Grid[index];
        }
    }
}

编辑：我更新了代码示例以展示我想要实现的内容。
我之所以要这样做，是为了将物理、网络和用户输入分开处理。有多个不同的控制器，每个控制器都有自己的打包和解包函数、控制器标识和对物理引擎的访问权限。

- Eli

不错的问题。对于那些不理解的人，你想在嵌套方法中使用已实现的基本方法。例如，你想像A类一样从Input()中调用Update()。 - John Alexiou

@ja72 是的，还有针对A、B、C等特定方法和变量。就像如果A.N直接从A继承一样，B.N也将直接从B继承，以此类推。 - Eli

也许你需要类封装而不是继承。我会尝试组合一个解决方案来进行说明。 - John Alexiou

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- John Alexiou · Accepted Answer

我有一个解决方案，使用类的封装而不是继承。

public abstract class BaseGeneric<T>
{
    T data;
    // ctor
    protected BaseGeneric(T data)
    {
        this.data=data;
    }
    // methods
    public abstract void Update();
    // properties
    public T Data
    {
        get { return data; }
        set { data=value; }
    }

    // base nested class
    public abstract class BaseNested<B> where B : BaseGeneric<T>
    {
        protected B @base;
        // ctor
        protected BaseNested(B @base)
        {
            this.@base=@base;
        }
        // methods
        public abstract void Input(T data);
        public void Update() { @base.Update(); }
        // properties
        public T Data
        {
            get { return @base.data; }
            set { @base.data=value; }
        }
    }
}

// implementation base
public class Base : BaseGeneric<int>
{
    // ctor
    protected Base(int data) : base(data) { }
    //methods
    public override void Update()
    {
        this.Data+=1;
    }
    // implemented nested class
    public class Nested : Base.BaseNested<Base>
    {
        // ctor
        public Nested(int data) : base(new Base(data)) { }
        public Nested(Base @base) : base(@base) { }
        // methods
        public override void Input(int data)
        {
            this.Data=data;
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        // new implemented class with value 0
        var nested=new Base.Nested(0);
        // set value to 100
        nested.Input(100);
        // call update as implemented by `Base`.
        nested.Update();
    }
}