public static class Member
{
    /// <summary>
    /// Retrieves the member that an expression is defined for.
    /// </summary>
    /// <param name="expression">The expression to retreive the member from.</param>
    /// <returns>A <see cref="MemberInfo"/> instance if the member could be found; otherwise <see langword="null"/>.</returns>
    private static MemberInfo GetTargetMemberInfo(this Expression expression)
    {
        switch (expression.NodeType)
        {
            case ExpressionType.Convert:
                return GetTargetMemberInfo(((UnaryExpression)expression).Operand);
            case ExpressionType.Lambda:
                return GetTargetMemberInfo(((LambdaExpression)expression).Body);
            case ExpressionType.Call:
                return ((MethodCallExpression)expression).Method;
            case ExpressionType.MemberAccess:
                return ((MemberExpression)expression).Member;
            default:
                return null;
        }
    }
 
    private static OfResult GetResult(Expression expression)
    {
        var member =
            GetTargetMemberInfo(expression);
 
        return new OfResult(member);
    }
 
    public static OfResult Of(Expression<Action> expression)
    {
        return GetResult(expression);
    }
 
    public static OfResult Of(Expression<Func<object>> expression)
    {
        return GetResult(expression);
    }
 
    public static OfResult Of<T>(Expression<Action<T>> expression)
    {
        return GetResult(expression);
    }
 
    public static OfResult Of<T>(Expression<Func<T, object>> expression)
    {
        return GetResult(expression);
    }
}
 
public class OfResult
{
    /// <summary>
    /// Initializes a new instance of the <see cref="OfResult"/> class.
    /// </summary>
    /// <param name="member">The <see cref="MemberInfo"/> instance to wrap.</param>
    public OfResult(MemberInfo member)
    {
        this.Member = member;
    }
 
    /// <summary>
    /// Gets the <see cref="MemberInfo"/> instace that the result wraps.
    /// </summary>
    /// <value>The <see cref="MemberInfo"/> instance that the result wraps.</value>
    public MemberInfo Member { get; private set; }
 
    /// <summary>
    /// Performs an implicit conversion from <see cref="OfResult"/> to <see cref="MemberInfo"/>.
    /// </summary>
    /// <param name="result">The <see cref="OfResult"/> instance to cast.</param>
    /// <returns>The <see cref="MemberInfo"/> that the <see cref="OfResult"/> instance wraps.</returns>
    public static implicit operator MemberInfo(OfResult result)
    {
        return result.Member;
    }
 
    /// <summary>
    /// Performs an implicit conversion from <see cref="ImplicitResultCasting.OfResult"/> to <see cref="System.String"/>.
    /// </summary>
    /// <param name="result">The result.</param>
    /// <returns>The result of the conversion.</returns>
    public static implicit operator string(OfResult result)
    {
        return result.Member.ToString();
    }
}
 
/// <summary>
/// Defines extension methods for the <see cref="OfResult"/> class.
/// </summary>
public static class OfResultExtensions
{
    public static FieldInfo AsField(this OfResult result)
    {
        return (FieldInfo)result.Member;
    }
 
    public static MethodInfo AsMethod(this OfResult result)
    {
        return (MethodInfo)result.Member;
    }
 
    public static PropertyInfo AsProperty(this OfResult result)
    {
        return (PropertyInfo)result.Member;
    }
 
    public static Type AsType(this OfResult result)
    {
        return (Type)result.Member;
    }
}