C# 操作员访问其他类'；s对象

我需要这个代码的帮助。如果您运行代码，您将在最后7行（即for…loop for Order object）Exercise.OrderItem中获得。问题是我希望使用for…loop访问OrderItem对象，但我得到的只是表示OrderItem对象的最后7行。如何在for…loop中访问它们，以便获得与foreach…loop中相同的结果？我想这和索引器有关。谢谢

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

    namespace Exercise
    {
        interface IPricing
        {
            //read/write property
            double Price
            {
                get;
                set;
            }
            double Discount
            {
                get;
                set;
            }
        }
        public class Order:IPricing
        {
            private string name;
            private double price;
            private static int OrderNo;
            //private ArrayList m_items = new ArrayList();
            private ArrayList m_items;


            //static constructor
            static Order()
            {
                OrderNo = 0;
            }

            //default constructor
            public Order()
            {
                name = null;
                price = 0;
                OrderNo++;
                m_items = new ArrayList();
            }
            //constructor with parameters
            public Order(string name, double price)
            {
                this.name = name;
                this.price = price;
                OrderNo++;
                this.m_items = new ArrayList();
            }
            //copy constructor
            public Order(Order order)
            {
                this.name = order.name;
                this.price = order.price;
                this.m_items = order.m_items;
            }

            public string Name
            {
                get { return name; }
                set { name = value; }
            }

            public IEnumerable Items
            {
                get { return m_items; }
                private set { }
            }

            public void AddItem(OrderItem orderItem)
            {
                orderItem.Order = name;
                m_items.Add(orderItem);
            }

            public static Order operator +(Order o1, Order o2)
            {
                Order o3 = new Order(o1.name+", "+o2.name,o1.price+o2.price);
                o3.m_items.AddRange(o1.m_items);
                o3.m_items.AddRange(o2.m_items);
                return o3;
            }

            //indexer 
            public object this[int index]
            {
                get 
                {
                    m_items[index] = this.m_items[index];
                    return m_items[index];
                }
                set { m_items[index] = value; }
            }

            public double ItemCount
            {
                get { return m_items.Count; }
                private set{}
            }


            public virtual void Print()
            {
                Console.WriteLine("*********************Order No. {0}***********************", OrderNo);
                Console.WriteLine("Details");
                Console.WriteLine("Name:              {0}", name);
                Console.WriteLine("Price:             {0}", price);
            }

            public double Price
            {
                get { return price - Discount; }
                set { price = value; }
            }

            public virtual double Discount
            {
                get { return 0; }
                set { ;}
            }

            public void PrintItems()
            {
                Console.WriteLine("Items in this order: ");
                Console.WriteLine();
                foreach(OrderItem itm in this.m_items)
                {
                    Console.WriteLine("Item name: {0,4};\tPart of order: {1}", itm.Name, itm.Order);
                }
            }


}

        public class OrderItem
        {
            private string m_name; //name of the item in order
            private string m_order; //name of the order whose parts are items with names m_name
            //default constructor
            public OrderItem()
            {
                m_order = null;
            }
            //parameter constructor
            public OrderItem(string name)
            {
                this.m_name = name;
                this.m_order = null;
            }
            //copy constructor
            public OrderItem(OrderItem orderItem)
            {
                this.m_name = orderItem.m_name;
                this.m_order = orderItem.m_order;
            }

            //Name read/write property
            public string Name
            {
                get { return m_name; }
                set { m_name = value; }
            }

            //Order read/write property
            public string Order
            {
                get { return m_order; }
                set { m_order = value; }
            }
        }

        public class MainProgram
        {
            static void Main(string[] args)
            {
                string order1 = "Desktop PC";
                Order desktopPC = new Order(order1,25000);
                desktopPC.AddItem(new OrderItem("pc mouse"));
                desktopPC.AddItem(new OrderItem("keyboard"));
                desktopPC.AddItem(new OrderItem("monitor"));
                desktopPC.AddItem(new OrderItem("pc"));

                desktopPC.Print();
                desktopPC.PrintItems();

                Console.WriteLine();


                string order2 = "Notebook";
                Order notebook = new Order(order2, 54000);
                notebook.AddItem(new OrderItem("mouse"));
                notebook.AddItem(new OrderItem("bag"));
                notebook.AddItem(new OrderItem("notebook"));


                notebook.Print();
                notebook.PrintItems();


                Console.WriteLine();
                Order total = desktopPC + notebook;
                total.Print();
                total.PrintItems();
                Console.WriteLine();

                Console.WriteLine("Getting the items via for loop");
                for (int k = 0; k < total.ItemCount; k++)
                {
                   Console.WriteLine(total[k]);
                }

                    Console.ReadKey();
            }
        }
    }

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
使用System.Threading.Tasks；
使用系统集合；
名称空间练习
{
接口定价
{
//读/写属性
双倍价格
{
得到；
设置
}
双倍折扣
{
得到；
设置
}
}
公共课堂秩序：IPricing
{
私有字符串名称；
私人双价；
私有静态int OrderNo；
//private ArrayList mu items=new ArrayList（）；
私有ArrayList m_项；
//静态构造函数
静态顺序（）
{
OrderNo=0；
}
//默认构造函数
公共秩序（）
{
name=null；
价格=0；
OrderNo++；
m_items=new ArrayList（）；
}
//带参数的构造函数
公共订单（字符串名称，双倍价格）
{
this.name=名称；
这个价格=价格；
OrderNo++；
this.m_items=new ArrayList（）；
}
//复制构造函数
公共秩序
{
this.name=order.name；
this.price=order.price；
this.m_items=order.m_items；
}
公共字符串名
{
获取{返回名称；}
设置{name=value；}
}
公共数字项目
{
获取{return m_items；}
私有集{}
}
公共无效附加项（OrderItem OrderItem）
{
orderItem.Order=名称；
m_items.Add（orderItem）；
}
公共静态命令运算符+（命令o1，命令o2）
{
订单o3=新订单（o1.name+“，”+o2.name，o1.price+o2.price）；
o3.m_items.AddRange（o1.m_items）；
o3.m_项目。添加范围（o2.m_项目）；
返回o3；
}
//索引器
公共对象此[int索引]
{
得到
{
m_items[索引]=此.m_items[索引]；
返回m_项目[索引]；
}
设置{m_items[index]=value；}
}
公共重复项目计数
{
获取{return m_items.Count；}
私有集{}
}
公共虚拟作废打印（）
{
Console.WriteLine（“*************************订单号{0}*******************************”，订单号）；
Console.WriteLine（“详细信息”）；
WriteLine（“名称：{0}”，名称）；
控制台.WriteLine（“价格：{0}”，价格）；
}
公共双价
{
获取{返回价格-折扣；}
设置{price=value；}
}
公共虚拟双重折扣
{
获取{返回0；}
集合{；}
}
公共项目（）
{
Console.WriteLine（“此顺序中的项目：”）；
Console.WriteLine（）；
foreach（此.m_items中的OrderItem itm）
{
WriteLine（“项目名称：{0,4}；\t顺序部分：{1}”，itm.name，itm.order）；
}
}
}
公共类OrderItem
{
私有字符串m_name；//顺序中项目的名称
私有字符串m_-order；//其部分是名称为m_-name的项的订单的名称
//默认构造函数
公共订单项目（）
{
m_顺序=空；
}
//参数构造函数
public OrderItem（字符串名称）
{
this.m_name=名称；
此.m_顺序=空；
}
//复制构造函数
公共OrderItem（OrderItem OrderItem）
{
this.m_name=orderItem.m_name；
this.m_order=orderItem.m_order；
}
//名称读/写属性
公共字符串名
{
获取{return m_name；}
设置{m_name=value；}
}
//顺序读/写属性
公共字符串秩序
{
获取{return m_order；}
集合{m_order=value；}
}
}
公共课程
{
静态void Main（字符串[]参数）
{
string order1=“桌面PC”；
订单desktopPC=新订单（订单125000）；
desktopPC.AddItem（新订单项（“pc鼠标”）；
desktopPC.AddItem（新订单项（“键盘”）；
desktopPC.AddItem（新订单项（“监视器”）；
Desktop C.AddItem（新订单项（“pc”）；
desktopPC.Print（）；
desktopPC.PrintItems（）；
Console.WriteLine（）；
string order2=“笔记本”；
订单笔记本=新订单（订单254000）；
notebook.AddItem（新订单项（“鼠标”））；
不
        for (int k = 0; k < total.ItemCount; k++)
        {
            var x = total[k] as OrderItem;
            if (x == null) continue;
            Console.WriteLine(x.Name);
            Console.WriteLine(x.Order);
        }