已回答 需要有关初始化对象中列表语法的帮助
- 线程启动器 邦德拉
- 开始日期
至于这个问题，还有很多要解决的地方。首先，如果要使用自动属性，则无需定义自己的后备字段，因为自动属性会为您做到这一点。在过去，我们曾经不得不实现如下属性：
如今，如果您在getter和setter中所做的只是获取并设置背景字段，则可以使用以下方法实现相同的结果：
The system will implement the getter, the setter and the backing field behind the scenes. If you look at the private members of the type, you'll find that you can actually access the implicitly declared field named
对于集合属性，您应该几乎总是将其声明为只读，然后在内部创建集合。这意味着调用代码可以获取现有集合，然后获取，设置，添加和删除项目，但是现有集合不能完全替换：
That's how it is throughout the .NET Framework already, with properties like
在您的情况下，这意味着，如果您实际上不打算在集合中添加任何匝数，则无需关心构造函数中的该属性：
To be frank, I'm not sure why you would need the
If there was a reason to pass in some existing values for
In that case, the second constructor invokes the first constructor to do the same thing with the first three parameters, then adds the
或像这样：
Because the
C#:
public class Player
{
private string _name;
public string Name
{
get
{
return _name;
}
set
{
_name = value
}
}
}
C#:
public class Player
{
public string Name { get; set; }
}_Name.对于集合属性，您应该几乎总是将其声明为只读，然后在内部创建集合。这意味着调用代码可以获取现有集合，然后获取，设置，添加和删除项目，但是现有集合不能完全替换：
C#:
public class Player
{
public string Name { get; set; }
public List<int> Turns { get; } = new List<int>();
}Control.Controls, ComboBox.Items, DataTable.Rows, etc, etc.在您的情况下，这意味着，如果您实际上不打算在集合中添加任何匝数，则无需关心构造函数中的该属性：
C#:
public class Player
{
public string Name { get; set; }
public bool PlayerIsComputer { get; set; }
public int RoundsPlayed { get; set; }
public List<int> Turns { get; } = new List<int>();
public Player(string name, bool playerIsComputer, int roundsPlayed)
{
Name = name;
PlayerIsComputer = playerIsComputer;
RoundsPlayed = roundsPlayed;
}
}roundsPlayed parameter either. Won't that always be zero for a new Player? If so, there's no point using a parameter and you can just set the property explicitly to zero.If there was a reason to pass in some existing values for
Turns then you could do it like this:
C#:
public class Player
{
public string Name { get; set; }
public bool PlayerIsComputer { get; set; }
public int RoundsPlayed { get; set; }
public List<int> Turns { get; } = new List<int>();
public Player(string name, bool playerIsComputer, int roundsPlayed)
{
Name = name;
PlayerIsComputer = playerIsComputer;
RoundsPlayed = roundsPlayed;
}
public Player(string name, bool playerIsComputer, int roundsPlayed, IEnumerable<int> turns)
: this(name, playerIsComputer, roundsPlayed)
{
Turns.AddRange(turns);
}
}turns values to the existing collection. You could then create a new Player like this:
C#:
players.Add(new Player(ShuffleName(), true, 0));
C#:
players.Add(new Player(ShuffleName(), true, 0, new [] {1, 2, 3}));turns parameter is type IEnumerable<int>, you can pass any type that implements that interface, which includes a 列表<int> or an int array or many other less common options.
Last edited:
I was just suggesting that there was no need for a parameter in the constructor, because that property would be initialised to zero every time. It's not such a bad idea to have a dedicated property for that but you should have a single source of truth. As it stands, it would be possible for the
Turns collection to have a number of items that does not match the RoundsPlayed property. A better option would be to implement RoundsPlayed like this:
C#:
public int RoundsPlayed
{
get
{
return Turns.Count;
}
}I guess it depends exactly what you consider to be the fundamentals.
IEnumerable<T> is an interface and implementing interfaces is an important part of OOP, although probably a level or two up from basic. Essentially, any IEnumerable is a list that you can enumerate using a foreach loop and an IEnumerable<T> is a strongly-type version of that. In this case, the idea is that you can pass any enumerable list as an argument. You could declare that parameter as int[] or 列表<int> but then you are limited to passing in only one type of object when the actual functionality of the constructor doesn't require that type. If you want to stick with types that you've already covered though, by all means use one of those types.话虽如此，这可能是有争议的，因为正如我所说，新球员一开始可能就没有回合，所以您永远不需要在这里传递任何东西。
Last edited:
You might define a
Round class that had a property each for the three attempts and then a property for the sum of those scores. Your Player class could then have a Rounds property that was a 列表<Round>. You might even have a TotalScore property that was implemented as a sum of the scores for all rounds.
我同意拥有一个带有三个属性的回合类来保存每个回合的值。 @jmcilhinney 在读我的思想，但在思考方面比我领先...这很接近 @jmcilhinney 毕竟是在建议，希望它没问题。您可以在早上04:30向男人期望什么类型的伪代码
:
C#:
public class Game
{
public Player AddPlayer(Player player)
{
return player;
}
public Player RemovePlayer(Player player)
{
return player;
}
public Player CreateAIPlayer(Player player)
{
return player;
}
public void BeginGame()
{
}
}
public class Player
{
public Player(int roundsPlayed, string playerName, double playerScore, RoundScores roundScores, bool playerIsAI)
{
RoundsPlayed = roundsPlayed;
PlayerName = playerName;
PlayerScore = playerScore;
RoundScores = roundScores;
PlayerIsAI = playerIsAI;
}
public int RoundsPlayed { get; set; }
public string PlayerName { get; set; }
public double PlayerScore { get; set; }
public RoundScores RoundScores { get; set; }
public bool PlayerIsAI { get; set; }
}
public class Score
{
public Score(double totalScore)
{
TotalScore = totalScore;
}
public double GetTotalScore(RoundScores roundScores)
{
TotalScore = roundScores.Round1Score + roundScores.Round2Score + roundScores.Round3Score;
return TotalScore;
}
public List<Score> ScoresList = new List<Score>();
public double TotalScore { get; set; }
}
public class RoundScores
{
public double Round1Score { get; set; }
public double Round2Score { get; set; }
public double Round3Score { get; set; }
}一切都已经涵盖了。
C#:
using System.Collections.Generic;
namespace ConsoleApp1
{
public class Program
{
public static void Main()
{
var p = new Player();
var r = new Round();
r.FirstAttempt = 16;
r.SecondAttempt = 5;
r.ThirdAttempt = 20;
p.RoundsPlayed.Add(r);
}
}
public class Player
{
public List<Round> RoundsPlayed { get; } = new List<Round>();
}
public class Round
{
public int FirstAttempt { get; set; }
public int SecondAttempt { get; set; }
public int ThirdAttempt { get; set; }
}
}
