Question

我试图根据派生的设置类自动实例化正确的派生类。

这里我有主基类和基本设置类

public abstract class BaseClass
{
    public BaseClass() { }

    public abstract BaseClassSettings Write();
}

public class BaseClassSettings
{

}

现在这里是我的派生类及其设置类

public class DerivedFoo : BaseClass
{
    public DerivedFoo(DerivedFooSettings settings) 
    { 
         // Apply settings
    }

    public override BaseClassSettings Write()
    {
        DerivedFooSettings settings = new DerivedFooSettings();

        return settings;
    }
}

public class DerivedFooSettings : BaseClassSettings
{

}

public class DerivedBar : BaseClass
{
    public DerivedBar(DerivedBarSettings settings) 
    { 
         // Apply settings
    }

    public override BaseClassSettings Write()
    {
        DerivedBarSettings settings = new DerivedBarSettings();

        return settings;
    }
}

public class DerivedBarSettings : BaseClassSettings
{

}

我可以将所有派生类设置保存在一个数组中

DerivedFoo foo = new DerivedFoo();
DerivedBar bar = new DerivedBar();

BaseClassSettings[] s = new BaseClassSettings[2];
s[0] = foo.Write();
s[1] = bar.Write();

以XML格式序列化为光盘。

如何根据派生的设置类自动实例化派生类？

因此，如果数组元素是DerivedBarSettings类，则创建DerivedBar类的新实例。

我想这样做而不使用越来越多的else if语句，具体取决于类的数量。

if (BaseClassSettings is DerivedFooSettings)
    new DerivedFoo(settings)
else if (BaseClassSettings is DerivedBarSettings) 
    new DerivedBar(settings)

如何做到这一点？

=============================================== ================================

[编辑]

这是我正在使用的内容：

[
    XmlInclude(typeof(DerivedSettingsClassA)),
    XmlInclude(typeof(DerivedSettingsClassB)),
    XmlInclude(typeof(DerivedSettingsClassC)),
    XmlInclude(typeof(DerivedSettingsClassD)),
    XmlInclude(typeof(DerivedSettingsClassE)),
]
public abstract class BaseSettingsClass
{
    public abstract DerivedClass Load(Game1 game, OutputDimensionSettings settings);
}

唯一的缺点是我必须为所有派生类明确定义XmlInclude。

Answer 1

这是家庭作业吗？

这是一种方式（还有其他可能性）：

public abstract class BaseClass
{ 
  public abstract BaseClassSettings Write(); 
} 

public abstract class BaseClassSettings
{
  public abstract BaseClass CreateCorrespondingInstance();
}

然后：

public class DerivedFoo : BaseClass             
{             
  public DerivedFoo(DerivedFooSettings settings)              
  {              
    // Apply settings             
  }             

  public override BaseClassSettings Write()             
  {             
    DerivedFooSettings settings = new DerivedFooSettings();             
    return settings;             
  }             
}             

public class DerivedFooSettings : BaseClassSettings             
{             
  public override BaseClass CreateCorrespondingInstance()
  {
    return new DerivedFoo(this);
  }
}

但看起来你可以从仿制药中受益！

Answer 2

我不确定仿制药在这里会有多大帮助。泛型用于推迟或约束在编译时直到未知的类型。你在做什么是在不相关的类型之间建立关系。这可以通过自定义属性和一些反射来完成。

首先我们的自定义属性：

    [System.AttributeUsage(System.AttributeTargets.Class)]
    public class BaseClassLinkAttribute : System.Attribute
    {
        public System.Type LinkedType { get; set; }

        public BaseClassLinkAttribute(Type linkedType)
        {
            // Probably wat to make sure type is derrived from BaseClass
            LinkedType = linkedType;
        }
    }

现在我们在基类中添加一个静态方法，在自定义属性中创建该类型的实例：

public abstract class BaseClass 
{ 
    public BaseClass() 
    { 
    } 

    public abstract BaseClassSettings Write();

    public static BaseClass CreateFromSettings(BaseClassSettings settings)
    {
        Attribute attr = Attribute.GetCustomAttribute(settings.GetType(), typeof(BaseClassLinkAttribute));

        // Check for null here and throw exception if attribute can't be found in prduction code

        BaseClassLinkAttribute linkAttribute = (BaseClassLinkAttribute)attr;

        // This is only going to work if class implements a constructor
        // that take a base settings class

        return (BaseClass)Activator.CreateInstance(linkAttribute.LinkedType,settings);
    }
}

现在我们要做的就是使用我们想要创建的类的属性标记settings类。

[BaseClassLink(typeof(DerivedFoo))]
public class DerivedFooSettings : BaseClassSettings
{
}

因此，给定一个设置类，我们现在可以创建关联类：

       DerivedFooSettings x = new DerivedFooSettings();

       BaseClass y = BaseClass.CreateFromSettings(x);

       Console.WriteLine(y.GetType().FullName);

这将为您提供Namespace.DerivedFoo的输出。

当然这里有一些限制，derrived类必须实现一个构造函数，它接受设置类或激活将失败。我认为我们可以通过一些工作来摆脱attrbiute并使用泛型传递类型。但是，您仍然需要在类型之间创建链接。

从关联的设置类自动创建派生类？

2 个答案: