public object GetInstance(ServiceChannel channel, InvokeMethodDelegate invokeMethod, ServiceUser user)
{
if (channel.Provider.Mode == ServiceMode.Single)
{
return(GetInstance(channel, invokeMethod));
}
if (UserInstances[user].ContainsKey(channel.Provider))
{
return(UserInstances[user][channel.Provider]);
}
Type type;
try
{
type = Builder.GetInstanceType(channel.Provider.Instance, channel.Provider.Contract);
}
catch
{
return(null);
}
object instance = CreateInstance(channel, invokeMethod, type);
if (channel.Provider.Mode == ServiceMode.PreClient)
{
UserInstances[user].Add(channel.Provider, instance);
}
return(instance);
}
/// <summary>
/// Builds method delegates
/// </summary>
protected virtual void SetupMethod()
{
lock (this)
{
if (ActivationFunc == null)
{
AssignActivationFunc();
BindParametersDelegate =
Services.ParameterBinderDelegateBuilder.CreateParameterBindingMethod(Configuration, out var parametersType);
if (Configuration.InvokeInformation.MethodInvokeDelegate == null)
{
InvokeMethodDelegate =
Services.MethodInvokerCreationService.BuildMethodInvoker <TReturn>(Configuration, parametersType);
}
else
{
InvokeMethodDelegate =
(InvokeMethodDelegate <TReturn>)(object) Configuration.InvokeInformation.MethodInvokeDelegate;
}
ResponseDelegate = Services.ResponseDelegateCreator.CreateResponseDelegate(Configuration);
}
}
}
public object GetInstance(ServiceChannel channel, InvokeMethodDelegate invokeMethod)
{
if (GlobaInstances.ContainsKey(channel.Provider))
{
return(GlobaInstances[channel.Provider]);
}
Type type;
try
{
type = Builder.GetInstanceType(channel.Provider.Instance, channel.Provider.Contract);
}
catch
{
return(null);
}
object instance = CreateInstance(channel, invokeMethod, type);
if (instance == null)
{
return(null);
}
GlobaInstances.Add(channel.Provider, instance);
return(instance);
}
private static void CreateDynamicAssembly()
{
new SecurityPermission(SecurityPermissionFlag.ControlEvidence).Assert();
Type[] types = new Type[] { typeof(Type), typeof(Type), typeof(string) };
MethodInfo methodInfo = typeof(Delegate).GetMethod("CreateDelegate", types);
DynamicMethod method = new DynamicMethod("CreateDelegate", typeof(Delegate), types);
method.DefineParameter(1, ParameterAttributes.In, "delegateType");
method.DefineParameter(2, ParameterAttributes.In, "targetType");
method.DefineParameter(3, ParameterAttributes.In, "methodName");
ILGenerator iLGenerator = method.GetILGenerator(5);
iLGenerator.Emit(OpCodes.Ldarg_0);
iLGenerator.Emit(OpCodes.Ldarg_1);
iLGenerator.Emit(OpCodes.Ldarg_2);
iLGenerator.EmitCall(OpCodes.Call, methodInfo, null);
iLGenerator.Emit(OpCodes.Ret);
s_CreateDelegate1 = (CreateDelegate1Delegate)method.CreateDelegate(typeof(CreateDelegate1Delegate));
types = new Type[] { typeof(Type), typeof(object), typeof(string) };
methodInfo = typeof(Delegate).GetMethod("CreateDelegate", types);
method = new DynamicMethod("CreateDelegate", typeof(Delegate), types);
method.DefineParameter(1, ParameterAttributes.In, "delegateType");
method.DefineParameter(2, ParameterAttributes.In, "target");
method.DefineParameter(3, ParameterAttributes.In, "methodName");
iLGenerator = method.GetILGenerator(5);
iLGenerator.Emit(OpCodes.Ldarg_0);
iLGenerator.Emit(OpCodes.Ldarg_1);
iLGenerator.Emit(OpCodes.Ldarg_2);
iLGenerator.EmitCall(OpCodes.Call, methodInfo, null);
iLGenerator.Emit(OpCodes.Ret);
s_CreateDelegate2 = (CreateDelegate2Delegate)method.CreateDelegate(typeof(CreateDelegate2Delegate));
types = new Type[] { typeof(Type), typeof(object[]) };
methodInfo = typeof(Activator).GetMethod("CreateInstance", types);
method = new DynamicMethod("CreateInstance", typeof(object), types);
method.DefineParameter(1, ParameterAttributes.In, "type");
method.DefineParameter(2, ParameterAttributes.In, "arguments");
iLGenerator = method.GetILGenerator(4);
iLGenerator.Emit(OpCodes.Ldarg_0);
iLGenerator.Emit(OpCodes.Ldarg_1);
iLGenerator.EmitCall(OpCodes.Call, methodInfo, null);
iLGenerator.Emit(OpCodes.Ret);
s_CreateInstance = (CreateInstanceDelegate)method.CreateDelegate(typeof(CreateInstanceDelegate));
types = new Type[] { typeof(object), typeof(object[]) };
Type[] parameterTypes = new Type[] { typeof(MethodInfo), typeof(object), typeof(object[]) };
methodInfo = typeof(MethodInfo).GetMethod("Invoke", types);
method = new DynamicMethod("InvokeMethod", typeof(object), parameterTypes);
method.DefineParameter(1, ParameterAttributes.In, "method");
method.DefineParameter(2, ParameterAttributes.In, "instance");
method.DefineParameter(3, ParameterAttributes.In, "args");
iLGenerator = method.GetILGenerator(5);
iLGenerator.Emit(OpCodes.Ldarg_0);
iLGenerator.Emit(OpCodes.Ldarg_1);
iLGenerator.Emit(OpCodes.Ldarg_2);
iLGenerator.EmitCall(OpCodes.Callvirt, methodInfo, null);
iLGenerator.Emit(OpCodes.Ret);
s_InvokeMethod = (InvokeMethodDelegate)method.CreateDelegate(typeof(InvokeMethodDelegate));
}
public CallbacksImpl(ICallbacks callbacks)
{
_callbacks = callbacks;
_isTypeValidDelegate = IsTypeValid;
GCHandle.Alloc(_isTypeValidDelegate);
_releaseNetReferenceDelegate = ReleaseNetReference;
GCHandle.Alloc(_releaseNetReferenceDelegate);
_releaseNetDelegateGCHandleDelegate = ReleaseNetDelegateGCHandle;
GCHandle.Alloc(_releaseNetDelegateGCHandleDelegate);
_createLazyTypeInfoDelegate = CreateLazyTypeInfo;
GCHandle.Alloc(_createLazyTypeInfoDelegate);
_loadTypeInfoDelegate = LoadTypeInfo;
GCHandle.Alloc(_loadTypeInfoDelegate);
_instantiateTypeDelgate = InstantiateType;
GCHandle.Alloc(_instantiateTypeDelgate);
_callComponentCompletedDelegate = CallComponentCompleted;
GCHandle.Alloc(_callComponentCompletedDelegate);
_callObjectDestroyedDelegate = CallObjectDestroyed;
GCHandle.Alloc(_callObjectDestroyedDelegate);
_readPropertyDelegate = ReadProperty;
GCHandle.Alloc(_readPropertyDelegate);
_writePropertyDelegate = WriteProperty;
GCHandle.Alloc(_writePropertyDelegate);
_invokeMethodDelegate = InvokeMethod;
GCHandle.Alloc(_invokeMethodDelegate);
_gcCollectDelegate = GCCollect;
GCHandle.Alloc(_gcCollectDelegate);
_raiseNetSignalsDelegate = RaiseNetSignals;
GCHandle.Alloc(_raiseNetSignalsDelegate);
_awaitTaskDelegate = AwaitTask;
GCHandle.Alloc(_awaitTaskDelegate);
_serializeDelegate = Serialize;
GCHandle.Alloc(_serializeDelegate);
_invokeDelegateDelegate = InvokeDelegate;
GCHandle.Alloc(_invokeDelegateDelegate);
}
public static object InvokeMethod(Form form, string methodName, params object[] parms)
{
if (form.InvokeRequired)
{
Delegate delg = new InvokeMethodDelegate(InvokeMethod);
var ret = form.Invoke(delg, form, methodName, parms);
are.WaitOne();
return(ret);
}
else
{
var type = form.GetType();
var methodInfo = type.GetMethod(methodName, Reflector.Flags);
var ret = methodInfo.Invoke(form, parms);
are.Set();
return(ret);
}
}
private object CreateInstance(ServiceChannel channel, InvokeMethodDelegate invokeMethod, Type type)
{
InstanceProxy proxy = new InstanceProxy(channel, channel.Provider.ClientOperations.ToList(), invokeMethod);
if (Unity.IsRegistered(type))
{
return(Unity.GetInstance(type));
}
foreach (var constructor in type.GetConstructors())
{
var parameters = constructor.GetParameters();
object[] parameterArray = new object[parameters.Length];
bool parameterSuccess = true;
parameterArray[0] = proxy;
for (int i = 1; i < parameters.Length; i++)
{
object obj = Unity.GetInstance(parameters[i].ParameterType);
if (obj == null)
{
parameterSuccess = false;
break;
}
parameterArray[i] = obj;
}
if (!parameterSuccess)
{
continue;
}
try
{
return(Activator.CreateInstance(type, parameterArray));
}
catch
{
}
}
return(null);
}
private static void CreateDynamicAssembly()
{
// 1. Assert permissions demanded by the DynamicMethod ctor.
new SecurityPermission(SecurityPermissionFlag.ControlEvidence).Assert(); // BlessedAssert
// 2. Create the transparent methods, each wrapping a call to a reflection method,
// and cache a delegate to each method.
Type[] parameterTypes; // signature of the reflection method
Type[] wrappedParameterTypes; // signature of the wrapping method (when different)
MethodInfo mi; // descriptor for the reflection method
DynamicMethod method; // wrapping method
ILGenerator il; // wrapping method's generator
// 2a. Delegate.CreateDelegate( Type, Type, String )
parameterTypes = new Type[] { typeof(Type), typeof(Type), typeof(String) };
mi = typeof(Delegate).GetMethod("CreateDelegate", parameterTypes);
method = new DynamicMethod("CreateDelegate", typeof(Delegate), parameterTypes);
method.DefineParameter(1, ParameterAttributes.In, "delegateType");
method.DefineParameter(2, ParameterAttributes.In, "targetType");
method.DefineParameter(3, ParameterAttributes.In, "methodName");
il = method.GetILGenerator(5);
il.Emit(OpCodes.Ldarg_0); // push delegateType
il.Emit(OpCodes.Ldarg_1); // push targetType
il.Emit(OpCodes.Ldarg_2); // push methodName
il.EmitCall(OpCodes.Call, mi, null); // call Delegate.CreateDelegate
il.Emit(OpCodes.Ret); // return the result
s_CreateDelegate1 = (CreateDelegate1Delegate)method.CreateDelegate(typeof(CreateDelegate1Delegate));
// 2b. Delegate.CreateDelegate( Type, Object, String )
parameterTypes = new Type[] { typeof(Type), typeof(Object), typeof(String) };
mi = typeof(Delegate).GetMethod("CreateDelegate", parameterTypes);
method = new DynamicMethod("CreateDelegate", typeof(Delegate), parameterTypes);
method.DefineParameter(1, ParameterAttributes.In, "delegateType");
method.DefineParameter(2, ParameterAttributes.In, "target");
method.DefineParameter(3, ParameterAttributes.In, "methodName");
il = method.GetILGenerator(5);
il.Emit(OpCodes.Ldarg_0); // push delegateType
il.Emit(OpCodes.Ldarg_1); // push target
il.Emit(OpCodes.Ldarg_2); // push methodName
il.EmitCall(OpCodes.Call, mi, null); // call Delegate.CreateDelegate
il.Emit(OpCodes.Ret); // return the result
s_CreateDelegate2 = (CreateDelegate2Delegate)method.CreateDelegate(typeof(CreateDelegate2Delegate));
// 2c. Activator.CreateInstance( Type, Object[] )
parameterTypes = new Type[] { typeof(Type), typeof(Object[]) };
mi = typeof(Activator).GetMethod("CreateInstance", parameterTypes);
method = new DynamicMethod("CreateInstance", typeof(Object), parameterTypes);
method.DefineParameter(1, ParameterAttributes.In, "type");
method.DefineParameter(2, ParameterAttributes.In, "arguments");
il = method.GetILGenerator(4);
il.Emit(OpCodes.Ldarg_0); // push type
il.Emit(OpCodes.Ldarg_1); // push arguments
il.EmitCall(OpCodes.Call, mi, null); // call Activator.CreateInstance
il.Emit(OpCodes.Ret); // return the result
s_CreateInstance = (CreateInstanceDelegate)method.CreateDelegate(typeof(CreateInstanceDelegate));
// 2d. MethodInfo.Invoke(object, args)
parameterTypes = new Type[] { typeof(Object), typeof(Object[]) };
wrappedParameterTypes = new Type[] { typeof(MethodInfo), typeof(Object), typeof(Object[]) };
mi = typeof(MethodInfo).GetMethod("Invoke", parameterTypes);
method = new DynamicMethod("InvokeMethod", typeof(Object), wrappedParameterTypes);
method.DefineParameter(1, ParameterAttributes.In, "method");
method.DefineParameter(2, ParameterAttributes.In, "instance");
method.DefineParameter(3, ParameterAttributes.In, "args");
il = method.GetILGenerator(5);
il.Emit(OpCodes.Ldarg_0); // push method
il.Emit(OpCodes.Ldarg_1); // push instance
il.Emit(OpCodes.Ldarg_2); // push args
il.EmitCall(OpCodes.Callvirt, mi, null); // call method.Invoke
il.Emit(OpCodes.Ret); // return the result
s_InvokeMethod = (InvokeMethodDelegate)method.CreateDelegate(typeof(InvokeMethodDelegate));
}
public static object InvokeMethod(Control ctrl, string methodName, params object[] args)
{
if (ctrl.InvokeRequired)
{
InvokeMethodDelegate del = new InvokeMethodDelegate(CrossThreadUI.InvokeMethod);
if (CrossThreadUI.ExecSync)
{
return(ctrl.Invoke(del, ctrl, methodName, args));
}
else
{
ctrl.BeginInvoke(del, ctrl, methodName, args);
}
}
else
{
Type ctrlType = ctrl.GetType();
// Determine the type of each passed argument in order to try and
// determine the unique signature for the requested method.
Type[] paramTypes = new Type[args.Length];
for (int i = 0; i < paramTypes.Length; i++)
{
paramTypes[i] = args[i].GetType();
}
// Now it's time to get a reference to the method.
MethodInfo mi = ctrlType.GetMethod(methodName, paramTypes);
if (mi != null)
{
#region DEPRECIATED :: Checking Method Parameters
// We don't really need to do this, since we're using the
// provided method arguments as a signature when we
// search for the method.
//// Check to make sure the proper number of parameters were passed
//// and that all the types match.
//ParameterInfo[] p = mi.GetParameters();
//if (p.Length > 0)
//{
// // If the 'args' value is null or the lengths don't match,
// // throw an exception.
// if (args == null || (args.Length != p.Length))
// throw new ArgumentException("Wrong number of arguments for method '" + methodName + "'.", "args");
// // Check to make sure all the parameters are of the correct type.
// for (int i = 0; i < p.Length; i++)
// {
// Type argType = args[i].GetType();
// if (argType.FullName != p[i].ParameterType.FullName && !p[i].ParameterType.IsSubclassOf(argType))
// throw new ArgumentException(string.Format("Given argument is of the wrong type for parameter '{0}'. Expected '{1}' but recieved '{2}' for parameter position {3}.", p[i].Name, p[i].ParameterType.FullName, argType.FullName, p[i].Position), "args");
// }
//}
#endregion
// If we passed all the validation, then call the invoke for the
// MemberInfo object.
return(mi.Invoke(ctrl, args));
}
else
{
throw new ArgumentException("Specified control does not expose a '" + methodName + "' method with the provided parameter types.", "methodName");
}
}
return(null);
}
internal InstanceProxy(ServiceChannel channel, List <MethodInfo> methods, InvokeMethodDelegate invokeMethod)
{
Channel = channel;
Methods = methods;
InvokeMethod = invokeMethod;
}
public StreamServiceReceiver(T serviceImplementor, Stream stream)
{
Stream = stream;
invoke = ProxyFactory.CreateReceiverProxy(serviceImplementor, out instance, out commandsMap);
}
// --- Private Static Methods ---
private static void InitStaticFields()
{
_methodInvokeDelegate = new InvokeDelegateDelegate(InvokeDelegate);
_methodInvokeMethod = new InvokeMethodDelegate(InvokeMethod);
}
/// <summary>
/// Invokes a method member on a given Control instance with proper type-safety.
/// </summary>
/// <param name="ctrl">The System.Windows.Forms.Control object on which the method will be invoked.</param>
/// <param name="methodName">The name of the method that will be invoked.</param>
/// <param name="args">Any arguments the method requires. Array objects must be properly typed to match the method's signature.</param>
/// <returns>An object whose type will match the specified method's signature or null if the method has no return value.</returns>
public static object InvokeMethod(Control ctrl, string methodName, params object[] args)
{
if (ctrl.InvokeRequired)
{
InvokeMethodDelegate del = new InvokeMethodDelegate(CrossThreadUI.InvokeMethod);
if (CrossThreadUI.ExecSync)
return ctrl.Invoke(del, ctrl, methodName, args);
else
ctrl.BeginInvoke(del, ctrl, methodName, args);
}
else
{
Type ctrlType = ctrl.GetType();
// Determine the type of each passed argument in order to try and
// determine the unique signature for the requested method.
Type[] paramTypes = new Type[args.Length];
for (int i = 0; i < paramTypes.Length; i++)
paramTypes[i] = args[i].GetType();
// Now it's time to get a reference to the method.
MethodInfo mi = ctrlType.GetMethod(methodName, paramTypes);
if (mi != null)
{
#region DEPRECIATED :: Checking Method Parameters
// We don't really need to do this, since we're using the
// provided method arguments as a signature when we
// search for the method.
//// Check to make sure the proper number of parameters were passed
//// and that all the types match.
//ParameterInfo[] p = mi.GetParameters();
//if (p.Length > 0)
//{
// // If the 'args' value is null or the lengths don't match,
// // throw an exception.
// if (args == null || (args.Length != p.Length))
// throw new ArgumentException("Wrong number of arguments for method '" + methodName + "'.", "args");
// // Check to make sure all the parameters are of the correct type.
// for (int i = 0; i < p.Length; i++)
// {
// Type argType = args[i].GetType();
// if (argType.FullName != p[i].ParameterType.FullName && !p[i].ParameterType.IsSubclassOf(argType))
// throw new ArgumentException(string.Format("Given argument is of the wrong type for parameter '{0}'. Expected '{1}' but recieved '{2}' for parameter position {3}.", p[i].Name, p[i].ParameterType.FullName, argType.FullName, p[i].Position), "args");
// }
//}
#endregion
// If we passed all the validation, then call the invoke for the
// MemberInfo object.
return mi.Invoke(ctrl, args);
}
else
throw new ArgumentException("Specified control does not expose a '" + methodName + "' method with the provided parameter types.", "methodName");
}
return null;
}
private static void CreateDynamicAssembly()
{
new SecurityPermission(SecurityPermissionFlag.ControlEvidence).Assert();
Type[] types = new Type[] { typeof(Type), typeof(Type), typeof(string) };
MethodInfo methodInfo = typeof(Delegate).GetMethod("CreateDelegate", types);
DynamicMethod method = new DynamicMethod("CreateDelegate", typeof(Delegate), types);
method.DefineParameter(1, ParameterAttributes.In, "delegateType");
method.DefineParameter(2, ParameterAttributes.In, "targetType");
method.DefineParameter(3, ParameterAttributes.In, "methodName");
ILGenerator iLGenerator = method.GetILGenerator(5);
iLGenerator.Emit(OpCodes.Ldarg_0);
iLGenerator.Emit(OpCodes.Ldarg_1);
iLGenerator.Emit(OpCodes.Ldarg_2);
iLGenerator.EmitCall(OpCodes.Call, methodInfo, null);
iLGenerator.Emit(OpCodes.Ret);
s_CreateDelegate1 = (CreateDelegate1Delegate) method.CreateDelegate(typeof(CreateDelegate1Delegate));
types = new Type[] { typeof(Type), typeof(object), typeof(string) };
methodInfo = typeof(Delegate).GetMethod("CreateDelegate", types);
method = new DynamicMethod("CreateDelegate", typeof(Delegate), types);
method.DefineParameter(1, ParameterAttributes.In, "delegateType");
method.DefineParameter(2, ParameterAttributes.In, "target");
method.DefineParameter(3, ParameterAttributes.In, "methodName");
iLGenerator = method.GetILGenerator(5);
iLGenerator.Emit(OpCodes.Ldarg_0);
iLGenerator.Emit(OpCodes.Ldarg_1);
iLGenerator.Emit(OpCodes.Ldarg_2);
iLGenerator.EmitCall(OpCodes.Call, methodInfo, null);
iLGenerator.Emit(OpCodes.Ret);
s_CreateDelegate2 = (CreateDelegate2Delegate) method.CreateDelegate(typeof(CreateDelegate2Delegate));
types = new Type[] { typeof(Type), typeof(object[]) };
methodInfo = typeof(Activator).GetMethod("CreateInstance", types);
method = new DynamicMethod("CreateInstance", typeof(object), types);
method.DefineParameter(1, ParameterAttributes.In, "type");
method.DefineParameter(2, ParameterAttributes.In, "arguments");
iLGenerator = method.GetILGenerator(4);
iLGenerator.Emit(OpCodes.Ldarg_0);
iLGenerator.Emit(OpCodes.Ldarg_1);
iLGenerator.EmitCall(OpCodes.Call, methodInfo, null);
iLGenerator.Emit(OpCodes.Ret);
s_CreateInstance = (CreateInstanceDelegate) method.CreateDelegate(typeof(CreateInstanceDelegate));
types = new Type[] { typeof(object), typeof(object[]) };
Type[] parameterTypes = new Type[] { typeof(MethodInfo), typeof(object), typeof(object[]) };
methodInfo = typeof(MethodInfo).GetMethod("Invoke", types);
method = new DynamicMethod("InvokeMethod", typeof(object), parameterTypes);
method.DefineParameter(1, ParameterAttributes.In, "method");
method.DefineParameter(2, ParameterAttributes.In, "instance");
method.DefineParameter(3, ParameterAttributes.In, "args");
iLGenerator = method.GetILGenerator(5);
iLGenerator.Emit(OpCodes.Ldarg_0);
iLGenerator.Emit(OpCodes.Ldarg_1);
iLGenerator.Emit(OpCodes.Ldarg_2);
iLGenerator.EmitCall(OpCodes.Callvirt, methodInfo, null);
iLGenerator.Emit(OpCodes.Ret);
s_InvokeMethod = (InvokeMethodDelegate) method.CreateDelegate(typeof(InvokeMethodDelegate));
}
public MethodHandler(Method method, MethodParameter[] parameters, InvokeMethodDelegate invoke)
{
_invoke = invoke;
Method = method;
Parameters = parameters;
}