“成员”上的 C# 扩展方法

Question

我有一些扩展方法可以像这样使用：

MyType myObject; 
string displayName = myObject.GetDisplayName(x => x.Property);

这里的问题是它需要一个实例，即使扩展方法只需要类型MyType。所以如果没有实例，就需要这样调用：

string displayName = BlahBlahUtility.GetDisplayName((MyTpe x) => x.Property);

这已经不是那么好了。

有没有办法为这种情况编写更好的语法？

我真正想做的是这个（伪语言）：

string displayName = MyType.Property.GetDisplayName()

这当然不适用于 C#。

但是像这样的事情呢：

string displayName = ((MyType x) => x.Property).GetDisplayName();

这也是不可能的（在 lambda 之后，不接受点）。

有什么想法吗？

---

编辑：

我的“最喜欢的语法”MyType.Property.GetDisplayName() 似乎具有误导性。我在这里不谈论静态属性。我知道这种语法是不可能的。我只是试图用伪语言显示，什么信息是必要的。这将是理想的，每一个额外的东西都只是语法开销。任何接近此的有效语法都会很棒。

我不想写某个扩展方法。我想要一种简单、易读且编译时安全的语法，使用任何语言功能。

Answer 1

查看Lokad Shared Libraries 中的Express 和Reflect 类。认为他们可能会帮助您完成您正在尝试做的事情。在这里阅读更多：

• Strongly Typed Reflection in Lokad Shared
• How to Find Out Variable or Parameter Name in C#?

Answer 2

根据您的评论：“我想要一种简单且编译时安全的语法来获取有关成员的信息”。

这是一个经常被请求的功能，并且已经在 C# 团队的会议上讨论了大约十年，但从未被优先考虑到足以被包括在内。

这篇博文解释了原因：

http://blogs.msdn.com/ericlippert/archive/2009/05/21/in-foof-we-trust-a-dialogue.aspx

所以现在，您只需要与缺失的功能作斗争。也许您可以发布有关您的更广泛问题的更多信息，看看人们是否可以提出不同的方法。

更新

如果没有关于您的问题的更多信息，这只是猜测。但是，如果您有一个表示值但还带有附加“元”信息的属性，则您始终可以将其表示为新类型并使用“注入”步骤来设置所有内容。

以下是此类“元属性”的建议抽象接口：

public interface IMetaProperty<TValue>
{
    TValue Value { get; set; }

    string DisplayName { get; }

    event Action<TValue, TValue> ValueChanged;
}

属性的值只是另一个子属性，其类型由用户定义。

我已经输入了显示名称，并且作为奖励，您有一个在值更改时触发的事件（因此您可以免费获得“可观察性”）。

要在一个类中拥有这样的属性，你可以这样声明它：

public class SomeClass
{
    public IMetaProperty<string> FirstName { get; private set; }
    public IMetaProperty<string> LastName { get; private set; }
    public IMetaProperty<int> Age { get; private set; }

    public SomeClass() { MetaProperty.Inject(this); }
}

注意属性上的设置器是如何私有的。这可以防止任何人意外设置属性本身而不是设置 Value 子属性。

所以这意味着类必须设置这些属性，使它们不仅仅是null。它通过调用一个神奇的Inject 方法来做到这一点，该方法可以在任何类上工作：

public static class MetaProperty
{
    // Make it convenient for us to fill in the meta information
    private interface IMetaPropertyInit
    {
        string DisplayName { get; set; }
    }

    // Implementation of a meta-property
    private class MetaPropertyImpl<TValue> : IMetaProperty<TValue>, 
                                             IMetaPropertyInit
    {
        private TValue _value;

        public TValue Value
        {
            get { return _value; }
            set
            {
                var old = _value;
                _value = value;
                ValueChanged(old, _value);
            }
        }

        public string DisplayName { get; set; }

        public event Action<TValue, TValue> ValueChanged = delegate { };
    }

    public static void Inject(object target)
    {
        // for each meta property...
        foreach (var property in target.GetType().GetProperties()
            .Where(p => p.PropertyType.IsGenericType && 
                        p.PropertyType.GetGenericTypeDefinition() 
                            == typeof(IMetaProperty<>)))
        {
            // construct an implementation with the correct type
            var impl = (IMetaPropertyInit) 
                typeof (MetaPropertyImpl<>).MakeGenericType(
                    property.PropertyType.GetGenericArguments()
                ).GetConstructor(Type.EmptyTypes).Invoke(null);

            // initialize any meta info (could examine attributes...)
            impl.DisplayName = property.Name;

            // set the value
            property.SetValue(target, impl, null);
        }
    }
}

它只是使用反射找到隐藏在对象中的所有IMetaProperty槽，并用一个实现填充它们。

所以现在SomeClass 的用户可以说：

var sc = new SomeClass
             {
                 FirstName = { Value = "Homer" },
                 LastName = { Value = "Simpson" },
                 Age = { Value = 38 },
             };

Console.WriteLine(sc.FirstName.DisplayName + " = " + sc.FirstName.Value);

sc.Age.ValueChanged += (from, to) => 
    Console.WriteLine("Age changed from " + from + " to " + to);

sc.Age.Value = 39;

// sc.Age = null; compiler would stop this

如果您已经在使用 IOC 容器，您也许可以在不直接进行反射的情况下实现其中的一些。

Answer 3

您似乎正在尝试创建静态扩展方法？

DateTime yesterday = DateTime.Yesterday(); // Static extension.

代替

DateTime yesterday = DateTime.Now.Yesterday(); // Extension on DateTime instance.

如果这是您想要实现的，我认为在当前版本的 C# 中是不可能的。

Answer 4

听起来您将层集成得太紧了。通常在这种情况下，我会让表示层决定GetDisplayName() 的实现，而不是使其成为属性本身的扩展。您可以创建一个名为 MyTypeDisplayer 的接口或任何您喜欢的接口，并让它有多个实现，而不是将您限制为单个显示实现。

Answer 5

这里的问题是无法通过实例 MyType.[Member] 获得对非静态方法的引用。这些只能通过对类型实例的引用来查看。您也不能在类型声明之上构建扩展方法，只能在类型的实例上构建 - 也就是说，扩展方法本身必须使用类型的实例（this T x）来定义。

然而，我们可以像这样定义表达式来获取对静态成员的引用： ((MyType x) => MyType.Property)

可以执行类似于 string displayName = ((MyType x) => x.Property).GetDisplayName(); 的操作 第一个问题是保证编译器将您的 (x=> x.Property) 视为表达式而不是动作/函数等... 要做到这一点，可能需要这样做：

string displayName = ((Expression<Func<PropertyType>>)((MyType x) => x.Property).GetDisplayName();

扩展方法必须像这样定义：

public static string GetDisplayName<T>(this Expression<Func<T>> expression)

如果您的成员也是方法，您可能还必须在 Expression<Action>> and Expression<Action<T>> 之上定义扩展方法。

您可以在 Expression 之后添加一个点 - 这是 Compile 方法所在的位置。

附加：

我认为，在没有类型的实例的情况下，对扩展方法的静态调用需要对其进行“反射”以确定成员名称，这仍然是最简洁的语法 - 这样你仍然可以在使用类型的实例时使用扩展方法，并在没有实例时回退到静态调用定义 => MyExtensionClass.GetDisplayName(TypeOfX x => TypeOfX.StaticMember OR x.Property/Member)

Answer 6

如果你接口你的属性，你可以在接口上做扩展：

namespace Linq1
{
    class Program
    {
        static void Main(string[] args)
        {
            MyType o = new MyType();
            o.Property.GetDisplayName();
        }
    }

    public class MyType
    {
        public IDisplayableProperty Property { get; set; }
    }

    public interface IDisplayableProperty 
    {
        string GetText();
    }

    public class MyProperty1 : IDisplayableProperty 
    {
        public string GetText() { return "MyProperty2"; }
    }

    public class MyProperty2 : IDisplayableProperty 
    {
        public string GetText() { return "MyProperty2"; }
    }

    public static class Extensions
    {
        public static string GetDisplayName(this IDisplayableProperty o)
        {
            return o.GetText();
        }
    }
}