public void Invoke(Action action)
{
SerializableLambda serializableAction = SerializableLambda.Create(action, _serializer);
// Invoke the action in the other AppDomain and get the return value +
// serialized version of the target in the other app domain.
InvocationResult result = InvokeLambda(serializableAction);
// Deserialize the other app domain's target and copy it to our local target.
_serializer.Populate(result.SerializedTarget, action.Target);
}
public InvocationResult <TReturnValue> Invoke <TReturnValue>(
SerializableLambda <TReturnValue> serializableLambda,
ISerializer serializer,
params object[] arguments)
{
object target = serializer.Deserialize(serializableLambda.TargetType, serializableLambda.TargetValues);
object rawReturnValue = serializableLambda.Method.IsStatic && target != null
? serializableLambda.Method.Invoke(null, new[] { target }.Concat(arguments).ToArray())
: serializableLambda.Method.Invoke(target, arguments);
TReturnValue returnValue = Transform((TReturnValue)rawReturnValue);
var serialized = serializer.Serialize(target);
return(new InvocationResult <TReturnValue>(serialized, returnValue));
}
private InvocationResult <T> InvokeLambda <T>(
SerializableLambda <T> serializableLambda,
params object[] arguments)
{
SerializableLambdaInvoker invoker = Create <SerializableLambdaInvoker>();
InvocationResult <T> result;
try
{
SerializableLambda <T> filtered = FilterLambda(serializableLambda);
result = invoker.Invoke(filtered, _serializer, arguments);
}
catch (FileLoadException exception)
{
_logger.Error("Error invoking SerializableLambda: {0}", exception.GetBaseException());
throw exception.GetBaseException();
}
return(result);
}
private T InvokeSerializableLambda <T>(SerializableLambda <T> serializableFunc, object target,
params object[] arguments)
{
InvocationResult <T> result;
try
{
// Invoke the action in the other AppDomain and get the return value +
// serialized version of the target in the other app domain.
result = InvokeLambda(serializableFunc, arguments);
}
catch (TargetInvocationException exception)
{
_logger.Error("Error invoking SerializableLambda: {0}", exception.GetBaseException());
// Unwrap the exception
throw exception.GetBaseException();
}
// Deserialize the other app domain's target and copy it to our local target.
_serializer.Populate(result.SerializedTarget, target);
return(result.ReturnValue);
}
/// <summary>
/// Creates a <see cref="SerializableLambda{T}" /> for a given <see cref="Func{TResult}" />.
/// </summary>
/// <typeparam name="TReturnValue">The type of the return value.</typeparam>
/// <param name="func">The lambda.</param>
/// <param name="serializer">The serializer used to serialize the target of the lambda.</param>
/// <returns>
/// A <see cref="SerializableLambda{T}" /> for the provided lambda.
/// </returns>
internal static SerializableLambda <TReturnValue> Create <TReturnValue>(
Func <TReturnValue> func, ISerializer serializer)
{
return(SerializableLambda <TReturnValue> .Create(func, serializer));
}
private SerializableLambda <T> FilterLambda <T>(SerializableLambda <T> serializableLambda)
{
return(_lambdaFilters.Aggregate(serializableLambda,
(current, filter) => filter.Filter(this, current)));
}
public TResult Invoke <T1, TResult>(Func <T1, TResult> func, T1 parameter)
{
SerializableLambda <TResult> serializableFunc = SerializableLambda.Create(func, _serializer);
return(InvokeSerializableLambda(serializableFunc, func.Target, parameter));
}
public T Invoke <T>(Func <T> func)
{
SerializableLambda <T> serializableFunc = SerializableLambda.Create(func, _serializer);
return(InvokeSerializableLambda(serializableFunc, func.Target));
}
public void Invoke <T>(Action <T> action, T parameter)
{
SerializableLambda <Unit> serializableFunc = SerializableLambda.Create(action, _serializer);
InvokeSerializableLambda(serializableFunc, action.Target, parameter);
}
