C#索引-我可以返回整个类吗？

如果我错过了一件很明显的事情，那就道歉吧

我希望有一个用户是一个代码，然后引用类名，并从中提取所有数据

在这里，我将向用户显示所述信息：

   Console.Write("Input a code:");
                Console.Read();


                Console.WriteLine("code: " + HU2H02.HeadCode);
                    var i = 0;
                    Console.WriteLine("Stop No:     Station:      Arr:     Dep:");
                    foreach (Station stop in HU2H02.CallingPattern)
                    {
                    if (i < HU2H02.CallingPattern.Count-1)
                    {   
                        if (i == 0)
                            Console.WriteLine("stop {0}: {1} \t  {3: hh:mm}", i, stop.Name, HU2H02.ArrTimes[i], HU2H02.DepTimes[i]);
                        else
                        Console.WriteLine("stop {0}: {1} \t {2: hh:mm} - {3: hh:mm}", i, stop.Name, HU2H02.ArrTimes[i], HU2H02.DepTimes[i]);
                    }
                    else
                    {
                        Console.WriteLine("stop {0}: {1} \t {2: hh:mm}", i, stop.Name, HU2H02.ArrTimes[i]);
                    }
                        i++;
                    }

Console.Write（“输入代码：”）；
Console.Read（）；
Console.WriteLine（“代码：+HU2H02.HeadCode”）；
var i=0；
控制台写入线（“站号：车站：Arr:Dep:”）；
foreach（HU2H02车站，呼叫模式）
{
if（i

这是我的课程代码：（对不起，有点乱，因为我还在写

     class Train
    {
        public string HeadCode { get; set; }
        public string Origin { get; set; }
        public string Destination { get; set; }
        public List<Station> callingPattern = new List<Station>();
        public List<DateTime> arrTimes = new List<DateTime>();
        public List<DateTime> depTimes = new List<DateTime>();
        public DateTime DepartOrigin { get; set; }
        public DateTime ArriveDestination { get; set; }
        public string Via1 { get; set; }
        public string Via2 { get; set; }
        public string Via3 { get; set; }
        public string Via4 { get; set; }

        public object this[string Headcode]
        {
            get
            {

                Type myType = typeof(Train);
                PropertyInfo myPropInfo = myType.GetProperty(Headcode);
                return myPropInfo.GetValue(this, null);
            }
            set
            {
                Type myType = typeof(Train);
                PropertyInfo myPropInfo = myType.GetProperty(Headcode);
                myPropInfo.SetValue(this, value, null);

            }
        }

        public Train(List<Station> patterns, string newheadCode, string timetoDepartOrigin, string Origin)
        {
            TimeSpan previousTime = new TimeSpan();
            TimeSpan holder = new TimeSpan();
            TimeSpan calcTimeSpan = new TimeSpan();
            int i = 0;
            foreach (Station pattern in patterns)
            {
                CallingPattern.Add(pattern);

                if (pattern.Name == Origin)
                {

                    depTimes.Add(Convert.ToDateTime(timetoDepartOrigin));
                    ArrTimes.Add(Convert.ToDateTime(timetoDepartOrigin));
                    previousTime = TimeSpan.Parse(timetoDepartOrigin);
                }
                else
                {
                    holder = TimeSpan.Parse(callingPattern[callingPattern.Count - 2].DwellTimePeak);
                    calcTimeSpan = previousTime + holder;
                    ArrTimes.Add(DateTime.Parse(Convert.ToString(calcTimeSpan)));

                    if (callingPattern[callingPattern.Count - 1].DwellTimePeak != null)
                    {
                        holder = TimeSpan.Parse(callingPattern[callingPattern.Count - 1].DwellTimePeak);
                        calcTimeSpan = calcTimeSpan + holder;
                        depTimes.Add(DateTime.Parse(Convert.ToString(calcTimeSpan)));

                        previousTime = depTimes[depTimes.Count - 1].TimeOfDay + TimeSpan.Parse(callingPattern[callingPattern.Count - 1].TimetonextStationUP[patterns[i + 1].Name]);
                    }
                }
                i++;
            }


            HeadCode = newheadCode;
            DepartOrigin = Convert.ToDateTime(timetoDepartOrigin);
        }

        public List<DateTime> ArrTimes { get => arrTimes; set => arrTimes = value; }
        public List<DateTime> DepTimes { get => depTimes; set => depTimes = value; }
        internal List<Station> CallingPattern { get => callingPattern; set => callingPattern = value; }



        }
    }
}

班列
{
公共字符串头代码{get；set；}
公共字符串源{get；set；}
公共字符串目标{get；set；}
public List callingPattern=new List（）；
public List arrTimes=新列表（）；
public List depTimes=新列表（）；
公共日期时间源{get；set；}
公共日期时间到达目的地{get；set；}
公共字符串Via1{get；set；}
公共字符串Via2{get；set；}
公共字符串Via3{get；set；}
公共字符串Via4{get；set；}
公共对象此[字符串头代码]
{
得到
{
类型myType=类型（列车）；
PropertyInfo myPropInfo=myType.GetProperty（Headcode）；
返回myPropInfo.GetValue（this，null）；
}
设置
{
类型myType=类型（列车）；
PropertyInfo myPropInfo=myType.GetProperty（Headcode）；
设置值（this，value，null）；
}
}
公共列车（列表模式、字符串newheadCode、字符串timetodepartororigin、字符串Origin）
{
TimeSpan previousTime=新TimeSpan（）；
TimeSpan holder=新的TimeSpan（）；
TimeSpan calcTimeSpan=新的TimeSpan（）；
int i=0；
foreach（模式中的站模式）
{
调用模式。添加（模式）；
if（pattern.Name==原点）
{
depTimes.Add（Convert.ToDateTime（timetodepartororigin））；
Add（Convert.ToDateTime（timetodepartororigin））；
previousTime=TimeSpan.Parse（timetoDepartOrigin）；
}
其他的
{
holder=TimeSpan.Parse（callingPattern[callingPattern.Count-2].timepeak）；
calcTimeSpan=以前的时间+持有人；
Add（DateTime.Parse（Convert.ToString（calcTimeSpan））；
if（callingPattern[callingPattern.Count-1].DeliveTimePeak！=null）
{
holder=TimeSpan.Parse（callingPattern[callingPattern.Count-1].timepeak）；
calcTimeSpan=calcTimeSpan+支架；
Add（DateTime.Parse（Convert.ToString（calcTimeSpan））；
previousTime=depTimes[depTimes.Count-1].TimeOfDay+TimeSpan.Parse（调用模式[callingPattern.Count-1].TimetonextStationUP[patterns[i+1].Name]）；
}
}
i++；
}
HeadCode=新HeadCode；
DepartOrigin=Convert.ToDateTime（timetodepartororigin）；
}
公共列表ArrTimes{get=>ArrTimes；set=>ArrTimes=value；}
公共列表DepTimes{get=>DepTimes；set=>DepTimes=value；}
内部列表调用模式{get=>CallingPattern；set=>CallingPattern=value；}
}
}
}

我是否需要将整个班级也宣布为公共班级

我希望将整个类解析回主程序或另一个类以供显示和进一步使用，因为我希望这个类在以后的程序设计中成为其他几个类的子类

我在C#有点新鲜，所以如果这些都没有意义的话，我会任命你！谢谢，

---

克里斯

如果你不把类定义为任何东西，它仍然是私有的。 私有类不能访问其他类。 所以我们将其定义为内部或公共

内部类可以访问包含当前项目的任何类。 公共类在任何类上都是可访问的，即使它是其他项目

---

根据您的目的选择它。

要查找火车，您需要维护火车的

静态

集合。静态变量和函数在类级别（而不是实例级别）上运行

在类中添加类似的内容：

private static Dictionary<string, Train> _trains;
private Train GetTrain(string headCode) {
    if (_trains.TryGetValue(headCode, out var train)) {
        return train;
    } else {
        return null;
    }
}
private bool TryGetTrain(string headCode, out Train train) {
    return _trains.TryGetValue(headCode, out train);
}

每次你创建一个新火车时，它都会被添加到火车字典中。然后，当你想查找火车时，你可以这样做

var myTrain = Train.GetTrain("some head code");

---

你的索引属性（

public object this[string Headcode]

）应该做什么？你是否试图拥有一个

对象集合，训练
对象并拉出其中一个？如果是这样，那么你很可能会使该集合
成为静态的
，并拥有静态访问器（属性或方法）要维护和访问collectionFlyDog，是的，我正在尝试创建一个Train对象的集合，并拉取一个用户通过其代码定义的对象
var myTrain = Train.GetTrain("some head code");