Question

我在面试C＃程序员的过程中得到了一个测试任务，但是从来没能解决，因为我不明白需要什么。

我写这篇文章是因为我希望改进，完成开始的业务，理解并知道在可能的范围内无法理解或不了解的内容。

用＆＃34;这是非常简单的测试＆＃34;面试官通过电子邮件给我发了短信。我引述声明：

课程＆＃34; A＆＃34;和＆＃34; B＆＃34;不包括属性的实现，   没有归属的领域和方法，是共同的继承人   祖先＆＃34; C＆＃34;

1）不创建所描述的类的实例，你应该实现＆＃34; C＆＃34;类   带有签名public static string GetName()的静态方法   这是真的A.GetName() == "A" && B.GetName() == "B"

2）实现所有实例数的单个count-variable   班级的继承人，签名public static int Count   上课，而不是在继承线之外联络

我问问采访者常数是什么意思＆＃34; A＆＃34;和＆＃34; B＆＃34; - 他回答说这是班级名字。即GetName（）方法应该返回后代类的名称。

在尝试完全按照简短和激烈的谷歌搜索中描述的方式实现了stackoverflow中的材料：How to get the class Type in a base class static method in .NET?

和

Get inherited caller type name in base static class

据我所知，在没有黑客攻击的情况下，从静态方法获取后代类的名称是不可能的。

我考虑过其他几个选项（例如创建一个未在作业中描述的新类），但它们都涉及绕过条件的尝试，这与面试官这个词有一个特定的解决方案不相符，我认为它应该是公平和简单的，因为他最初声称。

我能做到这一点，但我知道这是错的，因为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{}

}

采访者的回应：

  他说：美好的一天，我明白，但不得不让人失望，这个问题有一个具体的问题   溶液

me：即两点都无效？
     他：第二个取决于第一个

他：恰当的，第一个不是真的，因为创建副本不能

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

Answer 1

也许：

//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++;
    }
}

Answer 2

谢谢大家。感谢用户https://ru.stackoverflow.com/users/186999/grundy和自己的研究，我找到了第一部分这个问题的答案：

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

}

但我仍然需要你的帮助才能知道第二部分的答案。

什么子类导致静态父方法？或者不可能的任务？

2 个答案: