C#-从一元类型化方法（或类）创建并返回多类型泛型

以下是场景：

创建具有多个泛型类型的实例，如：

var obj = myBuilder
            .Combine<TypeA>()
            .And<TypeB>
            .And<TypeC>
            .Create();

这可能吗？

适用于以太类型的参数-类型或参数

因此，您可以相对轻松地创建类，这些类将为C#中的特定类型执行您想要的操作。一种可能的方法是将类型捕获到中间类中，如：

   class Captured<T>
   {
      public Captured<T,U> And<U>() { return new Captured<T,U>();}
   }

   class Captured<T,U>
   {
      public Captured<T,U, V> And<V>() { return new Captured<T,U,V>();}
   }

   class Captured<T,U, V>
   {
      public Combined<T,U, V> Build() { return new Combined<T,U,V>();}
   }

捕获的类
{
public Captured And（）{return new Captured（）；}
}
捕获的类
{
public Captured And（）{return new Captured（）；}
}
捕获的类
{
公共组合生成（）{return new Combined（）；}
}

尽管咖喱法有效，但正如我的同事所指出的，使用的代码在这个过程中创建了太多的实例。这样做的目的是真正将

组合起来

，并且使用几个中间对象似乎很费力。静态类是另一种选择，令我惊讶的是，带有泛型的嵌套静态类工作得非常出色，代码为此目的非常优雅。我很高兴我们甚至在C#中有嵌套类的特性。我为任何一个偶然发现类似问题的人发布了示例代码

public static class Combine<T>
{
    public static class With<U>
    {
        public static class And<V>
        {
            public static CombinedType<T, U, V> Create
            {
                get
                {
                    return new CombinedType<T, U, V>();
                }
            }
        }
    }
}
class CombinedType<T, U, V> { }

class TypeA { }
class TypeB { }
class TypeB { }

// client call
var type = Combine<TypeA>.With<TypeB>.And<TypeC>.Create;

公共静态类组合
{
带有
{
公共静态类和
{
公共静态组合类型创建
{
得到
{
返回新的CombinedType（）；
}
}
}
}
}
类组合类型{}
类TypeA{}
类TypeB{}
类TypeB{}
//客户电话
var type=Combine.With.And.Create；

我差点发明了它，但我很高兴我发布了这个。我从来不知道咖喱。谢谢我发布了一个静态嵌套类的替代方案，用更少的实例实现了相同的目标。+1：事实上，这是一个更紧凑的版本，与我的版本不同，它不会创建任何不必要的对象。

public static class Combine<T>
{
    public static class With<U>
    {
        public static class And<V>
        {
            public static CombinedType<T, U, V> Create
            {
                get
                {
                    return new CombinedType<T, U, V>();
                }
            }
        }
    }
}
class CombinedType<T, U, V> { }

class TypeA { }
class TypeB { }
class TypeB { }

// client call
var type = Combine<TypeA>.With<TypeB>.And<TypeC>.Create;