C# 创建类的多个实例并区分它们

我正在做一个项目，创建一个包含一些信息的类。比如说

public Player(string Playername, int PlayerRating)
        {
            name = Playername;
            rating = PlayerRating;
        }

我的问题是如何创建一种方法来区分玩家类的多个实例以更新评级。我尝试了一些ID号来选择正确的类。我想也许我可以制作一个ID指针数组，让每个指针指向不同的玩家

编辑：从副本更改为实例。 编辑：用于澄清程序功能是什么。这个想法是让一个大的a组“玩家”，让他们在这个项目之外进行比赛。然后在比赛结束后，我回到这里，更新球员的评分

我能描述它的最好方式是让一个玩家（鲍勃，1000）与另一个玩家（乔，1200）对弈。我有两份球员等级的副本，比赛后我想更改球员等级的值。我的问题是，我不知道如何选择Bobs玩家等级，将他的等级设置为一个新的值，然后对Joe进行同样的操作

我不确定我是否正确理解了这个问题，但是因为每个玩家都在一个单独的变量中，所以您应该能够使用这些变量更新评级

在代码中，它可能看起来像：

class Player
{
    public string Name { get; }
    public int Rating { get; set; }

    public Player(string name, int rating)
    {
        Name = name;
        Rating = rating;
    }
}

static class Game
{
    static void Play(Player player1, Player player2)
    {
        // code to play the game here, also sets player1NewRating and player2NewRating

        player1.Rating = player1NewRating;
        player2.Rating = player2NewRating;
    }

    static void Main()
    {
        var bob = new Player("Bob", 1000);
        var joe = new Player("Joe", 1200);

        Play(bob, joe);
    }
}

我能描述它的最好方式是让一个玩家（鲍勃，1000）与另一个玩家（乔，1200）对弈。我有两份球员等级的副本，比赛后我想更改球员等级的值。我的问题是，我不知道如何选择Bobs玩家等级，将他的等级设置为一个新的值，然后对Joe进行同样的操作

我不确定我是否正确理解了这个问题，但是因为每个玩家都在一个单独的变量中，所以您应该能够使用这些变量更新评级

在代码中，它可能看起来像：

class Player
{
    public string Name { get; }
    public int Rating { get; set; }

    public Player(string name, int rating)
    {
        Name = name;
        Rating = rating;
    }
}

static class Game
{
    static void Play(Player player1, Player player2)
    {
        // code to play the game here, also sets player1NewRating and player2NewRating

        player1.Rating = player1NewRating;
        player2.Rating = player2NewRating;
    }

    static void Main()
    {
        var bob = new Player("Bob", 1000);
        var joe = new Player("Joe", 1200);

        Play(bob, joe);
    }
}

---

您可能正在寻找的是一个。字典可以有一个键和一个值。没有两个键可以是相同的。键和值可以是整数、字符串或您想要的任何对象（类）。你的PlayerName是独一无二的吗？如果是这样，则可以在添加到字典时使用PlayerName作为键。否则，您可以生成Guid并使用它。大概是这样的：

// Keep a dictionary of all players
Dictionary<string, Player> PlayerDict = new Dictionary<string, Player>();

public void addNewPlayer(string newPlayerName)
{
    // create new player with rating of 0
    Player newPlayer = new Player(newPlayerName, 0);
    // check if the player already exists in dictionary
    if (!PlayerDict.ContainsKey(newPlayer.name))
    {
        // player doesn't exist / add player
        PlayerDict.Add(newPlayer.name, newPlayer);
    }
}

public void changePlayerRating(String name, int newRating)
{
    // check if player exists in dictionary
    if (PlayerDict.ContainsKey(name))
    {
        // player exists - change player rating
        PlayerDict[name].rating = newRating;
    }
    else
    {
        // player doesnt exist - add the player
        addNewPlayer(name);
    }
}

public class Player
{
    public string name { get; }
    public int rating { get; set; }

    public Player(string Playername, int PlayerRating)
    {
        name = Playername;
        rating = PlayerRating;
    }
}

PlayerDict["John"].rating += 10

var player = Players.Where(p => p.Name == "John").First();

或者像这样增加评级：

// Keep a dictionary of all players
Dictionary<string, Player> PlayerDict = new Dictionary<string, Player>();

public void addNewPlayer(string newPlayerName)
{
    // create new player with rating of 0
    Player newPlayer = new Player(newPlayerName, 0);
    // check if the player already exists in dictionary
    if (!PlayerDict.ContainsKey(newPlayer.name))
    {
        // player doesn't exist / add player
        PlayerDict.Add(newPlayer.name, newPlayer);
    }
}

public void changePlayerRating(String name, int newRating)
{
    // check if player exists in dictionary
    if (PlayerDict.ContainsKey(name))
    {
        // player exists - change player rating
        PlayerDict[name].rating = newRating;
    }
    else
    {
        // player doesnt exist - add the player
        addNewPlayer(name);
    }
}

public class Player
{
    public string name { get; }
    public int rating { get; set; }

    public Player(string Playername, int PlayerRating)
    {
        name = Playername;
        rating = PlayerRating;
    }
}

PlayerDict["John"].rating += 10

var player = Players.Where(p => p.Name == "John").First();

---

您可能正在寻找的是一个。字典可以有一个键和一个值。没有两个键可以是相同的。键和值可以是整数、字符串或您想要的任何对象（类）。你的PlayerName是独一无二的吗？如果是这样，则可以在添加到字典时使用PlayerName作为键。否则，您可以生成Guid并使用它。大概是这样的：

// Keep a dictionary of all players
Dictionary<string, Player> PlayerDict = new Dictionary<string, Player>();

public void addNewPlayer(string newPlayerName)
{
    // create new player with rating of 0
    Player newPlayer = new Player(newPlayerName, 0);
    // check if the player already exists in dictionary
    if (!PlayerDict.ContainsKey(newPlayer.name))
    {
        // player doesn't exist / add player
        PlayerDict.Add(newPlayer.name, newPlayer);
    }
}

public void changePlayerRating(String name, int newRating)
{
    // check if player exists in dictionary
    if (PlayerDict.ContainsKey(name))
    {
        // player exists - change player rating
        PlayerDict[name].rating = newRating;
    }
    else
    {
        // player doesnt exist - add the player
        addNewPlayer(name);
    }
}

public class Player
{
    public string name { get; }
    public int rating { get; set; }

    public Player(string Playername, int PlayerRating)
    {
        name = Playername;
        rating = PlayerRating;
    }
}

PlayerDict["John"].rating += 10

var player = Players.Where(p => p.Name == "John").First();

或者像这样增加评级：

// Keep a dictionary of all players
Dictionary<string, Player> PlayerDict = new Dictionary<string, Player>();

public void addNewPlayer(string newPlayerName)
{
    // create new player with rating of 0
    Player newPlayer = new Player(newPlayerName, 0);
    // check if the player already exists in dictionary
    if (!PlayerDict.ContainsKey(newPlayer.name))
    {
        // player doesn't exist / add player
        PlayerDict.Add(newPlayer.name, newPlayer);
    }
}

public void changePlayerRating(String name, int newRating)
{
    // check if player exists in dictionary
    if (PlayerDict.ContainsKey(name))
    {
        // player exists - change player rating
        PlayerDict[name].rating = newRating;
    }
    else
    {
        // player doesnt exist - add the player
        addNewPlayer(name);
    }
}

public class Player
{
    public string name { get; }
    public int rating { get; set; }

    public Player(string Playername, int PlayerRating)
    {
        name = Playername;
        rating = PlayerRating;
    }
}

PlayerDict["John"].rating += 10

var player = Players.Where(p => p.Name == "John").First();

---

看起来您的

Player

类已经有了区分玩家的方法，即

Name

属性。有很多方法可以做到这一点，但这里只有一个例子

如果您有一个名为

Players

的

列表

，您可以找到

玩家

的名字“John”，如下所示：

// Keep a dictionary of all players
Dictionary<string, Player> PlayerDict = new Dictionary<string, Player>();

public void addNewPlayer(string newPlayerName)
{
    // create new player with rating of 0
    Player newPlayer = new Player(newPlayerName, 0);
    // check if the player already exists in dictionary
    if (!PlayerDict.ContainsKey(newPlayer.name))
    {
        // player doesn't exist / add player
        PlayerDict.Add(newPlayer.name, newPlayer);
    }
}

public void changePlayerRating(String name, int newRating)
{
    // check if player exists in dictionary
    if (PlayerDict.ContainsKey(name))
    {
        // player exists - change player rating
        PlayerDict[name].rating = newRating;
    }
    else
    {
        // player doesnt exist - add the player
        addNewPlayer(name);
    }
}

public class Player
{
    public string name { get; }
    public int rating { get; set; }

    public Player(string Playername, int PlayerRating)
    {
        name = Playername;
        rating = PlayerRating;
    }
}

PlayerDict["John"].rating += 10

var player = Players.Where(p => p.Name == "John").First();

在该行之后，

player

将包含第一个

player

实例，其

名称为“John”

另一个选项是使用
字典
，它的工作原理类似于
var player=Players[“John”]

这两种方法都依赖于
Name
是唯一的，没有两个玩家可以有相同的名字


在进一步思考你的问题之后，你可能会对如何在一场比赛中跟踪球员感到困惑。这通常在计算机课上很早就有了，所以如果你已经知道了，请原谅我

这就是“参考”的概念。我们在这个领域处理三件事：程序员、变量、实例和引用<代码>变量播放器

定义变量

newplayer（）

创建

Player

的新实例，并返回对该实例的引用。通过将这两条语句与

var player=new player（）

组合，可以将该引用放入变量中。

player

变量现在保存对

player

实例的引用

如果我们谈论的是房屋，

类

将是蓝图。一次只能有一个，它定义了如何建造房子。

实例是每当有人使用蓝图建造房屋时所创建的。你可以有10个独立的房子，都是根据同一个蓝图建造的。这些房屋中的每一栋都是不同的房屋，但具有完全相同的物理特征

在一个游戏中，您可以有多个玩家，他们可以存储在
列表中
，并且您的游戏可以保留一个
currentPlayer
变量，该变量包含一个
int
，索引为轮到谁

举个简单的例子，这是一个简单的游戏循环（没有回合的实际逻辑）。最可能的情况是，您还希望将
Player
实例持久化到更持久的对象，例如数据库。相同的基本循环可以用于任意数量的玩家，它将依次通过每个玩家

bool gameOver = false;
var players = new List<Player>();
players.Add(new Player("John"));
players.Add(new Player("Bob"));
int currentPlayerIndex = 0;
Player winner = null;

while(!gameOver)
{
    var currentPlayer = players[currentPlayerIndex];

    //Do a player's turn here, "currentPlayer" will be whoever's turn it is.
    //set won to true if the current player won the game.

    if(won)
    {
       currentPlayer.Rating++;
       gameOver = true;
    }

    currentPlayerIndex++;
    if(currentPlayerIndex >= players.Count)
    {
        currentPlayerIndex = 0;
    }
}

bool gameOver=false；
var players=新列表（）；
玩家。添加（新玩家（“约翰”）；
添加（新玩家（“Bob”）；
int currentPlayerIndex=0；
玩家赢家=空；
而（！gameOver）
{
var currentPlayer=玩家[currentPlayerIndex]；
//在这里轮到一个玩家，“当前玩家”将是轮到谁的。
//如果当前玩家赢了游戏，则将“赢”设置为true。
如果（韩元）
{
currentPlayer.Rating++；
gameOver=true；
}
currentPlayerIndex++；
如果（currentPlayerIndex>=players.Count）
{
currentPlayerIndex=0；
}
}
看起来您的
玩家
类已经有了区分玩家的方法，即
名称
属性。有很多方法可以做到这一点，但这里只有一个例子

如果您有一个名为
玩家的
列表