/// <summary>
/// Evaluates the expression.
/// </summary>
/// <param name="context">Evaluation context.</param>
/// <returns>Expression result.</returns>
protected override object EvaluateNode(LogEventInfo context)
{
int parameterOffset = this.acceptsLogEvent ? 1 : 0;
var callParameters = new object[this.MethodParameters.Count + parameterOffset];
//Memory profiling pointed out that using a foreach-loop was allocating
//an Enumerator. Switching to a for-loop avoids the memory allocation.
for (int i = 0; i < this.MethodParameters.Count; i++)
{
ConditionExpression ce = this.MethodParameters[i];
callParameters[i + parameterOffset] = ce.Evaluate(context);
}
if (this.acceptsLogEvent)
{
callParameters[0] = context;
}
return(this.MethodInfo.DeclaringType.InvokeMember(
MethodInfo.Name,
BindingFlags.InvokeMethod | BindingFlags.Static | BindingFlags.Public | BindingFlags.OptionalParamBinding,
null,
null,
callParameters
#if !SILVERLIGHT
, CultureInfo.InvariantCulture
#endif
));
}
/// <summary>
/// Evaluates the expression.
/// </summary>
/// <param name="context">Evaluation context.</param>
/// <returns>Expression result.</returns>
protected override object EvaluateNode(LogEventInfo context)
{
int parameterOffset = _acceptsLogEvent ? 1 : 0;
int parameterDefaults = _lateBoundMethodDefaultParameters != null ? _lateBoundMethodDefaultParameters.Length : 0;
var callParameters = new object[MethodParameters.Count + parameterOffset + parameterDefaults];
//Memory profiling pointed out that using a foreach-loop was allocating
//an Enumerator. Switching to a for-loop avoids the memory allocation.
for (int i = 0; i < MethodParameters.Count; i++)
{
ConditionExpression ce = MethodParameters[i];
callParameters[i + parameterOffset] = ce.Evaluate(context);
}
if (_acceptsLogEvent)
{
callParameters[0] = context;
}
if (_lateBoundMethodDefaultParameters != null)
{
for (int i = _lateBoundMethodDefaultParameters.Length - 1; i >= 0; --i)
{
callParameters[callParameters.Length - i - 1] = _lateBoundMethodDefaultParameters[i];
}
}
return(_lateBoundMethod(null, callParameters)); // Static-method so object-instance = null
}
public override object Evaluate(LogEventInfo context)
{
object v1 = par1.Evaluate(context);
object v2 = par2.Evaluate(context);
return(Compare(v1, v2, op));
}
private object[] GenerateCallParameters(LogEventInfo context)
{
int parameterOffset = _acceptsLogEvent ? 1 : 0;
int callParametersCount = _methodParameters.Length + parameterOffset + _lateBoundMethodDefaultParameters.Length;
if (callParametersCount == 0)
{
return(ArrayHelper.Empty <object>());
}
var callParameters = new object[callParametersCount];
if (_acceptsLogEvent)
{
callParameters[0] = context;
}
//Memory profiling pointed out that using a foreach-loop was allocating
//an Enumerator. Switching to a for-loop avoids the memory allocation.
for (int i = 0; i < _methodParameters.Length; i++)
{
ConditionExpression ce = _methodParameters[i];
callParameters[i + parameterOffset] = ce.Evaluate(context);
}
if (_lateBoundMethodDefaultParameters.Length > 0)
{
for (int i = _lateBoundMethodDefaultParameters.Length - 1; i >= 0; --i)
{
callParameters[callParameters.Length - i - 1] = _lateBoundMethodDefaultParameters[i];
}
}
return(callParameters);
}
/// <summary>
/// Evaluates the expression by evaluating <see cref="Left"/> and <see cref="Right"/> recursively.
/// </summary>
/// <param name="context">Evaluation context.</param>
/// <returns>The value of the conjunction operator.</returns>
public override object Evaluate(LogEventInfo context)
{
bool bval1 = (bool)Left.Evaluate(context);
if (!bval1)
{
return(_boxedFalse);
}
bool bval2 = (bool)Right.Evaluate(context);
if (!bval2)
{
return(_boxedFalse);
}
return(_boxedTrue);
}
public override object Evaluate(LogEventInfo context)
{
return(!((bool)expr.Evaluate(context)));
}
