Chain of responsibility vs Reflection

Sometime ago I removed a chain of responsibility in a web site that I'am working on. The chain would call a method to generate a dynamic form for the website. Every object called would either return their form or "pass the ball" to the next object to retrieve the form. The website has around 300+ classes with this logic, no big deal in terms of performance but I found it horrible to see it and debugging it.

So I decided to remove the chain call and just replaced it with reflection, I know what object I have to call by a unique static "name" (the same name was used in the chain to check if the object has to load the form or "pass the ball") of the class and by foreaching all the objects in a list I'll check that name to be sure to call the correct class/method.

I know that reflection is supposed to be slower in terms of performance but after some tests I can't see any sustantial difference and since the code is much cleaner it's easier to understand and debug.

So my question is:

Is this a correct approach or is there any better pattern to use in a case like this ?

I feel like I use reflection more then I should when I'am coding and I don't know if it is always the better option.

This in 1 class:

foreach (TemplateHandler t in objectList)
{
    if (t.GetType().GetProperty("serviceCode") != null)
    {
        if (t.GetType().GetProperty("serviceCode").GetValue(t).ToString() == serviceCodeToCallFromParam)
        {       
            return t.GetTemplateParam(serviceCodeToCallFromParam/*, ...other params...*/);
        }
    }
}

over this in 300+ class:

public override List<Form> GetTemplateParam(string serviceCode)
{
    if (serviceCode == ClassServiceCode)
    {
        // long form logic build.
        //..
    }
    else
    {
        if (successor != null)
            form = successor.GetTemplateParam(serviceCode);
    }
    return form;
}