Существует ли эквивалент С# для typeof для свойств/методов/членов?

Метаданные классов Type могут быть получены несколькими способами. Два из них:

var typeInfo = Type.GetType("MyClass")

и

var typeInfo = typeof(MyClass)

Преимущество второго способа заключается в том, что опечатки будут пойманы компилятором, а среда IDE может понять, о чем я говорю (позволяя функциям, таким как рефакторинг, работать без бесшумного нарушения кода)

Существует ли эквивалентный способ сильного ссылки на элементы/свойства/методы для метаданных и отражения? Могу ли я заменить:

var propertyInfo = typeof(MyClass).GetProperty("MyProperty")

с чем-то вроде:

var propertyInfo = property(MyClass.MyProperty)

Ответы

Ответ 1

Нет, к сожалению нет. Он обсуждался и даже назывался: infoof (произносится как "in-foof" для комедии), но он еще не реализован... пока. Эрик Липперт имеет сообщение в блоге об этом.

Ближе всего вы можете зайти на С# 3, чтобы заставить компилятор сгенерировать дерево выражений, а затем вытащить его из этого, но это вряд ли приятно.

Ответ 2

Я только что реализовал эквивалент свойств конструкции '' метода '' fieldof ', используя Syste.Linq.Expressions

поэтому вместо записи

var mi = typeof (string).GetMethod("Concat", new[] {typeof (object), typeof (object)});

вы можете использовать:

var mi = ReflectionHelper.MethodOf(() => string.Concat(new object(), new object()));

Зачем нам это нужно? потому что теперь мы безопасны для рефакторинга, мы используем через отражение

список вспомогательного класса (возможно, вам нужно добавить некоторые информационные исключения в методы):

/// <summary>
/// Represents a set of helpers for .net reflection
///  </summary>
public static class ReflectionHelper
{
    #region Public methods

    /// <summary>
    /// Gets a MethodInfo object from specified expression
    ///  </summary>
    /// <typeparam name="TResult"></typeparam>
    /// <param name="methodExpression"></param>
    /// <returns></returns>
    public static MethodInfo MethodOf<TResult>(Expression<Func<TResult>> methodExpression)
    {
        return ((MethodCallExpression)methodExpression.Body).Method;
    }

    /// <summary>
    /// Gets a MethodInfo object from specified expression
    ///  </summary>
    /// <param name="methodExpression"></param>
    /// <returns></returns>
    public static MethodInfo MethodOf(Expression<Action> methodExpression)
    {
        return ((MethodCallExpression)methodExpression.Body).Method;
    }

    /// <summary>
    /// Gets a MethodInfo object from specified expression
    ///  </summary>
    /// <param name="methodExpression"></param>
    /// <returns></returns>
    public static MethodInfo MethodOf<TInstance, TResult>(Expression<Func<TInstance, TResult>> methodExpression)
    {
        return ((MethodCallExpression)methodExpression.Body).Method;
    }

    /// <summary>
    /// Gets a MethodInfo object from specified expression
    ///  </summary>
    /// <param name="methodExpression"></param>
    /// <returns></returns>
    public static MethodInfo MethodOf<TInstance>(Expression<Action<TInstance>> methodExpression)
    {
        return ((MethodCallExpression)methodExpression.Body).Method;
    }

    /// <summary>
    /// Gets a PropertyInfo object from specified expression
    ///  </summary>
    /// <param name="propertyGetExpression"></param>
    /// <returns></returns>
    public static PropertyInfo PropertyOf<TProperty>(Expression<Func<TProperty>> propertyGetExpression)
    {
        return ((MemberExpression)propertyGetExpression.Body).Member as PropertyInfo;
    }

    /// <summary>
    /// Gets a PropertyInfo object from specified expression
    ///  </summary>
    /// <param name="propertyGetExpression"></param>
    /// <returns></returns>
    public static PropertyInfo PropertyOf<TInstance, TProperty>(Expression<Func<TInstance, TProperty>> propertyGetExpression)
    {
        return ((MemberExpression)propertyGetExpression.Body).Member as PropertyInfo;
    }

    /// <summary>
    /// Gets a FieldInfo object from specified expression
    ///  </summary>
    /// <param name="fieldAccessExpression"></param>
    /// <returns></returns>
    public static FieldInfo FieldsOf<TProperty>(Expression<Func<TProperty>> fieldAccessExpression)
    {
        return ((MemberExpression)fieldAccessExpression.Body).Member as FieldInfo;
    }

    //TODO: ConstructorOf(...)

    #endregion //Public methods
}

как я понимаю, мы не могли использовать тот же aproach для getParameterInfo или EventInfo

Другой подход к этому, описанный Jb Evain, см.: http://evain.net/blog/articles/2010/05/05/parameterof-propertyof-methodof?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+jbevain+%28Jb+in+a+nutshell%29

Ответ 3

В С# 6 все еще нет infoof, но есть nameof:

var propertyInfo = typeof(MyClass).GetProperty(nameof(MyClass.MyProperty))

Это, конечно, не более краткое, но, по крайней мере, это рефакторинг.

Ответ 4

Нет, такого синтаксиса в С# нет.