标签: dynamic-language-runtime

在DLR的LINQ表达式中,有什么区别:

Expression.Convert(SomeVariableExpression, typeof(T));

还有这个:

Expression.Unbox(SomeVariableExpression, typeof(T));

关于这个的文档似乎有点粗略.

更重要的是,其中一个等同于这个C#代码:

(ClassA)InstanceOfClassB

ClassB有一个隐式或显式运算符强制转换为ClassA？

我还没有访问C#4.0预览版.但我很好奇,在下面的例子中调用重载方法时C#4.0运行时会做什么.它是否解决了泛型过载......或专门的过载问题.

public class Foo<T>
{
  protected string BarImpl( T value ) { return "Bar(T) says: " + value.ToString(); }

  protected string BarImpl( int value ) { return "Bar(int) says: " + value.ToString(); }

  public string Bar( T value )
  {
    dynamic foo = this;
    return foo.BarImpl( value );
  }
}

public static void Main( string args[] )
{
  var f = new Foo<int>();

  Console.WriteLine( f.Bar( 0 ) );
}

我知道匿名函数不支持作为动态方法调用的参数..NET 4.0中DLR的其他此类限制是什么？

我正在构建一个类似电子表格的应用程序,其中许多小型计算需要在树结构中拼接在一起.这些计算是用户定义的,我需要一种方法让用户在运行时输入它们.

我目前的方法是在F#中编写一个小的"表达式DSL",我用FParsec解析输入,基于区分联合构建语法树,然后可以计算表达式.这非常有效.

但是,我正在考虑将语言基于DLR.沿着这条路走下去是否有任何优势(解析输入,使用Scripting.AST东西而不是我自己的东西生成AST,让DLR处理计算的执行)？

每次计算都可能非常小.计算之间的依赖关系将在更高层次上得到处理.

我可以期待更好的性能,因为DLR会为表达式生成CIL代码,或者开销是否会消耗掉它？

(至于使用像IronPython这样的现有语言,它可能很难,因为我计划在语言语法中添加很多切片和骰子操作符和维度处理的东西)

我在一个较大的C#项目的一小部分内使用DLR,IronPython是有问题的语言.

对于系统的某些部分,用户可以输入一个小脚本来自定义它们的行为.我想做的是能够限制它们使用无副作用的纯函数或在某种沙盒中使它们的功能不能触及外面的任何东西.

此外,用户只能输入一个函数体,函数头和参数规范在传递给Python DLR引擎之前会自动在代码中预先设置,以便调用它的系统的C#端确切地知道要传递的args和什么回来了.用户只需要完全基于作为参数提供的值进行简单的操作和测试.

例如

还行吧: return (a * 100) > b;

这不行: delete_file_system(); return (a * 100) > b;

怎么可能实现这一目标？有更合适的语言或技术选择吗？

我有一个方法应该从List返回ID.通常我会使用反射来完成这个任务(我不能使用泛型方法,因为类通常是不共享接口或基类的POCOS,我不能修改它们).但是,我想到了新的dynamic关键字,并想尝试这个.

但是我的问题是dataSource [index]返回一个对象.在运行时,确保对象本身是我自己的类并具有id属性.但我想因为该方法返回一个对象,我在访问时会在运行时获得RumtineBinderExceptioncurrent.id

public List<int> GetItemIds()
{

    var result = new List<int>();
    var dataSource = GetDataSource(); // returns an List<Object>

    for (int i = 0; i <= dataSource.Count - 1; i++)
    {
        dynamic current = dataSource[i];
        int id = current.Id;  // throws RuntimeBinderException: Object has no definition for id
    }

    return result;
}

有没有办法实现我想要或做的事情我必须回到反思来获取id属性？

更新:

current.GetType() returns object
current.GetType().GetProperties() returns a TargetInvocationException

我的Pocos住在我的主项目(VB.net)中,但是这个方法是在类库中,也许这就是原因.然而:

object current = dataSource[i];
PropertyInfo prop = current.GetType().GetProperty("id", BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
if …

我必须为.NET的静态类型语言开发编译器我正在考虑使用DLR而不是构建所有部分(Lexer/Parser,语法,语义,代码生成).

DLR是否适合这种情况？或者最好直接为.NET构建编译器并避免所有动态调用.

编辑:我确实实现了语言而没有使用DLR提供的任何动态表达式,而是使用了其他表达式.

之后我可以说在实现编译器直接定位DLR而不是IL时会更好.生成的代码仍然非常干净.

如果你想看一些代码检查:tigerconverters.codeplex.com/

我知道变量捕获是由编译器完成的,而不是由.NET框架本身的类完成的.但是,当引入DLR时,必须在框架内完成某些工作,以便将其推迟到运行时.

例如,在下面给出的代码中:

dynamic d = ...

Func<int, bool> func = n => n > d;

变量的类型解析d及其作为整数的验证必须在运行时完成.并且因为d是lambda的contains方法中的变量,所以它将被捕获到闭包中.这部分肯定会在运行时完成.

因此,我推断必须有一部分DLR程序集(主要是System.Core.dll)才能完成这一部分.

我一直在寻找,我可以找到一些对这类任务看起来可疑的应受谴责的课程.具体来说,ExpressionQuoter(尽管它的外观,这个类不引用像Expression.Quote方法那样的lambda表达式),HoistedLocals和VariableBinder.

我想我会邀请一个知道更好的人回答这个问题.

.NET框架的哪个类或部分将包含lambda(或匿名方法)方法的本地变成具有表示它们的静态变量的那些单独的类？

我刚刚开始尝试了解有关 .Net VM 基础的更多信息，但立即就被某些事情迷惑了。我知道有一个叫做 DLR 的新东西，它允许 C# 中的所有动态内容和 IronX 语言的运行。但现在我正在阅读有关这种名为 Boo 的语言，显然早在 DLR 存在之前它就已经具有动态功能。所以，

1）这怎么可能？

2) DLR 在方程式中添加了什么？

3) 像 Boo 这样的语言通过在 DLR 中重新实现自身会获得什么好处吗？

从我在这里和那里收集到的信息来看，DLR 似乎来自 IronPython，当时他们提取了 .Net 中 DL 支持所需的所有内容，并将其置于可重用的形式。所以我猜测 DLR 没什么特别的，只是一些帮助 Microsoft.Scripting.dll 中的动态对象的库，但如果你有时间的话，你可以自己编写代码，这我猜 Boo 身上发生了什么事？然后对于 2 和 3，我想 DLR 的通用性和可重用性将允许任何未来的 DLR 改进自动继承，但如果您已经做出了您的计划，则没有迫切的“需要”重新实施使用 DLR自己的自定义运行时？或者 DLR 是否有一些秘密的 MS 技术，使其比我们在 .Net 上所做的任何事情都更好？

4) DLR 真的是一个运行时还是只是一组库？（到底什么是运行时？我可能需要学习更多编译器理论，然后才能理解这个问题的答案，或者它是否是一个有意义的问题。忽略这个问题。或者不要。）

5) IronPython 编译是如何工作的？它会编译为新的动态版本的 CIL，还是只是在包含程序文本的字符串前面添加“ironpython.exe”命令？嗯，如果dynamic是C#中的关键字，那么一定有一个动态版本的CIL，对吧？那么.Net如何知道在CIL上使用CLR还是DLR呢？

6) JVM 的 DaVinci 项目有什么不同吗？看起来它是 JVM 本身的实际重新实现。这种方法有什么影响？我猜性能会有巨大的提升，但还有其他什么吗？MS有什么理由不走这条路？

7) DLR 是否会让 Boo 在制作 DSL 方面变得有些过时了？

我对 DynamicMethods、表达式树和 DLR 之间的交互和关系有一些疑问。

1. 我知道 LambdaExpression.Compile 在内部使用 ILGenerator 来创建委托。但是，已编译的 LambdaExpression 和 DynamicMethod 之间存在一些根本差异。例如

   A。动态方法调用速度更快

   b. 编译后的 LambdaExpression 可以嵌入闭包（ConstantExpressions 是非原始值）

   b. 已编译的 LambdaExpression 没有 DeclaringType。

   问题：

   A。为什么 DynamicMethods 的调用速度比编译的 LambdaExpressions 更快？

   b. 允许闭包的已编译 LambdaExpressions 有什么特别之处？当我使用非 ConstantExpression 时，表达式树实际上会生成闭包类吗？如果是这样，这个生成的类去了哪里？

   C。编译后的 LambdaExpressions 去哪里（运行时）？对他们的支持在哪里实施？它不能只是 Reflection.Emit，不是吗？

2. 我知道，dynamic 关键字实际上只是一个用于发出 CSharp CallSites、Binder 等的编译器技巧。据我了解，在内部，这些会生成表达式树，并且还使用 C# 编译器的精简版本。

   问题

   A。生成的表达式树是 CallSiteBinders 的一般函数还是 Microsoft.CSharp dll 中它们的特定实现和用法？

   b. 这些表达式树是由 DynamicExpression 节点组成的吗？或者是其他东西？如果有其他原因，为什么？

   C。C# 编译器的精简版本在哪里以及为何发挥作用？它与常规调用 LambdaExpression.Compile 或 DynamicMethods 或任何类型的 IL 生成为何以及有何不同？我可以理解如何使用 CallSiteBinders 来构建表达式树，但为什么在发生转换后需要 C# 编译器？一旦它采用表达式树（这只是一个 API）的形式，C# 与它有什么关系呢？