哪个子类导致了静态父方法?或者是不可能完成的任务

我在面试c#程序员的时候得到了一个测试任务，但是我从来没有能够解决，因为我不明白需要什么。

我写这篇文章是因为我想要改进，完成开始的工作，尽可能地理解和知道自己不理解或不知道的地方。

面试官给我发了一封电子邮件，上面写着"这是一个非常简单的测试"。我引用下面的语句:

类"A"answers"B"不包括属性的实现，字段和方法，这些字段和方法没有属性，是公共属性的继承人祖先"C"

1)不创建所描述类的实例，您应该实现"C"类签名为public static string GetName()的静态方法哪一个是真的A.GetName() == "A" && B.GetName() == "B"

2)实现单个计数变量的所有实例的数量继承人的阶级与签名public static int Count在类，不要在继承线之外联络

我问采访者常数"A"answers"B"是什么意思，他回答说这是类名。例如，GetName()方法应该返回后代类的名称。

在尝试实现的过程中，正如在简短和愤怒的谷歌从stackoverflow中找到的材料:如何在。net的基类静态方法中获得类类型?

和

在基静态类中继承调用者类型名称

Where，据我所知，认为从静态方法中获得后代类的名称是不可能的。

我考虑了一些其他的选择(例如，创建一个没有在工作中描述的新类)，但它们都涉及试图绕过条件，这不符合面试官的话，有一个具体的解决方案，我认为它应该是公平和简单的，因为他最初声称。

我能够做到这一点，但我知道这是错误的，因为GetName方法非静态和实例化类:

1:

using System;
namespace Rextester
{
    public class Program
    {
        public static void Main(string[] args)
        {
            Console.WriteLine ( new A().GetName() == "A" && new B().GetName() == "B" );
        }
    }
    class C {
        public string GetName() {
            return this.GetType().Name;
        }
    }
    class A : C{}
    class B : C{}
}

2:

using System;
namespace Rextester
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var a = new A();
            var b = new B();
            var c = new C();
        }
    }
    public class C {
        public static int Count;
        public C () {
            if ( this is A
               || this is B )
                Count++;
            Console.WriteLine ( "Count is: " + Count );
        }

    }
    public class A : C{}
    public class B : C{}
}

面试官的回答:

他:日子过得好，我看到了，但是不得不失望，问题已经具体了解决方案

我:也就是说，这两点都无效吗?

他:第二个取决于第一个

he:适当地，第一个是不正确的，因为创建副本不能

请帮我解决这个问题。在我看来，这个提法中存在矛盾，越是使用双重否定就越难以理解。

//This _assumes_ you're allowed to use Generics, seems impossible otherwise as A.GetName would compile to C.GetName
void Main()
{
    A.GetName().Dump(); //A
    B.GetName().Dump(); //B
    new A();new A();new A();new A();
    new B();
    //For part 2 I'm not 100% sure what number is wanted    
    baseC.TotalCount.Dump(); //5 
    A.Count.Dump(); //4
    B.Count.Dump(); //1
}
abstract class baseC 
//cant think of any way to stop something other than C inheriting unless in own assembly
// if TotalCount is not the one wanted this can be dropped
{
    public static int TotalCount {get; protected set;} //Must be in the non-generic part so only one copy
}
abstract class C<T> : baseC where T: C<T> //Hopefully enough to FORCE A to inherit C<A> etc
{
    public static int Count {get; private set;}
    public static string GetName() 
    {
        return typeof(T).Name;
    }
    protected C() 
    { 
        TotalCount++;
        Count++;
    }
}

using System;
namespace Rextester
{
    public class Program
    {
        public static void Main(string[] args)
        {
            Console.WriteLine ( A.GetName() == "A" && B.GetName() == "B" );
        }
    }
    class C<T> {
        public static string GetName(){
            return typeof(T).Name;
        }
    }
    class A : C<A>{ }
    class B : C<B> { }
}