C# 使用预定义的类创建列表类，这不可能创建列表<；t>；课堂之外

也许是一个令人困惑的标题，我想要的是一个类，它只有一定数量的实例化。还困惑吗

我实际上想要的是一个星级列表（无、一半、一、一、一、一半）等等。所以我需要一个类（或者可能是一个结构？），它有两个字段，值和字符串表示（现在不管怎样，指向其他字段；图像的url等等）。我需要一个容器，一个列表，ObservColl，IEnumerable，只是用来容纳它们的东西

但是我不希望这个类被任何东西实例化，除了容器对象，但是仍然可以将这个类作为一个类型设置为另一个类上的字段

---

这可能吗？还是我要牺牲一些东西呢？

我希望这就是你想要的：

将类设置为公共类或内部类（根据需要），但将构造函数设置为私有类：

public class MyClass
{
    private MyClass() { }
}

然后在类中创建公共或内部静态方法以获取列表：

public class MyClass
{
    // ...
    public static List<MyClass> GetList()
    {
        List<MyClass> list = new List<MyClass>();
        list.Add(new MyClass());
        // ...
        return list;
    }
}

公共类MyClass
{
// ...
公共静态列表GetList（）
{
列表=新列表（）；
添加（新的MyClass（））；
// ...
退货清单；
}
}

您现在只能通过此方法获取列表<代码>列表a=MyClass.GetList（）如果需要，也可以使用静态属性和privat static字段实现它：

public class MyClass
{
    // ...
    static MyClass()
    {
        myList = new List<MyClass>();
        myList.Add(new MyClass());
        // ...
    }
    private static List<MyClass> myList = null;
    public static List<MyClass> MyList
    {
        get { return myList; }
    }
}

公共类MyClass
{
// ...
静态MyClass（）
{
myList=新列表（）；
添加（新的MyClass（））；
// ...
}
私有静态列表myList=null；
公共静态列表MyList
{
获取{return myList；}
}
}

构造函数的访问级别可以设置为以下级别：

• 公共（完全访问）
• 内部（仅来自同一命名空间内的类）
• 受保护（仅从自身和派生类）
• 私人（仅来自自身）

要实现您的意思，您可以做的最接近的事情是创建一个只包含“container”类和“starrating”类的新名称空间，并将starrating构造函数设置为内部

不过，如果您（或其他人）要扩展该名称空间，则该名称空间的所有成员都可以使用构造函数。

public interface IInnerType
public interface IInnerType
{
    Int32 Id { get; set; }
}

public class Container
{
    public Container()
    {
        Items = new InnerTypeCollection();
        Items.Add(new InnerType() { Id = 1 });
        Items.Add(new InnerType() { Id = 2 });
        Items.Add(new InnerType() { Id = 3 });
        Items.Add(new InnerType() { Id = 4 });
        Items.Add(new InnerType() { Id = 5 });
    }

    public InnerTypeCollection Items { get; protected set; }

    class InnerType : IInnerType
    {
        public InnerType()
        { }

        public Int32 Id { get; set; }
    }

    public class InnerTypeCollection : ICollection<IInnerType>
    {
        List<IInnerType> Items { get; set; }

        public InnerTypeCollection()
        {
            Items = new List<IInnerType>();
        }

        public void Add(IInnerType item)
        {
            if (!(item is InnerType))
            {
                throw new ArgumentException("item must be of InnerType");
            }
            Items.Add(item);
        }

        public void Clear()
        {
            Items.Clear();
        }

        public bool Contains(IInnerType item)
        {
            return Items.Contains(item);
        }

        public void CopyTo(IInnerType[] array, int arrayIndex)
        {
            Items.CopyTo(array, arrayIndex);
        }

        public int Count
        {
            get { return Items.Count; }
        }

        public bool IsReadOnly
        {
            get { return (Items as ICollection<IInnerType>).IsReadOnly; }
        }

        public bool Remove(IInnerType item)
        {
            return Items.Remove(item);
        }

        public IEnumerator<IInnerType> GetEnumerator()
        {
            return Items.GetEnumerator();
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return Items.GetEnumerator();
        }
    }
}

{
Int32 Id{get；set；}
}
公营货柜
{
公共容器（）
{
Items=新的InnerTypeCollection（）；
添加（新的InnerType（）{Id=1}）；
添加（新的InnerType（）{Id=2}）；
添加（新的InnerType（）{Id=3}）；
添加（新的InnerType（）{Id=4}）；
添加（新的InnerType（）{Id=5}）；
}
公共InnerTypeCollection项{get；protected set；}
类InnerType:IInnerType
{
公共InnerType（）
{ }
公共Int32 Id{get；set；}
}
公共类InnerTypeCollection:ICollection
{
列表项{get；set；}
公共InnerTypeCollection（）
{
项目=新列表（）；
}
公共作废添加（IInnerType项）
{
如果（！（项目为InnerType））
{
抛出新ArgumentException（“项必须为InnerType”）；
}
项目。添加（项目）；
}
公共空间清除（）
{
Items.Clear（）；
}
公共bool包含（iInerType项）
{
返回项目。包含（项目）；
}
public void CopyTo（IInnerType[]数组，int arrayIndex）
{
Items.CopyTo（数组、数组索引）；
}
公共整数计数
{
获取{return Items.Count；}
}
公共图书馆是只读的
{
获取{return（项目作为ICollection）.IsReadOnly；}
}
公共bool删除（IInnerType项）
{
返回项目。删除（项目）；
}
公共IEnumerator GetEnumerator（）
{
返回项。GetEnumerator（）；
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator（）
{
返回项。GetEnumerator（）；
}
}
}

将星级作为容器的接口公开，并在容器上设置工厂以返回具体实现？

只有

Container

类才能创建

InnerType

的实例，并且自定义集合限制任何不是

InnerType

的添加。这也是我的解决方案。留下一个问题：“singleton”的复数形式是什么？从MyList返回一个不可变的值（例如IEnumerable），并且可能不必担心延迟初始化-使其线程安全会增加复杂性。谢谢Pete，我更改了初始化。我没有将列表更改为IEnumerable，因为我认为这取决于他想用它做什么。您不能使用枚举来描述评级，并使用一些工厂来根据枚举生成各种类型的评级数据吗？