3

我试着简短地说：FrameworkElement 和 FrameworkContentElement 共享许多相同的 API，但没有通用接口。只有 DependencyObject 作为基类。

我遇到过IFrameworkElement 的这个实现，它手动添加了一个接口和两个包装类。现在这段代码是在 .NET 3.5 中实现的，作者评论说在 .NET 4 中使用动态编程会容易得多：

实际代码非常简单，但每个元素大约有 624 行。（这将是动态语言中更简单的单行实现 - C# 4.0 即将推出 :)）。

我会很好奇它的实现会是什么样子。我认为它可以归结为 的动态实现IFrameworkElement，并阅读ExpandoObject并DynamicObject查看我是否可以实现自己，但我有点难过。我想可以编写一个 DynamicObject 的自定义实现——但这不是一个单行。这真的可以通过动态编程变得那么容易吗？我什至不需要成为一个班轮，我可以用 10 甚至 100 行而不是原来的 1250。

我在想这样的事情：

// Example, not working:
public IFrameworkElement AsFrameworkElement(FrameworkElement ele)
{
  dynamic ife = ele as IFrameworkElement;
  return ife;    
}

IFrameworkElement frameworkElement = AsFrameworkElement(new Button());
frameworkElement.DataContext = "Whatever";

IFrameworkElement frameworkContentElement = AsFrameworkElement(new Paragraph());
frameworkContentElement.DataContext = "Whatever again";
4

2 回答 2

2

看博客原代码：

var dataContect = "DataContext";
var frameworkElement = sender as FrameworkElement;
if ( frameworkElement != null )
{
    frameworkElement.DataContext = dataContect;
}
else
{
    var frameworkContentElement = sender as FrameworkContentElement;
    if ( frameworkContentElement != null )
    {
        frameworkContentElement.DataContext = dataContect;
    }
}

它会变成

var dataContext = "DataContext"
dynamic element = sender;
element.DataContext = dataContext;

就是这样。在运行时，DataContext将通过反射搜索具有名称的属性（注意：当涉及动态类型列表时，事情可能会非常慢），然后调用它。

注意：如果属性不存在，RuntimeBinderException将抛出 a。您可以在最后一行添加一些 try...catch 。

于 2016-08-08T08:28:18.397 回答
1

我不知道那篇文章的作者到底是什么意思（也许我们应该问他/她），但我想它需要的代码不止一行。关键是动态关键字（4.0 .NET 中的新关键字）允许所谓的鸭子类型。

这篇文章的作者必须编写 2 个包装类来制作FrameworkElement和FrameworkContentElement实现IFrameworkElement接口。

现在有了dynamickeywork，我们可以只写类（为了保持我们界面的舒适）。

public interface IFrameworkElement
{
    /* Let's suppose we have just one property, since it is a sample */
    object DataContext
    {
        get;
        set;
    }
}

public class FrameworkElementImpl : IFrameworkElement
{
    private readonly dynamic target;

    public FrameworkElementImpl(dynamic target)
    {
        this.target = target;
    }

    public object DataContext
    {
        get
        {
            return target.DataContext;
        }
        set
        {
            target.DataContext = value;
        }
    }
}

public static class DependencyObjectExtension
{
    public static IFrameworkElement AsIFrameworkElement(this DependencyObject dp)
    {
        if (dp is FrameworkElement || dp is FrameworkContentElement)
        {
            return new FrameworkElementImpl(dp);
        }

        return null;
    }
}

所以现在我们可以在我们的代码中编写如下内容：

System.Windows.Controls.Button b = new System.Windows.Controls.Button();
IFrameworkElement ife = b.AsIFrameworkElement();

ife.DataContext = "it works!";

Debug.Assert(b.DataContext == ife.DataContext);

现在，如果您不想编写包装器（或您希望的代理）类（即FrameworkElementImpl在我们的示例中），有一些库可以为您完成（即兴接口或Castle DynamicProxy）。

您可以在这里找到一个使用 Castle DynamicProxy 的非常简单的示例：

public class Duck
{
    public void Quack()
    {
        Console.WriteLine("Quack Quack!");
    }

    public void Swim()
    {
        Console.WriteLine("Swimming...");
    }
}

public interface IQuack
{
    void Quack();
}

public interface ISwimmer
{
    void Swim();
}

public static class DuckTypingExtensions
{
    private static readonly ProxyGenerator generator = new ProxyGenerator();

    public static T As<T>(this object o)
    {
        return generator.CreateInterfaceProxyWithoutTarget<T>(new DuckTypingInterceptor(o));
    }
}

public class DuckTypingInterceptor : IInterceptor
{
    private readonly object target;

    public DuckTypingInterceptor(object target)
    {
        this.target = target;
    }

    public void Intercept(IInvocation invocation)
    {
        var methods = target.GetType().GetMethods()
            .Where(m => m.Name == invocation.Method.Name)
            .Where(m => m.GetParameters().Length == invocation.Arguments.Length)
            .ToList();
        if (methods.Count > 1)
            throw new ApplicationException(string.Format("Ambiguous method match for '{0}'", invocation.Method.Name));
        if (methods.Count == 0)
            throw new ApplicationException(string.Format("No method '{0}' found", invocation.Method.Name));
        var method = methods[0];
        if (invocation.GenericArguments != null && invocation.GenericArguments.Length > 0)
            method = method.MakeGenericMethod(invocation.GenericArguments);
        invocation.ReturnValue = method.Invoke(target, invocation.Arguments);
    }
}

如您所见，在这种情况下，只需几行代码即可获得与作者使用相同的结果

每个元素大约 624 行 [...]

于 2016-08-14T15:36:06.457 回答