让子对象继承自特定的父对象

Question

我正在自学 C#，并且有一个关于从父对象的特定实例继承的问题。
例如，如果我这样定义我的类：

class League
{
    public string name { get; set; }
}
class Player : League
{
    public Guid PlayerGuid { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}
class Team : Player
{
    public Guid TeamGuid { get; set; }
    public string TeamName { get; set; }
}

然后像这样实例化类：

    static void Main(string[] args)
    {
        League myLeague = new League() { name = "The League" };
        Player taco = new Player() { PlayerGuid = Guid.NewGuid(), FirstName = "Taco", LastName = "MacArthur" };
        Player pete = new Player() { PlayerGuid = Guid.NewGuid(), FirstName = "Pete", LastName = "Eckhart" };
        Team tacoTeam = new Team() { TeamGuid = Guid.NewGuid(), TeamName = "Password is Taco" };
        Team peteTeam = new Team() { TeamGuid = Guid.NewGuid(), TeamName = "3-Pete" };
    }

如何确保 Team tacoTeam 继承自 Player taco 而 Team peteTeam 继承自 Player pete？

我的感觉是，我不了解如何为这种情况正确定义类，并希望得到有关如何完成此操作的指针。

为了阐明元素之间的关系，我将“玩家”更改为“所有者”更能代表我的想法。我可以进一步为“玩家”添加一个类来代表真正的玩家而不是扶手椅玩家。

根据@neoistheone 和@McGarnagle 的输入，我能够修改它并这样定义类：

class League
{
    public string name { get; set; }
}
class Owner
{
    public Guid OwnerGuid { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}
class Team
{
    public Guid TeamGuid { get; set; }
    public string TeamName { get; set; }
    public Owner TeamOwner { get; set; }
    public League League { get; set; }

}

然后我可以创建类的一个实例并从中获取什么：

    static void Main(string[] args)
    {
        League MyLeague = new League() { name = "The League" };
        Owner taco = new Owner() { FirstName = "Taco", LastName = "MacArthur", OwnerGuid = Guid.NewGuid() };
        Owner pete = new Owner() { FirstName = "Pete", LastName = "Eckhart", OwnerGuid = Guid.NewGuid() };
        Team tacoTeam = new Team() { TeamGuid = Guid.NewGuid(), TeamName = "Password is Taco", League = MyLeague, TeamOwner = taco };
        Team peteTeam = new Team() { TeamGuid = Guid.NewGuid(), TeamName = "3-Pete", League = MyLeague, TeamOwner = pete };

        List<Team> Teams = new List<Team>();
            Teams.Add(tacoTeam);
            Teams.Add(peteTeam);

        foreach(Team team in Teams){
            Console.WriteLine("Team Name:\t{0}\nTeam Owner:\t{1}\nLeague Name:\t{2}\n-----", 
                team.TeamName, team.TeamOwner.FirstName + " " + team.TeamOwner.LastName, team.League.name);
        }

        Console.ReadLine();
    }

这似乎做得相当不错，有助于在我的代码中对数据进行建模，以便更轻松地将数据输入和输出我正在使用此应用程序开发的数据库。

Answer 1

退后一步，想想它在现实生活中的运作方式。一个League 有一个或多个Teams，一个Team 有一个或多个Players。这就是您想要构建类的方式：

class League
{
    public string name { get; set; }
    public List<Team> Teams { get; set; }
}

class Team
{
    public Guid TeamGuid { get; set; }
    public string TeamName { get; set; }
    public List<Player> Players { get; set; }
}

class Player
{
    public Guid PlayerGuid { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

所以现在你可以这样做：

var league = new League()
{
    name = "AFC",
    Teams = new List<Team>()
};

var team = new Team()
{
    TeamGuid = Guid.NewGuid(),
    TeamName = "Chicago Bears",
    Players = new List<Player>()
}
league.Teams.Add(team);

var player = new Player()
{
    PlayerGuid = Guid.NewGuid(),
    FirstName = "Test",
    LastName = "Player"
};
team.Players.Add(player);

但就这一点而言：

如何确保 Team tacoTeam 继承自 Player taco 而 Team peteTeam 继承自 Player pete？

这不是继承的目的。继承是为了让您可以将Player 扩展为例如Linebacker：

public class Linebacker : Player
{
    public int Tackles { get; set; }
}

看，不是每个 Player 都有 Tackles 作为统计数据，但 Linebacker 会。你可以进一步抽象，但我只是想举个例子。

Answer 2

类继承意味着“is-a”关系。例如，您不希望 Player 继承 League，因为这意味着玩家是一个联盟。

相反，您想要的是组成——联赛由球队组成，球队由球员组成。您通过创建班级成员来表达组成。类Team 应该有一个成员是类Player 的集合，依此类推。例如：

class Player
{
    public Guid PlayerGuid { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

class Team
{
    public Guid TeamGuid { get; set; }
    public string TeamName { get; set; }
    public IList<Player> Players { get; private set; }

    public Team()
    {
        Players = new List<Player>();
    }
}

class League
{
    public string name { get; set; }
    public IList<Team> Teams { get; private set; }

    public League()
    {
        Teams = new List<Team>();
    }
}

现在，为了确保 Taco 属于 Taco 团队，您将他添加到 Team 类的相应实例中：

static void Main(string[] args)
{
    Player taco = new Player { PlayerGuid = Guid.NewGuid(), FirstName = "Taco", LastName = "MacArthur" };
    Player pete = new Player { PlayerGuid = Guid.NewGuid(), FirstName = "Pete", LastName = "Eckhart" };
    Team tacoTeam = new Team { TeamGuid = Guid.NewGuid(), TeamName = "Password is Taco" };
    Team peteTeam = new Team { TeamGuid = Guid.NewGuid(), TeamName = "3-Pete" };

    tacoTeam.Players.Add(taco);
    peteTeam.Players.Add(pete);

    League myLeague = new League { name = "The League" };
    myLeague.Teams.Add(tacoTeam);
    myLeague.Teams.Add(peteTeam);
}

Answer 3

我不确定你是否完全理解继承。在这种情况下，真的没有。

一个联赛由一组球队组成，一个球队由一组球员组成。

class League
{
    public string name { get; set; }
    public List<Team> Teams { get; set; }
}

class Team
{
    public Guid TeamGuid { get; set; }
    public string TeamName { get; set; }
    public List<Player> Players { get; set; }
}

class Player
{
    public Guid PlayerGuid { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

在这种情况下，如果您有不同类型的联赛，例如一个 BaseballLeague 和一个 FootballLeague，所以在这种情况下，它们除了具有其他属性外，还将继承自 League，

class BaseballLeague : League
{
    public string SomeOtherProperty { get; set; }
}

Answer 4

您在此示例中误用了继承。考虑一个简单的形状示例。

class Shape
{
    Color Color { get; set; }
}

class Rectangle : Shape
{
    double SideA { get; set; }
    double SideB { get; set; }
}

class Square : Rectangle
{
}

你可以看到一个Square是一个Rectangle，一个Rectangle是一个Square。这三个都有颜色。矩形有两组相等的边。 Square 还有其他一些更具体的属性。

您的结构应该遵循以下原则：

class League
{
    public Team[] Teams { get; set; }
}

class Team
{
    public League League { get; set; }
    public Player[] Players { get; set; }
}

class Player
{
    public Team Team { get; set; }
}

Answer 5

这句话至少可以说很奇怪：

如何确保 Team tacoTeam 继承自 Player taco 而 Team peteTeam 继承自 Player pete？

事实上，继承不一定与您创建的对象有任何关系。 Team 继承自 Player……就是这样。

我有点困惑问题的出处，但我想指出这种继承很奇怪：

class Team : Player

我不明白团队会如何继承玩家。你确定你应该继承吗？

这样想。正如其他人指出的那样，继承意味着“is-a”关系。说一个 Team 是一个 Player 没有任何意义，说一个 Player 是一个 Team 也没有任何意义。一个团队由个玩家组成。这并不意味着应该有任何继承。