C# 访问嵌套在泛型类中的类

这是可能的，还是我应该找到另一种模式并忘记嵌套

非常感谢任何帮助

格雷佐

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
}

公共类外部类，其中T:InnerClass，new（）
{
公共T GetInnerInstance（）
{
返回新的T（）；
}
公共类内部类
{
公共内部阶级
{
}
}
}
公开课Foo
{
OuterClass _实例；//否
}

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

编辑：为清晰起见，以下是完整的模式，感谢Greg的帮助：

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其中ProductType:InnerClass，ReturnInterfaceType，new（）
where ReturnInterfaceType:MinInterface
{                   
私有字符串_privateName；
公共外部类（字符串名称）
{
_privateName=名称；
}
public ReturnInterfaceType GetProduct（）
{
ProductType产品=新的ProductType（）；
product.SetParent（本）；
返回新的ProductType（）；
}
公共类内部类
{
受保护的OuterClass\u父级；
public InnerClass（）{}//泛型new（）的构造函数为空
public void SetParent（OuterClassparent）
{
_父母=父母；
}
//微接口实现
公共字符串工厂名
{
获取{return\u parent.\u privateName；}//访问父级私有成员
}
}
}
公共接口微接口
{
字符串FactoryName{get；}
}
公共接口MyProductInterface:微型接口
{
int productID{get；}
}
公共类MyProduct:OuterClass。InnerClass，MyProductInterface
{
public int productID{get；private set；}
静态int _unbof产品=0；
公共产品（）
{
productID=_\n产品的数量；
__nbf产品++；
}
}

现在很容易创建任何子管道类型和接口的工厂：

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

OuterClass\u工厂；
_工厂=新外部类（“工厂”）；
MyProductInterface_protectedProduct=_factory.GetProduct（）；
字符串factoryName=\u protectedProduct.factoryName；
//与外部类的私有成员的交互仅限于产品的基类和最小接口
//可以很容易地派生新成员和接口

请指定您所指的语言。我猜是C

仔细想想，你使用的模式毫无意义<代码>外部类本身不是一个类<代码>外部类是一个类。事实上，编译器用于

外部类

和

类

的标识符是不同的，因此您实际上可以在同一个文件中定义这两个类

因为

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

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
}

公共类X:OuterClass.InnerClass
{
}
公共类OuterClass，其中T:OuterClass.InnerClass，new（）
{
公共T GetInnerInstance（）
{
返回新的T（）；
}
公共类内部类
{
公共内部类（）
{
}
}
}
公开课Foo
{
OuterClass _instance；//是的
}

为了参数化
OuterClass
，首先需要创建一个与所需的zany约束匹配的类型。实际上不能使用
OuterClass.InnerClass
，因为首先需要一个与约束
T:OuterClass.InnerClass
匹配的类型
T
。这有点像是一种“第二十二条军规”的情况。您可以通过显式定义类型来避免它。
请指定所指的语言。我猜是C

仔细想想，你使用的模式毫无意义<代码>外部类

本身不是一个类<代码>外部类是一个类。事实上，编译器用于

外部类

和

类

的标识符是不同的，因此您实际上可以在同一个文件中定义这两个类

因为

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

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
}

公共类X:OuterClass.InnerClass
{
}
公共类OuterClass，其中T:OuterClass.InnerClass，new（）
{
公共T GetInnerInstance（）
{
返回新的T（）；
}
公共类内部类
{
公共内部类（）
{
}
}
}
公开课Foo
{
OuterClass _instance；//是的
}

为了参数化
OuterClass
，首先需要创建一个与所需的zany约束匹配的类型。实际上不能使用
OuterClass.InnerClass
，因为首先需要一个与约束
T:OuterClass.InnerClass
匹配的类型
T
。这有点像是一种“第二十二条军规”的情况。您可以通过显式定义类型来避免它。
您使用的是什么语言，C#？请在问题上加上适当的标记。你用的是什么语言，C#？请适当地标记问题。非常感谢Greg，非常感谢。为什么滑稽？我使用这个模式，以便所有扩展InnerClass的类都可以访问OuterClass的私有成员。扩展InnerClass的用户不需要了解它的基本功能，但可以轻松地添加新方法并将OuterClass用作工厂。也许有一些Drawnack我还看不到？除非我在您的解释中遗漏了什么，否则从嵌套类继承不会让您访问嵌套类的容器类的
private
或
protected
成员。但是，如果这就是您所追求的，您可以从
外部类继承
内部类
。这可以让你接触到受保护的成员嗨Greg我刚