标签: expression

请帮我写一个货币/货币领域的JavaScript验证.

所以请提供任何正则表达式,如果你有 :)

此外,对于我的地区,在该字段中不需要任何货币符号,如'$'.

只包含小数作为特殊字符进行验证,以及数字.

如何在图表的标题中组合文本和数学表达式.如果我使用粘贴,表达式将转换为字符.例如,我想要这样的东西作为标题

$ ARL_1 $曲线$ S ^ 2 $

谢谢

我在使用反射时遇到了性能问题.
所以我决定为我的对象的属性创建委托,到目前为止得到了这个:

TestClass cwp = new TestClass();
var propertyInt = typeof(TestClass).GetProperties().Single(obj => obj.Name == "AnyValue");
var access = BuildGetAccessor(propertyInt.GetGetMethod());
var result = access(cwp);

static Func<object, object> BuildGetAccessor(MethodInfo method)
{
    var obj = Expression.Parameter(typeof(object), "o");

    Expression<Func<object, object>> expr =
        Expression.Lambda<Func<object, object>>(
            Expression.Convert(
                Expression.Call(
                    Expression.Convert(obj, method.DeclaringType),
                    method),
                typeof(object)),
            obj);

    return expr.Compile();
}

结果非常令人满意,比使用传统方法快30-40倍(PropertyInfo.GetValue (obj, null);)

问题是:我怎样才能创建SetValue一个属性相同的属性？不幸的是没有办法.

我这样做是因为我不能使用方法,<T>因为我的应用程序的结构.

为什么Func<>从Expression<Func<>>via .Compile()创建的文件比直接使用Func<>声明要慢得多？

我刚刚使用Func<IInterface, object>声明直接更改为Expression<Func<IInterface, object>>在我正在处理的应用程序中创建的一个,我注意到性能下降了.

我刚做了一点测试,Func<>从一个Expression创建的"几乎"是Func<>直接声明的时间的两倍.

在我的机器上,Direct Func<>大约需要7.5秒,Expression<Func<>>大约需要12.6秒.

这是我使用的测试代码(运行Net 4.0)

// Direct
Func<int, Foo> test1 = x => new Foo(x * 2);

int counter1 = 0;

Stopwatch s1 = new Stopwatch();
s1.Start();
for (int i = 0; i < 300000000; i++)
{
 counter1 += test1(i).Value;
}
s1.Stop();
var result1 = s1.Elapsed;



// Expression . Compile()
Expression<Func<int, Foo>> expression = x => new Foo(x …

你能在JSP表达式中做一个if-then-else语句吗？

编辑:具体来说,我正在寻找一个JSP解决方案,而不是一个JSTL解决方案.但是下面的一些JSTL解决方案评价很高,非常受欢迎.请不要因为重复的问题而投票给我,因为已经有人问过JSTL.

我正在尝试创建一个通用函数来帮助我从本地列表中使用LINQ to SQL选择数千条记录.SQL Server(至少2005)将查询限制为2100个参数,我想选择更多的记录.

这将是一个很好的示例用法:

var some_product_numbers = new int[] { 1,2,3 ... 9999 };

Products.SelectByParameterList(some_product_numbers, p => p.ProductNumber);

这是我的(非工作)实现:

public static IEnumerable<T> SelectByParameterList<T, PropertyType>(Table<T> items, 

IEnumerable<PropertyType> parameterList, Expression<Func<T, PropertyType>> property) where T : class
{
    var groups = parameterList
        .Select((Parameter, index) =>
            new
            {
                GroupID = index / 2000, //2000 parameters per request
                Parameter
            }
        )
        .GroupBy(x => x.GroupID)
        .AsEnumerable();

    var results = groups
    .Select(g => new { Group = g, Parameters = g.Select(x => x.Parameter) } )
    .SelectMany(g …

任何人都可以帮助我解决我的问题.我使用下面给出的代码:

public IEnumerable<InvoiceHeader> Getdata(Expression<Func<InvoiceHeader, bool>> predicate)
{
    return AccountsContext.InvoiceHeaders.Include("Company").Include("Currency")
        .Include("BusinessPartnerRoleList").Include("DocumentType")
        .Where(predicate);
}

.....

在我的代码中我使用如下

Expression<Func<InvoiceHeader, bool>> predicate = PredicateBuilder.True<InvoiceHeader>();
predicate = predicate.And(o => o.CompanyId == oInvoiceHeader.CompanyId);
List<InvoiceHeader> lstInvheader=Getdata(predicate).ToList();

通过这样做,我得到了例外.[System.NotSupportedException] --- {"LINQ to Entities中不支持LINQ表达式节点类型'Invoke'."}

几天前,这里有一个关于表达方式的讨论

i = ++ i + 1

是否调用UB(未定义的行为).

最后得出的结论是它调用UB,因为'i'的值在两个序列点之间不止一次变化.

我参与了与Johannes Schaub在同一个线程中的讨论.据他介绍

i =(i,i ++,i)+1 ------(1)/*也调用UB*/

我说(1),因为先前的子表达式的副作用是由逗号运算符清零不调用UB""之间i和i ++和我++和我之间.

然后他给出了以下解释:

"是的,在i ++完成之前的所有副作用之后的序列点,但没有任何东西可以阻止赋值副作用与i ++的副作用重叠.潜在的问题是赋值的副作用未指定发生在或之后在评估赋值的两个操作数之前,所以序列点在保护它时无法做任何事情:序列点诱导偏序:只是因为在i ++之后和之前有一个序列点并不意味着所有的副作用都被排序关于我.

另外,请注意,只有序列点没有任何意义:评估的顺序不是由代码的形式决定的.它由语义规则决定.在这种情况下,没有语义规则说明何时在评估那些操作数的操作数或子表达式时发生赋值副作用".

用"大胆"写的声明使我感到困惑.我所知道的:

"在执行序列中称为序列点的某些特定点,先前评估的所有副作用都应完整,并且不会产生后续评估的副作用."

因为,逗号运算符也指定了执行顺序,当我们到达最后一个i时,i ++的副作用已被取消.如果未指定评估顺序,那么(Johannes)会是正确的(但是在逗号运算符的情况下,它已被明确指定) ).

所以我只想知道(1)是否调用UB？有人能给出另一个有效的解释吗

谢谢!

虽然讨论的Type(identifier);语法和它是如何声明,我碰到Type(::x);不锵工作.我希望给定一个全局变量x,它将被::x视为一个表达式(::x + 2作品)并转换::x为Type.但是,它给出了编译器错误.

这是一个简短的例子:

int x;

int main() {
    int(::x); //does not compile
    int(::x + 2); //compiles
}

Clang 3.5给出的编译器错误是:

错误:'x'的定义或重新声明不能命名全局范围

但是,GCC 4.9.0编译就好了.这段代码有效吗？

我很好奇Expression.Compile与代码中的lambda表达式和直接方法使用的性能如何,以及直接方法调用与虚方法调用(伪代码):

var foo = new Foo();
var iFoo = (IFoo)foo;

foo.Bar();
iFoo.Bar();
(() => foo.Bar())();
(() => iFoo.Bar())();
Expression.Compile(foo, Foo.Bar)();
Expression.Compile(iFoo, IFoo.Bar)();
Expression.CompileToMethod(foo, Foo.Bar);
Expression.CompileToMethod(iFoo, IFoo.Bar);
MethodInfo.Invoke(foo, Foo.Bar);
MethodInfo.Invoke(iFoo, IFoo.Bar);