Dynamic method selection based on performance

• Download source code - 41.6 KB

Introduction

Often times, we find more than a single way of doing things. Even when we create the most sophisticated methods to obtain information from a source, we still rely on external dependencies, such as database or network latency; or physical factors such as hard drive or computer failures that are non-deterministic and make our lives more difficult when it comes to fine tuning these systems. In such situations, a good approach is to have a second or third alternative where if data can’t be obtained the usual way, we could try it a different way, and here is where we fall in this try/catch mode that never seems to have an end.

Approach

The approach presented here helps your system in proactively identifying a method, from a set of methods, that has the best response time and no exceptions at any given moment. The way this works is as follows: based on a set of methods with the same signature, the same functionality, but different implementations, the algorithm will test each method first and measure response times; then, it’ll choose the fastest method that does not throw exceptions; then, if the method response time is above an threshold or an exception is thrown, it’ll revaluate all the methods again and chooses the fastest one. At the same time, it will continually adjust to adapt in case the performance is degraded.

Sample

Let’s suppose we have two different implementations to concatenate two strings. The first method uses String.Concat, the second uses StringBuilder. As expected, the latter should perform better as you can see when running the example.

The following is a way you can subscribe all the methods in the adaptive method selector:

private AdaptiveMethodSelector<string, ParamsMethods> _methodOptimizer;
private AdaptiveMethodSelector<string, ParamsMethods> MethodOptimizer
{
    get
    {
       if (_methodOptimizer != null)
         return _methodOptimizer;

       Collection<AdaptiveMethodSelector<string, ParamsMethods>.EvaluationMethodDelegate>
            functionsToEvaluate = new Collection<AdaptiveMethodSelector<string, 
                                  ParamsMethods>.EvaluationMethodDelegate>();
            functionsToEvaluate.Add(new AdaptiveMethodSelector<string, 
                                    ParamsMethods>.EvaluationMethodDelegate(Method1));
            functionsToEvaluate.Add(new AdaptiveMethodSelector<string, 
                                    ParamsMethods>.EvaluationMethodDelegate(Method2));

       _methodOptimizer = new AdaptiveMethodSelector<string, 
                                ParamsMethods>(functionsToEvaluate);
       return _methodOptimizer;
    }
}

The AdaptiveMethodSelector takes two types, the first one is the return type of the methods, the second is a type for the parameters being passed. When you need to pass multiple parameters to the methods, you can define a structure as in this example; otherwise, you can indicate the type such as string, int, etc.

The methods signature in the example is as follows:

public string Method1(ParamsMethods parameters)
public string Method2(ParamsMethods parameters)

where ParamsMethods is:

public struct ParamsMethods
{
    public ParamsMethods(string param1, string param2)
    {
       Param1 = param1;
       Param2 = param2;
    }

    public string Param1;
    public string Param2;
}

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)