哪个孩子调用了父母的静态方法？还是不可能完成的任务？

我在面试C#程序员职位时接到了一个测试任务，但是我无法解决，因为 不明白到底需要什么。

我写这个是因为 我想改进，完成所有我开始的事情，尽可能地理解和知道我以前不明白或不知道的事情。

面试官说“这是一个简单的测试任务”给我发了一封电子邮件。我引用声明：

类А并且В不包括属性、字段和方法的实现，没有属性并且是共同祖先的继承人С

1) 在不创建所描述类的实例的情况下，在类中实现一个C带有签名的静态方法public static string GetName()，其中 trueA.GetName() == "A" && B.GetName() == "B"

2)在不位于继承线之外的类中实现С一个具有字段签名的类的所有继承人的实例数的单个计数器public static int Count

我向面试官解释了常量的含义"A"-"B"他回答说这些正是类的名称。那些。该方法GetName()必须返回子类的类名。

在徒劳地尝试完全按照作业和谷歌搜索中的描述进行实施的过程中，发现了来自stackoverflow的材料：

• 如何在 .NET 的基类静态方法中获取类类型？

• 在基静态类中获取继承的调用者类型名称

据我所知，据我所知，如果没有 hack，就不可能从静态方法中获取子类的名称。

我又考虑了几个选项（比如创建一个任务中没有描述的新类），但是都涉及尝试规避条件，这与面试官说的有具体解决方案不符，我觉得应该诚实和简单，因为他一开始就这么说了。

我只能这样做，但我知道这是错误的，因为 该方法GetName不是静态的，并且创建了类实例：

一。

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{}
}

面试官的回应：

A：下午好，我明白了，但我不得不失望，这个问题有具体的解决办法

B: 即 这两点都不对？

A：第二个取决于第一个

A：因此，第一个不正确，因为您无法创建实例

请帮我解决这个问题。在我看来，这句话本身就存在矛盾，尤其是它使用了双重否定，很难理解。

更新：同事们，感谢您的回答，解释和评论，我仍然设法以这种方式解决了问题：我创建了另一个C类，我为每个人做了基础，并在其中安装了一个计数器。新类强制执行条件“A 和 B 是 C 的共同祖先的继承人”。

using System;
namespace Rextester
{
    public class Program
    {
        public static void Main ( string[] args )
        {
            Console.WriteLine ( A.GetName() == "A" 
                               && B.GetName() == "B" );

            new A (); // 1 
            new B (); // 2
            new C (); // 3
            new A (); // 4
            new B (); // 5
        }
    }

    class C {
        public static int Count;
    }

    class C < T > : C where T: C < T > {

        public C () { 

            if ( this is A
               || this is B )

                Count++;
            Console.WriteLine ( "Count is:" + Count );
        }

        public static string GetName(){
            return typeof ( T ).Name;
        }
    }

    class A : C < A > { }
    class B : C < B > { }

}

感谢国外同事的回答和评论，我在这段代码中补充了适当的修饰符：基类C和C < T >标记了abstract定义这些类为基类的修饰符，字段Count补充了getter和setter（带有访问修饰符protected）来限制对变量的访问。基类构造函数也C标有访问修饰符protected。成品解决方案：

using System;
namespace Rextester
{
    public class Program
    {
        public static void Main ( string[] args )
        {
            Console.WriteLine ( A.GetName() == "A" 
                               && B.GetName() == "B" );

            new A (); 
            new B ();
        }
    }

    abstract class C {
        public static int Count { get; protected set;}
    }

    abstract class C < T > : C where T: C < T > {

        protected C () { 

            if ( this is A
               || this is B )

                Count++;
            Console.WriteLine ( "Count is:" + Count );
        }

        public static string GetName(){
            return typeof ( T ).Name;
        }
    }

    class A : C < A > { }
    class B : C < B > { }

}

感谢所有参与解决这个难题的人！你们是了不起的人）