/// <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; }
public static Type FindCompatibleType(string libraryfile, Type neededinterface) { System.Reflection.Assembly ass = null; try { ass = System.Reflection.Assembly.LoadFile(libraryfile); Type[] types = ass.GetExportedTypes(); foreach (Type t in types) { foreach (Type ti in t.GetInterfaces()) { if (ti == neededinterface) { return(t); } } } } catch (Exception x) { ass = null; MessageBox.Show(x.ToString(), "Error browsing types.", MessageBoxButtons.OK, MessageBoxIcon.Error); } return(null); }
public PackageContent Run() { PackageContent result = new PackageContent(); foreach (string file in Directory.EnumerateFiles(AppDomain.CurrentDomain.BaseDirectory, "*.dll")) { try { System.Reflection.Assembly assembly = System.Reflection.Assembly.LoadFrom(file); foreach (System.Type type in assembly.GetExportedTypes()) { if (type != typeof(IBootstrapper) && typeof(IBootstrapper).IsAssignableFrom(type)) { result.Bootstrappers.Add(Contract.Type.FromType(type)); } if (type != typeof(Updater) && typeof(Updater).IsAssignableFrom(type)) { result.Updaters.Add(Contract.Type.FromType(type)); } } } catch (Exception ex) { Logger.Warn(this, "Could not scan " + file + " because: " + ex.GetRootCause().Message); } } Console.WriteLine("there are " + result.Bootstrappers.Count + " bootstrappers and " + result.Updaters.Count + " updaters"); return(result); }
private LibraryExceptions() { //add exceptions from dots_generated { System.Reflection.Assembly ass = System.Reflection.Assembly.Load("dots_generated-dotnet"); System.Type[] exportedTypes = ass.GetExportedTypes(); foreach (System.Type type in exportedTypes) { if (type.IsSubclassOf(typeof(System.Exception))) { System.IntPtr typename = Internal.InternalOperations.CStringOf(type.FullName); m_exceptionNameTable.Add(Internal.Kernel.DotsC_TypeIdFromName(typename), type.FullName + ", dots_generated-dotnet"); Marshal.FreeHGlobal(typename); } } } //add exceptions from dots_dotnet { System.Reflection.Assembly ass = System.Reflection.Assembly.Load("Safir.Dob.Typesystem"); System.Type[] exportedTypes = ass.GetExportedTypes(); foreach (System.Type type in exportedTypes) { if (type.IsSubclassOf(typeof(System.Exception))) { System.IntPtr typename = Internal.InternalOperations.CStringOf(type.FullName); m_exceptionNameTable.Add(Internal.Kernel.DotsC_TypeIdFromName(typename), type.FullName + ", Safir.Dob.Typesystem"); Marshal.FreeHGlobal(typename); } } } }
/// <summary> /// 在指定的模块中根据插件类型获取插件类 /// </summary> /// <param name="model"></param> /// <param name="Type"></param> /// <returns></returns> public static List <Type> GetTypesByType(this System.Reflection.Assembly model, string Type = "") { List <Type> lstType = new List <Type>(); var types = model.GetExportedTypes(); if (String.IsNullOrWhiteSpace(Type)) { Type = model.GetAssemblyPluginAttribute().Type; } foreach (var type in types) { //System.Threading.Tasks.Parallel.ForEach(types, type => //{ var pluginAttribute = type.GetPluginAttribute(); if (!String.IsNullOrWhiteSpace(Type) && pluginAttribute != null && pluginAttribute.Type.ToLower() == Type.ToLower()) { lstType.Add(type); } if (pluginAttribute != null && String.IsNullOrWhiteSpace(pluginAttribute.Type)) { lstType.Add(type); } //}); } return(lstType); }
public void RegisterAssemblyBrushes(System.Reflection.Assembly assembly) { Message("BrushManager: RegisterAssemblyBrushes..."); foreach (System.Type type in assembly.GetExportedTypes()) { bool hasAny = type.GetCustomAttributes( typeof(BrushAttribute), false ).Any(); if (hasAny) { try { object o = System.Activator.CreateInstance(type); Brush brush = (Brush)(o); brushes.Add(brush); } catch (System.Reflection.TargetInvocationException e) { System.Diagnostics.Trace.TraceError(e.ToString()); if (e.InnerException != null) { System.Diagnostics.Trace.TraceError(e.InnerException.ToString()); } } } } }
/// <summary> /// Creates a collection of all plug-ins that are available in the executing folder. /// </summary> /// <param name="pParent">Parent class <seealso cref="CommonBusControl"/></param> public PluginCollection(CommonBusControl pParent) { m_TraceSource = pParent.GetTraceSource; string ialphmFiltr = typeof(IDataProviderID).ToString(); //Przeszukujemy katalog w poszykiwaniu odpowiedniego pluginu string lPathToScann = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location); foreach (string fileOn in Directory.GetFiles(lPathToScann)) { System.IO.FileInfo file = new System.IO.FileInfo(fileOn); //roszerzenie powinno byæ dll if (file.Extension.ToLower().Equals(".dll") && file.Name.ToLower().Contains("plugin")) { m_TraceSource.TraceEvent (TraceEventType.Verbose, 148, "NetworkConfiguration: Trying to find helper interface in file: {0}", fileOn); try { //Create a new assembly from the plugin we're reading System.Reflection.Assembly pluginAssembly = System.Reflection.Assembly.LoadFrom(fileOn); //Gets a type object of the interface we need the plugins to match foreach (Type pluginType in pluginAssembly.GetExportedTypes()) { m_TraceSource.TraceEvent (TraceEventType.Verbose, 158, "NetworkConfiguration: Checking if {0} implements the helper interface", pluginType.ToString()); if (pluginType.IsPublic && !pluginType.IsAbstract && pluginType.GetInterface(ialphmFiltr) != null) //Only look at public types { m_TraceSource.TraceEvent (TraceEventType.Verbose, 162, "NetworkConfiguration: Trying to create helper."); IDataProviderID lHelper = (IDataProviderID)Activator.CreateInstance(pluginType); m_SortedDic.Add(lHelper.GetDataProviderDescription.Identifier, lHelper); m_TraceSource.TraceEvent (TraceEventType.Verbose, 158, "NetworkConfiguration: {0} has benn added to the plugins collection.", pluginType.ToString()); } else { m_TraceSource.TraceEvent (TraceEventType.Verbose, 158, "NetworkConfiguration: {0} does not implement the helper interface", pluginType.ToString()); } } //foreach (Type pluginType in pluginAssembly.GetTypes()) } //try catch (BadImageFormatException)//w przypadku biblioteki nie .NET - np WtOPCSvr.dll { m_TraceSource.TraceEvent (TraceEventType.Warning, 211, "NetworkConfiguration: The file {0} image is invalid.", fileOn); } catch (LicenseException ex) { m_TraceSource.TraceEvent (TraceEventType.Warning, 217, "NetworkConfiguration: The component cannot be granted a license for the type: {0}.", ex.LicensedType.ToString()); } catch (Exception ex) { m_TraceSource.TraceEvent (TraceEventType.Warning, 223, "Some problem encountered while trying to connect a plugin in file {0}. An exception was thrown: {1}", fileOn, ex.Message); } } //if(file.Extension.Equals(".dll")) } //foreach(string fileOn in System.IO.Directory.GetFiles(Win32API.Application.Path)) }
/// <summary> /// 在指定的模块中根据插件ID获取插件类 /// </summary> /// <param name="model"></param> /// <param name="PluginId"></param> /// <returns></returns> public static Type GetTypeByPluginId(this System.Reflection.Assembly model, string PluginId = "") { var types = model.GetExportedTypes(); if (String.IsNullOrWhiteSpace(PluginId)) { PluginId = model.GetAssemblyPluginAttribute().DefaultPluginID; } if (String.IsNullOrWhiteSpace(PluginId)) { return(null); } var existType = types.FirstOrDefault(type => { var pluginAttribute = type.GetPluginAttribute(); if (pluginAttribute != null) { return(pluginAttribute.ID.ToLower() == PluginId.ToLower()); } else { return(false); } }); return(existType); }
public static System.Text.StringBuilder GetClassHierarchyForAssembly(System.Reflection.Assembly assembly) { var classTypes = assembly.GetExportedTypes().Where(type => type.IsClass); var classTreeNodes = new Dictionary <string, ClassTreeNode>(); foreach (Type classType in classTypes) { var newTreeNode = new ClassTreeNode(classType.Name); var parentIdentifier = classType.BaseType.Name; if (!classTreeNodes.TryGetValue(parentIdentifier, out ClassTreeNode parentNode)) { parentNode = new ClassTreeNode(parentIdentifier); classTreeNodes.Add(parentIdentifier, parentNode); } classTreeNodes.Add(newTreeNode.TypeName, newTreeNode); parentNode.AddChild(newTreeNode); } var builder = new System.Text.StringBuilder(); foreach (var node in classTreeNodes.Values.Where(it => it.Parent == null).OrderBy(it => it.TypeName)) { Display(builder, "", node); } return(builder); }
public IStore RegisterIndexes(System.Reflection.Assembly assembly) { var exportedTypes = assembly.GetExportedTypes(); var indexes = exportedTypes.Where(x => typeof(IIndexProvider).IsAssignableFrom(x)); return(RegisterIndexes(indexes)); }
public static int initManager() { bool bb = AppCommon.Log.UMCLog.Enable;//使用静态变量触发类的静态构造函数(get√) #region 务注册 GalaSoft.MvvmLight.Ioc.SimpleIoc.Default.Register <FunctionService>(true);//注入ioc,并立即实例化 #endregion DirectoryInfo AppFolder = new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory); foreach (FileInfo NextFile in AppFolder.GetFiles()) { bool b = NextFile.Name.StartsWith("UMC"); if (NextFile.Extension.ToUpper() == ".DLL" && NextFile.Name.StartsWith("UMC")) { Loghelper.WriteLogTrace("正在加载:" + NextFile.FullName.ToString()); System.Reflection.Assembly assemblyInfo = null; try { assemblyInfo = System.Reflection.Assembly.LoadFrom(NextFile.FullName); } catch { assemblyInfo = null; } if (assemblyInfo == null) { continue; } //获取所有公开类型 Type[] TempTArray = assemblyInfo.GetExportedTypes(); foreach (Type type in TempTArray) { object[] TypeAttributes = type.GetCustomAttributes(typeof(AppModel.UMCAttributes.UMCAttribute), false); if (TypeAttributes != null && TypeAttributes.Length > 0) { //程序集里面不是所有的公共类型都是自定义特性的,所以在此做个判断 try { //特性只有一个,所以是0 AppModel.UMCAttributes.UMCAttribute temp = TypeAttributes[0] as AppModel.UMCAttributes.UMCAttribute; switch (temp.CurrentType) { case AppModel.UMCAttributes.FuncType.Func: //↓先从容器中获取Service实例,然后调用service的自定义注入方法 GalaSoft.MvvmLight.Ioc.SimpleIoc.Default.GetInstance <FunctionService>().RegisterFunction(temp.ClassType, temp.Key); break; default: break; } } catch (Exception ex) { Loghelper.WriteLogException(ex); } } } } } return(-1); }
public static Regulus.Remote.IProtocol Create(System.Reflection.Assembly protocol_assembly) { System.Type[] types = protocol_assembly.GetExportedTypes(); System.Type protocolType = types.Where(type => type.GetInterface(nameof(Regulus.Remote.IProtocol)) != null).FirstOrDefault(); if (protocolType == null) { throw new System.Exception($"找不到{nameof(Regulus.Remote.IProtocol)}的實作"); } return(System.Activator.CreateInstance(protocolType) as Regulus.Remote.IProtocol); }
public static System.Collections.Generic.IEnumerable <Regulus.Remote.IProtocol> Create(System.Reflection.Assembly protocol_assembly) { System.Type[] types = protocol_assembly.GetExportedTypes(); var protocolTypes = types.Where(type => type.GetInterface(nameof(Regulus.Remote.IProtocol)) != null); foreach (var type in protocolTypes) { yield return(System.Activator.CreateInstance(type) as Regulus.Remote.IProtocol); } }
public static void AppendFromAssembly(System.Reflection.Assembly assembly) { foreach (Type t in assembly.GetExportedTypes()) { Measure proxy = Measure.TryRetrieveFrom(t); if (proxy != null) { Add(proxy); } } }
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]); } }
/// <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 void btTest_Click(object sender, System.EventArgs e) { this.Cursor = System.Windows.Forms.Cursors.WaitCursor; try { string sExe = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(Application.ExecutablePath), "TestLoadWin.exe"); if (System.IO.File.Exists(sExe)) { string sType = ""; System.Reflection.Assembly a = System.Reflection.Assembly.LoadFile(frmPerformerImport.WizardInfo.CompiledFile); System.Type[] tps = a.GetExportedTypes(); if (tps != null) { for (int i = 0; i < tps.Length; i++) { if (tps[i].GetInterface("EPControl.IPerformer") != null) { sType = tps[i].AssemblyQualifiedName; break; } } } if (sType.Length > 0) { System.Diagnostics.Process pr = new System.Diagnostics.Process(); pr.StartInfo = new System.Diagnostics.ProcessStartInfo(sExe, "\"" + sType + "\""); Microsoft.Win32.RegistryKey reg = Microsoft.Win32.Registry.LocalMachine.CreateSubKey("Software\\Longflow\\Limnor"); reg.SetValue("TestLoad", ""); reg.Close(); pr.Start(); pr.WaitForExit(); reg = Microsoft.Win32.Registry.LocalMachine.CreateSubKey("Software\\Longflow\\Limnor"); string s = (string)reg.GetValue("TestLoad"); txtMsg.Text = s; pr.Dispose(); } else { txtMsg.Text = "No Performer found in this file"; } } else { txtMsg.Text = "File not found:" + sExe; } } catch (Exception er) { txtMsg.Text = "Failed:\r\n" + ImportException.FormExceptionText(er); } this.Cursor = System.Windows.Forms.Cursors.Default; btSave.Enabled = true; }
public bool HasPlugins(string path) { AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += new ResolveEventHandler(CurrentDomain_ReflectionOnlyAssemblyResolve); System.Reflection.Assembly a = System.Reflection.Assembly.ReflectionOnlyLoadFrom(path); foreach (Type t in a.GetExportedTypes()) { if (MetaPlugin.IsPlugin(t)) { return(true); } } return(false); }
private AbstractPlatform GetPlatformInstance(System.Reflection.Assembly assembly) { foreach (System.Type type in assembly.GetExportedTypes()) { // TODO: check to make sure it inherits from AbstractPlatform // Perhaps make that the only qualification instead of going by name? if (type.Name == "PlatformImpl" && !type.IsAbstract) { return((AbstractPlatform)assembly.CreateInstance(type.FullName)); } } throw new System.InvalidOperationException("This assembly does not define a PlatformImpl type: " + assembly.FullName); }
public string Value(byte[] rawAssembly) { string s = ""; try { System.Reflection.Assembly assy = System.Reflection.Assembly.Load(rawAssembly); string h = String.Format("\n---------\n---------\n{0}: Assembly\n---------\n", assy.GetType().Name); string t = "---------\n"; s += h; s += assy.ToString() + "\n"; foreach (var p in typeof(System.Reflection.Assembly).GetProperties()) { try { s += string.Format(" {0}: {1}\n", p.Name, "" + p.GetValue(assy, null)); } catch (Exception ex) { s += string.Format(" {0}: Error reading Value: {1}\n", p.Name, ex.Message); } } s += "\nReferences:\n"; foreach (var p in assy.GetReferencedAssemblies()) { s += string.Format(" Ref: {0}\n", p.ToString()); } s += "\nExported Types:\n"; try { Type[] exportedTypes = assy.GetExportedTypes(); foreach (var p in exportedTypes) { s += string.Format(" Type: {0}\n", p.ToString()); } } catch (Exception ex) { s += " Cannot get Exported Types: " + ex.Message + "\n"; } s += t; } catch (Exception ex) { s = "\n---------\n---------\n Assembly\n---------\n"; for (Exception inex = ex; inex != null; inex = inex.InnerException) { s += "\n" + inex.Message; s += "\n" + inex.StackTrace; s += "\n-----"; } s += "---------\n"; } return(s); }
/// <summary> /// Register a group of services from the specified assembly /// </summary> /// <param name="container"></param> /// <param name="repositoryAssembly"></param> /// <param name="endString"></param> public static void RegisterSpecial(this Container container, System.Reflection.Assembly repositoryAssembly, string endString) { var registrations = from type in repositoryAssembly.GetExportedTypes() where type.Name.ToLower().EndsWith(endString.ToLower()) where type.GetInterfaces().Any() where !type.IsInterface select new { Service = type.GetInterfaces().Where(t => !t.IsGenericType).FirstOrDefault(), Implementation = type }; foreach (var reg in registrations) { container.Register(reg.Service, reg.Implementation, Lifestyle.Scoped); } }
/// <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 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); } } } }
public static void RegisterSpecialDecorator(this Container container, System.Reflection.Assembly repositoryAssembly, string endString) { //var repositoryAssembly = type.Assembly; var registrations = from type in repositoryAssembly.GetExportedTypes() //where type.Namespace == "MyComp.MyProd.BL.SqlRepositories" where type.Name.ToLower().EndsWith(endString.ToLower()) where type.GetInterfaces().Any() select new { Service = type.GetInterfaces().Single(), Implementation = type }; foreach (var reg in registrations) { container.RegisterDecorator(reg.Service, reg.Implementation); } }
public static void SearchFactor(System.Reflection.Assembly ass) { Type Factor = typeof(ISerializationFactory <SerializationType>); foreach (Type type in ass.GetExportedTypes()) { foreach (Type inter in type.GetInterfaces()) { if (inter == Factor) { Add(ass.CreateInstance(type.ToString()) as ISerializationFactory <SerializationType>); } } } }
/// <summary> /// Gets all migrations that should be executed, ordered by name. /// </summary> public IEnumerable <IMigration> GetMigrations(IContextManager contextManager, IUpgradeLog log) { var availableMigrations = _assemblyContainingMigrations .GetExportedTypes() .Where(candidateType => typeof(IMigration).IsAssignableFrom(candidateType) && !candidateType.IsAbstract && candidateType.IsClass && candidateType.GetConstructor(Type.EmptyTypes) != null) .Where(migrationType => _filter(migrationType.FullName)) .Select(migrationType => (IMigration)Activator.CreateInstance(migrationType)) .OrderBy(migration => migration.Name) .ToList(); return(availableMigrations); }
public FormToolbox() { InitializeComponent(); TopLevel = false; Type[] tpsD = this.GetType().Assembly.GetExportedTypes(); for (int i = 0; i < tpsD.Length; i++) { if (!tpsD[i].IsAbstract) { if (tpsD[i].IsSubclassOf(typeof(DrawingItem))) { listBox1.AddDrawItem(tpsD[i]); } } } // //load additional drawings string[] ss = System.IO.Directory.GetFiles(System.IO.Path.GetDirectoryName(Application.ExecutablePath), "drawing*.dll"); if (ss != null) { for (int i = 0; i < ss.Length; i++) { System.Reflection.Assembly a = null; try { a = System.Reflection.Assembly.LoadFile(ss[i]); if (a != null) { System.Type[] tps = a.GetExportedTypes(); if (tps != null) { for (int j = 0; j < tps.Length; j++) { if (!tps[j].IsAbstract && tps[j].IsSubclassOf(typeof(DrawingItem))) { listBox1.AddDrawItem(tps[j]); } } } } } catch { } } } }
static EnumExtensions() { //let's collect the enums we care about List <Type> enumTypeList = new List <Type>(); //probe this assembly for all enums System.Reflection.Assembly assembly = System.Reflection.Assembly.GetExecutingAssembly(); Type[] exportedTypes = assembly.GetExportedTypes(); foreach (Type type in exportedTypes) { if (type.IsEnum) { enumTypeList.Add(type); } } //for each enum in our list, populate the appropriate dictionaries foreach (Type type in enumTypeList) { //add dictionaries for this type EnumExtensions.enumToStringDictionary.Add(type, new Dictionary <object, string>()); EnumExtensions.stringToEnumDictionary.Add(type, new Dictionary <string, object>()); Array values = Enum.GetValues(type); //its ok to manipulate 'value' as object, since when we convert we're given the type to cast to foreach (object value in values) { System.Reflection.FieldInfo fieldInfo = type.GetField(value.ToString()); //check for an attribute System.ComponentModel.DescriptionAttribute attribute = Attribute.GetCustomAttribute(fieldInfo, typeof(System.ComponentModel.DescriptionAttribute)) as System.ComponentModel.DescriptionAttribute; //populate our dictionaries if (attribute != null) { EnumExtensions.enumToStringDictionary[type].Add(value, attribute.Description); EnumExtensions.stringToEnumDictionary[type].Add(attribute.Description, value); } else { EnumExtensions.enumToStringDictionary[type].Add(value, value.ToString()); EnumExtensions.stringToEnumDictionary[type].Add(value.ToString(), value); } } } }
void InsertUnitsFromAssembly(System.Reflection.Assembly assembly) { Type[] types = assembly.GetExportedTypes(); foreach (Type type in types) { if (typeof(CapeOpen.ICapeUnit).IsAssignableFrom(type) && !type.IsAbstract && type != typeof(UnitOperationWrapper)) { UnitOperationInformation unit = new UnitOperationInformation(); object[] attributes = type.GetCustomAttributes(true); for (int i = 0; i < attributes.Length; i++) { if (attributes[i] is CapeNameAttribute) { unit.Name = ((CapeNameAttribute)attributes[i]).Name; } if (attributes[i] is CapeDescriptionAttribute) { unit.Description = ((CapeDescriptionAttribute)attributes[i]).Description; } if (attributes[i] is CapeVersionAttribute) { unit.CapeVersion = ((CapeVersionAttribute)attributes[i]).Version; } if (attributes[i] is CapeVendorURLAttribute) { unit.VendorURL = ((CapeVendorURLAttribute)attributes[i]).VendorURL; } if (attributes[i] is CapeHelpURLAttribute) { unit.HelpURL = ((CapeHelpURLAttribute)attributes[i]).HelpURL; } if (attributes[i] is CapeAboutAttribute) { unit.About = ((CapeAboutAttribute)attributes[i]).About; } unit.ProgID = type.FullName; unit.Assembly = assembly.FullName; } unit.Type = type; m_UnitOperations.Add(unit); m_DotNetUnitOperations.Add(unit); } } }
public void LoadData(bool bHotspotsOnly) { Type[] tpsD = this.GetType().Assembly.GetExportedTypes(); for (int i = 0; i < tpsD.Length; i++) { if (!tpsD[i].IsAbstract) { if (tpsD[i].IsSubclassOf(typeof(DrawingItem))) { addType(tpsD[i], bHotspotsOnly); } } } // //load additional drawings string[] ss = System.IO.Directory.GetFiles(System.IO.Path.GetDirectoryName(Application.ExecutablePath), "drawing*.dll"); if (ss != null) { for (int i = 0; i < ss.Length; i++) { System.Reflection.Assembly a = null; try { a = System.Reflection.Assembly.LoadFile(ss[i]); if (a != null) { System.Type[] tps = a.GetExportedTypes(); if (tps != null) { for (int j = 0; j < tps.Length; j++) { if (!tps[j].IsAbstract && tps[j].IsSubclassOf(typeof(DrawingItem))) { addType(tps[j], bHotspotsOnly); } } } } } catch { } } } }