Question

我有一个班级玩家，玩家有一个镜头列表。每个镜头都有自己的yPos（位置），因为玩家的yPos可以改变但是射击会保持他的位置：

class Player
{
    public string Id { set; get; }
    public int yPos { set; get; }
    public List<Shot> shots;

    public Player(string _Id, int _yPos)
    {
        Id = _Id;
        yPos = _yPos;
    }

}
class Shot
{
    public int yPos { set; get; }
    public Shot(int _yPos)
    {
        yPos = _yPos;
    }
}

然后在游戏中的某个时刻有一个id，我需要找到玩家。并添加到他的投篮列表中的新球员的位置以下是我最终的结果：

string tempID = "xxx"; // not important where this temp id is coming from
players.Find(p => p.Id == tempID).shots.Add(new Shot(players.Find(p => p.Id == tempID).yPos));

看起来很好，但看起来很奇怪。有没有办法简化这个陈述，所以我不必在一个陈述中两次查找同一个玩家？

Answer 1

我至少会缓存你的玩家结果：

var player = players.Find(p => p.Id == tempId);
player.shots.Add(new Shot(player.yPos));

Answer 2

不是进入玩家来取出它的yPos值并用它创建一个新的Shot，然后把那个Shot推入玩家的射击系列（多么粗鲁！），你可以通过给你的玩家一点来简化一些事情更聪明一点：

class Player
{
    public string Id { set; get; }
    public int yPos { set; get; }
    public List<Shot> shots;

    public Player(string _Id, int _yPos)
    {
        Id = _Id;
        yPos = _yPos;
    }

    public void AddShotToYPos()
    {
        shots.Add(new Shot(yPos));
    }
}

然后你可以说：

players.Find(p => p.Id == tempID).AddShotToYPos();

Answer 3

冒着可能说明显而易见的事情的风险，这样可以少做一次查找，并且可能更具可读性：

string tempID = "xxx";
var player = players.Find(p => p.Id == tempID);
player.shots.Add(new Shot(player.yPos));

Answer 4

KISS：

var p = players.Find(p => p.Id == tempID);
p.shots.Add(new Shot(p.yPos));

毫无意义的LINQ：

(from p in players
         where p.Id == tempID
         select p).Take(1).ToList().ForEach(p => p.shots.Add(new Shot(p.yPos)));

美好而短暂的延伸：

players.Find(p => p.Id == tempID).Shoot();
...
static class Extensions
{
    public static void Shoot(this Player p)
    {
        p.shots.Add(new Shot(p.yPos));
    }
}

Cooler Lambda

(from p in players
         where p.Id == tempID
         let x = new Func<bool>(() => { p.shots.Add(new Shot(p.yPos)); return true; })
         select x()).First();

C＃lambda简化

4 个答案: