将通用基础对象转换为派生类型

Question

What is the correct way to cast a base class that is using generics back to its derived type?

I have the following object implemented.

Note that the "Save" method is calling the "WriteSettings" method here (takes in a BaseSettings object)

public class Settings1
{
    public string strData;
}

public class BaseSettings<T>
{
    T settings;
    public iSettingsDestination Destination;

    public bool Save()
    {
        return Destination.WriteSettings(this);
    }
}

public class Settings1Manager : BaseSettings<Settings1>
{
    public bool DoSomething()
    {
        return true;
    }
}

I have created an interface iSettingsDestination that will always use the base class (BaseSettings) to pass the object. Classes derived from iSettingsDestination can choose which object types to handle. I want to be able to pass this object as it's base type into a method, determine the derived type, and reverse the cast. (see below) I receive a compile error when trying to cast back to the derived type.

public interface iSettingsDestination
{
    bool WriteSettings<T>(BaseSettings<T> settings);
}

public class FileDestination : iSettingsDestination
{
    bool WriteSettings1ManagerToFile(Settings1Manager settings)
    {
        // write to file
        return true;
    }

    bool WriteSettings<T>(BaseSettings<T> settings)
    {
        if (typeof(Settings1Manager).IsAssignableFrom(settings.GetType()))
        {
            // generates error
            // Cannot convert type 'BaseSettings<T>' to 'Settings1Manager'
            return WriteSettings1ManagerToNetwork((Settings1Manager)settings);
        }

        // unhandled object type
        return false;
    }

}

I want to be able to call the code like below. For the example here, I only show 1 type of "Destination" and "Settings" but you can imagine that there are many different types that can be used here.

    void main()
    {
        Settings1Manager settings1 = new Settings1Manager();
        settings1.Destination = new FileDestination();
        settings1.Save(); // saves to a file
    }

I am able to do this with other base classes but it seems that using generics here causes issues.

1) How can I correctly make the cast back to the derived type in the call WriteSettings1ManagerToNetwork((Settings1Manager)settings);

2) Does anyone see any issues blatant misuse of the Generics/interface/etc logic here?

Thanks in advance for any help.

Answer 1

A reference declared as BaseSettings<T> may or may not refer to an actual instance of Settings1Manager . That's how inheritance works. In fact though, what you're doing is casting a base type reference that's actually referring to an object that you've just confirmed actually is of the derived type.

settings as Settings1Manager will compile, because as will just return null if the cast fails. You and I know that particular cast won't fail, but the compiler just follows its rules.

if (typeof(Settings1Manager).IsAssignableFrom(settings.GetType()))
{
    return WriteSettings1ManagerToNetwork(settings as Settings1Manager);
}

This works too, because you can cast anything to object and you can cast object to anything. But you don't want people seeing your name on code that looks like this.

return WriteSettings1ManagerToFile((Settings1Manager)(object)settings);