2

说我有一个List<Objects>. 我想在一种方法中定义对象列表，并在其他几种方法中使用它们。

这是我想出的方法，我正在寻找更多或正确的方法。

  1. 您可以List<Objects>在使用它的每个方法中进行定义。
    • 优点：它有效。没有机会得到错误的变量。
    • 缺点：代码重复。
  2. 您可以使用List<Objects>类中定义的私有并使用更新它(ref ListObjects)
    • 优点：我只需要定义一次。
    • 缺点：我觉得这是一种混乱和不好的做法。
  3. 您可以List<Objects>作为参数传递给使用它的方法。
    • 优点：防止代码重复
    • 缺点：必须让我的填充函数返回函数，并向我的其他方法添加参数。可能与事件发生冲突？

所以这就是我想出的。我真的不确定使用哪个，或者是否有更好的方法来做到这一点。想法？

编辑：根据要求包括一些代码。

private List<MedicalPlan> medicalPlansList;

这是清单。这是一个从数据库中获取信息的列表，这里：

private void BindMedicalList()
{
   medicalPlansList = new MedicalPlanRepository().RetrieveAll().Where(x => x.Year == year).ToList();
}

然后它用于在该列表中查找对象，例如

var result =
                    medicalPlansList.FirstOrDefault(
                        c => c.CoverageLevels.Any(p => p.Id == id));
4

4 回答 4

2

一般来说，我会这样做。如果您总是在列表上使用相同的函数序列，请考虑创建一个链式函数来处理它。您也可以直接在其他函数调用之一中传递函数调用（只要它返回一个列表），但这往往看起来很混乱。

public List<int> DoSomethingWithList(List<int> list)
{
    //do stuff
    return list;
}

public List<int> DoSomethingElseWithList(List<int> list)
{
    //do other stuff
    return list;
}

public void SomeOtherFunction(string[] args)
{
    var list = new List<int>() { 1, 2, 3, 4 }; //create list
    list = DoSomethingWithList(list); //change list
    list = DoSomethingElseWithList(list); //change list further
}

如果您正在使用具有List<T>字段的对象，我会这样做：

public class MyBigClass
{
    private List<int> myList;
    public MyBigClass()
    {
        //instantiate list in constructor
        myList = new List<int>() { 1, 2, 3, 4 }; 
    }

    public void PublicListAdder(int val)
    {
        myList.Add(val);
    }

    private void PrivateListCleaner()
    {
        //remove all even numbers, just an example
        myList.RemoveAll(x => x % 2 == 0);
    }
}

您很少需要ref在 C# 中使用，因为它会自动为您处理指针。您（通常）不是在传递一个结构，而是在传递一个对象引用（基本上是一个指针）。

于 2012-07-27T17:46:02.150 回答
0

你的 #1 和 #2 真的没有意义：

  1. 如果您在使用它的每个方法中定义不同的列表，那么您每次都使用不同的列表。这不是共享列表；这不起作用。如果您的意思是“调用从使用它的每个方法创建列表的方法”，那么同样适用：您每次都使用不同的列表。
  2. 您不需要使用ref ListObjects来更新私人会员；私有成员仅通过其名称访问。这不是坏习惯。这是标准的面向对象实践。
  3. 将所有必需的数据作为参数传递到方法中，使方法本质上更具可重用性，因为它减少了与方法所属类的耦合。

简而言之：#3 在一定程度上是一种很好的做法，因为它增加了代码的可重用性。然而，#2 的使用是我们进行面向对象编程的根本原因：使您免于向所有方法重复传递参数。这正是私有字段的设计目的！

于 2012-07-27T17:48:40.087 回答
0

在大多数情况下，我可能会选择安德斯的回答。根据您的情况，另一种值得考虑的方法是为 List 编写扩展方法。

namespace ExtensionMethods
{
    public static class MyExtensions
    {
        public static object DoSomething(this List<T> list)
        {
            //do the something with list
        }
    }   
}

然后你可以像这样使用它：

var list = new List<int>();
list.DoSomething();

在该示例中，list作为参数传递给扩展方法。

于 2012-07-27T17:55:07.997 回答
-1

通常 aList<T>不应该属于实例的状态并公开，因为它是可变的，否则您可以从外部更改状态 - 除非您的 getter 旨在返回只读列表。除非您的设计明确允许这种可能性发生时。我的回复并没有真正回答您的问题，只是对良好的面向对象设计的建议。正如有人已经建议比我更好的那样，您可以在每种方法中来回传递一个列表并直接修改它。

于 2012-07-27T17:46:17.580 回答