抽象类中的嵌套抽象类以及如何实现它

Question

I have an abstract class A and a abstract method with a parameter which is again abstract class B defined in the same abstract class A. When I extended this abstract class A as apart of another class C how can I implement the method with parameter of nested abstract class.

public abstract class A<T, V>
{
    public abstract int GetObject(T t, V v);
    public abstract int GetAnotherObject(B b);
    public abstract class B{}
}

This class is extended by another class C

public class C: A<ABC, DEF>
{
        public C()
        {

        }
        public override int GetObject(ABC abc, DEF def)
        {
            return 10;
        }

        public override int GetAnotherObject(B b)
        {
            return 15;
        }
}

How to implement class B with some properties and pass in GetAnotherObject method. Could someone please help me.

Answer 1

From ECMA:

Any class nested inside a generic class declaration or a generic struct declaration (§25.2) is itself a generic class declaration, since type parameters for the containing type shall be supplied to create a constructed type.

So, you cannot implement nested B without providing type arguments for A .

void Main()
{
    var c = new C();
    var result = c.GetAnotherObject(new BImpl<string, int>());
}

public class BImpl<T, V> : A<T, V>.B
{
    public override int BM()
    {
        return 1;
    }
}

// Or you can supply type arguments right here
//public class BImpl : A<string, int>.B
//{
//  public override int BM()
//  {
//      return 1;
//  }
//}

public abstract class A<T, V>
{
    public abstract int GetObject(T t, V v);
    public abstract int GetAnotherObject(B b);
    public abstract class B
    {
        public abstract int BM();
    }
}

public class C : A<string, int>
{
    public C()
    {

    }

    public override int GetObject(string abc, int def)
    {
        return 10;
    }

    public override int GetAnotherObject(B b)
    {
        return b.BM();
    }
}

Answer 2

You're very close already.

public class C<ABC, DEF> : A<ABC, DEF>
{
    public C()
    {

    }
    public override int GetObject(ABC abc, DEF def)
    {
        return 10;
    }

    // since B is a nested class of A, it has no scope outside of A
    // outside of the definition of A, it must always be referred to as A.B
    public override int GetAnotherObject(A<ABC,DEF>.B b)
    {
        return 15;
    }
}

public class D : A<ABC,DEF>.B
{
    // implementation of A.B
}

Keep in mind that C will always take exactly AB . You will never be able to define an implementation of AB (let's call it D ) and have C 's method signature refer to that in the override. GetAnotherObject is defined in A as taking an AB and must therefore be implemented to accept any AB , not some specific implementation of AB .

RE: your comment on how to implement AB inside C

There is no point to implementing AB inside C . C will still have to have AB in its method signature. But if you really must, for some reason.

public class C<ABC, DEF> : A<ABC, DEF> 
{
    // C's implementation of A

    public override int GetAnotherObject(A<ABC,DEF>.B b)
    {
        return 15;
    }

    public class D : A<ABC,DEF>.B
    {
        // implementation of A.B
    }
}

Note that GetAnotherObject still takes an AB , not a D .

Answer 3

How about

public class C<ABC, DEF> : A<ABC, DEF>
{
    public C()
    {

    }
    public override int GetObject(ABC abc, DEF def)
    {
        return 10;
    }

    public override int GetAnotherObject(B b)
    {
        return 15;
    }
}

Just postfix the class with the generics.