Untitled

Automatic creation of derived classes from an associated settings class?
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();

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);
}

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);
  }
}

[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);
    }
}

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

DerivedFooSettings x = new DerivedFooSettings();

       BaseClass y = BaseClass.CreateFromSettings(x);

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