internal override void TranslateToILDelete(ILGenerator il, Type rtype)
{
IReflect ir = this.func.InferType(null);
Type obType = Convert.ToType(ir);
this.func.TranslateToIL(il, obType);
this.args.TranslateToIL(il, typeof(Object[]));
if (this.func is Binding)
{
MethodInfo deleteOp;
if (ir is ClassScope)
{
deleteOp = ((ClassScope)ir).owner.deleteOpMethod;
}
else
{
deleteOp = ir.GetMethod("op_Delete", BindingFlags.ExactBinding | BindingFlags.Public | BindingFlags.Static,
null, new Type[] { obType, typeof(Object[]) }, null);
}
if (deleteOp != null && (deleteOp.Attributes & MethodAttributes.SpecialName) != 0 && deleteOp.ReturnType == Typeob.Boolean)
{
il.Emit(OpCodes.Call, deleteOp);
Convert.Emit(this, il, Typeob.Boolean, rtype);
return;
}
}
ConstantWrapper.TranslateToILInt(il, this.args.count - 1);
il.Emit(OpCodes.Ldelem_Ref);
Convert.Emit(this, il, Typeob.Object, Typeob.String);
il.Emit(OpCodes.Call, CompilerGlobals.deleteMemberMethod);
Convert.Emit(this, il, Typeob.Boolean, rtype);
}
internal override void TranslateToILDelete(ILGenerator il, Type rtype)
{
IReflect ir = this.func.InferType(null);
Type type = Microsoft.JScript.Convert.ToType(ir);
this.func.TranslateToIL(il, type);
this.args.TranslateToIL(il, Typeob.ArrayOfObject);
if (this.func is Binding)
{
MethodInfo deleteOpMethod;
if (ir is ClassScope)
{
deleteOpMethod = ((ClassScope)ir).owner.deleteOpMethod;
}
else
{
deleteOpMethod = ir.GetMethod("op_Delete", BindingFlags.ExactBinding | BindingFlags.Public | BindingFlags.Static, null, new Type[] { type, Typeob.ArrayOfObject }, null);
}
if (((deleteOpMethod != null) && ((deleteOpMethod.Attributes & MethodAttributes.SpecialName) != MethodAttributes.PrivateScope)) && (deleteOpMethod.ReturnType == Typeob.Boolean))
{
il.Emit(OpCodes.Call, deleteOpMethod);
Microsoft.JScript.Convert.Emit(this, il, Typeob.Boolean, rtype);
return;
}
}
ConstantWrapper.TranslateToILInt(il, this.args.count - 1);
il.Emit(OpCodes.Ldelem_Ref);
Microsoft.JScript.Convert.Emit(this, il, Typeob.Object, Typeob.String);
il.Emit(OpCodes.Call, CompilerGlobals.deleteMemberMethod);
Microsoft.JScript.Convert.Emit(this, il, Typeob.Boolean, rtype);
}
private static MemberInfo[] GetAndWrapMember(IReflect reflect, Object namedItem, String name, BindingFlags bindingAttr)
{
PropertyInfo property = reflect.GetProperty(name, bindingAttr);
if (property != null)
{
MethodInfo getMethod = JSProperty.GetGetMethod(property, false);
MethodInfo setMethod = JSProperty.GetSetMethod(property, false);
if ((getMethod != null && !getMethod.IsStatic) || (setMethod != null && !setMethod.IsStatic))
{
MethodInfo method = reflect.GetMethod(name, bindingAttr);
if (method != null && !method.IsStatic)
{
MemberInfo[] propMethods = new MemberInfo[1];
propMethods[0] = new JSWrappedPropertyAndMethod(property, method, namedItem);
return(propMethods);
}
}
}
MemberInfo[] members = reflect.GetMember(name, bindingAttr);
if (members != null && members.Length > 0)
{
return(ScriptObject.WrapMembers(members, namedItem));
}
return(null);
}
private static MethodInfo getOperator(IReflect type, string methodName)
{
const BindingFlags bindingFlags = BindingFlags.Static | BindingFlags.Public;
var equalityOperator = type.GetMethod(methodName, bindingFlags);
return(equalityOperator);
}
private static bool TryInvokeMethod(IReflect target, string name, bool ignoreCase, object[] args, out object result)
{
// ReSharper disable once SuspiciousTypeConversion.Global
if (target is IDispatchEx dispatchEx)
{
// Standard IExpando-over-IDispatchEx support appears to leak the variants it
// creates for the invocation arguments. This issue has been reported. In the
// meantime we'll bypass this facility and interface with IDispatchEx directly.
result = dispatchEx.InvokeMethod(name, ignoreCase, args);
return(true);
}
var flags = BindingFlags.Public;
if (ignoreCase)
{
flags |= BindingFlags.IgnoreCase;
}
var method = target.GetMethod(name, flags);
if (method != null)
{
result = method.Invoke(target, BindingFlags.InvokeMethod | flags, null, args, CultureInfo.InvariantCulture);
return(true);
}
result = null;
return(false);
}
internal virtual void TranslateToConditionalBranch(ILGenerator il, bool branchIfTrue, Label label, bool shortForm)
{
IReflect ir = this.InferType(null);
if ((ir != Typeob.Object) && (ir is Type))
{
string name = branchIfTrue ? "op_True" : "op_False";
MethodInfo meth = ir.GetMethod(name, BindingFlags.ExactBinding | BindingFlags.Public | BindingFlags.Static, null, new Type[] { (Type)ir }, null);
if (meth != null)
{
this.TranslateToIL(il, (Type)ir);
il.Emit(OpCodes.Call, meth);
il.Emit(OpCodes.Brtrue, label);
return;
}
}
Type rtype = Microsoft.JScript.Convert.ToType(ir);
this.TranslateToIL(il, rtype);
Microsoft.JScript.Convert.Emit(this, il, rtype, Typeob.Boolean, true);
if (branchIfTrue)
{
il.Emit(shortForm ? OpCodes.Brtrue_S : OpCodes.Brtrue, label);
}
else
{
il.Emit(shortForm ? OpCodes.Brfalse_S : OpCodes.Brfalse, label);
}
}
internal virtual void TranslateToConditionalBranch(ILGenerator il, bool branchIfTrue, Label label, bool shortForm)
{
//This method is overridden in all interesting cases.
IReflect ir = this.InferType(null);
if (ir != Typeob.Object && ir is Type)
{
String op = branchIfTrue ? "op_True" : "op_False";
MethodInfo meth = ir.GetMethod(op, BindingFlags.ExactBinding | BindingFlags.Public | BindingFlags.Static, null, new Type[] { (Type)ir }, null);
if (meth != null)
{
this.TranslateToIL(il, (Type)ir);
il.Emit(OpCodes.Call, meth);
il.Emit(OpCodes.Brtrue, label);
return;
}
}
Type t = Convert.ToType(ir);
this.TranslateToIL(il, t);
Convert.Emit(this, il, t, Typeob.Boolean, true);
if (branchIfTrue)
{
il.Emit(shortForm ? OpCodes.Brtrue_S : OpCodes.Brtrue, label);
}
else
{
il.Emit(shortForm ? OpCodes.Brfalse_S : OpCodes.Brfalse, label);
}
}
private static MethodInfo GetCreateContainerMethod(IReflect type, string createContainerMethodName)
{
var createContainerMethod = type.GetMethod(createContainerMethodName, BindingFlags.Static | BindingFlags.Public)
?? throw new InvalidOperationException("Unable to access container creation method. Make sure it's static and public.");
ValidateCreateContainerParameters(createContainerMethod);
ValidateCreateContainerReturnType(createContainerMethod);
return(createContainerMethod);
}
private static OperationFilterContext GetContext(IReflect controllerType, string methodName)
{
var methodInfo = controllerType.GetMethod(
name: methodName,
bindingAttr: BindingFlags.NonPublic | BindingFlags.Static);
return(new OperationFilterContext(
apiDescription: new ApiDescription(),
schemaRegistry: default,
private static MethodInfo GetMethodInfo(IReflect source, string methodName, BindingFlags bindingFlags)
{
Requires.NotDefault(bindingFlags, nameof(bindingFlags));
var method = source.GetMethod(methodName, bindingFlags);
Requires.NotNull(method, nameof(method));
return(method !);
}
private static object GetEnumeration(IReflect enumerationType, string value)
{
if (string.IsNullOrEmpty(value))
{
return(null);
}
int listItemValue;
if (int.TryParse(value, out listItemValue))
{
var fromValueMethod = enumerationType.GetMethod("FromValue", BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy, null, new[] { typeof(int) }, null);
return(fromValueMethod.Invoke(null, new object[] { listItemValue }));
}
var parseMethod = enumerationType.GetMethod("Parse", BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy, null, new[] { typeof(string) }, null);
return(parseMethod.Invoke(null, new object[] { value }));
}
private static MethodInfo DeclaringMethod(MethodInfo method, IReflect declaringType)
{
var flags = Default;
flags |= method.IsStatic ? Static : Instance;
flags |= method.IsPublic ? Public : NonPublic;
var parameters = method.GetParameters().Select(_ => _.ParameterType).ToArray();
return(declaringType.GetMethod(method.Name, flags, null, parameters, null) ?? method);
}
private static MethodInfo GetImplicitOperatorInfo(IReflect type)
{
return(type.GetMethod(
ImplicitOperatorMethodName,
BindingFlags.Static | BindingFlags.Public,
null,
new [] { typeof(string) },
new ParameterModifier[0]
));
}
private static MethodInfo GetGenericMethodInfo(IReflect source, string methodName, BindingFlags bindingFlags, Type[] types)
{
Requires.NotDefault(bindingFlags, nameof(bindingFlags));
var method = source.GetMethod(methodName, bindingFlags, new GenericMethodBinder(), types, null);
Requires.NotNull(method, nameof(method));
return(method !);
}
static Func <string, object> Bind(IReflect factory)
{
var method = factory.GetMethod("GetGrain",
BindingFlags.Public | BindingFlags.Static, null,
new[] { typeof(long), typeof(string) }, null);
var argument = Expression.Parameter(typeof(string), "ext");
var call = Expression.Call(method, new Expression[] { Expression.Constant(0L), argument });
var lambda = Expression.Lambda <Func <string, object> >(call, argument);
return(lambda.Compile());
}
/// <summary>
/// Initializes a new instance of the <see cref="CustomTask{T}" /> class.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="methodName">Name of the method.</param>
/// <param name="args">The arguments.</param>
/// <exception cref="System.ArgumentException">methodName;Fitting method with the given name was not found.</exception>
public CustomTask(IReflect type, string methodName, params object[] args)
{
var methodInfo = type.GetMethod(methodName,
BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.InvokeMethod | BindingFlags.Static);
if (methodInfo == null)
{
throw new ArgumentException("methodName", "Fitting method with the given name was not found.");
}
_function = t => (T)methodInfo.Invoke(null, args);
}
static Func<string, object> Bind(IReflect factory)
{
var method = factory.GetMethod("GetGrain",
BindingFlags.Public | BindingFlags.Static, null,
new[]{typeof(long), typeof(string)}, null);
var argument = Expression.Parameter(typeof(string), "ext");
var call = Expression.Call(method, new Expression[]{Expression.Constant(0L), argument});
var lambda = Expression.Lambda<Func<string, object>>(call, argument);
return lambda.Compile();
}
private static object ExecMethod(IReflect sourceType, string metodo, object sourceMethod, object[] param, BindingFlags flags)
{
var m = sourceType.GetMethod(metodo, flags);
if (m == null)
{
throw new ArgumentException(string.Format("Unknown methond '{0}' in type '{1}'.", metodo, sourceType));
}
var objRet = m.Invoke(sourceMethod, param);
return(objRet);
}
public FunctionDetour(IReflect originalClassType, string originalFunctionName, IReflect targetClassType, string targetFunctionName)
{
// Ensure the arguments passed in are valid
if (string.IsNullOrWhiteSpace(originalFunctionName))
{
throw new ArgumentException($"The parameter '{nameof(originalFunctionName)}' can't be null / empty or whitespace!");
}
if (string.IsNullOrWhiteSpace(targetFunctionName))
{
throw new ArgumentException($"The parameter '{nameof(targetFunctionName)}' can't be null / empty or whitespace!");
}
if (originalClassType == null)
{
throw new ArgumentNullException($"The parameter '{nameof(originalClassType)}' can't be null!");
}
if (targetClassType == null)
{
throw new ArgumentNullException($"The parameter '{nameof(targetClassType)}' can't be null!");
}
// Get the information about the original function
var originalFunctionInfo = originalClassType.GetMethod(originalFunctionName, MethodBindingFlags);
if (originalFunctionInfo == null)
{
throw new InvalidOperationException($"Could not find function '{originalFunctionName}' in class {originalClassType}!");
}
// Get the information about the target function
var targetFunctionInfo = targetClassType.GetMethod(targetFunctionName, MethodBindingFlags);
if (targetFunctionInfo == null)
{
throw new InvalidOperationException($"Could not find function '{targetFunctionName}' in class {targetClassType}!");
}
if (targetFunctionInfo.MethodImplementationFlags != MethodImplAttributes.NoInlining)
{
throw new InvalidOperationException($"The function {targetFunctionName} must be decorated with the NoInlining attribute.");
}
InitialiseDetour(originalFunctionInfo, targetFunctionInfo);
}
private static MemberInfo[] GetAndWrapMember(IReflect reflect, Object namedItem, String name, BindingFlags bindingAttr){
PropertyInfo property = reflect.GetProperty(name, bindingAttr);
if (property != null){
MethodInfo getMethod = JSProperty.GetGetMethod(property, false);
MethodInfo setMethod = JSProperty.GetSetMethod(property, false);
if ((getMethod != null && !getMethod.IsStatic) || (setMethod != null && !setMethod.IsStatic)){
MethodInfo method = reflect.GetMethod(name, bindingAttr);
if (method != null && !method.IsStatic){
MemberInfo[] propMethods = new MemberInfo[1];
propMethods[0] = new JSWrappedPropertyAndMethod(property, method, namedItem);
return propMethods;
}
}
}
MemberInfo[] members = reflect.GetMember(name, bindingAttr);
if (members != null && members.Length > 0)
return ScriptObject.WrapMembers(members, namedItem);
return null;
}
/// <summary>
/// An instance capable of detouring a method to call another method
/// </summary>
public MethodDetour(IReflect originalClass, string originalMethod, IReflect targetClass, string targetMethod)
{
if (originalClass is null || string.IsNullOrWhiteSpace(originalMethod) || targetClass is null || string.IsNullOrWhiteSpace(targetMethod))
{
throw new ArgumentException("One or more the parameters was invalid");
}
const BindingFlags bindingFlags = BindingFlags.FlattenHierarchy | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static;
var originalMethodInfo = originalClass.GetMethod(originalMethod, bindingFlags) ?? throw new MissingMethodException($"Failed to find the method {originalMethod} in the class {nameof(originalClass)}");
_originalMethodHandle = originalMethodInfo.MethodHandle;
var targetMethodInfo = targetClass.GetMethod(targetMethod, bindingFlags) ?? throw new MissingMethodException($"Failed to find the method {targetMethod} in the class {nameof(targetClass)}");
_targetMethodHandle = targetMethodInfo.MethodHandle;
PrepareDetour();
}
private static object InvokeMethod(IReflect type, object instance, string methodName, object[] @params, BindingFlags flags)
{
try
{
var method = type.GetMethod(methodName, flags);
if (method == null && instance != null)
{
method = instance.GetType().GetMethod(methodName, flags);
}
if (method == null)
{
throw new ArgumentException(string.Format("Type '{0}' does not have a method named '{1}'.", type, methodName));
}
return(method.Invoke(instance, @params));
}
catch (AmbiguousMatchException)
{
return(type.InvokeMember(methodName, flags | BindingFlags.InvokeMethod, null, instance, @params, null, null, null));
}
}
private static bool TryInvokeMethod(IReflect target, string name, bool ignoreCase, object[] args, out object result)
{
var flags = BindingFlags.InvokeMethod | BindingFlags.Public;
if (ignoreCase)
{
flags |= BindingFlags.IgnoreCase;
}
var method = target.GetMethod(name, flags);
if (method != null)
{
result = method.Invoke(target, flags, null, args, CultureInfo.InvariantCulture);
return(true);
}
result = null;
return(false);
}
//Use the below line to print out the finished sorted string
// Console.WriteLine(stringSorted);
//Method for running sorting-method by algoName and printing out time and words/millisecond
static int SortAndTime(string[] words, IReflect sortClassName)
{
//Finds the matching method name "Run" from the Class given as parameter sortClassName
var sortMethod = sortClassName?.GetMethod("Run", BindingFlags.Static | BindingFlags.Public);
//Start a stopwatch
var watch = Stopwatch.StartNew();
//Invoke the found sortingmethod (null because the class is static) with the string array as parameter (words)
sortMethod?.Invoke(null, new object[] { words });
//Stop stopwatch
watch.Stop();
Console.WriteLine($"Total time for {sortClassName} sorting the words is: {watch.ElapsedMilliseconds} milliseconds");
var wordsPerMilisecond = (int)(words.Length / watch.ElapsedMilliseconds);
Console.WriteLine($"The number of words per millisecond for {sortClassName} sorting the words is: {wordsPerMilisecond}");
return(wordsPerMilisecond);
}
private static MemberInfo[] GetAndWrapMember(IReflect reflect, object namedItem, string name, BindingFlags bindingAttr)
{
PropertyInfo property = reflect.GetProperty(name, bindingAttr);
if (property != null)
{
MethodInfo getMethod = JSProperty.GetGetMethod(property, false);
MethodInfo setMethod = JSProperty.GetSetMethod(property, false);
if (((getMethod != null) && !getMethod.IsStatic) || ((setMethod != null) && !setMethod.IsStatic))
{
MethodInfo method = reflect.GetMethod(name, bindingAttr);
if ((method != null) && !method.IsStatic)
{
return new MemberInfo[] { new JSWrappedPropertyAndMethod(property, method, namedItem) };
}
}
}
MemberInfo[] member = reflect.GetMember(name, bindingAttr);
if ((member != null) && (member.Length > 0))
{
return ScriptObject.WrapMembers(member, namedItem);
}
return null;
}
private static bool TryInvokeMethod(IReflect type, object instance, string methodName, object[] @params, BindingFlags flags, out object result)
{
try
{
var method = type.GetMethod(methodName, flags);
if (method == null && instance != null)
{
method = instance.GetType().GetMethod(methodName, flags);
}
if (method == null)
{
result = default;
return(false);
}
result = method.Invoke(instance, @params);
return(true);
}
catch (AmbiguousMatchException)
{
result = type.InvokeMember(methodName, flags | BindingFlags.InvokeMethod, null, instance, @params, null, null, null);
return(true);
}
}
private static object GetMethodExtended(
IReflect type,
string name,
bool staticMethod,
int parameterCount)
{
var haveMethodName = false;
BindingFlags flags = (staticMethod ? BindingFlags.Static :
BindingFlags.Instance) | BindingFlags.Public |
BindingFlags.NonPublic | BindingFlags.InvokeMethod;
foreach (var method in type.GetMethods(flags))
{
if (method.Name.Equals(name))
{
haveMethodName = true;
if (method.GetParameters().Length == parameterCount)
{
return(method);
}
}
}
return(haveMethodName ? type.GetMethod(name, flags) : null);
}
private static MemberInfo[] GetAndWrapMember(IReflect reflect, object namedItem, string name, BindingFlags bindingAttr)
{
PropertyInfo property = reflect.GetProperty(name, bindingAttr);
if (property != null)
{
MethodInfo getMethod = JSProperty.GetGetMethod(property, false);
MethodInfo setMethod = JSProperty.GetSetMethod(property, false);
if (((getMethod != null) && !getMethod.IsStatic) || ((setMethod != null) && !setMethod.IsStatic))
{
MethodInfo method = reflect.GetMethod(name, bindingAttr);
if ((method != null) && !method.IsStatic)
{
return(new MemberInfo[] { new JSWrappedPropertyAndMethod(property, method, namedItem) });
}
}
}
MemberInfo[] member = reflect.GetMember(name, bindingAttr);
if ((member != null) && (member.Length > 0))
{
return(ScriptObject.WrapMembers(member, namedItem));
}
return(null);
}
private static IEnumerable<Type> GetRegisteredEvents(IReflect proxyType, object proxy)
{
return (IEnumerable<Type>)proxyType
.GetMethod("RegisteredEvents", BindingFlags.Instance | BindingFlags.NonPublic)
.Invoke(proxy, new object[] { });
}
System.Reflection.MethodInfo IReflect.GetMethod(string name, System.Reflection.BindingFlags bindingAttr)
{
return(typeIReflectImplementation.GetMethod(name, bindingAttr));
}
MethodInfo?IReflect.GetMethod(string name, BindingFlags bindingAttr, Binder?binder, Type[] types, ParameterModifier[]?modifiers) => publicIReflect.GetMethod(name, bindingAttr, binder, types, modifiers);
private static MethodInfo GetMethod(string funcName, IReflect type)
{
return(type.GetMethod(funcName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance));
}
public static MethodInfo GetMethodFromTypeAndMethodName(this IReflect type, string methodName)
{
return(type.GetMethod(methodName,
BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic));
}
MethodInfo IReflect.GetMethod(string name, BindingFlags bindingAttr)
{
var ret = typeIReflectImplementation.GetMethod(name, bindingAttr);
return(ret);
}
/// <summary>
/// Runs the method.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="strMethod">The STR method.</param>
/// <param name="objInstance">The obj instance.</param>
/// <param name="objParams">The obj params.</param>
/// <param name="eFlags">The e flags.</param>
/// <returns></returns>
private static object RunMethod(IReflect type, string strMethod, object objInstance, object [] objParams, BindingFlags eFlags)
{
MethodInfo method;
try
{
if ((eFlags == InstanceBindingFlags) && (objInstance == null))
{
throw new ArgumentException("The reflection non-static object argument was invalid");
}
if ((eFlags == StaticBindingFlags) && (objInstance != null))
{
throw new ArgumentException("The reflection static object argument was invalid");
}
if ((objInstance != null) && (objInstance.GetType() != (Type)type) && (objInstance.GetType().BaseType != (Type)type))
{
throw new ArgumentException("The object instance was of type '" + objInstance.GetType() + "' for type '" + type + "'.");
}
if (string.IsNullOrEmpty(strMethod))
{
throw new ArgumentException("The reflection method argument was invalid");
}
method = type.GetMethod(strMethod, eFlags);
if (method == null)
{
throw new ArgumentException("There is no method '" + strMethod + "' for type '" + type + "'.");
}
var objRet = method.Invoke(objInstance, objParams);
return objRet;
}
catch (Exception exception)
{
Console.WriteLine(exception.Message);
throw;
}
}
private static object GetMethodExtended(
IReflect type,
string name,
bool staticMethod,
int parameterCount)
{
var haveMethodName = false;
BindingFlags flags = (staticMethod ? BindingFlags.Static :
BindingFlags.Instance) | BindingFlags.Public |
BindingFlags.NonPublic | BindingFlags.InvokeMethod;
foreach (var method in type.GetMethods(flags)) {
if (method.Name.Equals(name)) {
haveMethodName = true;
if (method.GetParameters().Length == parameterCount) {
return method;
}
}
}
return haveMethodName ? type.GetMethod(name, flags) : null;
}