Question

我有一个抽象的 Group 类和一个抽象的 Member 类。 Group类有一个名为 member 的Member类的字段（属性），Member有一个名为 group 的Group类字段。

它们都必须以这种方式继承，因此我们有 DerGroup 和 DerMember ，而DerGroup有 成员字段> DerMember 和DerMember具有组类的组字段。

我正在尝试使用泛型。

abstract class Member
{
    public Group<Member> group;
    public void Init(Group<Member> grp)
    {
        group = grp;
    }
}

abstract class Group<T> where T : Member
{
    public T member;
    public void InitMember()
    {
        // Here I have an Error: Can't convert Group<T> to Group<Member>
        member.Init(this);
    }
}

如果Group是Generic，如何将此组实例发送到其成员实例？我正在使用Generics来继承Group和Member类并保存它们的关系。像那样：

class Student : Member {}
class ClassRoom<T> : Group<Member> where T : Student {}

所以我们可以这样：typeof（ClassRoom.member）= 学生，而不是会员

向我提供有关如何正确声明Member.Init()功能或完成此操作的任何帮助。

Answer 1

我真的不明白你尝试使用这些类构建的内容（我的意思是，你的核心业务），但你可以引入一个界面：

abstract class Member
{
    public IGroup<Member> group;
    public void Init(IGroup<Member> grp)
    {
        group = grp;
    }
}

interface IGroup<T> where T : Member
{
    T member { get; set; }
}

abstract class Group<T> : IGroup<Member>
{
    public Member member { get; set; }

    public void InitMember()
    {
        member.Init(this);
    }
}

class Student : Member { }

class ClassRoom<T> : Group<Student> where T : Student { }

工作fiddle here。

Answer 2

恐怕你可能已经走下了GRHOM - 疯狂的通用兔子洞。如果环顾四周，你会看到我的爪痕。

这些类之间的关系很难遵循，因为它表明一个组只能有一个成员，而一个成员只能属于一个组。

你想要做的事情是循环的。您正在尝试确保组只有一种成员，而成员只属于包含成员的组，这些成员只是该类组的成员......等等。

问题是，为什么你需要限制这两种方式？鉴于此：

class Group<T> : Group where T : Member

您已经确保Group只能包含Member或Member的子类 - 无论您在定义具体类时是T。

为什么Member还需要指定它只能属于只能将其作为成员的组？这种限制已经完成。

假设组必须包含对成员和组成员的引用，你可以这样做：

abstract class Member
{
    private List<Group> Groups { get; } = new List<Group>();

    internal void AddGroup(Group group)
    {
        Groups.Add(group);
    }
}

abstract class Group
{
    protected List<Member> Members { get; } = new List<Member>();
}

abstract class Group<TMember> :Group  where TMember : Member
{
    void AddMember(TMember member)
    {
        Members.Add(member);
        member.AddGroup(this);
    }
}

现在，组可以受成员类型的约束，但成员可以引用一组非约束的组。

避免让成员引用组可能更简单。如果您想知道成员所在的组，请查询组以查看哪些组包含给定成员。

发送Generic Instance作为参数

2 个答案: