Receiving dynamically changing classes

问题

In my system I have 16 different classes alike used for statistics. They look like the following

public class myClass : myInheritage
{
    private static myClass _instance;

    public static myClass  Instance
    {
        get { return _instance ?? (_instance = new myClass(); }
    }

    public static void Reset()
    {
        _instance = null;
    }
}

They are all made into singletons

myInheritage looks like this:

public class myInheritage
{
    int data = 0;

    public myInheritage()
    {
    }

    public int Data
    {
        get { return data; }
        set { data+= value; }
    }
}

The program is made, so the user chooses which class he wants to make statistics with.

Something like this is what I want

    public void statistics(Object myObject, string name)
    {
        Object x = myObject;

        x.Data = 10;

        x.Data();
    }

Called from another class

    statistics(myClass.Instance, "myClass");
    statistics(myClass2.Instance, "myClass2)";

So I want to dynamically change my instance in my statistics class.

Is that possible with .NET 2.0 ?

回答1:

You could use reflection...

MethodInfo method = myObject.GetType().GetMethod("Reset");
if (method != null) method.Invoke(myObject, null);

If you can modify the classes themselves, a better approach might be to have each implement an interface (or base class) IResettable.

public interface IResettable
{
    void Reset();
}

public class myClass : myInheritage, IResettable
{
    public void Reset() { ... }
}

Then you could write the function against the interface:

public void statistics(IResettable myObject, string name)
{
    myObject.Reset();
}

回答2:

Yes. What you want here is a Strategy/Factory pattern. I name both as they could be used in conjunction for your case. There are great examples of these design patterns here and the following are detailed intros to the Strategy pattern and the Factory pattern. The former of the last two links also shows you how to combine the two to do exactly waht you require.

So in your case, you could set up the following interface

public interface IStatistics
{
    // Some method used by all classes to impose statistics.
    void ImposeStatistics();
}

Then in you singleton classes you could have

public class myClass : myInheritage, IStatistics
{
    private static myClass _instance;

    public static myClass  Instance
    {
        get { return _instance ?? (_instance = new myClass()); }
    }

    public static void Reset()
    {
        _instance = null;
    }

    // You would also inherit from IStatistics in your other classes.
    public void ImposeStatistics()
    {
        // Do stuff.
    }
}

Then you would have a 'factory' class that imposes you stratgey at runtime.

public static class StatisticFactory 
{
    public static void ImposeStatistics(IStatistics statsType)
    {
        statsType.ImposeStatistics();
    }

    /// <summary>
    /// Get the conversion type.
    /// </summary>
    /// <param name="col">The column to perform the conversion upon.</param>
    public static IStatistics GetStatsType(string typeName)
    {
        switch (typeName)
        {
            case "BoseEinstein":
                return new BoseEinsteinStats();
            case "FermiDirac":
                return new FermiDiracStats();
            default:
                return null;
        }
    }
}

You can then call this like

// Run stats.
IStatistics stats = StatisticFactory(GetStatsType("BoseEinstein"));

to get the statistics for the required class.

I hope this helps.

来源：https://stackoverflow.com/questions/13641711/receiving-dynamically-changing-classes

标签

object

dynamic

singleton