3

我试图举一个尽可能简单的例子，但这个问题的本质至少对我来说是相当混乱的。

为了重用代码而不是重复我自己，我有一个IStudent实现另一个接口的接口IPerson。

interface IPerson
{
    string FirstName { get; set; }
    string LastName { get; set; }
}

interface IStudent : IPerson
{
    int StudentNumber { get; set; }
}

我有一个类实现IStudent

class Student : IStudent
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int StudentNumber { get; set; }
}

现在我有一个CommunityBase具有类型字段的抽象类IPerson

abstract class CommunityBase
{
    public IPerson member;

    public CommunityBase(IPerson member)
    {
        this.member = member;
    }

    public void ShowName()
    {
        Console.WriteLine(this.member.FirstName + " " + this.member.LastName);
    }
}

我还有一个派生自CommunityBase被调用的类University。因为University是一个更具体的类我想使用更具体的接口。所以代码如下：

class University : CommunityBase
{
    public new IStudent member;

    public University(IStudent member)
        : base(member)
    {
        this.member = member;
    }

    public void ShowStudentNumber()
    {
        Console.WriteLine(this.member.StudentNumber);
    }
}

为了使所有这些工作，new应为IStudent member. 此外，我需要在基类中分配该member字段一次，然后在派生类中再次分配。

我想要做的是member在构造函数中分配一次，CommunityBase但是这样我就不能使用类中定义的属性或IStudent方法University。

上述所有代码都按预期编译和工作，但我想知道是否有一种更简单、更简单/易于阅读的方法来做到这一点。从我读到的内容来看，new如果我继续使用此代码，人们倾向于避免使用隐藏关键字，是否会有任何潜在问题？

4

2 回答 2

2

让你的CommunityBase类通用

abstract class CommunityBase<T> where T : IPerson
{
    protected T _member;
    public T Member { get return _member; }

    public CommunityBase(T member)
    {
        _member = member;
    }

    public virtual void ShowName()
    {
        Console.WriteLine(_member.FirstName + " " + _member.LastName);
    }
}

也使ShowName虚拟，这使得更具体的类可以覆盖它。

class University : CommunityBase<IStudent>
{
    public University(IStudent member)
        : base(member)
    {
    }

    public override void ShowName()
    {
        Console.WriteLine(_member.FirstName + " " + _member.LastName +
             " Student-No. = " + _member.StudentNumber);
    }
}
于 2014-04-08T21:43:30.677 回答
1

将 CommunityBase 实现为泛型，将类型参数限制为 IPerson

abstract class CommunityBase<T> where T : IPerson {
{
    public abstract T Member { get; }

    public void ShowName() {
        Console.WriteLine(this.Member.FirstName + " " + this.Member.LastName);
    }
}

class University : CommunityBase<IStudent>
{
    IStudent member;

    public University(IStudent member) {
        this.member = member;
    }

    public override IStudent Member { get { return member; } }

}
于 2014-04-08T21:39:12.840 回答