Ефективне використання відображення в C #

Оскільки ви отримаєте всі MethodInfo , а також назву для їхнього розташування (імовірно, через MethodInfo.Name , ви можете перейти на один крок далі і створити компілюється лямбда-вираз у вигляді делегата, який ви можете виконати.

First, it's assumed that all of your methods will have the same signature. In this case, it's an Action delegate. With that, your dictionary will look like this:

// No need to have the dictionary **not** readonly
private static readonly IDictionary> methods =
    new Dictionary>;

Тоді, у вашому статичному конструкторі, ви б використовували відображення, щоб отримати всі приклади MethodInfo :

static MyClass()
{
   //Cycle through all the public instance methods.
   //Should filter down to make sure signatures match.
    foreach (MethodInfo methodInfo in typeof(MyClass).
        GetMethods(BindingFlags.Public | BindingFlags.Instance))
    {
       //Create the parameter expression.
        ParameterExpression parameter = Expression.
            Parameter(typeof(MyClass), "mc");

       //Call the method.
        MethodCallExpression body = Expression.Call(pe, methodInfo);

       //Compile into a lambda.
        Action action = Expression.Lambda>(
            body, parameter).Compile();

       //Add to the dictionary.
        methods.Add(methodInfo.Name, action);
    }
}

Тоді ваш приватний метод виглядатиме так:

private void ExecuteMethod(string method)
{
   //Add error handling.
    methods[method]();
}

Перевага тут полягає в тому, що ви отримуєте продуктивність складеного коду, плативши дуже низьку ціну (ІМО) у складності коду (при створенні делегата). Отримано невелику нагоду при виклику коду через делегата, але це значно покращилося (це повинно було бути з введенням LINQ, оскільки вони будуть виконуватися багато, багато разів).

Якщо б я мав вибір тут, я б, ймовірно, пішов із пропозицією Генка і використовував динаміку. Виклики методу є надзвичайно швидкими (набагато швидше, ніж звичайні відображення і майже як звичайні виклики методу).

Ви також можете отримати натхнення, переглянувши цей клас , який розширює DynamicObject і показує, як можна виконувати динамічне виклик методів.

Однак, якщо ви хочете підтримати версію 3.5 або залишити свої параметри відкритими, і у вас немає заперечень щодо використання сторонньої бібліотеки то це все одно можна зробити досить легко:

void Invoke( string methodName )
{
    this.CallMethod( methodName );
}

CallMethod створює делегат DynamicMethod для виклику цього конкретного методу і кешування його, якщо ви знову викликаєте той самий метод. Існують також розширення для виклику методів з параметрами та тоні інших допоміжних інструментів відбиття.

Якщо ви вважаєте за краще кешувати делегата самостійно (ми використовуємо ConcurrentDictionary та WeakReferences для цього, це означає, що він може зібрати сміття), просто зателефонувати за допомогою DelegateForCallMethod .

Бібліотека підтримує як 3.5, так і 4.0. WP7 не підтримує Reflection.Emit і тому не може використовувати генерацію IL і DynamicMethod. Тим не менш, WP 7.5 підтримує це (але Fasterflect, так як називається бібліотека, ще не підтримує).

З вашого коментарю:

Well, simply put it's connected to a server, the server sends commands in the form of ... , and the name determines what functionality should be performed. I want to be able to just add functions with matching names (or rather, I've created an attribute that lets me name methods other than their method-name cause command-names might be numeric), cause the list of names is looooong, and I don't want to do a switch-case.

Ви можете вирішити цю проблему за допомогою простого командного інтерфейсу та фабрики, що керує таблицями, для відповідного екземпляра (або типу, якщо екземпляри команди не повторюються).

public interface ICommand {
  void Execute();
}

public class Processor {
  private static Dictionary commands;
  static Processor() {
   //create and populate the table
  }
  public void ExecuteCommand(string name) {
   //some validation...
    commands[name].Execute();
  }
}

Ніяких роздумів не було.

Щоб створити нову команду, просто створіть новий клас, який реалізує ICommand і додає відповідну рядок в таблицю в стековий конструктор Processor .

public class FooCommand : ICommand {
  public void Execute() {
   //foo away!
  }
}

...

public class Processor {
  static Processor() {
    ...
    commands["foo"] = new FooCommand();
    ...
  }
}

У цьому дизайні є багато переваг, крім виконання. Ваші команди ізольовані один від одного, зміни до однієї команди або створення нових команд не впливатимуть на інші команди. Вони краще перевіряються і легше підтримувати. Навіть процесор може бути закритий (у способі OCP ), якщо ви можете зберегти свою таблицю наприклад, конфігураційний файл або база даних.

Ви, звичайно, можете знайти альтернативні конструкції та способи передачі параметрів командам, але я сподіваюсь, що це дасть вам основну ідею.

У цьому конкретному випадку ви можете оголосити свій словник трохи по-різному і отримати результат, який ви після цього:

class MyClass
{
    private static Dictionary> methods;

    public void Method1()
    {
       //Do something.
    }

    public void Method2()
    {
       //Do something else.
    }
    static MyClass(){
       methods = new Dictionary>();
       foreach(var method in typeof(MyClass).GetMethods(
               BindingFlags.Public | BindingFlags.Instance)
       )
        {
            methods.Add(
                method.Name,
                Delegate.CreateDelegate(typeof(Action),method) 
                  as Action);
        }
    }
}

Цей код має перевагу не використання генерації коду. Однак, якщо у вас є методи різних підписів, то буде потрібний інший підхід. Тут ми створюємо делегованих відкритих екземплярів. (Зауважте, що це не завжди правильно, якщо MyClass є структурою або якщо будь-який з цих методів є загальними віртуальними методами).

Invoking a MethodInfo is slow. So I think creating a new dictionary for each instance should be good enough. Another option is to create a delegate that accepts the instance (Action) using Expressions (and then store them in the static dictionary):

MethodInfo method = typeof(MyClass).GetMethod("Method1");

var parameter = Expression.Parameter(typeof(MyClass));

var call = Expression.Call(parameter, method);

var lambda = Expression.Lambda>(call, parameter);

Action del = lambda.Compile();

Найшвидший спосіб зробити щось не робити це взагалі. Чи знаєте ви, що просто створюєте інтерфейс, як:

interface ICallMe 
{
 void CallByName(string name, object args);
}

Таким чином, якщо деякі з реалізацій хоче бути надзвичайно розумними, це може зробити рефлексію + кешування + створення IL, інші можуть просто використовувати if/switch.

Недоліком - значно менше задоволення для реалізації та налагодження.

Ви розглядали можливість використання Кодування покоління та текстових шаблонів T4 ?

http://msdn.microsoft.com/en-us/library/bb126445.aspx
http://msdn.microsoft.com/en-us/library/bb126478.aspx

Тоді ви могли б скористатися твердженням справи.

Щось на зразок

partial Class MyClass
{
    public void Exec(string funcToExec)
    {
        swtich(funcToExec)
        {
            <#
            foreach(MethodInfo mi in 
                typeof(MyClass).GetMethods(BindingFlags.Public | BindingFlags.Static)
            { 
                if(mi.Name != "Exec"){
            #>
            case : "<#= mi.Name #>"
                <#= mi.Name #>();
            <#
            }}
            #>
        }
    }
}