Блог

Я столкнулся с проблемой при попытке создать абстрактный класс и метод в нем, который был бы универсальным по своей природе.

 class GameRoomManager : MonoBehaviour {
    public GameRoom GetSomething(string s){
        //do things here
        return GameRoomvar;
    }
}
  

Теперь у меня есть другой класс, который делает нечто подобное, но задействованы другие классы

 class PlayerManager : MonoBehaviour{
    public Player GetSomething(string s){
        //player related things here
        return Playervar;
    }
}
  

Я хочу, чтобы оба класса GameRoomManager и PlayerManager наследовались от абстрактного класса Abs

 class GameRoomManager : Abs{
    public override GameRoom GetSomething<GameRoom>(string s){
        return GameRoomvar;
    }
}
  

где

 public abstract class Abs{
    public T GetSomething<T>(string s);
}
  

Я видел несколько ответов на эту тему, когда искал решения, и все предлагали, чтобы сам абстрактный класс был универсальным. Я не хочу делать абстрактный класс универсальным, поскольку примеры, которые я видел, заставили бы меня это сделать class GameRoomManager : Abs<GameRoomManager> . Но я хочу, чтобы метод возвращал тип GameRoom, а не Gameroocommanager.

Я не совсем знаком с обобщениями, поэтому, пожалуйста, укажите мне правильное направление, если я ошибаюсь

У вас должно быть что-то общее с PQR и HIJ для того, чтобы классы использовали общий метод.

Планируйте

Соединяйте вещи с интерфейсами.

 public interface IPart
{
    // put things here that are common between Part and GameRoom
    int ID { get; }
}
public interface IAbs
{
    IPart GetSomething(string name);
}

public class GameRoom : IPart
{
    public int ID { get; set; }
}

public class GameRoomManager : IAbs
{
    GameRoom part;

    #region IAbs Members

    public GameRoom GetSomething(string name)
    {
        return part;
    }


    IPart IAbs.GetSomething(string name)
    {
        return GetSomething(name);
    }

    #endregion
}

public class Player : IPart
{
    public int ID { get; set; }
}

public class PlayerManager : IAbs
{
    Player part;


    #region IAbs Members

    public Player GetSomething(string name)
    {
        return part;
    }
    IPart IAbs.GetSomething(string name)
    {
        return GetSomething(name);
    }

    #endregion
}
  

План B

Используйте базовый класс с универсальным типом и интерфейсами

 public interface IItem
{
    // put things here that are common between Part and GameRoom
    int ID { get; }
}
public class GameRoom : IItem
{
    public int ID { get; set; }
}
public class Player : IItem
{
    public int ID { get; set; }
}


public interface IAbs
{
    IItem GetItem(string guid);
}
public abstract class Abs<T> : IAbs
    where T : IItem
{
    protected abstract T GetItem(string name);

    protected Abs(T item)
    {
        this.Item=item;
    }
    protected T Item { get; private set; }

    #region IAbs Members

    IItem IAbs.GetItem(string name)
    {
        return GetItem(name);
    }

    #endregion
}


public class GameRoomManager : Abs<GameRoom>
{
    public GameRoomManager(GameRoom room) : base(room)
    {
    }
    protected override GameRoom GetItem(string guid)
    {
        return Item;
    }
    public GameRoom GetRoom(string guid) { return GetItem(guid); }
}

public class PlayerManager : Abs<Player>
{
    public PlayerManager(Player player)
        : base(player)
    {
    }
    protected override Player GetItem(string guid)
    {
        return Item;
    }
    public Player GetPlayer(string guid) { return GetItem(guid); }
}
  

вот несколько примеров использования:

 class Program
{
    static void Main(string[] args)
    {

        List<IAbs> managers=new List<IAbs>();
        var pm=new PlayerManager(new Player() { ID=1001 });
        var gm=new GameRoomManager(new GameRoom() { ID=2050 });

        managers.Add(pm);
        managers.Add(gm);

        IItem part = managers[0].GetItem("0000");

    }
}