C# 将用户输入与以前输入的值进行比较

我在让我的程序检查之前的输入并进行比较时遇到问题，因此用户无法复制订单号。现在，程序将一直运行，并以我想要的方式查看，但它接受重复的订单号，同时我希望它通知用户并要求他们重新输入。问题似乎是我的check[y]数组在比较时不包含任何值。如何使此数组包含以前输入的订单号，以便显示错误消息。我将发布整个代码，这样您就可以看到我到目前为止所做的工作。其他人建议使用列表类型，但我是一名学生，还没有学会。我相信我应该使用Equals方法。任何帮助都将不胜感激

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;

namespace Assignment6_Hergott
{

class Order : IComparable <Order>
{

    public int orderNumber { get; set; }
    public string customerName { get; set; }
    public int quanityOrdered { get; set; }
    public double total;
    public const double priceEach = 19.95;

    public Order()
    {
    }
    public Order(int number, string name, int quanity)
    {
        number = orderNumber;
        name = customerName;
        quanity = quanityOrdered;
    }

    public double totalPrice
    {
        get
        {
            return total;
        }
    }

    public int CompareTo(Order o)
    {
        return this.orderNumber.CompareTo(o.orderNumber);
    }

    public override bool Equals(Object e)
    {
        bool equal;
        Order temp = (Order)e;
        if (orderNumber == temp.orderNumber)
            equal = true;
        else
            equal = false;
        return equal;

    }
    public override int GetHashCode()
    {
        return Convert.ToInt32(orderNumber);
    }
    public override string ToString()
    {
    return "ShippedOrder " + orderNumber + " " + customerName + " " + quanityOrdered + 
    " @ " + priceEach + " each.";

    }

}
class ShippedOrder : Order
{

    public const int shippingFee = 4;

    public override string ToString()
    {
   return base.ToString() + " Shipping is " + shippingFee + " Total is " + totalPrice;
    }
}
class Program
{
    static void Main(string[] args)
    {

        double sum = 0;
        ShippedOrder[] orderArray = new ShippedOrder[5];
        ShippedOrder[] check = new ShippedOrder[5];
        bool wrong = true;
        for (int x = 0; x < orderArray.Length; ++x)
        {

            orderArray[x] = new ShippedOrder(); 

            Console.Write("Enter order number: ");
            orderArray[x].orderNumber = Convert.ToInt32(Console.ReadLine());

            for (int y = 0; y < x; y++)
            {
                check[y] = new ShippedOrder();

                if (orderArray[x].Equals(check[y]))
                    wrong = false;
                    while (!wrong)
                    {
                        Console.WriteLine("Sorry, the order number {0} is a duplicate. 
\nPlease reenter: ", orderArray[x].orderNumber);
                        for (y = 0; y < x; y++)
                        {
                        if (orderArray[x].Equals(check[y]))
                            wrong = false;

                        }
                        check[y] = orderArray[x];
                    }
            }


            Console.Write("Enter cusomer name: ");
            orderArray[x].customerName = Console.ReadLine();

            Console.Write("Enter quanity: ");
            orderArray[x].quanityOrdered = Convert.ToInt32(Console.ReadLine());

            orderArray[x].total = orderArray[x].quanityOrdered * Order.priceEach + 
ShippedOrder.shippingFee;

            sum += orderArray[x].total;

        }
        Array.Sort(orderArray);
        for (int x = 0; x < orderArray.Length; x++)
        {
            Console.WriteLine(orderArray[x].ToString());
        }
        Console.WriteLine();
        Console.WriteLine("Total for all orders is {0:c} ", sum);
    }
}
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
命名空间分配6_Hergott
{
类顺序：i可比较
{
public int orderNumber{get；set；}
公共字符串customerName{get；set；}
public int quanityOrdered{get；set；}
公共双总；
公用工程双价各=19.95；
公共秩序（）
{
}
公共秩序（整数编号、字符串名称、整数数量）
{
编号=订单编号；
名称=客户名称；
quanity=quanityOrdered；
}
公共双总价
{
得到
{
返回总数；
}
}
公共整数比较（o阶）
{
返回此.orderNumber.CompareTo（o.orderNumber）；
}
公共覆盖布尔等于（对象e）
{
布尔相等；
订单温度=（订单）e；
如果（订单号==临时订单号）
相等=正确；
其他的
相等=错误；
回报相等；
}
公共覆盖int GetHashCode（）
{
返回Convert.ToInt32（订单号）；
}
公共重写字符串ToString（）
{
返回“ShippedOrder”+orderNumber+“”+customerName+“”+quanityOrdered+
“@”+priceEach+“each.”；
}
}
类别ShippedOrder:订单
{
公共工程运输费=4；
公共重写字符串ToString（）
{
return base.ToString（）+“Shipping is”+shippingFee+“Total is”+totalPrice；
}
}
班级计划
{
静态void Main（字符串[]参数）
{
双和=0；
ShippedOrder[]orderArray=新的ShippedOrder[5]；
ShippedOrder[]检查=新的ShippedOrder[5]；
布尔错=真；
对于（int x=0；x

我的check[y]数组在比较时不包含任何值。怎么办 我让这个数组包含以前输入的订单号

如果希望

check[]

包含订单号，则需要为订单号类型（在本例中为

int

）。因此，无论何时将新订单添加到

orderArray

，也要将其编号添加到

检查

数组中。然后，您可以根据前面的数字进行测试

---

如果这不能解决您的问题，请添加一个后续问题作为注释，告诉我们您尝试了什么，我们可以从那里开始。

我有几分钟的时间，所以我更改了答案，向您展示了一种方法。不过，如果你只是复制/粘贴这些内容，你会对自己造成伤害（你的导师可能会告诉你）。看看这个解决方案，看看它和你的有什么不同。我犹豫是否发布完整的解决方案，但我认为这可能是一个好办法，让你找出你做错了什么

namespace ConsoleApplication2
{
    using System;
    using System.Linq;

    public class Order : IComparable<Order>
    {
        public const double PriceEach = 19.95;

        public Order()
        {
        }

        public Order(int number, string name, int quanity)
        {
            this.OrderNumber = number;
            this.CustomerName = name;
            this.QuanityOrdered = quanity;
        }

        public int OrderNumber { get; set; }

        public string CustomerName { get; set; }

        public int QuanityOrdered { get; set; }

        public int CompareTo(Order o)
        {
            return this.OrderNumber.CompareTo(o.OrderNumber);
        }

        public override bool Equals(object e)
        {
            int compareTo;
            int.TryParse(e.ToString(), out compareTo);
            return this.OrderNumber == compareTo;
        }

        public override int GetHashCode()
        {
            return Convert.ToInt32(this.OrderNumber);
        }

        public override string ToString()
        {
            return "Shipped order number " + this.OrderNumber + " for customer " + this.CustomerName + " " + this.QuanityOrdered +
            " @ $" + PriceEach + " each.";
        }
    }

    public class ShippedOrder : Order
    {
        public const int ShippingFee = 4;

        public double TotalPrice
        {
            get
            {
                return (this.QuanityOrdered * PriceEach) + ShippingFee;
            }
        }

        public override string ToString()
        {
            return base.ToString() + " Shipping is $" + ShippingFee + ". Total is $" + this.TotalPrice;
        }
    }

    public class Program
    {
        private static readonly int[] OrderNumbers = new int[5];
        private static readonly ShippedOrder[] ShippedOrders = new ShippedOrder[5];

        public static void Main(string[] args)
        {
            double sum = 0;

            for (var i = 0; i < OrderNumbers.Length; i++)
            {
                OrderNumbers[i] = InputOrderNumber();
                var name = InputCustomerName();
                var quantity = InputQuantity();
                ShippedOrders[i] = new ShippedOrder { CustomerName = name, QuanityOrdered = quantity, OrderNumber = OrderNumbers[i] };
                sum += ShippedOrders[i].TotalPrice;
            }

            Array.Sort(ShippedOrders);
            foreach (var t in ShippedOrders)
            {
                Console.WriteLine(t.ToString());
            }

            Console.WriteLine();
            Console.WriteLine("Total for all orders is {0:c} ", sum);
            Console.WriteLine();
            Console.WriteLine("Press enter to exit.");
            Console.ReadLine();
        }

        private static int InputOrderNumber()
        {
            Console.Write("Enter order number: ");
            var parsedOrderNumber = InputNumber();

            if (ShippedOrders.Any(shippedOrder => shippedOrder != null && shippedOrder.OrderNumber.Equals(parsedOrderNumber)))
            {
                Console.WriteLine("Order number {0} is a duplicate.", parsedOrderNumber);
                return InputOrderNumber();
            }

            return parsedOrderNumber;
        }

        private static string InputCustomerName()
        {
            Console.Write("Enter customer name: ");
            var customerName = Console.ReadLine();
            if (customerName == null || string.IsNullOrEmpty(customerName.Trim()))
            {
                Console.WriteLine("Customer name may not be blank.");
                return InputCustomerName();
            }

            return customerName;
        }

        private static int InputQuantity()
        {
            Console.Write("Enter quantity: ");
            return InputNumber();
        }

        private static int InputNumber()
        {
            int parsedInput;
            var input = Console.ReadLine();
            if (!int.TryParse(input, out parsedInput))
            {
                Console.WriteLine("Enter a valid number.");
                return InputNumber();
            }

            return parsedInput;
        }
    }
}

命名空间控制台应用程序2
{
使用制度；
使用System.Linq；
公共类秩序：IComparable
{
公用工程双价各=19.95；
公共秩序（）
{
}
公共秩序（整数编号、字符串名称、整数数量）
{
this.OrderNumber=编号；
this.CustomerName=名称；
this.QuanityOrdered=数量；
}
public int OrderNumber{get；set；}
公共字符串CustomerName{get；set；}
public int QuanityOrdered{get；set；}
公共整数比较（o阶）
{
返回此.OrderNumber.CompareTo（o.OrderNumber）；
}
公共覆盖布尔等于（对象e）
{
国际比较；
int.TryParse（如ToString（），out compareTo）；
返回this.OrderNumber==compareTo；
}
公共覆盖int GetHashCode（）
{