在课堂上收集

这个问题在这里已经有了答案：

为什么不从List <T>继承？ 25个答案

---

我的建议是在你的类中定义一个通用的List，并编写像这样的其他Add和Remove方法，并实现IEnumerable：

public class MyClass : IEnumerable
{
    private List<string> myList;

    public MyClass()
    {
        myList = new List<string>();
    }

    public void Add(string item)
    {
        if (item != null) myList.Add(item);
    }

    public void Remove(string item)
    {
        if (myList.IndexOf(item) > 0) myList.Remove(item);
    }

    public IEnumerable<string> MyList { get { return myList; } }

    public IEnumerator GetEnumerator()
    {
        return myList.GetEnumerator();
    }
}

如果你不想实现你自己的集合，这是最好的方式。你不需要实现一个接口来Add和Remove方法。像这样的其他方法，我想你的需要。

---

那么这实际上是一个基于意见的问题，它不是专门用于SO的。 但是，所有的实现都有不同的pro和con，就像你列出的那样，你实现的是一个最适合应用程序使用的选项。

我个人认为，我会选择第一种方法，并添加您需要与内部集合进行交互的方法。 这很容易实现并且使用简单。

就像是。

public class AClass : IEnumerable<string>
{
    public AClass()
    {
        this.values = new List<string>();
    }

    private readonly List<string> values;

    public void Add(string inputString)
    {
        this.values.Add(inputString);
    }

    public void Remove(string inputString)
    {
        this.values.Remove(inputString);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    public IEnumerator<string> GetEnumerator()
    {
        return values.GetEnumerator();
    }
}

现在这有简单的添加删除功能。 另请注意，我使用了readonly列表，因为在构造函数被调用后，列表不需要休息。

根据评论更新AS。

是的，你已经从列表转换到其他类的AClass （你将不得不反正）。 我已经在构造函数中添加了一个额外的构造函数和一个隐式操作符来从List或IEnumerable进行强制转换。

public class AClass : IEnumerable<string>
{
    public static implicit operator AClass(List<string> collection)
    {
        return new AClass(collection);
    }

    public static implicit operator List<string>(AClass aClass)
    {
        return aClass.values;
    }

    public AClass()
    {
        this.values = new List<string>();
    }

    public AClass(IEnumerable<string> collection)
    {
        this.values = collection.ToList();
    }

    private readonly List<string> values;

    public void Add(string inputString)
    {
        this.values.Add(inputString);
    }

    public void Remove(string inputString)
    {
        this.values.Remove(inputString);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    public IEnumerator<string> GetEnumerator()
    {
        return values.GetEnumerator();
    }
}

这可以被用作以下方式：

List<string> listA = new List<string>();

AClass classA = new AClass(); //parameterless constructor
AClass classA1 = new AClass(listA); //simple constructor call with collection
AClass classA2 = (AClass)listA; //direct cast
List<string> listB = (List<string>)listA; //cast back to a list

只是一个想法，也是个人观点。

---

这只是Selman建议的一小部分改编，所以他的回答符合我的期望：

public class MyClass : IEnumerable<string>
{
   private List<string> myList;

   public MyClass()
   {
       myList = new List<string>();
   }

   public ICollection<string> MyList { get { return myList; } }

   IEnumerator IEnumerable.GetEnumerator()
   {
      return GetEnumerator();
   }

   public IEnumerator<T> GetEnumerator(){
      return myList.GetEnumerator();
   }
}

链接地址: http://www.djcxy.com/p/53919.html

上一篇: Having a collection in class

下一篇: profiler