本文整理汇总了C#中ParameterExpression类的典型用法代码示例。如果您正苦于以下问题：C# ParameterExpression类的具体用法？C# ParameterExpression怎么用？C# ParameterExpression使用的例子？那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
ParameterExpression类属于命名空间，在下文中一共展示了ParameterExpression类的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: FreeTemp
private void FreeTemp(ParameterExpression temp) {
Debug.Assert(_freeTemps == null || !_freeTemps.Contains(temp));
if (_freeTemps == null) {
_freeTemps = new List<ParameterExpression>();
}
_freeTemps.Add(temp);
}示例2: LocalStorage
internal LocalStorage(LambdaCompiler compiler, ParameterExpression variable)
: base(compiler, variable) {
// ByRef variables are supported. This is used internally by
// the compiler when emitting an inlined lambda invoke, to
// handle ByRef parameters. BlockExpression prevents this
// from being exposed to user created trees.
_local = compiler.GetNamedLocal(variable.IsByRef ? variable.Type.MakeByRefType() : variable.Type, variable);
}示例3: CreateSimpleDefCommand
public void CreateSimpleDefCommand()
{
IList<ParameterExpression> parameters = new ParameterExpression[] { new ParameterExpression("a", null, false), new ParameterExpression("b", null, false) };
ICommand body = new SetCommand("c", new ConstantExpression(1));
DefCommand command = new DefCommand("foo", parameters, body);
Assert.AreEqual("foo", command.Name);
Assert.AreEqual(parameters, command.ParameterExpressions);
Assert.AreEqual(body, command.Body);
}示例4: UseTemp
private ParameterExpression UseTemp(ParameterExpression temp) {
Debug.Assert(_freeTemps == null || !_freeTemps.Contains(temp));
Debug.Assert(_usedTemps == null || !_usedTemps.Contains(temp));
if (_usedTemps == null) {
_usedTemps = new Stack<ParameterExpression>();
}
_usedTemps.Push(temp);
return temp;
}示例5: SubGenerator
public SubGenerator()
{
Runtime = Expression.Parameter(typeof(Runtime), "runtime");
Arguments = Expression.Parameter(typeof(P5Array), "args");
Context = Expression.Parameter(typeof(Opcode.ContextValues), "context");
Pad = Expression.Parameter(typeof(P5ScratchPad), "pad");
Variables = new List<ParameterExpression>();
Lexicals = new List<ParameterExpression>();
Temporaries = new List<ParameterExpression>();
BlockLabels = new Dictionary<BasicBlock, LabelTarget>();
ValueBlocks = new Dictionary<BasicBlock, Expression>();
LexStates = new List<ParameterExpression>();
RxStates = new List<ParameterExpression>();
}示例6: RaiseWhenNonDefaultArgumentFollowsDefaultArgument
public void RaiseWhenNonDefaultArgumentFollowsDefaultArgument()
{
IList<ParameterExpression> parameters = new ParameterExpression[] { new ParameterExpression("a", new ConstantExpression(1), false), new ParameterExpression("b", null, false) };
ICommand body = new SetCommand("c", new ConstantExpression(1));
try
{
DefCommand command = new DefCommand("foo", parameters, body);
Assert.Fail("Exception expected");
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(SyntaxError));
Assert.AreEqual("non-default argument follows default argument", ex.Message);
}
}示例7: CreateAndEvaluateParameterExpressionWithNameAndList
public void CreateAndEvaluateParameterExpressionWithNameAndList()
{
var expression = new ParameterExpression("a", null, true);
var result = expression.Evaluate(null);
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(Parameter));
var param = (Parameter)result;
Assert.AreEqual("a", expression.Name);
Assert.IsNull(expression.DefaultExpression);
Assert.IsTrue(expression.IsList);
Assert.AreEqual("a", param.Name);
Assert.IsNull(param.DefaultValue);
Assert.IsTrue(param.IsList);
}示例8: HoistedLocals
internal HoistedLocals(HoistedLocals parent, ReadOnlyCollection<ParameterExpression> vars)
{
if (parent != null)
{
// Add the parent locals array as the 0th element in the array
vars = vars.AddFirst(parent.SelfVariable);
}
Dictionary<Expression, int> indexes = new Dictionary<Expression, int>(vars.Count);
for (int i = 0; i < vars.Count; i++)
{
indexes.Add(vars[i], i);
}
SelfVariable = Expression.Variable(typeof(object[]), name: null);
Parent = parent;
Variables = vars;
Indexes = new ReadOnlyDictionary<Expression, int>(indexes);
}示例9: Extends
/// <summary>
/// Extendses the specified parameter map.
/// </summary>
/// <param name="extend">The extend id.</param>
/// <returns></returns>
public ParameterExpression Extends(string extend)
{
Contract.Require.That(extend, Is.Not.Null & Is.Not.Empty).When("retrieving extend argument in Extends method");
if (parentConfiguration == null)
{
parameterExpression = new ParameterExpression(builder);
parentConfiguration = builder.RegisterConfiguration();
parameterExpression.parentConfiguration = parentConfiguration;
}
if (parameterExpression == null)
{
parameterExpression = new ParameterExpression(builder);
parameterExpression.parentConfiguration = parentConfiguration;
}
parentConfiguration.CreateAttribute(ConfigConstants.ATTRIBUTE_EXTENDS, builder.ApplyNamespace(extend));
return parameterExpression;
}示例10: ExecuteSimpleDefCommand
public void ExecuteSimpleDefCommand()
{
IList<ParameterExpression> parameters = new ParameterExpression[] { new ParameterExpression("a", null, false), new ParameterExpression("b", null, false) };
ICommand body = new SetCommand("c", new ConstantExpression(1));
DefCommand command = new DefCommand("foo", parameters, body);
Machine machine = new Machine();
command.Execute(machine.Environment);
var func = machine.Environment.GetValue("foo");
Assert.IsNotNull(func);
Assert.IsInstanceOfType(func, typeof(IFunction));
Assert.IsInstanceOfType(func, typeof(DefinedFunction));
var dfunc = (DefinedFunction)func;
Assert.AreEqual(parameters.Count, dfunc.Parameters.Count);
Assert.AreEqual(body, dfunc.Body);
}示例11: CreateAndEvaluateParameterExpressionWithNameAndDefaultExpression
public void CreateAndEvaluateParameterExpressionWithNameAndDefaultExpression()
{
var environment = new BindingEnvironment();
environment.SetValue("b", 1);
var defaultExpression = new NameExpression("b");
var expression = new ParameterExpression("a", defaultExpression, false);
var result = expression.Evaluate(environment);
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(Parameter));
var param = (Parameter)result;
Assert.AreEqual("a", expression.Name);
Assert.AreEqual(defaultExpression, expression.DefaultExpression);
Assert.IsFalse(expression.IsList);
Assert.AreEqual("a", param.Name);
Assert.AreEqual(1, param.DefaultValue);
Assert.IsFalse(param.IsList);
}示例12: EmitLift
private void EmitLift(ExpressionType nodeType, Type resultType, MethodCallExpression mc, ParameterExpression[] paramList, Expression[] argList)
{
Debug.Assert(TypeUtils.AreEquivalent(TypeUtils.GetNonNullableType(resultType), TypeUtils.GetNonNullableType(mc.Type)));
switch (nodeType)
{
default:
case ExpressionType.LessThan:
case ExpressionType.LessThanOrEqual:
case ExpressionType.GreaterThan:
case ExpressionType.GreaterThanOrEqual:
{
Label exit = _ilg.DefineLabel();
Label exitNull = _ilg.DefineLabel();
LocalBuilder anyNull = _ilg.DeclareLocal(typeof(bool));
for (int i = 0, n = paramList.Length; i < n; i++)
{
ParameterExpression v = paramList[i];
Expression arg = argList[i];
if (TypeUtils.IsNullableType(arg.Type))
{
_scope.AddLocal(this, v);
EmitAddress(arg, arg.Type);
_ilg.Emit(OpCodes.Dup);
_ilg.EmitHasValue(arg.Type);
_ilg.Emit(OpCodes.Ldc_I4_0);
_ilg.Emit(OpCodes.Ceq);
_ilg.Emit(OpCodes.Stloc, anyNull);
_ilg.EmitGetValueOrDefault(arg.Type);
_scope.EmitSet(v);
}
else
{
_scope.AddLocal(this, v);
EmitExpression(arg);
if (!arg.Type.GetTypeInfo().IsValueType)
{
_ilg.Emit(OpCodes.Dup);
_ilg.Emit(OpCodes.Ldnull);
_ilg.Emit(OpCodes.Ceq);
_ilg.Emit(OpCodes.Stloc, anyNull);
}
_scope.EmitSet(v);
}
_ilg.Emit(OpCodes.Ldloc, anyNull);
_ilg.Emit(OpCodes.Brtrue, exitNull);
}
EmitMethodCallExpression(mc);
if (TypeUtils.IsNullableType(resultType) && !TypeUtils.AreEquivalent(resultType, mc.Type))
{
ConstructorInfo ci = resultType.GetConstructor(new Type[] { mc.Type });
_ilg.Emit(OpCodes.Newobj, ci);
}
_ilg.Emit(OpCodes.Br_S, exit);
_ilg.MarkLabel(exitNull);
if (TypeUtils.AreEquivalent(resultType, TypeUtils.GetNullableType(mc.Type)))
{
if (resultType.GetTypeInfo().IsValueType)
{
LocalBuilder result = GetLocal(resultType);
_ilg.Emit(OpCodes.Ldloca, result);
_ilg.Emit(OpCodes.Initobj, resultType);
_ilg.Emit(OpCodes.Ldloc, result);
FreeLocal(result);
}
else
{
_ilg.Emit(OpCodes.Ldnull);
}
}
else
{
switch (nodeType)
{
case ExpressionType.LessThan:
case ExpressionType.LessThanOrEqual:
case ExpressionType.GreaterThan:
case ExpressionType.GreaterThanOrEqual:
_ilg.Emit(OpCodes.Ldc_I4_0);
break;
default:
throw Error.UnknownLiftType(nodeType);
}
}
_ilg.MarkLabel(exit);
return;
}
case ExpressionType.Equal:
case ExpressionType.NotEqual:
{
if (TypeUtils.AreEquivalent(resultType, TypeUtils.GetNullableType(mc.Type)))
{
goto default;
}
Label exit = _ilg.DefineLabel();
Label exitAllNull = _ilg.DefineLabel();
Label exitAnyNull = _ilg.DefineLabel();
LocalBuilder anyNull = _ilg.DeclareLocal(typeof(bool));
LocalBuilder allNull = _ilg.DeclareLocal(typeof(bool));
//.........这里部分代码省略.........
示例13: AddressOf
private void AddressOf(ParameterExpression node, Type type)
{
if (TypeUtils.AreEquivalent(type, node.Type))
{
if (node.IsByRef)
{
_scope.EmitGet(node);
}
else
{
_scope.EmitAddressOf(node);
}
}
else
{
EmitExpressionAddress(node, type);
}
}示例14: Update
/// <summary>
/// Creates a new expression that is like this one, but using the
/// supplied children. If all of the children are the same, it will
/// return this expression.
/// </summary>
/// <param name="variable">The <see cref="Variable" /> property of the result.</param>
/// <param name="filter">The <see cref="Filter" /> property of the result.</param>
/// <param name="body">The <see cref="Body" /> property of the result.</param>
/// <returns>This expression if no children changed, or an expression with the updated children.</returns>
public CatchBlock Update(ParameterExpression variable, Expression filter, Expression body) {
if (variable == Variable && filter == Filter && body == Body) {
return this;
}
return Expression.MakeCatchBlock(Test, variable, body, filter);
}示例15: CatchBlock
internal CatchBlock(Type test, ParameterExpression variable, Expression body, Expression filter) {
_test = test;
_var = variable;
_body = body;
_filter = filter;
}