每次调用方法时在方法中向数组添加值

Question

我有一个名为乘客的数组，假设它有 10 个位置。 我还有一个 class 供新乘客使用，它会有乘客的年龄。 我想按他的年龄将新乘客添加到数组中。 该乘客将由其 class 通过调用构造函数创建。 假设我通过调用该方法只添加了一名乘客，并且 9 个地方是空的。 下一次调用该方法，我想在乘客数组的下一个位置添加一个新乘客，所以每次我想添加一个新乘客时，我都会调用乘客方法，它将保存在下一个空放在数组中。 直到满为止。 一条消息会说它已满，没有乘客可以打开 go。

我的代码问题是我必须一次输入所有乘客。 但我每次调用该方法时只想输入一名乘客。

public void Add_Passengers ()
    {
        Console.WriteLine("How old are the passengers?");

        for (int i = 0; i < passengers.Length; i++)
        {
            int age = Int32.Parse(Console.ReadLine());
            passengers[i] = new Passenger(age);
        }
    }

Answer 1

    /// <summary>
    /// Passengers array
    /// </summary>
    public Passenger[] Passengers = new Passenger[10];

    public class Passenger
    {
        public int Age { get; set; }

        public Passenger(int age)
        {
            Age = age;
        }
    }

    public void AddPassenger()
    {
        // Get the number of passengers
        int passengerCount = Passengers.Count(p => p != null);

        if (passengerCount == Passengers.Length)
            Console.WriteLine("Maximum number of passengers");
        else
        {
            Console.WriteLine("How old are the passengers?");
            int age = int.Parse(Console.ReadLine());

            // Add passenger
            Passengers[passengerCount] = new Passenger(age);
        }
    }

Answer 2

你可以试试：

    public void AddPassengers(Passenger[] passengers)
    {
        int i = Array.IndexOf(passengers, null);

        if (i < 0)
        {
            Console.WriteLine("The array is full.");
            return;
        }

        Console.WriteLine("How old is the passenger?");

        int age = Int32.Parse(Console.ReadLine());
        passengers[i] = new Passenger(age);
    }

希望这可以帮助。

Answer 3

public void Add_Passengers()
    {
        PassengerClass PassengerClass = new PassengerClass();

        Console.WriteLine("How old are the passengers?");

        PassengerClass.AddPassanger(Int32.Parse(Console.ReadLine()));
    }

    public class PassengerClass
    {
        public List<int> passangerList;
        public PassengerClass()
        {
            if (passangerList == null)
                passangerList = new List<int>();
        }

        public void AddPassanger(int age)
        {
            passangerList.Add(age);
        }
    }

Answer 4

我将 go 与 class 解决方案：

public class Passanger {
        public int age;

        public Passanger(int age)
        {
            this.age = age;
        }
    }

    public class Passangers
    {
        private List<Passanger> passangers;
        private int limit;
        public bool ready { get; private set; }

        public Passangers(int capacity)
        {
            passangers = new List<Passanger>(capacity);
            limit = capacity;
            ready = false;
        }

        public void addPassanger(Passanger passanger)
        {
            passangers.Add(passanger);

            if(passangers.Count == limit)
            {
                ready = true;
            }
        }

        public List<Passanger> getPassangers()
        {
            passangers.Sort((p1, p2) => p1.age.CompareTo(p2.age));
            return passangers;
        }
    }

Answer 5

您可以保留一个额外的字段来跟踪索引并在添加操作中递增它，而不是每次都迭代数组。

private Passenger[] passengers = new Passenger[10];
private int _count = 0;
public void Add_Passengers()
{
    // validate overflow. >= not strictly necessary but a better safeguard than ==
    if (_count >= passengers.Length)
       throw new InvalidOperationException("Array is filled");
    
    Console.WriteLine("How old are the passengers?");
    
    // validate input
    if (!int.TryParse(Console.ReadLine(), out int age)) 
      throw new InvalidOperationException("Not an integer");

    // Postfix increment returns original value 
    passengers[_count++] = new Passenger(age);
    
}

显然，您应该按照您认为合适的方式处理错误情况。 为了演示，我只是抛出一个InvalidOperationException 。

编辑：我刚刚注意到您明确要求显示错误消息。 这可能看起来像这样：

private Passenger[] passengers = new Passenger[10];
private int _count = 0;
public void Add_Passengers()
{
    // validate overflow. >= not strictly necessary but a better safeguard than ==
    if (_count >= passengers.Length)
    {
       Console.WriteLine("Error: No more passengers are allowed. Size limit reached.");
       return;
    } 
    
    Console.WriteLine("How old are the passengers?");
    
    // validate input
    if (!int.TryParse(Console.ReadLine(), out int age)) 
    {
       Console.WriteLine("Error: Value is not an integer");
       return;
    } 

    // Postfix increment returns original value 
    passengers[_count++] = new Passenger(age);
    
}

List<Passenger>可能是更好的选择。 然后你不需要跟踪索引或担心大小溢出。 请注意，这两种解决方案都不是线程安全的，但这是一个不同的问题。