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); }