1

我目前有以下问题：
我有一个包含 3 个不同字段的类

  • 枚举 x
  • ActiveDirectory 用户 y
  • 自定义类 z

可以通过传递字符串或枚举对象来初始化枚举。ADUser 可以通过传递字符串 (LoginName) 或用户本身来初始化，而 CustomClass 可以通过传递字符串、int 或对象来初始化。

现在我想初始化类以传递所有不同的组合，例如

class(string enumValue, string adUser, string customClass) 
class(string enumValue, ADUser adUser, CustomClass customClass)
class(EnumValue enumValue, string adUser, CustomClass customClass)

有没有办法在不输入所有 12 种可能性（Enum-2 * ADUser-2 * CClass-3 = 12）的情况下简化构造函数？

我想到了链式构造函数，我最终也得到了 12 个构造函数，但也考虑过只在每个参数上传递 c# 对象并对其进行强制转换并对其进行处理，但我认为这只是一个肮脏的解决方法？

编辑

该类包含在库中，因此可以在内部使用，也可以在公共使用。对于内部使用，传递对象的具体版本没有问题。但是如果我在其他解决方案中公开使用它，这些解决方案只能引用字符串或整数值。因此，该类应该能够在初始化时“获取”这些值并转换它们，因为它可以访问所有真实对象。
也许这可以稍微澄清一下问题。

这里有一些更改名称的代码片段：

#region Content of libraryOne

public class ClassName
{
    internal EnumValueWrapper { get; set; }
    internal CustomClass { get; set; }
    internal ADUser { get; set; }

    public ClassName() { ... } //Now via Builder Pattern
    internal ClassName() { ... } //With Parameters for internal initialisations

    public InformationContainer GetContentInfo()
    {
        //[...]Process Stuff and Return Container
    }
}

internal CustomClass { ... }
internal EnumValueWrapper { ... }
internal ADUser { ... }

#endregion Content of libraryOne
4

2 回答 2

1

如果您的类只有 3 个属性 ( EnumValue, ADUser, CustomClass)，那么您应该只有一个具有这些属性的构造函数：class(EnumValue enumValue, ADUser adUser, CustomClass customClass)。ADUserandCustomClass应该使用支持stringorint等​​的构造函数在您的类之外实例化；例子：

class (EnumValue param, new ADUser(string_param), new CustomClass(int_param));
class (EnumValue param, new ADUser(ADUser_param), new CustomClass(string_param));

编辑 您可以像我上面描述的那样将它用于内部范围，对于公共部分，您可以使用并公开一个工厂（包装器）类，该类实际上可以接收用户和其他参数作为字符串或 int 并在内部实例化并返回您的类。

除了您的代码段：在您的程序集中创建一个类似公共类的代理，可以从外部（从其他程序集）访问。使您的类内部：

   public class ClassNameBuilder
   {
        private ClassName _className;

        public ClassNameBuilder(string enumValue, string user, string custom_class) 
        { 
           _className = new ClassName(EnumToString, new User(user), new CustomClass(custom_class));

        } 

        public void CallClassNameMethod1()
        {
            return _className.Method1()
        }

        public void CallClassNameMethod2()
        {
            return _className.Method2()
        }
}

builder 类可以使用任何你想构建 ClassName 对象的方法；这样您就可以在不使用多个构造函数的情况下公开所有类方法。

于 2015-11-12T12:12:27.497 回答
0

我认为最好的办法是使用 Builder 模式。您甚至可以将它与派生类一起使用。

我要建立的课程：

public class MyBaseClass
{
    public MyBaseClass(SomeEnum enumValue, User user)
    {
    }
}

public class MyDerivedClass : MyBaseClass
{
    public MyDerivedClass(SomeEnum enumValue, User user, CustomClass customStuff)
        : base(enumValue, user)
    {
    }
}

现在让我们添加一个具有附加扩展类的构建器类，以使事情变得更加舒适（它是一种使用 C# 扩展方法 wizadry 的扩展构建器模式）：

public class MyBaseClassBuilder
{
    public SomeEnum EnumValue { get; set; }

    public User User { get; set; }
}

public static class MyBaseClassBuilderExtensions
{
    public static T SetEnumValue<T>(this T instance, SomeEnum value)
        where T : MyBaseClassBuilder
    {
        instance.EnumValue = value;
        return instance;
    }

    public static T SetEnumValue<T>(this T instance, string value)
        where T : MyBaseClassBuilder
    {
        instance.EnumValue = (SomeEnum)Enum.Parse(typeof(SomeEnum), value);
        return instance;
    }

    public static T SetUser<T>(this T instance, User value)
        where T : MyBaseClassBuilder
    {
        instance.User = value;
        return instance;
    }

    public static T SetUser<T>(this T instance, string value)
        where T : MyBaseClassBuilder
    {
        instance.User = new User(value);
        return instance;
    }

    public static MyBaseClass Build(this MyBaseClassBuilder instance)
    {
        return new MyBaseClass(instance.EnumValue, instance.User);
    }
}

现在让我们对派生类做同样的事情：

public class MyDerivedClassBuilder : MyBaseClassBuilder
{
    public CustomClass CustomStuff { get; set; }
}

public static class MyDerivedClassBuilderExtensions
{
    public static T SetCustomStuff<T>(this T instance, CustomClass value)
        where T : MyDerivedClassBuilder
    {
        instance.CustomStuff = value;
        return instance;
    }

    public static T SetCustomStuff<T>(this T instance, string value)
        where T : MyDerivedClassBuilder
    {
        instance.CustomStuff = new CustomClass(value);
        return instance;
    }

    public static MyDerivedClass Build(this MyDerivedClassBuilder instance)
    {
        return new MyDerivedClass(instance.EnumValue, instance.User, instance.CustomStuff);
    }
}

现在，您可以以某种流畅的 API 样式方式构建您的实例：

    static void Main(string[] args)
    {
        MyBaseClass baseInstance = new MyBaseClassBuilder()
            .SetEnumValue("Alpha")
            .SetUser("Big Duke")
            .Build();

        MyDerivedClass derivedInstance = new MyDerivedClassBuilder()
            .SetEnumValue(SomeEnum.Bravo)
            .SetUser(new User("Lt. Col. Kilgore"))
            .SetCustomStuff("Smells like victory")
            .Build();
    }

最后是其他类型：

public enum SomeEnum
{
    Alpha,
    Bravo
}

public class User
{
    public User(string name)
    {
        this.Name = name;
    }

    public string Name { get; private set; }
}

public class CustomClass
{
    public CustomClass(string notation)
    {
        this.Notation = notation;
    }

    public string Notation { get; private set; }
}

这样，您可以以舒适的方式构造需要许多构造函数参数的实例。

于 2015-11-12T12:36:23.590 回答