public static void AddQueryModelBinders(System.Reflection.Assembly assembly, IKernel kernel) { var queryTypes = assembly.GetExportedTypes() .Where(t => typeof(RaffleLib.Domain.Queries.IQuery).IsAssignableFrom(t)); foreach (var queryType in queryTypes) { var queryInterface = queryType.GetInterfaces().Where(i => i.Name.EndsWith(queryType.Name)).FirstOrDefault(); if (queryInterface != null) ModelBinders.Binders.Add(queryInterface, new WebLib.Ninject.NinjectModelBinder(queryType, kernel)); } }
/// <summary> /// Finds all Extension methods defined in an assembly /// </summary> /// <param name="asm"></param> /// <returns></returns> public static IEnumerable<ExtensionMethodRecord> EnumExtensionMethods(System.Reflection.Assembly asm) { var exported_types = asm.GetExportedTypes(); foreach (var extending_type in exported_types) { foreach (var emi in EnumExtensionMethods(extending_type)) { yield return emi; } } }
private static void addTypes(System.Reflection.Assembly assembly) { try { if (assembly is System.Reflection.Emit.AssemblyBuilder) return; var types = assembly.GetExportedTypes(); for (var i = 0; i < types.Length; i++) { NamespaceProvider.types[types[i].FullName] = types[i]; } } catch { } }
/// <summary> /// Parses a plugin and create all the commands defined therein. /// </summary> /// <param name="pPlugIn">Plugin to harvest for commands.</param> /// <param name="pluginAssembly">Assembly associated with the plugin.</param> /// <returns>The number of newly created commands.</returns> public static int CreateCommands(IntPtr pPlugIn, System.Reflection.Assembly pluginAssembly) { int rc = 0; // This function must ONLY be called by Rhino_DotNet.Dll if (IntPtr.Zero == pPlugIn || null == pluginAssembly) return rc; Type[] exported_types = pluginAssembly.GetExportedTypes(); if (null == exported_types) return rc; Type command_type = typeof(Commands.Command); for (int i = 0; i < exported_types.Length; i++) { if (exported_types[i].IsAbstract) continue; if (command_type.IsAssignableFrom(exported_types[i])) { if( Rhino.PlugIns.PlugIn.CreateCommandsHelper(null, pPlugIn, exported_types[i], null)) rc++; } } return rc; }
private static Type[] TryGetExportedTypes(System.Reflection.Assembly asm) { try { return asm.GetExportedTypes(); } catch (Exception) { tracer.Warn("Failed to retrieve exported types from assembly {0}.", asm.FullName); return new Type[0]; } }
public static void RegisterProviders(System.Reflection.Assembly assembly, System.Guid pluginId) { Rhino.PlugIns.PlugIn plugin = Rhino.PlugIns.PlugIn.GetLoadedPlugIn(pluginId); if (plugin == null) return; Type[] exported_types = assembly.GetExportedTypes(); if (exported_types != null) { List<Type> provider_types = new List<Type>(); for (int i = 0; i < exported_types.Length; i++) { Type t = exported_types[i]; if (!t.IsAbstract && t.IsSubclassOf(typeof(Rhino.Render.CustomRenderMesh.Provider)) && t.GetConstructor(new Type[] { }) != null) provider_types.Add(t); } if (provider_types.Count == 0) return; RdkPlugIn rdk_plugin = RdkPlugIn.GetRdkPlugIn(plugin); if (rdk_plugin == null) return; foreach (Type t in provider_types) { Provider p = System.Activator.CreateInstance(t) as Provider; if (p == null) continue; IntPtr pCppObject = p.CreateCppObject(pluginId); if (pCppObject != IntPtr.Zero) { //rdk_plugin.AddRegisteredCRMProvider(p); m_all_providers.Add(p.m_runtime_serial_number, p); UnsafeNativeMethods.Rdk_RegisterCRMProvider(pCppObject); } } } }
internal static void LoadCLRAssembly(System.Reflection.Assembly Assembly, Frame caller) { foreach (System.Type type in Assembly.GetExportedTypes()) Load(type, caller, true); }
/// <summary> /// Call this method once from your plug-ins OnLoad override for each /// assembly containing a custom mesh provider. Only publicly exported /// classes derived from CustomRenderMeshProvider with a public constructor /// that has no parameters will get registered. /// </summary> /// <param name="assembly"> /// Assembly to search for valid CustomRenderMeshProvider derived classes. /// </param> /// <param name="pluginId"> /// The plug-in that owns the custom mesh providers. /// </param> public static void RegisterProviders(System.Reflection.Assembly assembly, Guid pluginId) { var plugin = PlugIns.PlugIn.GetLoadedPlugIn(pluginId); if (plugin == null) return; var exported_types = assembly.GetExportedTypes(); var provider_types = new List<Type>(); var custom_type = typeof(CustomRenderMeshProvider); var options = new Type[] {}; foreach (var type in exported_types) if (!type.IsAbstract && type.IsSubclassOf(custom_type) && type.GetConstructor(options) != null) provider_types.Add(type); if (provider_types.Count == 0) return; var rdk_plugin = RdkPlugIn.GetRdkPlugIn(plugin); if (rdk_plugin == null) return; foreach (var type in provider_types) { var provider = Activator.CreateInstance(type) as CustomRenderMeshProvider; if (provider == null) continue; var cpp_object = provider.CreateCppObject(pluginId); if (cpp_object == IntPtr.Zero) continue; g_all_providers.Add(provider.m_runtime_serial_number, provider); UnsafeNativeMethods.Rdk_RegisterCRMProvider(cpp_object); } }
public static Type[] RegisterContentIo(System.Reflection.Assembly assembly, System.Guid pluginId) { Rhino.PlugIns.PlugIn plugin = Rhino.PlugIns.PlugIn.GetLoadedPlugIn(pluginId); if (plugin == null) return null; //Find all public types exported in the plug-in that we're dealing with Type[] exported_types = assembly.GetExportedTypes(); if (exported_types != null) { List<Type> contentio_types = new List<Type>(); for (int i = 0; i < exported_types.Length; i++) { //If the type is a Render.IOPlugIn, add it to the "to register" list. Type t = exported_types[i]; if (!t.IsAbstract && t.IsSubclassOf(typeof(Rhino.Render.IOPlugIn)) && t.GetConstructor(new Type[] { }) != null) { contentio_types.Add(t); } } // make sure that content types have not already been registered for (int i = 0; i < contentio_types.Count; i++) { Type t = contentio_types[i]; if (!RdkPlugIn.RenderContentIoTypeIsRegistered(t)) { //The object registers itself in a static array IOPlugIn pi = System.Activator.CreateInstance(t) as IOPlugIn; pi.Construct(pluginId); } } return contentio_types.ToArray(); } return null; }
private void ProbeAssembly(System.Reflection.Assembly a) { foreach (Type t in a.GetExportedTypes()) { if (MetaPlugin.IsPlugin(t)) { MetaPlugin plugin = new MetaPlugin(t); if (!plugins.ContainsKey(plugin.Name)) { plugins.Add(plugin.Name, plugin); Logger.Info("Found plugin: " + plugin); } else Logger.Info("Already have plugin: " + plugin); } } }