Question

这可能，或者我应该找到另一种模式并忘记嵌套？

非常感谢任何帮助！

Gregzo

public class OuterClass<T> where T : InnerClass, new()
{
    public T GetInnerInstance()
    {
        return new T();
    }

    public class InnerClass
    {
         public InnerClass
         {

         }
    }

}

public class Foo
{
    OuterClass<OuterClass.InnerClass> _instance; // nope
}

目标是让用户扩展InnerClass并将OuterClass用作工厂。

编辑：为了清楚起见，这里是完整的模式，感谢格雷格的帮助：

public class OuterClass< ProductType, ReturnInterfaceType > where ProductType : InnerClass, ReturnInterfaceType, new()
                                                            where ReturnInterfaceType : MinInterface
{                   
    private string _privateName;

    public OuterClass( string name )
    {
        _privateName = name;
    }

    public ReturnInterfaceType GetProduct()
    {
        ProductType product = new ProductType();

        product.SetParent( this );

        return new ProductType();
    }

    public class InnerClass
    {
        protected OuterClass< ProductType, ReturnInterfaceType > _parent;

        public InnerClass(){} //empty ctor for generic new()

        public void SetParent( OuterClass< ProductType, ReturnInterfaceType > parent )
        {
            _parent = parent;
        }

        //MinInterface implementation
        public string FactoryName
        {
            get{ return _parent._privateName; }//access parent private members
        }
    }
}

public interface MinInterface
{
    string FactoryName{ get; }
}

public interface MyProductInterface : MinInterface
{
    int productID{ get; }
}

public class MyProduct : OuterClass< MyProduct, MyProductInterface >.InnerClass, MyProductInterface
{
    public int productID{ get; private set; }
    static int __nbOfProducts = 0;

    public MyProduct()
    {
        productID = __nbOfProducts;
        __nbOfProducts++;
    }
}

现在可以轻松创建任何子产品类型和界面的工厂：

OuterClass<MyProduct, MyProductInterface> _factory;
_factory = new OuterClass<MyProduct, MyProductInterface>( "Factory");

MyProductInterface _protectedProduct = _factory.GetProduct();
string factoryName = _protectedProduct.FactoryName; 
//interaction with the outer class's private members is limited to the product's base class and minimum interface
//New members and interfaces can be easily derived

Answer 1

请指明您所指的语言。我认为它是C＃。

当你想到它时，你正在使用的模式毫无意义。 OuterClass本身不是一个类; OuterClass<T>是一个班级。实际上，编译器用于OuterClass<T>和ΟuterClass的标识符是不同的，因此您可以在同一文件中实际定义这两个类。

因为ΟuterClass本身不是一个类，所以它显然没有成员。但是，如果你真的想，你可以这样做：

public class X : OuterClass<X>.InnerClass
{

}

public class OuterClass<T> where T : OuterClass<T>.InnerClass, new()
{
    public T GetInnerInstance()
    {
        return new T();
    }

    public class InnerClass
    {
        public InnerClass()
        {

        }
    }

}

public class Foo
{
    OuterClass<X> _instance; // yup
}

为了参数化OuterClass，首先需要创建一个与所需的zany约束匹配的类型。您实际上无法使用OuterClass<T>.InnerClass，因为您首先需要与约束T匹配的类型T : OuterClass<T>.InnerClass。它有点变成了捕获22型的情况。您可以通过明确定义类型来避免它。

访问嵌套在泛型类中的类

1 个答案: