public void DLLRegisterServer(int regMode)
{
//register dll
//same as:
//post build event: C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\regasm.exe $(TargetPath) /codebase
RegistrationServices regAsm = new RegistrationServices();
bool bResult = regAsm.RegisterAssembly(
ComponentConfig.typeToRegister.Assembly,
AssemblyRegistrationFlags.SetCodeBase);
GME.Util.MgaRegistrar reg = new GME.Util.MgaRegistrar();
if ((int)GME.MGA.Core.GMEInterfaceVersion_enum.GMEInterfaceVersion_Current != (int)((GME.MGA.Core.IGMEVersionInfo)reg).version)
{
throw new Exception("MgaInterfaceVersion mismatch: this assembly is using " +
(int)GME.MGA.Core.GMEInterfaceVersion_enum.GMEInterfaceVersion_Current +
" but the GME interface version is " + (int)((GME.MGA.Core.IGMEVersionInfo)reg).version +
"\n\nPlease install a compatible GME version or update the interop dlls.");
}
reg.RegisterComponent(
regAsm.GetProgIdForType(ComponentConfig.typeToRegister),
GME.MGA.componenttype_enum.COMPONENTTYPE_INTERPRETER,
ComponentConfig.componentName,
regacc_translate(regMode));
reg.set_ComponentExtraInfo(regacc_translate(regMode), regAsm.GetProgIdForType(ComponentConfig.typeToRegister), "Icon", ComponentConfig.iconId);
if (!ComponentConfig.paradigmName.Equals("*"))
{
reg.Associate(regAsm.GetProgIdForType(ComponentConfig.typeToRegister), ComponentConfig.paradigmName, (GME.Util.regaccessmode_enum)regMode);
}
}
public bool RegisterAsm(string filepath)
{
Assembly asm = Assembly.LoadFile(defaultCSMPath + filepath);
RegistrationServices regAsm = new RegistrationServices();
return(regAsm.RegisterAssembly(asm, AssemblyRegistrationFlags.SetCodeBase));
}
private void Regasm(bool register)
{
string file = base.Context.Parameters["Assembly"];
if (string.IsNullOrEmpty(file))
{
throw new InstallException("Assembly not defined");
}
if (!File.Exists(file))
{
return;
}
RegistrationServices regsrv = new RegistrationServices();
Assembly assembly = Assembly.LoadFrom(file);
if (register)
{
regsrv.RegisterAssembly(assembly, AssemblyRegistrationFlags.SetCodeBase);
}
else
{
try
{
regsrv.UnregisterAssembly(assembly);
}
catch
{
//Exceptions are ignored: even if the unregistering failes
//it should notprevent the user from uninstalling
}
}
}
/// <summary>
/// 注册程序集到系统
/// </summary>
/// <param name="assemblyName"></param>
/// <returns></returns>
public int RegistAssembly(string assemblyName)
{
if (!IsAdministrator())
{
return(RunAsAdmin(assemblyName, "-regist"));
}
Assembly assembly = Assembly.UnsafeLoadFrom(assemblyName);
RegistrationServices registrationServices = new RegistrationServices();
try
{
bool flag3 = registrationServices.RegisterAssembly(assembly, AssemblyRegistrationFlags.SetCodeBase);
if (!flag3)
{
return(-3);
}
}
catch (UnauthorizedAccessException ex)
{
// 无权限
Console.Error.Write(ex.Message);
return(-1);
}catch (Exception ex)
{
// 其他错误
Console.Error.Write(ex.Message);
return(-2);
}
return(0);
}
static void Main(string[] args)
{
// Get the path to the assembly.
Console.WriteLine("Please enter the path to the .NET binary");
Console.WriteLine(@"Example: C:\MyStuff\Blah\myDotNetServer.dll");
Console.Write("Path: ");
string pathToAssembly = Console.ReadLine();
// Generate type lib for this assembly.
UCOMITypeLib i = GenerateTLBFromAsm(pathToAssembly);
// Ask if user wants to register this server with COM.
int regValue;
Console.WriteLine("Would you like to register this .NET library with COM?");
Console.Write("1 = yes or 0 = no ");
regValue = Console.Read();
if (regValue == 1)
{
RegistrationServices rs = new RegistrationServices();
Assembly asm = Assembly.LoadFrom(pathToAssembly);
rs.RegisterAssembly(asm, AssemblyRegistrationFlags.None);
Console.WriteLine(".NET assembly registered with COM!");
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////
public void RegisterSystemWebAssembly(int doReg, out IntPtr exception)
{
exception = IntPtr.Zero;
try {
Assembly webAssembly = Assembly.GetExecutingAssembly();
RegistrationServices rs = new RegistrationServices();
if (doReg != 0)
{
if (!rs.RegisterAssembly(webAssembly, AssemblyRegistrationFlags.None))
{
exception = Marshal.StringToBSTR((new Exception(SR.GetString(SR.Unable_To_Register_Assembly, webAssembly.FullName))).ToString());
}
}
else
{
if (!rs.UnregisterAssembly(webAssembly))
{
exception = Marshal.StringToBSTR((new Exception(SR.GetString(SR.Unable_To_UnRegister_Assembly, webAssembly.FullName))).ToString());
}
}
}
catch (Exception e) {
exception = Marshal.StringToBSTR(e.ToString());
}
}
static int Main(string[] args)
{
try
{
// Copy from the current directory to the target directory:
Directory.CreateDirectory(ComClassDirectory);
File.Copy(ComClassAssemblyName, ComClassAssemblyPath, true);
var assembly = Assembly.LoadFile(ComClassAssemblyPath);
// PER USER INSTALL - COMMENT OUT FOR SYSTEM-WIDE INSTALL (REQUIRES ADMIN)
RegOverridePredefKey(Registry.ClassesRoot.Handle,
Registry.CurrentUser
.OpenSubKey("SOFTWARE")
.OpenSubKey("Classes").Handle);
var registrationService = new RegistrationServices();
registrationService.RegisterAssembly(assembly, AssemblyRegistrationFlags.SetCodeBase);
}
catch (Exception)
{
// This app runs headless and there's nothing to do
// a more realistic example would have exception-specific return codes
return(-1);
}
return(0);
}
public static void Register()
{
var regservice = new RegistrationServices();
regservice.RegisterAssembly(Assembly.LoadFrom("YIME.Core.dll"),
AssemblyRegistrationFlags.SetCodeBase);
var iconname = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(Assembly.GetEntryAssembly().Location),
"YIME.Core.dll");
Console.WriteLine(iconname);
Console.WriteLine(CultureInfo.GetCultureInfo("zh-cn").LCID);
//Insert code here.
var p = new ITfInputProcessorProfiles();
var result = p.Register(CLSID_TEXTSERVICE);
Console.WriteLine(result.ToString());
result = p.AddLanguageProfile(CLSID_TEXTSERVICE, new LangID((ushort)CultureInfo.GetCultureInfo("zh-cn").LCID), GUID_PROFILE,
name.ToCharArray(), (uint)name.ToCharArray().Length, iconname.ToCharArray(), (uint)iconname.Length, 0);
Console.WriteLine(result.ToString());
var c = new ITfCategoryMgr();
foreach (var supportCategory in SupportCategories)
{
var r = c.RegisterCategory(CLSID_TEXTSERVICE, supportCategory, CLSID_TEXTSERVICE);
Console.WriteLine(r.ToString());
}
}
/// <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 override void Install(IDictionary stateSaver)
{
base.Install(stateSaver);
RegistrationServices regSrv = new RegistrationServices();
regSrv.RegisterAssembly(base.GetType().Assembly, AssemblyRegistrationFlags.SetCodeBase);
}
private void DoRegister(bool allUsers)
{
try
{
if (!allUsers)
{
OverrideHKCR();
}
var rs = new RegistrationServices();
rs.RegisterAssembly(Assembly.LoadFrom(Path.Combine(crtDir, @"KeContextMenuHandler.dll")),
AssemblyRegistrationFlags.SetCodeBase);
ShellExtensionManager.RegisterShellExtContextMenuHandler(allUsers);
if (!allUsers)
{
OverrideHKCR(true);
}
}
catch (Exception e)
{
MessageBox.Show(this, e.Message + "\r\n\r\n" + e.StackTrace);
}
}
/// <summary>
/// Register assembly
/// </summary>
public void Install()
{
if (!File.Exists(dll))
{
throw new FileNotFoundException($"Target assembly is not found: \"{dll}\"");
}
var key = Registry.CurrentUser.OpenSubKey(@"Software\Classes", true);
try
{
// temporarily override HKCR to HKCU\Software\Classes
var ret = RegOverridePredefKey(HKEY_CLASSES_ROOT, key.Handle.DangerousGetHandle());
if (ret != ERROR_SUCCESS)
{
throw new Exception($"Cannot override HKEY_CLASSES_ROOT (error code {ret})");
}
// register assembly using RegistrationServices API
var rs = new RegistrationServices();
var asm = Assembly.LoadFrom(dll);
rs.RegisterAssembly(asm, AssemblyRegistrationFlags.SetCodeBase);
}
finally
{
// restore HKCR back
RegOverridePredefKey(HKEY_CLASSES_ROOT, IntPtr.Zero);
key.Close();
}
}
public static void RegisterSelf()
{
RegistrationServices aRS = new RegistrationServices();
Assembly thisAssembly = Assembly.GetExecutingAssembly();
aRS.RegisterAssembly(thisAssembly, AssemblyRegistrationFlags.SetCodeBase);
}
protected override void OnCommitted(IDictionary savedState)
{
base.OnCommitted(savedState);
Assembly assembly = Assembly.LoadFile(Assembly.GetExecutingAssembly().Location);
RegistrationServices registrationServices = new RegistrationServices();
registrationServices.RegisterAssembly(assembly, AssemblyRegistrationFlags.SetCodeBase);
}
public static void RegisterCom()
{
var rs = new RegistrationServices();
var a = new MediaMonkeyAkkaProxy();
rs.RegisterAssembly(typeof(MediaMonkeyAkkaProxy).Assembly,
AssemblyRegistrationFlags.SetCodeBase);
}
public static void RegisterServer(Assembly assemblyToRegister)
{
if (ComRegister != null)
{
RegistrationServices reg = new RegistrationServices();
reg.RegisterAssembly(assemblyToRegister, AssemblyRegistrationFlags.SetCodeBase);
ComRegister();
}
}
public static void Register()
{
try
{
RegistrationServices svc = new RegistrationServices();
svc.RegisterAssembly(typeof(Program).Assembly, AssemblyRegistrationFlags.SetCodeBase);
}
catch (Exception e) { throw new ApplicationException(e.Message, e); }
}
public void DLLRegisterServer(int regMode)
{
//register dll
//same as:
//post build event: C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\regasm.exe $(TargetPath) /codebase
RegistrationServices regAsm = new RegistrationServices();
bool bResult = regAsm.RegisterAssembly(ComponentConfig.typeToRegister.Assembly, AssemblyRegistrationFlags.SetCodeBase);
}
/// <summary>
/// Регистрация сборки
/// </summary>
/// <param name="asmFile">Ссылка на файл сборки</param>
/// <param name="codebase">Флаг регистрации codebase</param>
/// <returns>Возвращает результат регистрации: Installed или Fail</returns>
public static RegistrationResult Install(FileInfo asmFile, bool codebase = false)
{
var assembly = ResolveAssembly(asmFile);
var services = new RegistrationServices();
bool regResult = services.RegisterAssembly(assembly, codebase ? AssemblyRegistrationFlags.SetCodeBase : AssemblyRegistrationFlags.None);
return(regResult ? RegistrationResult.Installed : RegistrationResult.Fail);
}
public override void Install(IDictionary stateSaver)
{
base.Install(stateSaver);
RegistrationServices regsrv = new RegistrationServices();
if (!regsrv.RegisterAssembly(this.GetType().Assembly, AssemblyRegistrationFlags.SetCodeBase))
{
throw new InstallException("Failed To Register for COM");
}
}
/// <summary>
/// When overridden in a derived class, performs the installation.
/// </summary>
/// <param name="stateSaver">An <see cref="T:System.Collections.IDictionary"/> used to save information needed to perform a commit, rollback, or uninstall operation.</param>
public override void Install(IDictionary stateSaver)
{
base.Install(stateSaver);
RegistrationServices regServices = new RegistrationServices();
if (!regServices.RegisterAssembly(GetType().Assembly, AssemblyRegistrationFlags.SetCodeBase))
{
throw new InstallException("Error during registration of " + GetType().Assembly.FullName);
}
}
public override void Install(IDictionary stateSaver)
{
base.Install(stateSaver);
// Call RegistrationServices.RegisterAssembly to register the classes in
// the current managed assembly to enable creation from COM.
var regService = new RegistrationServices();
regService.RegisterAssembly(GetType().Assembly, AssemblyRegistrationFlags.SetCodeBase);
}
public override void Install(System.Collections.IDictionary stateSaver)
{
System.Windows.Forms.MessageBox.Show("开始执行安装类自定义操作...");
base.Install(stateSaver);
RegistrationServices regsrv = new RegistrationServices();
if (!regsrv.RegisterAssembly(this.GetType().Assembly, AssemblyRegistrationFlags.SetCodeBase))
{
throw new InstallException("Failed To Register for COM");
}
}
public override void Install(IDictionary stateSaver)
{
base.Install(stateSaver);
RegistrationServices regsrv = new RegistrationServices();
if (!regsrv.RegisterAssembly(typeof(ComInstaller).Assembly, AssemblyRegistrationFlags.SetCodeBase))
{
throw new Exception("Failed to register for COM interop.");
}
Utilities.DebugLine("[MsasSink] Installed COM assembly: " + typeof(ComInstaller).Assembly);
}
public override void Install(System.Collections.IDictionary stateSaver)
{
base.Install(stateSaver);
RegistrationServices regsrv = new RegistrationServices();
if (!regsrv.RegisterAssembly(this.GetType().Assembly,
AssemblyRegistrationFlags.SetCodeBase))
{
throw new InstallException("Libronツールバーの登録に失敗しました");
}
}
public override void Install(IDictionary stateSaver)
{
base.Install(stateSaver);
// Call RegistrationServices.RegisterAssembly to register the classes in
// the current managed assembly to enable creation from COM.
RegistrationServices regService = new RegistrationServices();
regService.RegisterAssembly(
Assembly.LoadFrom(@"AobaContextMenu.dll"),
AssemblyRegistrationFlags.SetCodeBase);
}
private void materialRaisedButton1_Click(object sender, EventArgs e)
{
//args = (
// from x in args
// select x.ToLower()).ToArray<string>();
string dllsToRegister = pathField.Text;
Assembly assembly = Assembly.LoadFrom(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), dllsToRegister));
RegistrationServices registrationService = new RegistrationServices();
registrationService.RegisterAssembly(assembly, AssemblyRegistrationFlags.SetCodeBase);
}
/// <summary>
/// Register the assembly for COM interop
/// </summary>
/// <param name="stateSaver">An IDictionary used to save information
/// needed to perform a commit, rollback, or uninstall operation.
/// </param>
public override void Install(IDictionary stateSaver)
{
base.Install(stateSaver);
RegistrationServices regSrv = new RegistrationServices();
System.Reflection.Assembly assembly = base.GetType().Assembly;
AssemblyRegistrationFlags flags = AssemblyRegistrationFlags.SetCodeBase;
regSrv.RegisterAssembly(assembly, flags);
}
public override void Install(System.Collections.IDictionary stateSaver)
{
base.Install(stateSaver);
RegistrationServices regSrv = new RegistrationServices();
regSrv.RegisterAssembly(base.GetType().Assembly,
AssemblyRegistrationFlags.SetCodeBase);
//Add a new context menu item.
RegistryKey regmenu = null;
RegistryKey regcmd = null;
try
{
regmenu = Registry.ClassesRoot.CreateSubKey(MenuName);
if (regmenu != null)
{
regmenu.SetValue("", "Sync with OneSync 4");
}
regcmd = Registry.ClassesRoot.CreateSubKey(Command);
if (regcmd != null)
{
regcmd.SetValue("", "\"" + Assembly.GetExecutingAssembly().Location + "\" \"%1\"");
}
regmenu = Registry.ClassesRoot.CreateSubKey(AppMenuName);
if (regmenu != null)
{
regmenu.SetValue("", "Open OneSync 4");
}
regcmd = Registry.ClassesRoot.CreateSubKey(AppCommand);
if (regcmd != null)
{
regcmd.SetValue("", "\"" + Assembly.GetExecutingAssembly().Location + "\"");
}
}
catch (Exception)
{
//Do nothing?!
}
finally
{
if (regmenu != null)
{
regmenu.Close();
}
if (regcmd != null)
{
regcmd.Close();
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Use: Registry Install / Uninstall
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public static void InstallRegistry(IDictionary stateSaver, Assembly asm)
{
if (CommonUtils.Is64BitOperatingSystem())
{
RegAsm64("/codebase", asm);
}
else
{
RegistrationServices regsrv = new RegistrationServices();
regsrv.RegisterAssembly(asm, AssemblyRegistrationFlags.SetCodeBase);
}
}