Question

Still learning my ways around C# generics… is it possible to achieve this functionality?

public interface ISetting<T>
{
    void SetSettings(T obj);
    // myTypeHere GetSettings(T obj);
}

public class RadDockSetting : ISetting<CormantRadDock>
{
    public RadDockSetting()
    {
    }

    public RadDockSetting GetSettings(CormantRadDock dock)
    {
    }

    public void SetSettings(CormantRadDock dock)
    {
    }
 }

I realize this is a counter-intuitive way to be using a Getter — shouldn’t have to pass anything to it. What I’m doing is creating an object, RadDockSetting, that stores the relevant properties of the CormantRadDock — and then returns the ‘got’ settings.

GetSettings is currently a static method, but I realize this will need to be refactored in order to allow implementing a getter from the interface. Maybe once this occurs the ‘weirdness’ of the getter will fall away?

So, a little background on all of this:

I started with a class that had a lot of ‘copy/pasted’ functions. These functions were in charge of saving and removing controls from a manager. When I realized this I set out trying to make these functions more generic. I succeeded, with SO’s help, in making remove generic.

For reference, here is remove:

public static void Remove<T>(string controlID) where T: new()
{
    Logger.InfoFormat("Removing control {0}", controlID);
    T states = RadControlStates.GetStates<T>();
    (states as IDictionary).Remove(controlID);
    RadControlStates.SetStates<T>(states);
}

and it is called like so: RadControlSave.Remove<SerializableDictionary<string, RadPaneSetting>>(ID);

Now, I am trying to extend this genericness to the rest of the methods — the savers. Here’s how one of these methods looks currently:

public static void SavePane(CormantRadPane pane)
{
    Logger.InfoFormat("Saving pane {0}", pane.ID);
    RadPaneSetting paneSettings = RadPaneSetting.GetSettings(pane);
    SerializableDictionary<string, RadPaneSetting> paneStates = RadControlStates.GetStates<SerializableDictionary<string, RadPaneSetting>>();

    bool paneIsKnown = paneStates.ContainsKey(paneSettings.ID);

    if (paneIsKnown)
    {
        Logger.Debug("Pane is known. Overwriting data.");
        paneStates[paneSettings.ID] = paneSettings;
    }
    else
    {
        Logger.Debug("Pane is unknown. Saving data.");
        paneStates.Add(paneSettings.ID, paneSettings);
    }

    RadControlStates.SetStates<SerializableDictionary<string, RadPaneSetting>>(paneStates);
}

At the start of this code block there is a call to “RadPaneSetting.GetSettings(pane)”.

RadPaneSettings implements the ISettings interface. Here is ISetting’s setter being used.

/// <summary>
/// Recreates a dashboard control based off of its settings.
/// </summary>
/// <typeparam name="T"> The type of control to be recreated. </typeparam>
/// <param name="settings"> The known settings needed to recreate the control.</param>
/// <returns> The recreated control. </returns>
public static T Recreate<T>(ISetting<T> settings) where T : new()
{
    T _control = new T();
    settings.SetSettings(_control);
    Logger.DebugFormat("Recreated control {0}", (_control as Control).ID);
    return _control;
}

Answer 1

It looks like you just need to add another generic parameter here

public interface ISetting<T1, T2>
{
    void SetSettings(T1 obj);
    T2 GetSettings(T1 obj);
}

public class RadDockSettings : ISetting<CormantRadDock, RadDockSetting>