用Derived类覆盖属性。

Question

I'm trying to separate out a big classes I had into 3 separate classes:

A base class with shared functionality

A server class with server only functionality

A client class with client only functionality

The problem I'm having is I cannot overload properties with a derived class.

Below I've prepared a code sample of a base classes and their server counterparts.

I'm way off somewhere but I was expecting to be able to call "base class" functions and them to work with the overridden derived class.

public class Battlefield
{
    public Tile[,] Tiles { get; set; }
    public virtual Game Game { get; set; }

    public Battlefield(int sizeX, int sizeY, Game game)
    {
        Tiles = new Tile[sizeX, sizeY];
        Game = game;
    }

    public Tile GetTile(int x, int y)
    {
        return Tiles[x, y];
    }
}

public class ServerBattleField : Battlefield
{
    public override ServerGame Game  { get; set; }

    public ServerBattleField(int sizeX, int sizeY, ServerGame game) : base(sizeX, sizeY, game)
    {
    }

    public void DoSomethingServerSpecific()
    {
        Game.DoSomethingServerSpecialWithTile(10,5);
    }
}

public class Game
{
    public virtual Battlefield Battlefield {get;set;}

    public Game(int sizeX, int sizeY)
    {
        Battlefield = new Battlefield(sizeX,sizeY,this);
    }

    public void DoSomethingWithTile(int x, int y)
    {
        Battlefield.GetTile(x,y).DoSomethingWithTile();
    }


}

public class ServerGame : Game
{
    public override ServerBattleField Battlefield {get;set;}

    public ServerGame(int sizeX, int sizeY)
        : base(sizeX, sizeY)
    {
    }

    public void DoSomethingServerSpecialWithTile(int x, int y)
    {
        Battlefield.GetTile(x, y).DoSomethingWithTile();
        Battlefield.GetTile(x, y).DoSomethingSpecialWithTile();
    }

}

public class Tile {
    public void DoSomethingWithTile() { }
    public void DoSomethingSpecialWithTile() { }
}

Answer 1

Your ovveriden property must respect exact signature of the base class property.

In your specific case, you need

public class ServerBattleField : Battlefield
{
    public override ServerGame Game  { get; set; } //CHANGE TO RETURN TYPE GAME

    ....
}

like:

public class ServerBattleField : Battlefield
{
    public override Game Game  { get; set; } //CHANGE TO RETURN TYPE GAME

    ....
}

note that it overlaps with the property name itself: not good , better to change it to avoid future confusion in naming

Answer 2

The problem is as Tigran explained in the signature of the property. If you want to custom-type it per derived class you can use generics.

public class ServerBattleField : Battlefield<GameType>
{
}

Where Battlefield is:

public class Battlefield<T>
{
    public T Game { get; set; }
}

You could force T to derive from a base Game class or interface.

There is no need to derive that property any more.

Answer 3

Using Generics is a good approach, your Battlefield classes will look like this:

public class Battlefield<T> where T: Game
{
    public Tile[,] Tiles { get; set; }
    public T Game { get; set; }

    public Battlefield(int sizeX, int sizeY, T game)
    {
        Tiles = new Tile[sizeX, sizeY];
        Game = game;
    }

    public Tile GetTile(int x, int y)
    {
        return Tiles[x, y];
    }
}

public class ServerBattleField : Battlefield<ServerGame> 
{

    public ServerBattleField(int sizeX, int sizeY, ServerGame game)
        : base(sizeX, sizeY, game)
    {
    }

    public void DoSomethingServerSpecific()
    {
        Game.DoSomethingServerSpecialWithTile(10, 5);
    }
}

Answer 4

You cannot overload something that differs only by return type. Here's why:

ServerGame oServer = new ServerGame();
BattleField oBF = oServer.BattleField; //No way to know which BattleField property to return.

You can override something with an identical signature, and since ServerBattleField inherits from BattleField , there is no issue with return an object of type ServerBattleField from the BattleField property. The code that uses it will just have to know to cast it to the correct type if it needs ServerBattleField functionality specifically.

Also, note that any code that accesses ServerGame 's BattleField property, even though it's defined as returning a BattleField object, it will use the any derived class's overriden functionality.