Example #1
0
		private static object RunMethod(System.Type t, string methodName, object objInstance, BindingFlags eFlags, System.Type[] parameterDefinitions, object[] parameterValues)
		{
			foreach (MethodInfo m in t.GetMethods(eFlags))
			{
				if (m.Name == methodName && MethodMatchesParameterDefinitions(m, parameterDefinitions))
				{
					if (parameterDefinitions.Length == parameterValues.Length + 1)
					{
						throw new NotImplementedException("The case in which no args are passed to params parameter.");
					}
						// if only parameter is params arg, compiler collapses it. this re-expands it: 
					else if (parameterDefinitions[parameterDefinitions.Length - 1] != parameterValues[parameterValues.Length - 1].GetType())
					{
						Array unknownTypeArray = Array.CreateInstance(parameterValues[0].GetType(), parameterValues.Length);
						parameterValues.CopyTo(unknownTypeArray, 0);

						return m.Invoke(objInstance, new object[] { unknownTypeArray });
					}
					else
					{
						return m.Invoke(objInstance, parameterValues);
					}
					
				}
			}
			throw new ArgumentException("There is no method '" + methodName + "' for type '" + t.ToString() + "' which matched the parameter type list.");
		}
 private static void ProcessStaticMethodAttributes(System.Type type)
 {
   List<string> methodNames = (List<string>) null;
   List<RuntimeInitializeLoadType> loadTypes = (List<RuntimeInitializeLoadType>) null;
   MethodInfo[] methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
   for (int index = 0; index < methods.GetLength(0); ++index)
   {
     MethodInfo methodInfo = methods[index];
     if (Attribute.IsDefined((MemberInfo) methodInfo, typeof (RuntimeInitializeOnLoadMethodAttribute)))
     {
       RuntimeInitializeLoadType initializeLoadType = RuntimeInitializeLoadType.AfterSceneLoad;
       object[] customAttributes = methodInfo.GetCustomAttributes(typeof (RuntimeInitializeOnLoadMethodAttribute), false);
       if (customAttributes != null && customAttributes.Length > 0)
         initializeLoadType = ((RuntimeInitializeOnLoadMethodAttribute) customAttributes[0]).loadType;
       if (methodNames == null)
       {
         methodNames = new List<string>();
         loadTypes = new List<RuntimeInitializeLoadType>();
       }
       methodNames.Add(methodInfo.Name);
       loadTypes.Add(initializeLoadType);
     }
     if (Attribute.IsDefined((MemberInfo) methodInfo, typeof (InitializeOnLoadMethodAttribute)))
       methodInfo.Invoke((object) null, (object[]) null);
   }
   if (methodNames == null)
     return;
   EditorAssemblies.StoreRuntimeInitializeClassInfo(type, methodNames, loadTypes);
 }
Example #3
0
 /// <summary>
 ///  Finds all Extension methods defined by a type
 /// </summary>
 /// <param name="extending_type"></param>
 /// <returns></returns>
 public static IEnumerable<ExtensionMethodRecord> EnumExtensionMethods(System.Type extending_type)
 {
     var ext_methods = extending_type.GetMethods().Where(IsExtensionMethod).ToList();
     foreach (var ext_method in ext_methods)
     {
         var first_param = ext_method.GetParameters()[0];
         var extended_type = first_param.ParameterType;
         var rec = new ExtensionMethodRecord(extending_type, extended_type, ext_method);
         yield return rec;
     }
 }
 private static MethodInfo[] GetMethods(System.Type type)
 {
     MethodInfo[] methods = type.GetMethods(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance);
     List<MethodInfo> list = new List<MethodInfo>();
     foreach (MethodInfo info in methods)
     {
         if (((info.GetBaseDefinition().DeclaringType != typeof(object)) & !info.IsSpecialName) && !info.IsAbstract)
         {
             list.Add(info);
         }
     }
     return list.ToArray();
 }
        /// <summary>
        /// Overrides all methods in the given interface type with methods that throw a <see cref="NotImplementedException"/>.
        /// </summary>
        /// <param name="interfaceType">The interface type that will be implemented by the target type.</param>
        /// <param name="type">The target type.</param>
        /// <returns>The list of stubbed methods.</returns>
        private static IEnumerable<MethodDefinition> CreateInterfaceStub(System.Type interfaceType, TypeDefinition type)
        {
            var module = type.Module;
            var overrider = new MethodOverrider();
            var methods = interfaceType.GetMethods();
            var stubbedMethods = new List<MethodDefinition>();
            foreach (var method in methods)
            {
                var newMethod = CreateMethodStub(type, module, overrider, method);
                stubbedMethods.Add(newMethod);
            }

            return stubbedMethods;
        }
Example #6
0
        public static IEnumerable<System.Type> GetTypeInterfaceGenericArguments(System.Type type, System.Type interfaceType)
        {
            System.Type[] arguments = interfaceType.GetGenericArguments();

            if (arguments != null)
            {
                return arguments;
            }

            if (interfaceType == typeof(ICollection<>))
            {
                return type.GetMethods(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance).
                    Where(methodInfo => methodInfo.Name == "Add" && methodInfo.ParameterTypes.Length == 1).First().ParameterTypes;
            }

            if (interfaceType == typeof(IDictionary<,>))
            {
                return type.GetMethods(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance).
                    Where(methodInfo => methodInfo.Name == "Add" && methodInfo.ParameterTypes.Length == 2).First().ParameterTypes;
            }

            throw new Granular.Exception("Can't get generic arguments for type \"{0}\" interface \"{1}\"", type.Name, interfaceType.Name);
        }
Example #7
0
 internal void AddOperationsFromType(System.Type type)
 {
     foreach (MethodInfo info in type.GetMethods(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance))
     {
         if (info.GetCustomAttributes(typeof(WebGetAttribute), true).Length != 0)
         {
             this.AddServiceOperation(info, "GET");
         }
         else if (info.GetCustomAttributes(typeof(WebInvokeAttribute), true).Length != 0)
         {
             this.AddServiceOperation(info, "POST");
         }
     }
 }
        public static object CallMethod(object target, System.Type type, string methodCMD)
        {
            string method_str = "";
            string parasCMD = "";
            object[] paras = null;

            method_str = methodCMD.Substring(0,methodCMD.IndexOf("("));
            parasCMD =  methodCMD.Substring(methodCMD.IndexOf("("), methodCMD.Length - methodCMD.IndexOf("("));
            parasCMD = parasCMD.Substring( 1, parasCMD.Length - 2);
            if(!parasCMD .Equals( "" )){
                if(parasCMD.Contains(",")){
                    string[] strParas = parasCMD.Split(',');
                    paras = new object[strParas.Length];
                    for (int pos = 0; pos < strParas.Length; pos++) {
                        //  TODO loop in strParas
            //					paras[pos] = int.Parse( strParas[pos] );
            //					if(strParas[pos].Contains("\"")){
            //						paras.SetValue(parasCMD.Replace("\"",""),pos);
            //					}
            //
            //					else
            //						paras.SetValue(int.Parse(strParas[pos]),pos);
                        paras.SetValue(GetParaFromString(strParas[pos]),pos);
                    }
                }else{
                    paras = new object[1];
                    paras.SetValue(GetParaFromString(parasCMD),0);

            //				if(parasCMD.Contains("\"")){
            //					parasCMD = parasCMD.Replace("\"","");
            //					paras.SetValue(parasCMD,0);
            ////					paras.SetValue(parasCMD,0);
            //				}
            //				else
            //					paras.SetValue(int.Parse(parasCMD),0);
            //				paras[0] = int.Parse( parasCMD );
                }
            }
            MethodInfo[] thods = type.GetMethods();

            //		MethodInfo method = type.GetMethod(method_str,System.Reflection.BindingFlags.);
            MethodInfo method = type.GetMethod(method_str);
            if( null == method){
                XLogger.Log(target + " not have a " + method_str + " method." );
                return null;
            }
            object returnValue = method.Invoke(target,paras);
            return returnValue;
        }
	protected object GetBusinessObject(string name, System.Type type, params object[] parameters)
	{
		object businessObjects = Session[name];
		if (businessObjects == null || (!object.ReferenceEquals(businessObjects.GetType(), type)) )
		{
			foreach (MethodInfo method in type.GetMethods())        // Looking for a method which returns Business Object of type pased in parm
			{   
				if (object.ReferenceEquals(method.ReturnType, type) && !method.IsConstructor && method.IsStatic)
				{
					bool methodMatch = false;                       // Check if parameters match.
					ParameterInfo[] methodParameters = method.GetParameters();
					if (parameters == null)                         //    no parameters
					{
						methodMatch = methodParameters.Length == 0;
					}
					else if (parameters.Length == methodParameters.Length)
					{
						methodMatch = true;                         //    compare parameters.
						for (int i = 0; i <= parameters.Length - 1; i++)
						{
							if (parameters[i] == null)
							{
								methodMatch = methodMatch && methodParameters[i].IsOptional;
							}
							else
							{
								methodMatch = methodMatch && object.ReferenceEquals(parameters[i].GetType(), methodParameters[i].ParameterType);
							}
						}
					}
					if (methodMatch)                                // Execute it, if found. It will return Business Object with data. Save it in Session storage
					{
						try
						{
							businessObjects = method.Invoke(null, parameters);
						}
						catch
						{
						}
						Session[name] = businessObjects;            // Save in Session storage
						break; 
					}
				}
			}
		}
		return businessObjects;
	}
Example #10
0
    private static void ConnectDefaultHandlers(GType gtype, System.Type t)
    {
        foreach (MethodInfo minfo in t.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.DeclaredOnly)) {
            MethodInfo baseinfo = minfo.GetBaseDefinition ();
            if (baseinfo == minfo)
                continue;

            foreach (object attr in baseinfo.GetCustomAttributes (typeof (DefaultSignalHandlerAttribute), false)) {
                DefaultSignalHandlerAttribute sigattr = attr as DefaultSignalHandlerAttribute;
                MethodInfo connector = sigattr.Type.GetMethod (sigattr.ConnectionMethod, BindingFlags.Static | BindingFlags.NonPublic, null, new Type[] { typeof (GType) }, new ParameterModifier [0]);
                object[] parms = new object [1];
                parms [0] = gtype;
                connector.Invoke (null, parms);
                break;
            }
        }
    }
Example #11
0
		private ContainerRowModel CreateTypeTree(System.Type type)
		{
			var children = new List<RowModel>();
			object[] attrs;
			Attribute attr;
			BindingFlags flags = BindingFlags.Static | BindingFlags.Public;
			Lazy<object> instance = null;
			if (IsConstructable(type)) {
				flags |= BindingFlags.Instance;
				instance = new Lazy<object>(() => Activator.CreateInstance(type), LazyThreadSafetyMode.ExecutionAndPublication);
			}

			foreach (MethodInfo method in type.GetMethods(flags).Where(m => IsTestMethod(m, true, true, true)))
			{
				// Create a row for this method
				attrs = method.GetCustomAttributes(true);
				attr = FindAttribute(attrs, "TestAttribute") ?? FindAttribute(attrs, "BenchmarkAttribute");
				var eea = FindAttribute(attrs, "ExpectedExceptionAttribute");
				bool isTestSet = method.IsStatic && MayBeTestSuite(method.ReturnType) && IsTestMethod(method, true, true, false);
				var utt = new UnitTestTask(method, instance, attr, eea, isTestSet);
				var row = new TaskRowModel(method.Name, TestNodeType.Test, utt, true);
				
				if (IsTestMethod(method, false, false, true)) // benchmark?
					row.BasePriority--; // Give benchmarks low priority by default

				children.Add(row);
			}

			foreach (Type nested in type.GetNestedTypes().Where(IsTestFixtureOrSuite))
				children.Add(CreateTypeTree(nested));
			
			// Create a row for this type
			var result = new ContainerRowModel(type.Name, TestNodeType.TestFixture, children);
			result.SetSummary(type.FullName);
			attrs = type.GetCustomAttributes(true);
			attr = FindAttribute(attrs, "TestFixtureAttribute");
			string description = GetPropertyValue<string>(attr, "Description", null);
			if (description != null)
				result.SetSummary(string.Format("{0} ({1})", description, type.FullName));
			return result;
		}
        internal static IEnumerable<System.Reflection.MethodInfo> GetCommandMethods(System.Type mytype)
        {
            var cmdsettype = typeof(VA.Scripting.CommandSet);

            if (!cmdsettype.IsAssignableFrom(mytype))
            {
                string msg = string.Format("{0} must derive from {1}", mytype.Name, cmdsettype.Name);
            }

            var methods = mytype.GetMethods().Where(m => m.IsPublic && !m.IsStatic);

            foreach (var method in methods)
            {
                if (method.Name == "ToString" || method.Name == "GetHashCode" || method.Name == "GetType" || method.Name == "Equals")
                {
                    continue;
                }

                yield return method;
            }
        }
        internal static IEnumerable<Command> GetCommands(System.Type mytype)
        {
            var cmdsettype = typeof(CommandSet);

            if (!cmdsettype.IsAssignableFrom(mytype))
            {
                string msg = $"{mytype.Name} must derive from {cmdsettype.Name}";
            }

            var methods = mytype.GetMethods().Where(m => m.IsPublic && !m.IsStatic);

            foreach (var method in methods)
            {
                if (method.Name == "ToString" || method.Name == "GetHashCode" || method.Name == "GetType" || method.Name == "Equals")
                {
                    continue;
                }

                var cmd = new Command(method);
                yield return cmd;
            }
        }
		/// <summary>
		/// 得到一个类型中,所有标记为ControllerMethod的方法
		/// </summary>
		/// <param name="type"></param>
		/// <returns></returns>
		private static ControllerInfo FindControllerMethods(System.Type type)
		{
			MethodInfo[] mis = type.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);

			List<ControllerMethodInfo> methodList = new List<ControllerMethodInfo>();
			MethodInfo defaultMethod = null;

			foreach (MethodInfo mi in mis)
			{
				ControllerMethodAttribute cma = AttributeHelper.GetCustomAttribute<ControllerMethodAttribute>(mi);

				if (cma != null)
				{
					ControllerMethodInfo cmi = new ControllerMethodInfo(mi, cma.ForceIgnoreParameters);

					methodList.Add(cmi);

					if (defaultMethod == null && cma.Default)
						defaultMethod = mi;
				}
			}

			return new ControllerInfo(methodList.ToArray(), defaultMethod);
		}
Example #15
0
        /// <summary>
        /// Get public MethodInfos in a type.
        /// <param name="type">The type of the target object to get the methods.</param>
        /// <param name="staticMethods">If True returns only static members; otherwise returns instance members.</param>
        /// <returns>Public methods in a type.</returns>
        /// </summary>
        public static MethodInfo[] GetPublicMembers (System.Type type, bool staticMethods) {
            List<MethodInfo> methodInfos = new List<MethodInfo>();
            BindingFlags bindingFlags = staticMethods ? BindingFlags.Public | BindingFlags.Static : BindingFlags.Public | BindingFlags.Instance;

            foreach (MethodInfo method in type.GetMethods(bindingFlags)) {
                Type returnType = method.ReturnParameter.ParameterType;
                
                if (returnType == typeof(void) || FunctionUtility.IsSupported(returnType)) {
                    bool validParameters = true;

                    foreach (ParameterInfo parameter in method.GetParameters()) {
                        if (!FunctionUtility.IsSupported(parameter.ParameterType)) {
                            validParameters = false;
                            break;
                        }
                    }
                    
                    if (validParameters)
                        methodInfos.Add(method);
                }
            }

            return methodInfos.ToArray();
        }
Example #16
0
        public NodeMigrationData MigrateXmlNode(WorkspaceModel homespace, XmlNode elNode, System.Type type, Version workspaceVersion)
        {
            var migrations = (from method in type.GetMethods()
                              let attribute =
                                  method.GetCustomAttributes(false).OfType<NodeMigrationAttribute>().FirstOrDefault()
                              where attribute != null
                              let result = new { method, attribute.From, attribute.To }
                              orderby result.From
                              select result).ToList();

            var currentVersion = MigrationManager.VersionFromWorkspace(homespace);

            XmlElement nodeToMigrate = elNode as XmlElement;
            NodeMigrationData migrationData = new NodeMigrationData(elNode.OwnerDocument);
            migrationData.AppendNode(elNode as XmlElement);

            while (workspaceVersion != null && workspaceVersion < currentVersion)
            {
                var nextMigration = migrations.FirstOrDefault(x => x.From >= workspaceVersion);

                if (nextMigration == null)
                    break;

                object ret = nextMigration.method.Invoke(this, new object[] { migrationData });
                migrationData = ret as NodeMigrationData;

                if(DynamoModel.EnableMigrationLogging)
                {
                    // record migration data for successful migrations
                    migrationReport.AddMigrationDataToNodeMap(nodeToMigrate.Name, migrationData.MigratedNodes);
                }
                workspaceVersion = nextMigration.To;
            }

            return migrationData;
        }
Example #17
0
	private IEnumerable<MethodInfo> GetProxiableMethods(System.Type type, IEnumerable<System.Type> interfaces)
	{
		const BindingFlags candidateMethodsBindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
		return 
			type.GetMethods(candidateMethodsBindingFlags)
				.Where(method=> method.IsProxiable())
				.Concat(interfaces.SelectMany(interfaceType => interfaceType.GetMethods())).Distinct();
	}
Example #18
0
		public static Hashtable GetMethodsByAttribute(System.Type parentType, System.Type attributeType)
		{
			try
			{
				var retval = new Hashtable();
				var methods = parentType.GetMethods();
				foreach (var m in methods)
				{
					var attributes = m.GetCustomAttributes(attributeType, true);
					if (attributes.Length > 0)
					{
						retval.Add(attributes[0], m);
					}
				}

				//Sort the array

				return retval;
			}
			catch (Exception ex)
			{
				throw;
			}
		}
		private MethodInfo FindMethodForType(CallSite site, System.Type otype, string name, bool isStatic, object[] args, out object[] outArgs)
		{
			BindingFlags bindingFlags = isStatic ? BindingFlags.Static | BindingFlags.FlattenHierarchy : BindingFlags.Instance;
			var methods = otype.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | bindingFlags);
			var len = methods.Length;
			for (var mi = 0; mi < len; mi++) {
				var m = methods[mi];
				if ((m.IsStatic == isStatic) && m.Name == name) {
					// attempt to convert method parameters
					if (Dynamic.ConvertMethodParameters(m, args, out outArgs)) {
						return m;
					}
				}
			}

			// method not found
			outArgs = null;
			return null;
		}
        /// throws an exception if the current user does not have enough permission to access the method;
        /// this uses a custom attribute associated with the method of the connector
        static public bool CheckUserPermissionsForMethod(System.Type AConnectorType, string AMethodName, string AParameterTypes, Int32 ALedgerNumber)
        {
            MethodInfo[] methods = AConnectorType.GetMethods();

            MethodInfo MethodToTest = null;
            AParameterTypes = AParameterTypes.Replace("[]", ".ARRAY");

            foreach (MethodInfo method in methods)
            {
                if (method.Name == AMethodName)
                {
                    string ParameterTypes = ";";
                    ParameterInfo[] Parameters = method.GetParameters();

                    foreach (ParameterInfo Parameter in Parameters)
                    {
                        string ParameterName = Parameter.ParameterType.ToString().Replace("&", "");

                        ParameterName = ParameterName.Replace("System.Collections.Generic.Dictionary`2", "DICTIONARY");
                        ParameterName = ParameterName.Replace("Ict.Common.", string.Empty);
                        ParameterName = ParameterName.Replace("Ict.Petra.Shared.MCommon.", string.Empty);
                        ParameterName = ParameterName.Replace("System.", string.Empty);

                        if (ParameterName.Contains("."))
                        {
                            ParameterName = ParameterName.Substring(ParameterName.LastIndexOf(".") + 1);
                        }

                        ParameterName = ParameterName.Replace("`1", string.Empty);
                        ParameterName = ParameterName.Replace("`2", string.Empty);
                        ParameterName = ParameterName.Replace("Boolean", "bool");
                        ParameterName = ParameterName.Replace("Int32", "int");
                        ParameterName = ParameterName.Replace("Int64", "long");
                        ParameterName = ParameterName.Replace("[]", ".Array");

                        ParameterTypes += ParameterName + ";";
                    }

                    ParameterTypes = ParameterTypes.ToUpper();

                    if (ParameterTypes == AParameterTypes)
                    {
                        MethodToTest = method;
                        break;
                    }
                }
            }

            if (MethodToTest != null)
            {
                System.Object[] attributes = MethodToTest.GetCustomAttributes(typeof(RequireModulePermissionAttribute), false);

                if ((attributes != null) && (attributes.Length > 0))
                {
                    RequireModulePermissionAttribute requiredModules = (RequireModulePermissionAttribute)attributes[0];

                    string moduleExpression = requiredModules.RequiredModulesExpression.ToUpper();

                    if (moduleExpression == "NONE")
                    {
                        return true;
                    }

                    try
                    {
                        CheckUserModulePermissions(moduleExpression);

                        if (ALedgerNumber != -1)
                        {
                            CheckUserModulePermissions(LEDGER_MODULESTRING + ALedgerNumber.ToString("0000"));
                        }
                    }
                    catch (ESecurityModuleAccessDeniedException Exc)
                    {
                        string msg =
                            String.Format(Catalog.GetString(
                                    "Module access permission was violated for method '{0}' in Connector class '{1}':  Required Module access permission: {2}, UserName: {3}"),
                                AMethodName, AConnectorType, Exc.Module, Exc.UserName);
                        TLogging.Log(msg);

                        Exc.Context = AMethodName + " [raised by ModuleAccessManager]";

                        throw;
                    }
                    catch (ArgumentException argException)
                    {
                        throw new EOPAppException("Problem with ModulePermissions, " +
                            argException.Message + ": '" +
                            moduleExpression + "' for " +
                            AConnectorType.ToString() + "." +
                            AMethodName + "()", argException);
                    }

                    return true;
                }
            }

            // TODO: resolve module permission from namespace?

            throw new EOPAppException(
                "Missing definition of access permission for method " + AMethodName + " in Connector class " + AConnectorType);
        }
Example #21
0
        /// <summary> Derive a ranking based on how "natural" the conversion is.
        /// The special value CONVERSION_NONE means no conversion is possible,
        /// and CONVERSION_NONTRIVIAL signals that more type conformance testing
        /// is required.
        /// Based on
        /// <a href="http://www.mozilla.org/js/liveconnect/lc3_method_overloading.html">
        /// "preferred method conversions" from Live Connect 3</a>
        /// </summary>
        internal static int GetConversionWeight(System.Object fromObj, System.Type to)
        {
            int fromCode = GetJSTypeCode (fromObj);

            switch (fromCode) {
                case JSTYPE_UNDEFINED:
                    if (to == typeof (string) || to == typeof (object)) {
                        return 1;
                    }
                    break;
                case JSTYPE_NULL:
                    if (!to.IsPrimitive) {
                        return 1;
                    }
                    break;
                case JSTYPE_BOOLEAN:
                    if (to == typeof (bool)) {
                        return 1;
                    }
                    else if (to == typeof (object)) {
                        return 2;
                    }
                    else if (to == typeof (string)) {
                        return 3;
                    }
                    break;

                case JSTYPE_NUMBER:
                    if (to.IsPrimitive) {
                        if (to == typeof (double)) {
                            return 1;
                        }
                        else if (to != typeof (bool)) {
                            return 1 + GetSizeRank (to);
                        }
                    }
                    else {
                        if (to == typeof (string)) {
                            // native numbers are #1-8
                            return 9;
                        }
                        else if (to == typeof (object)) {
                            return 10;
                        }
                        else if (CliHelper.IsNumberType (to)) {
                            // "double" is #1
                            return 2;
                        }
                    }
                    break;

                case JSTYPE_STRING:
                    if (to == typeof (string)) {
                        return 1;
                    }
                    else if (to.IsInstanceOfType (fromObj)) {
                        return 2;
                    }
                    else if (to.IsPrimitive) {
                        if (to == typeof (char)) {
                            return 3;
                        }
                        else if (to != typeof (bool)) {
                            return 4;
                        }
                    }
                    break;

                case JSTYPE_CLI_CLASS:
                    if (to == typeof (Type)) {
                        return 1;
                    }
                    else if (to == typeof (object)) {
                        return 3;
                    }
                    else if (to == typeof (string)) {
                        return 4;
                    }
                    break;

                case JSTYPE_CLI_OBJECT:
                case JSTYPE_CLI_ARRAY:
                    object cliObj = fromObj;
                    if (cliObj is Wrapper) {
                        cliObj = ((Wrapper)cliObj).Unwrap ();
                    }
                    if (to.IsInstanceOfType (cliObj)) {
                        return CONVERSION_NONTRIVIAL;
                    }
                    if (to == typeof (string)) {
                        return 2;
                    }
                    else if (to.IsPrimitive && to != typeof (bool)) {
                        return (fromCode == JSTYPE_CLI_ARRAY) ? CONVERSION_NONTRIVIAL : 2 + GetSizeRank (to);
                    }
                    break;

                case JSTYPE_OBJECT:
                    // Other objects takes #1-#3 spots
                    if (to == fromObj.GetType ()) {
                        // No conversion required
                        return 1;
                    }
                    if (to.IsArray) {
                        if (fromObj is BuiltinArray) {
                            // This is a native array conversion to a java array
                            // Array conversions are all equal, and preferable to object
                            // and string conversion, per LC3.
                            return 1;
                        }
                    }
                    else if (to == typeof (object)) {
                        return 2;
                    }
                    else if (to == typeof (string)) {
                        return 3;
                    }
                    else if (to == typeof (DateTime)) {
                        if (fromObj is BuiltinDate) {
                            // This is a native date to java date conversion
                            return 1;
                        }
                    }
                    else if (to.IsInterface) {
                        if (fromObj is IFunction) {
                            // See comments in coerceType
                            if (to.GetMethods ().Length == 1) {
                                return 1;
                            }
                        }
                        return 11;
                    }
                    else if (to.IsPrimitive && to != typeof (bool)) {
                        return 3 + GetSizeRank (to);
                    }
                    break;
            }

            return CONVERSION_NONE;
        }
Example #22
0
        /// <summary>
        /// Map the Java members of the specified
        /// class to my slots for reflection.
        /// </summary>
        private void finishSlots(System.Type type, bool staticOnly)
        {
            // map the class's fields to my slots
              FieldInfo[] fields = type.GetFields();
              for (int i=0; i<fields.Length; i++)
            finishField(fields[i]);

              // map the class's methods to my slots
              MethodInfo[] methods = type.GetMethods();
              for (int i=0; i<methods.Length; i++)
            finishMethod(methods[i], staticOnly);
        }
Example #23
0
	public static void DisposMethods(System.Type type,Dictionary<string,ClassMethodInfo> cmfDict){
        BindingFlags options = BindingFlags | BindingFlags.Instance | BindingFlags.FlattenHierarchy;
        MethodInfo[] infoArray = type.GetMethods(options);

		foreach(MethodInfo info in infoArray){
			if(info.IsGenericMethod) continue;			
			if(info.Name.IndexOf('_') > 0 ) continue;
			string key = type.Namespace +"." + type.Name +"."+ info.Name;
			ClassMethodInfo cmf = !cmfDict.ContainsKey(key)?  new ClassMethodInfo() :cmfDict[key];
			cmf.fullName =  key;
			cmf.className = type.Name;
			cmf.name = 	info.Name;
			cmf.returnName = info.ReturnType.Name;
			cmf.isStatic = info.IsStatic;
			cmfDict[key] = cmf;
            cmf.overrideList.Add(DisposMethodArgs( info.GetParameters() ) );
		}
	}
Example #24
0
	/// <summary> Retrieves public methods for a class. In case the class is not
	/// public, retrieves methods with same signature as its public methods
	/// from public superclasses and interfaces (if they exist). Basically
	/// upcasts every method to the nearest acccessible method.
	/// </summary>
	private static System.Reflection.MethodInfo[] getAccessibleMethods(System.Type clazz) {
	    System.Reflection.MethodInfo[] methods = clazz.GetMethods();


	    // TODO:  the rest of this method is trying to determine what is supposed to be callable - I think .Net just returns what is callable
	    return methods;

	    /*
	    *  Short circuit for the (hopefully) majority of cases where the
	    *  clazz is public
	    */

	    //UPGRADE_TODO: Method java.lang.reflect.Modifier.isPublic was not converted. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1095"'
	    //UPGRADE_ISSUE: Method 'java.lang.Class.getModifiers' was not converted. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1000_javalangClassgetModifiers"'
	    if (clazz.IsPublic) {
		return methods;
	    }

	    /*
	    *  No luck - the class is not public, so we're going the longer way.
	    */

	    MethodInfo[] methodInfos = new MethodInfo[methods.Length];

	    for (int i = methods.Length; i-- > 0; ) {
		methodInfos[i] = new MethodInfo(methods[i]);
	    }

	    int upcastCount = getAccessibleMethods(clazz, methodInfos, 0);

	    /*
	    *  Reallocate array in case some method had no accessible counterpart.
	    */

	    if (upcastCount < methods.Length) {
		methods = new System.Reflection.MethodInfo[upcastCount];
	    }

	    int j = 0;
	    for (int i = 0; i < methodInfos.Length; ++i) {
		MethodInfo methodInfo = methodInfos[i];
		if (methodInfo.upcast) {
		    methods[j++] = methodInfo.method;
		}
	    }
	    return methods;
	}
		public CellFactoryInvokerClass (System.Type aType, CellFactoryProviderAttribute aAttr)
		{
			factoryType = aType;
			factoryProvider = aAttr;

			if (ShellMethod == null)
				ShellMethod = this.GetType().GetMethod ("Invoke");
			if (ShellMethodParameters == null)
				ShellMethodParameters = ShellMethod.GetParameters();
			
			MethodInfo[] methods = aType.GetMethods();
			foreach (MethodInfo method in methods) {
				if ((method.IsStatic == true) && (method.Name == aAttr.MethodName)) {
					ParameterInfo[] parms = method.GetParameters();
					if (method.ReturnType != ShellMethod.ReturnType)
						continue;
					if (ShellMethodParameters.Length == parms.Length) {
						for (int i=0; i<ShellMethodParameters.Length; i++)
							if (ShellMethodParameters[i].ParameterType != parms[i].ParameterType)
								continue;
					}
					factoryMethod = method;
				}
			}
			if (factoryMethod == null)
				throw new Exception ("Class doesn't support factory method");
		}
 private static MethodInfo[] GetIntroducedMethods(System.Type type, ref string[] methodAttributes)
 {
     BindingFlags bindingAttr = BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly;
     MethodInfo[] methods = type.GetMethods(bindingAttr);
     if (!type.IsInterface)
     {
         methodAttributes = new string[methods.Length];
         FindMethodAttributes(type, methods, ref methodAttributes, bindingAttr);
         ArrayList list = new ArrayList();
         foreach (System.Type type2 in type.GetInterfaces())
         {
             foreach (MethodInfo info in type.GetInterfaceMap(type2).TargetMethods)
             {
                 if (!info.IsPublic && (type.GetMethod(info.Name, bindingAttr | BindingFlags.NonPublic) != null))
                 {
                     list.Add(info);
                 }
             }
         }
         MethodInfo[] infoArray2 = null;
         if (list.Count > 0)
         {
             infoArray2 = new MethodInfo[methods.Length + list.Count];
             for (int i = 0; i < methods.Length; i++)
             {
                 infoArray2[i] = methods[i];
             }
             for (int j = 0; j < list.Count; j++)
             {
                 infoArray2[methods.Length + j] = (MethodInfo) list[j];
             }
             return infoArray2;
         }
     }
     return methods;
 }
Example #27
0
	private static MethodInfo getMethod( System.Type type, string name, System.Type[] paramTypes )
	{

		// NOTE: There is a bug in Unity 4.3.3+ on Windows Phone that causes all reflection 
		// method overloads that take a BindingFlags parameter to throw a runtime exception.
		// This means that we cannot have 100% compatibility between Unity 4.3.3 and prior
		// versions on the Windows Phone platform, and that some functionality 
		// will unfortunately be lost.

#if UNITY_EDITOR || !UNITY_WP8

		var method = type.GetMethod(
			name,
			BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance,
			null,
			paramTypes,
			null
		);

		return method;

#else

			var methods = type.GetMethods();
			for( int i = 0; i < methods.Length; i++ )
			{

				var info = methods[ i ];
				if( info.IsStatic || info.Name != name )
					continue;

				if( matchesParameterTypes( info, paramTypes ) )
					return info;

			}

			return null;

#endif

	}
	// Attempt to find a method methodName matching the parameters given. If none is found, try to pass the entire string to a method methodName.
	// If neither of those things work, or no parameters are given, try to call a parameterless version of methodName. If none is found, either
	// methodName has no overload matching parameters given or methodName does not exist.
	// Returns: boolean indicating whether or not the command was handled here (true, if a method with the correct name was found, regardless of other failures).
	public static bool CallMethod(System.Type targetClass, string methodName, string parameters) {
		MethodInfo[] targetMethods = targetClass.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.InvokeMethod | BindingFlags.FlattenHierarchy);
		MethodInfo[] targetInstancedMethods = new MethodInfo[0];
		object main = GetMainOfClass(targetClass);
		if(main != null) {
			targetInstancedMethods = targetClass.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod | BindingFlags.FlattenHierarchy);
		}
		if(parameters != null && parameters.Length != 0) {
			// Try to find a static method matching name and parameters
			if(CallMethodMatchingParameters(null, methodName, targetMethods, parameters.SplitUnlessInContainer(' ', '\"'))) {
				return true;
			}
			// Try to find an instanced method matching name and parameters if a main object to invoke on exists
			if(main != null) {
				if(CallMethodMatchingParameters(main, methodName, targetInstancedMethods, parameters.SplitUnlessInContainer(' ', '\"'))) {
					return true;
				}
			}
			// Try to find a static method matching name with one string parameter
			MethodInfo targetMethod = targetClass.GetMethod(methodName, BindingFlags.Static | BindingFlags.Public | BindingFlags.InvokeMethod | BindingFlags.FlattenHierarchy, null, new System.Type[] { typeof(string) }, null);
			if(targetMethod != null && IsAccessible(targetMethod)) {
				if(IsCheat(targetMethod) && !cheats) {
					PrintCheatMessage(targetMethod.Name);
				} else {
					InvokeAndEchoResult(targetMethod, null, new string[] { ParseParameterListIntoType("String", parameters.SplitUnlessInContainer(' ', '\"')).ToString() });
				}
				return true;
			}
			// Try to find a method matching name with one string parameter if a main object to invoke on exists
			if(main != null) {
				MethodInfo targetInstancedMethod = targetClass.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod | BindingFlags.FlattenHierarchy, null, new System.Type[] { typeof(string) }, null);
				if(targetInstancedMethod != null && IsAccessible(targetInstancedMethod)) {
					if(IsCheat(targetInstancedMethod) && !cheats) {
						PrintCheatMessage(targetInstancedMethod.Name);
					} else {
						InvokeAndEchoResult(targetInstancedMethod, main, new string[] { ParseParameterListIntoType("String", parameters.SplitUnlessInContainer(' ', '\"')).ToString() });
					}
					return true;
				}
			}
		}
		// Try to find a static parameterless method matching name
		MethodInfo targetParameterlessMethod = targetClass.GetMethod(methodName, BindingFlags.Static | BindingFlags.Public | BindingFlags.InvokeMethod | BindingFlags.FlattenHierarchy, null, new System.Type[] { }, null);
		if(targetParameterlessMethod != null && IsAccessible(targetParameterlessMethod)) {
			if(IsCheat(targetParameterlessMethod) && !cheats) {
				PrintCheatMessage(targetParameterlessMethod.Name);
			} else {
				InvokeAndEchoResult(targetParameterlessMethod, null, new object[] { });
			}
			return true;
		}
		// Try to find a parameterless method matching name if a main object to invoke on exists
		if(main != null) {
			MethodInfo targetInstancedParameterlessMethod = targetClass.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod | BindingFlags.FlattenHierarchy, null, new System.Type[] { }, null);
			if(targetInstancedParameterlessMethod != null && IsAccessible(targetInstancedParameterlessMethod)) {
				if(IsCheat(targetInstancedParameterlessMethod) && !cheats) {
					PrintCheatMessage(targetInstancedParameterlessMethod.Name);
				} else {
					InvokeAndEchoResult(targetInstancedParameterlessMethod, main, new object[] { });
				}
				return true;
			}
		}
		// At this point no method will be invoked. Print an error message based on what has happened.
		if(targetMethods.Length > 0 || targetInstancedMethods.Length > 0) {
			bool methodWithRightNameFound = false;
			foreach(MethodInfo methodInfo in targetMethods) {
				if(methodInfo.Name == methodName && IsAccessible(methodInfo)) { methodWithRightNameFound = true; break; }
			}
			if(!methodWithRightNameFound) {
				foreach(MethodInfo methodInfo in targetInstancedMethods) {
					if(methodInfo.Name == methodName && IsAccessible(methodInfo)) { methodWithRightNameFound = true; break; }
				}
			}
			if(methodWithRightNameFound) {
				if(parameters != null && parameters.Length != 0) {
					Echo("No method "+methodName+" matching the parameters provided could be found.");
				} else {
					Echo("No method "+methodName+" taking no parameters could be found. Provide some parameters!");
				}
				// In either case, the error message is handled here, so return true;
				return true;
			}
		}
		// No method matched this command, therefore indicate a failure
		return false;
	}
Example #29
0
    /// <summary>
    /// 	- Gets the methods of a type.
    /// </summary>
    /// <returns>
    /// 	- A list of methods accessible from this type.
    /// </returns>
    /// <param name='type'>
    /// 	- The type to get the methods of.
    /// </param>
    /// <param name='includeInfo'>
    /// 	- Whether or not to include each method's method info in the list.
    /// </param>
    public static string MethodsOfType(System.Type type, bool includeInfo = false)
    {
        string methods = "";
        MethodInfo[] methodInfos = type.GetMethods();
        for(var i = 0; i < methodInfos.Length; i++){
            if(includeInfo){
                methods += methodInfos[i]+"\n";
            }

            else{
                methods += methodInfos[i].Name+"\n";
            }
        }

        return (methods);
    }
 protected override void InvokeEqualsMethod(System.Type type, string[] parameters)
 {
     var method = type.GetMethods().First(m => m.Name == this.areEqual && m.GetParameters().Count() == 2);
     method.Invoke(null, parameters);
 }