public void GetComponentInfo(string assemblyPath, out string numComponents, out string componentInfo) { RegistrationServices services = new RegistrationServices(); Assembly assembly = this.LoadAssembly(assemblyPath); Type[] registrableTypesInAssembly = services.GetRegistrableTypesInAssembly(assembly); int num = 0; string str = ""; foreach (Type type in registrableTypesInAssembly) { if (type.IsClass && type.IsSubclassOf(typeof(ServicedComponent))) { num++; string str2 = Marshal.GenerateGuidForType(type).ToString(); string str3 = Marshal.GenerateProgIdForType(type); if ((str2.Length == 0) || (str3.Length == 0)) { throw new COMException(); } string str4 = str; str = str4 + str3 + ",{" + str2 + "},"; } } numComponents = num.ToString(CultureInfo.InvariantCulture); componentInfo = str; }
/// <summary> /// Registers the COM types in the specified assembly. /// </summary> public static List <System.Type> RegisterComTypes(string filePath) { // load assmebly. Assembly assembly = Assembly.LoadFrom(filePath); // check that the correct assembly is being registered. VerifyCodebase(assembly, filePath); RegistrationServices services = new RegistrationServices(); // list types to register/unregister. List <System.Type> types = new List <System.Type>(services.GetRegistrableTypesInAssembly(assembly)); // register types. if (types.Count > 0) { // unregister types first. if (!services.UnregisterAssembly(assembly)) { throw new ApplicationException("Unregister COM Types Failed."); } // register types. if (!services.RegisterAssembly(assembly, AssemblyRegistrationFlags.SetCodeBase)) { throw new ApplicationException("Register COM Types Failed."); } } return(types); }
public void DaServerTest() { DaServer _daServer = new DaServer(); Assert.IsNotNull(_daServer); Assert.IsTrue(File.Exists("CommServer_Main.log"), $"Cannot find the file in {Environment.CurrentDirectory}"); Assert.IsFalse(Environment.Is64BitProcess); RegistrationServices _registrationServices = new RegistrationServices(); //GetProgIdForType string _progId = _registrationServices.GetProgIdForType(typeof(DaServer)); Assert.AreEqual <string>("CAS.CommServer.DA.Server.NETServer.DaServer", _progId); //GetRegistrableTypesInAssembly Type[] _typesToRegister = _registrationServices.GetRegistrableTypesInAssembly(typeof(DaServer).Assembly); Assert.IsNotNull(_typesToRegister); Assert.AreEqual <int>(1, _typesToRegister.Length); Assert.AreEqual <string>("CAS.CommServer.DA.Server.NETServer.DaServer", _typesToRegister[0].FullName); //TypeRepresentsComType Assert.IsFalse(_registrationServices.TypeRepresentsComType(typeof(DaServer))); Assert.IsFalse(_registrationServices.TypeRepresentsComType(typeof(IOPCCommon))); Assert.IsFalse(_registrationServices.TypeRepresentsComType(typeof(IOPCCommon))); Assert.IsFalse(_registrationServices.TypeRepresentsComType(typeof(IOPCWrappedServer))); //TypeRequiresRegistration Assert.IsTrue(_registrationServices.TypeRequiresRegistration(typeof(DaServer))); object[] _attributes = typeof(DaServer).GetCustomAttributes(typeof(GuidAttribute), false); Assert.AreEqual <int>(1, _attributes.Length); Assert.AreEqual <string>("BE77A3C7-D2B7-44E7-B943-B978C1C87E5A", ((GuidAttribute)_attributes[0]).Value.ToUpper()); }
static bool PerformAssemblyRegistration(string strTargetAssemblyFilePath, bool bCodeBase) { try { RegistrationServices registration_services = new RegistrationServices(); Assembly assembly = Assembly.LoadFrom(strTargetAssemblyFilePath); AssemblyRegistrationFlags flags; bool bRet = false; if (bCodeBase == true) { flags = AssemblyRegistrationFlags.SetCodeBase; } else { flags = AssemblyRegistrationFlags.None; } bRet = registration_services.RegisterAssembly(assembly, flags); if (bRet) { Console.WriteLine(string.Format("Successfully registered assembly [{0:S}].", strTargetAssemblyFilePath)); if (m_bVerbose) { Type[] types = registration_services.GetRegistrableTypesInAssembly(assembly); Console.WriteLine(string.Format("Types Registered :")); foreach (Type type in types) { Console.WriteLine(string.Format("GUID : [{0:S}] [{1:S}].", type.GUID.ToString(), type.FullName)); } } } else { Console.WriteLine(string.Format("Failed to register assembly [{0:S}].", strTargetAssemblyFilePath)); } return(bRet); } catch (Exception ex) { Console.WriteLine(string.Format("An exception occurred. Exception description : [{0:S}].", ex.Message)); return(false); } }
/// <include file='doc\ImportUtil.uex' path='docs/doc[@for="ComManagedImportUtil.GetComponentInfo"]/*' /> public void GetComponentInfo(string assemblyPath, out string numComponents, out string componentInfo) { RegistrationServices rs = new RegistrationServices(); Assembly asm = LoadAssembly(assemblyPath); Type[] asmTypes = rs.GetRegistrableTypesInAssembly(asm); int nComponents = 0; string s = ""; foreach (Type t in asmTypes) { if (t.IsClass && t.IsSubclassOf(typeof(ServicedComponent))) { nComponents++; string clsid = Marshal.GenerateGuidForType(t).ToString();; string progId = Marshal.GenerateProgIdForType(t); s += progId + ",{" + clsid + "},"; } } numComponents = nComponents.ToString(); componentInfo = s; }
/// <summary> /// Generates the registry file (.reg) asked for by the user via the /// <c>/regfile</c> command-line option. /// </summary> /// <returns>Exit code to return from the CLRegAsm tool.</returns> /// <exception cref="CoreException">User asked for codebase but provided assembly /// has no codebase.</exception> private int GenerateRegistryFile() { // This will be changed if an error occurs int exitCode = 0; // Get list of registrable types in the assembly. Type[] registrableTypes = regServices.GetRegistrableTypesInAssembly(assembly); // Check if assembly is a primary interop assembly. IList <CustomAttributeData> attribs = CustomAttributeData.GetCustomAttributes(assembly); bool assemblyIsPrimaryInterop = false; foreach (CustomAttributeData attrib in attribs) { if (attrib.Constructor.DeclaringType == typeof(PrimaryInteropAssemblyAttribute)) { assemblyIsPrimaryInterop = true; break; } } if (registrableTypes.Length != 0 || assemblyIsPrimaryInterop) { // Get codebase if needed. string codebase = null; if (prms.setCodeBase) { codebase = assembly.CodeBase; if (String.IsNullOrEmpty(codebase)) { throw new CoreException(String.Format("Assembly \"{0}\" has no codebase; " + "cannot include codebase in registry file.", prms.assemblyName)); } } // Get root key name depending on whether this is per-user or per-machine. string rootKeyName; if (prms.perUser) { rootKeyName = String.Format(@"{0}\Software\Classes", Registry.CurrentUser.Name); } else { rootKeyName = Registry.ClassesRoot.Name; } // Create regfile writer. Debug.Assert(!String.IsNullOrEmpty(prms.registryFile)); using (RegistryFileWriter writer = new RegistryFileWriter(prms.registryFile)) { // Write each registrable type to the file. foreach (Type type in registrableTypes) { if (type.IsValueType) { // Value type, like struct. WriteValueTypeInRegistryFile(type, codebase, rootKeyName, writer); } else if (regServices.TypeRepresentsComType(type)) { // Com-imported type. WriteComImportInRegistryFile(type, codebase, rootKeyName, writer); } else { // Class type. WriteClassInRegistryFile(type, codebase, rootKeyName, writer); } } // Write primary interop assembly info. foreach (CustomAttributeData attrib in attribs) { if (attrib.Constructor.DeclaringType == typeof(PrimaryInteropAssemblyAttribute)) { WritePrimaryInteropAssemblyInRegistryFile(attrib, codebase, rootKeyName, writer); break; } } } // We're done, tell the user. console.WriteLine("Registry file \"{0}\" generated successfully.", prms.registryFile); } else if (!prms.silent) { // No registrable types and assembly isn't a primary interop assembly; can't continue. console.Error.WriteLine("Assembly \"{0}\" has no registrable types and is not a " + "primary interop assembly: cannot generate registry file.", prms.assemblyName); exitCode = 500; } return(exitCode); }