private static AssemblyInstaller GetInstaller()
{
AssemblyInstaller installer = new AssemblyInstaller(
typeof(Program).Assembly, null);
installer.UseNewContext = true;
return installer;
}
public static bool UninstallWindowsService()
{
StopService();
IDictionary mySavedState = new Hashtable();
try
{
// Set the commandline argument array for 'logfile'.
string[] commandLineOptions = new string[1] { string.Format("/LogFile={0}", _logFile) };
// Create an object of the 'AssemblyInstaller' class.
AssemblyInstaller myAssemblyInstaller = new
AssemblyInstaller(_installAssembly, commandLineOptions);
myAssemblyInstaller.UseNewContext = true;
// Install the 'MyAssembly' assembly.
myAssemblyInstaller.Uninstall(mySavedState);
// Commit the 'MyAssembly' assembly.
myAssemblyInstaller.Commit(mySavedState);
}
catch (Exception e)
{ return false; }
return true;
}
/// <summary>
/// 安装windows服务
/// </summary>
private void InstallService(IDictionary stateSaver, string filepath, string serviceName)
{
try
{
ServiceController service = new ServiceController(serviceName);
if (!ServiceIsExisted(serviceName))
{
AssemblyInstaller myAssemblyInstaller = new AssemblyInstaller();
myAssemblyInstaller.UseNewContext = true;
myAssemblyInstaller.Path = filepath;
myAssemblyInstaller.Install(stateSaver);
myAssemblyInstaller.Commit(stateSaver);
myAssemblyInstaller.Dispose();
service.Start();
}
else
{
if (service.Status != ServiceControllerStatus.Running && service.Status != ServiceControllerStatus.StartPending)
service.Start();
}
}
catch (Exception ex)
{
throw new Exception("InstallServiceError\r\n" + ex.Message);
}
}
private void Install(AssemblyInstaller installer, IDictionary state, bool undo)
{
try
{
if (undo)
{
_log.Write(LogLevel.Info, "Uninstalling {0}...", StringConstants.ServiceName);
installer.Uninstall(state);
_log.Write(LogLevel.Info, "{0} has been successfully removed from the system.", StringConstants.ServiceName);
}
else
{
_log.Write(LogLevel.Info, "Installing {0}...", StringConstants.ServiceName);
installer.Install(state);
_log.Write(LogLevel.Info, "Commiting changes...");
installer.Commit(state);
_log.Write(LogLevel.Info, "Install succeeded.");
}
}
catch (Exception ex)
{
_log.Write(LogLevel.Error, "An error occured during {1}. {0}", ex, undo?"uninstall" : "install");
_log.Write(LogLevel.Info, "Trying to roll back...");
TryRollback(installer, state);
}
}
/// <summary>
/// 安装服务：
/// </summary>
/// <param name="filepath"></param>
public void InstallService(string filepath)
{
try
{
string serviceName = GetServiceName(filepath);
ServiceController service = new ServiceController(serviceName);
if (!ServiceIsExisted(serviceName))
{
//Install Service
AssemblyInstaller myAssemblyInstaller = new AssemblyInstaller() { UseNewContext = true, Path = filepath };
myAssemblyInstaller.Install(new Hashtable());
myAssemblyInstaller.Commit(new Hashtable());
myAssemblyInstaller.Dispose();
//--Start Service
service.Start();
}
else
{
if (service.Status != ServiceControllerStatus.Running && service.Status != ServiceControllerStatus.StartPending)
{
service.Start();
}
}
}
catch (Exception ex)
{
throw new Exception("installServiceError/n" + ex.Message);
}
}
/// <summary>
/// 安装服务
/// </summary>
private void btnInstall_Click(object sender, EventArgs e)
{
if (!Vaild())
{
return;
}
try
{
string[] cmdline = { };
string serviceFileName = txtPath.Text.Trim();
string serviceName = GetServiceName(serviceFileName);
if (string.IsNullOrEmpty(serviceName))
{
txtTip.Text = "指定文件不是Windows服务！";
return;
}
if (ServiceIsExisted(serviceName))
{
txtTip.Text = "要安装的服务已经存在！";
return;
}
TransactedInstaller transactedInstaller = new TransactedInstaller();
AssemblyInstaller assemblyInstaller = new AssemblyInstaller(serviceFileName, cmdline);
assemblyInstaller.UseNewContext = true;
transactedInstaller.Installers.Add(assemblyInstaller);
transactedInstaller.Install(new System.Collections.Hashtable());
txtTip.Text = "服务安装成功！";
}
catch (Exception ex)
{
txtTip.Text = ex.Message;
}
}
private static AssemblyInstaller GetInstaller(System.Reflection.Assembly assem)
{
AssemblyInstaller installer = new AssemblyInstaller(
assem, null);
installer.UseNewContext = true;
return installer;
}
public static void Uninstall(string[] args)
{
try
{
using (var installer = new AssemblyInstaller(typeof(InstallationManager).Assembly, args))
{
IDictionary state = new Hashtable();
// Install the service
installer.UseNewContext = true;
try
{
installer.Uninstall(state);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
try
{
installer.Rollback(state);
}
catch (Exception exception)
{
Console.WriteLine(exception.ToString());
}
}
}
}
catch (Exception exception)
{
Console.WriteLine("Failed to install service. Error: " + exception.Message);
}
}
/// <summary>
/// 安装服务。
/// </summary>
/// <param name="fileName">文件名称</param>
/// <param name="args">命令行参数</param>
public static void InstallService(string fileName, string[] args)
{
TransactedInstaller transactedInstaller = new TransactedInstaller();
AssemblyInstaller assemblyInstaller = new AssemblyInstaller(fileName, args);
transactedInstaller.Installers.Add(assemblyInstaller);
transactedInstaller.Install(new System.Collections.Hashtable());
}
/// <summary>
///
/// </summary>
/// <param name="assembly"></param>
/// <returns></returns>
public static AssemblyInstaller GetInstaller(string serviceName)
{
//TODO: THis is not working
AssemblyInstaller installer = new AssemblyInstaller();
installer.UseNewContext = true;
return installer;
}
private static bool ServiceInstaller(bool uninstall = false)
{
IDictionary mySavedState = new Hashtable();
try
{
// Set the commandline argument array for 'logfile'.
string[] commandLineOptions = new string[1] { string.Format("/LogFile={0}", _logFile) };
// Create an object of the 'AssemblyInstaller' class.
AssemblyInstaller myAssemblyInstaller = new
AssemblyInstaller(_installAssembly, commandLineOptions);
myAssemblyInstaller.UseNewContext = true;
if (!uninstall)
{
myAssemblyInstaller.Install(mySavedState);
// Commit the 'MyAssembly' assembly.
myAssemblyInstaller.Commit(mySavedState);
}
else
{ myAssemblyInstaller.Uninstall(mySavedState); }
}
catch (FileNotFoundException)
{
throw;
}
catch (Exception)
{ return false; }
return true;
}
public void InstallTheService()
{
try
{
IDictionary state = new Hashtable();
using (AssemblyInstaller installer = new AssemblyInstaller(InstallersAssembly, Args))
{
installer.UseNewContext = true;
try
{
installer.Install(state);
installer.Commit(state);
InternalTrace("Installed the service");
}
catch (Exception installException)
{
try
{
installer.Rollback(state);
InternalTrace("Rolledback the service installation because:" + installException.ToString());
}
catch { }
throw;
}
}
}
catch (Exception exception)
{
InternalTrace("Failed to install the service " + exception.ToString());
}
}
static void Install(bool undo, string[] args)
{
try
{
Console.WriteLine(undo ? "Uninstalling" : "Installing");
using (AssemblyInstaller inst = new AssemblyInstaller(typeof(WinSvc).Assembly, args))
{
IDictionary state = new Hashtable();
inst.UseNewContext = true;
try
{
if (undo) inst.Uninstall(state);
else
{
inst.Install(state);
inst.Commit(state);
}
}
catch
{
try { inst.Rollback(state); }
catch { }
throw;
}
}
Console.WriteLine("Done");
}
catch (Exception ex)
{
Console.Error.WriteLine(ex.Message);
}
}
public Installation() : base()
{
#region Install on MSR.LST.Net.Rtp (a necessary dependency)
AssemblyInstaller ai = new AssemblyInstaller();
ai.UseNewContext = true;
ai.Assembly = Assembly.Load("MSR.LST.Net.Rtp");
Installers.Add(ai);
#endregion
#region Install MDShowManager (if it is in the same directory)
FileInfo fi = new FileInfo(Assembly.GetExecutingAssembly().Location);
FileInfo[] foundFiles = fi.Directory.GetFiles("MDShowManager.dll");
if (foundFiles.Length == 1)
{
ai = new AssemblyInstaller();
ai.UseNewContext = true;
ai.Path = foundFiles[0].FullName;
Installers.Add(ai);
}
#endregion
#region Install Pipecleaner Agent Service (if it is in the same directory)
fi = new FileInfo(Assembly.GetExecutingAssembly().Location);
foundFiles = fi.Directory.GetFiles("Pipecleaner Agent Service.exe");
if (foundFiles.Length == 1)
{
ai = new AssemblyInstaller();
ai.UseNewContext = true;
ai.Path = foundFiles[0].FullName;
Installers.Add(ai);
}
#endregion
}
public Installation() : base()
{
// - Add the installer for MSR.LST.Net.Rtp to the list
AssemblyInstaller rtpInstall = new AssemblyInstaller();
rtpInstall.Assembly = Assembly.Load("MSR.LST.Net.Rtp");
Installers.Add(rtpInstall);
}
public void InstallService(string user, string pass) {
using (AssemblyInstaller installer = new AssemblyInstaller(Path.Combine(Utils.GetApplicationPath(), Utils.GetExecutableName()), null)) {
installer.UseNewContext = true;
Hashtable savedState = new Hashtable();
UserPassCombination c = new UserPassCombination();
c.User = user;
c.Pass = pass;
_userPassCombination = c;
installer.BeforeInstall += new InstallEventHandler(installer_BeforeInstall);
//Rollback has to be called by user code. According msdn-doc for AssemblyInstaller.Install() is probably wrong.
try {
installer.Install(savedState);
installer.Commit(savedState);
}
catch (Exception ex) {
installer.Rollback(savedState);
throw new InstallException(String.Format("Install failed: {0}", ex.Message), ex);
}
installer.BeforeInstall -= installer_BeforeInstall;
}
}
private static void Main(string[] args)
{
AppDomain.CurrentDomain.SetupInformation.PrivateBinPath = "." + Path.DirectorySeparatorChar + "lib";
Thread.CurrentThread.Name = "MAIN";
AssemblyInstaller installer = new AssemblyInstaller(Assembly.GetExecutingAssembly(), null);
Hashtable rollback = new Hashtable();
try
{
//installer.Install(rollback);
//installer.Commit(rollback);
////installer.Uninstall(rollback);
}
catch (Exception ex)
{
//installer.Rollback(rollback);
Console.WriteLine("Error installing as system service");
Console.WriteLine(ex.Message);
//Console.ReadKey();
}
Console.ReadKey();
}
private static AssemblyInstaller GetInstaller()
{
AssemblyInstaller installer = new AssemblyInstaller(
typeof(SetItUpService).Assembly, null);
installer.UseNewContext = true;
return installer;
}
/// <summary>
/// 安装Windows服务
/// </summary>
/// <param name="stateSaver">状态集合</param>
/// <param name="filepath">程序文件路径</param>
public static void InstallService(IDictionary stateSaver, String filepath)
{
AssemblyInstaller AssemblyInstaller1 = new AssemblyInstaller();
AssemblyInstaller1.UseNewContext = true;
AssemblyInstaller1.Path = filepath;
AssemblyInstaller1.Install(stateSaver);
AssemblyInstaller1.Commit(stateSaver);
AssemblyInstaller1.Dispose();
}
private void TryRollback(AssemblyInstaller installer, IDictionary state)
{
try { installer.Rollback(state); }
catch (Exception ex )
{
_log.Write(LogLevel.Warning, "An error occured during rollback. {0}", ex);
}
}
// Print help for a specific installer assembly.
private void PrintHelpFor(String filename)
{
AssemblyInstaller inst;
inst = new AssemblyInstaller(filename, options);
Console.WriteLine("Help options for {0}:", filename);
Console.WriteLine();
Console.Write(inst.HelpText);
}
private TransactedInstaller InitializeInstaller(Dictionary<string, string> parameters)
{
SetupParameters(parameters);
var ti = new TransactedInstaller();
var ai = new AssemblyInstaller(Path.Combine(_sourcePath, _serviceExecutable), _parameters);
ti.Installers.Add(ai);
var ic = new InstallContext("Install.log", _parameters);
ti.Context = ic;
return ti;
}
public void SetUp ()
{
testAssembly = Assembly.LoadFrom (testAssemblyPath);
args = new string [] { "/Option1", "--Option2", "-Option3=val", "LogFile=", "LogToConsole" };
ins = new AssemblyInstaller (testAssemblyPath, args);
ins.UseNewContext = false;
log = new StringWriter ();
log.NewLine = "\n";
Console.SetOut (log);
}
/// <summary>
/// Remove um serviço do windows do registro
/// </summary>
public static void UninstallService(String fileName)
{
Directory.SetCurrentDirectory(Path.GetDirectoryName(fileName));
String serviceName = Path.GetFileNameWithoutExtension(fileName);
String[] arguments = new string[] { "/LogFile=" + serviceName + "_Install.log" };
AssemblyInstaller installer = new AssemblyInstaller(fileName, arguments);
installer.UseNewContext = true;
installer.Uninstall(null);
}
static void Main(string[] args)
{
// 运行服务
if (args.Length == 0)
{
ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[] { new Servicesqlbackup() };
ServiceBase.Run(ServicesToRun);
}
// 安装服务
else if (args[0].ToLower() == "/i" || args[0].ToLower() == "-i")
{
try
{
string[] cmdline = { };
string serviceFileName = System.Reflection.Assembly.GetExecutingAssembly().Location;
TransactedInstaller transactedInstaller = new TransactedInstaller();
AssemblyInstaller assemblyInstaller = new AssemblyInstaller(serviceFileName, cmdline);
transactedInstaller.Installers.Add(assemblyInstaller);
transactedInstaller.Install(new System.Collections.Hashtable());
}
catch (Exception ex)
{
string msg = ex.Message;
}
}
// 删除服务
else if (args[0].ToLower() == "/u" || args[0].ToLower() == "-u")
{
try
{
string[] cmdline = { };
string serviceFileName = System.Reflection.Assembly.GetExecutingAssembly().Location;
TransactedInstaller transactedInstaller = new TransactedInstaller();
AssemblyInstaller assemblyInstaller = new AssemblyInstaller(serviceFileName, cmdline);
transactedInstaller.Installers.Add(assemblyInstaller);
transactedInstaller.Uninstall(null);
}
catch (Exception ex)
{
string msg = ex.Message;
}
}
//以窗口方式运行服务
else if (args[0].ToLower() == "/f" || args[0].ToLower() == "-f" || args[0].ToLower() == "/form" || args[0].ToLower() == "-form")
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
}
public Installer()
: base()
{
AssemblyInstaller ai = new AssemblyInstaller();
ai.Assembly = Assembly.Load("Conference");
Installers.Add(ai);
AssemblyInstaller ai2 = new AssemblyInstaller();
ai2.Assembly = Assembly.Load("LSTCommon");
Installers.Add(ai2);
}
/// <summary>
/// 卸载windows服务
/// </summary>
/// <param name="filepath">获取或设置要安装的程序集的路径。</param>
public static void UnInstallService(String serviceName, string filepath)
{
if (ServiceIsExisted(serviceName))
{
AssemblyInstaller myAssemblyInstaller = new AssemblyInstaller();
myAssemblyInstaller.UseNewContext = true;
myAssemblyInstaller.Path = filepath;
myAssemblyInstaller.Uninstall(null);
myAssemblyInstaller.Dispose();
}
}
/// <summary>
/// Acrescenta um serviço do windows no registro
/// </summary>
public static void InstallService(String fileName)
{
Directory.SetCurrentDirectory(Path.GetDirectoryName(fileName));
String serviceName = Path.GetFileNameWithoutExtension(fileName);
String[] arguments = new string[] { "/LogFile=" + serviceName + "_Install.log" };
IDictionary state = new Hashtable();
AssemblyInstaller installer = new AssemblyInstaller(fileName, arguments);
installer.UseNewContext = true;
installer.Install(state);
installer.Commit(state);
}
/// <summary>
/// Install the service that is contained in specified assembly.
/// </summary>
/// <param name="pathToAssembly">Path to service assembly.</param>
/// <param name="commandLineArguments">Parameters, that are passed to assembly.</param>
public static void InstallAssembly(string pathToAssembly, string[] commandLineArguments)
{
List<string> argList = new List<string>(commandLineArguments);
argList.Add(string.Format("/LogFile={0}_install.log",
Path.GetFileNameWithoutExtension(pathToAssembly)));
using (AssemblyInstaller installer = new AssemblyInstaller(pathToAssembly, argList.ToArray())) {
var state = new Hashtable();
installer.Install(state);
installer.Commit(state);
}
}
public void SetUp ()
{
Installer[] ins;
ins = new AssemblyInstaller[3];
ins[0] = new AssemblyInstaller ();
ins[1] = new AssemblyInstaller ();
ins[2] = new AssemblyInstaller ();
ti = new TransactedInstaller ();
ic = ti.Installers;
ic.AddRange (ins);
}
static void Install(bool undo, string[] args)
{
try
{
Console.WriteLine(undo ? "uninstalling" : "installing");
using (AssemblyInstaller inst = new AssemblyInstaller(typeof(Program).Assembly, args))
{
IDictionary state = new Hashtable();
inst.UseNewContext = true;
try
{
if (undo)
{
inst.Uninstall(state);
}
else
{
inst.Install(state);
inst.Commit(state);
try
{
ServiceController service = new ServiceController("DpFamService");
TimeSpan timeout = TimeSpan.FromMilliseconds(1000);
service.Start();
service.WaitForStatus(ServiceControllerStatus.Running, timeout);
}
catch
{
Console.WriteLine("Could not start the server\n");
}
}
}
catch
{
try
{
inst.Rollback(state);
}
catch { }
throw;
}
}
}
catch (Exception ex)
{
Console.Error.WriteLine(ex.Message);
}
}
/// <summary>Checks to see if the specified assembly can be installed.</summary>
/// <param name="assemblyName">The assembly in which to search for installers. </param>
/// <exception cref="T:System.Exception">The specified assembly cannot be installed. </exception>
public static void CheckIfInstallable(string assemblyName)
{
var assemblyInstaller = new AssemblyInstaller();
assemblyInstaller.UseNewContext = false;
assemblyInstaller.Path = assemblyName;
assemblyInstaller.CommandLine = new string[0];
assemblyInstaller.Context = new InstallContext(null, new string[0]);
assemblyInstaller.InitializeFromAssembly();
if (assemblyInstaller.Installers.Count == 0)
{
throw new InvalidOperationException(Res.GetString("InstallNoPublicInstallers", assemblyName));
}
}
public static void CheckIfInstallable(string assemblyName)
{
AssemblyInstaller installer = new AssemblyInstaller {
UseNewContext = false,
Path = assemblyName,
CommandLine = new string[0],
Context = new InstallContext(null, new string[0])
};
installer.InitializeFromAssembly();
if (installer.Installers.Count == 0)
{
throw new InvalidOperationException(System.Configuration.Install.Res.GetString("InstallNoPublicInstallers", new object[] { assemblyName }));
}
}
/// <include file='doc\AssemblyInstaller.uex' path='docs/doc[@for="AssemblyInstaller.CheckIfInstallable"]/*' />
/// <devdoc>
/// <para>
/// Finds the installers in the specified assembly, creates
/// a new instance of <see cref='System.Configuration.Install.AssemblyInstaller'/>
/// , and adds the installers to its installer collection.
/// </para>
/// </devdoc>
public static void CheckIfInstallable(string assemblyName)
{
AssemblyInstaller tester = new AssemblyInstaller();
tester.UseNewContext = false;
tester.Path = assemblyName;
tester.CommandLine = new string[0];
tester.Context = new InstallContext(null, new string[0]);
// this does the actual check and throws if necessary.
tester.InitializeFromAssembly();
if (tester.Installers.Count == 0)
{
throw new InvalidOperationException(Res.GetString(Res.InstallNoPublicInstallers, assemblyName));
}
}
public static string Uninstall(string filePath, string serviceName)
{
string msg = string.Empty;
try
{
System.Configuration.Install.AssemblyInstaller myAssemblyInstaller = new System.Configuration.Install.AssemblyInstaller();
myAssemblyInstaller.UseNewContext = true;
myAssemblyInstaller.Path = filePath;
myAssemblyInstaller.Uninstall(null);
myAssemblyInstaller.Dispose();
msg = "卸载服务" + serviceName + "成功！";
}
catch (Exception er)
{
msg = er.ToString();
}
return(msg);
}
// Run the installation process for a specific assembly.
private void RunInstall(String filename)
{
// Load the installer assembly.
AssemblyInstaller inst;
inst = new AssemblyInstaller(filename, options);
// Wrap the installer in a transaction.
TransactedInstaller trans;
trans = new TransactedInstaller();
trans.Installers.Add(inst);
// Install the assembly.
IDictionary dict = new Hashtable();
trans.Install(dict);
// Write the state information, for later uninstall.
// TODO
}
// Run the uninstallation process for a specific assembly.
private void RunUninstall(String filename)
{
// Load the installer assembly.
AssemblyInstaller inst;
inst = new AssemblyInstaller(filename, options);
// Wrap the installer in a transaction.
TransactedInstaller trans;
trans = new TransactedInstaller();
trans.Installers.Add(inst);
// Load the previous state information from the install.
IDictionary dict = new Hashtable();
// TODO
// Install the assembly.
trans.Uninstall(dict);
}
/// <summary>
///
/// </summary>
/// <param name="exeFilename">Installer class (not the service class!)</param>
/// <param name="exception"></param>
/// <returns></returns>
public static bool UninstallService(string exeFilename, out Exception exception)
{
exception = null;
string[] commandLineOptions = new string[1] {
"/LogFile=uninstall.log"
};
System.Configuration.Install.AssemblyInstaller installer =
new System.Configuration.Install.AssemblyInstaller(exeFilename, commandLineOptions);
try
{
installer.UseNewContext = true;
installer.Uninstall(null);
}
catch (Exception ex)
{
exception = ex;
return(false);
}
return(true);
}
private void InitializeFromAssembly()
{
Type[] installerTypes;
try
{
installerTypes = AssemblyInstaller.GetInstallerTypes(Assembly);
}
catch (Exception ex)
{
Context.LogMessage(Res.GetString("InstallException", (object)Path));
Installer.LogException(ex, Context);
Context.LogMessage(Res.GetString("InstallAbort", (object)Path));
throw new InvalidOperationException(Res.GetString("InstallNoInstallerTypes", (object)Path), ex);
}
if (installerTypes == null || installerTypes.Length == 0)
{
Context.LogMessage(Res.GetString("InstallNoPublicInstallers", (object)Path));
}
else
{
for (var index = 0; index < installerTypes.Length; ++index)
{
try
{
Installers.Add((Installer)Activator.CreateInstance(installerTypes[index], BindingFlags.Instance | BindingFlags.Public | BindingFlags.CreateInstance, null, new object[0], null));
}
catch (Exception ex)
{
Context.LogMessage(Res.GetString("InstallCannotCreateInstance", (object)installerTypes[index].FullName));
Installer.LogException(ex, Context);
throw new InvalidOperationException(Res.GetString("InstallCannotCreateInstance", (object)installerTypes[index].FullName), ex);
}
}
_initialized = true;
}
}
public static void InstallHelper(string[] args)
{
bool flag1 = false;
bool flag2 = false;
TransactedInstaller transactedInstaller = new TransactedInstaller();
bool flag3 = false;
try
{
ArrayList arrayList = new ArrayList();
for (int index = 0; index < args.Length; ++index)
{
if (args[index].StartsWith("/", StringComparison.Ordinal) || args[index].StartsWith("-", StringComparison.Ordinal))
{
string strA = args[index].Substring(1);
if (string.Compare(strA, "u", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(strA, "uninstall", StringComparison.OrdinalIgnoreCase) == 0)
{
flag1 = true;
}
else if (string.Compare(strA, "?", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(strA, "help", StringComparison.OrdinalIgnoreCase) == 0)
{
flag3 = true;
}
else if (string.Compare(strA, "AssemblyName", StringComparison.OrdinalIgnoreCase) == 0)
{
flag2 = true;
}
else
{
arrayList.Add((object)args[index]);
}
}
else
{
Assembly assembly;
try
{
assembly = !flag2?Assembly.LoadFrom(args[index]) : Assembly.Load(args[index]);
}
catch (Exception ex)
{
if (args[index].IndexOf('=') != -1)
{
throw new ArgumentException(Res.GetString("InstallFileDoesntExistCommandLine", new object[1]
{
(object)args[index]
}), ex);
}
else
{
throw;
}
}
AssemblyInstaller assemblyInstaller = new AssemblyInstaller(assembly, (string[])arrayList.ToArray(typeof(string)));
transactedInstaller.Installers.Add((Installer)assemblyInstaller);
}
}
if (flag3 || transactedInstaller.Installers.Count == 0)
{
flag3 = true;
transactedInstaller.Installers.Add((Installer) new AssemblyInstaller());
throw new InvalidOperationException(ManagedInstallerClass.GetHelp((Installer)transactedInstaller));
}
else
{
transactedInstaller.Context = new InstallContext("InstallUtil.InstallLog", (string[])arrayList.ToArray(typeof(string)));
}
}
catch (Exception ex)
{
if (flag3)
{
throw ex;
}
throw new InvalidOperationException(Res.GetString("InstallInitializeException", (object)ex.GetType().FullName, (object)ex.Message));
}
try
{
string strA1 = transactedInstaller.Context.Parameters["installtype"];
if (strA1 != null && string.Compare(strA1, "notransaction", StringComparison.OrdinalIgnoreCase) == 0)
{
string strA2 = transactedInstaller.Context.Parameters["action"];
if (strA2 != null && string.Compare(strA2, "rollback", StringComparison.OrdinalIgnoreCase) == 0)
{
transactedInstaller.Context.LogMessage(Res.GetString("InstallRollbackNtRun"));
for (int index = 0; index < transactedInstaller.Installers.Count; ++index)
{
transactedInstaller.Installers[index].Rollback((IDictionary)null);
}
}
else if (strA2 != null && string.Compare(strA2, "commit", StringComparison.OrdinalIgnoreCase) == 0)
{
transactedInstaller.Context.LogMessage(Res.GetString("InstallCommitNtRun"));
for (int index = 0; index < transactedInstaller.Installers.Count; ++index)
{
transactedInstaller.Installers[index].Commit((IDictionary)null);
}
}
else if (strA2 != null && string.Compare(strA2, "uninstall", StringComparison.OrdinalIgnoreCase) == 0)
{
transactedInstaller.Context.LogMessage(Res.GetString("InstallUninstallNtRun"));
for (int index = 0; index < transactedInstaller.Installers.Count; ++index)
{
transactedInstaller.Installers[index].Uninstall((IDictionary)null);
}
}
else
{
transactedInstaller.Context.LogMessage(Res.GetString("InstallInstallNtRun"));
for (int index = 0; index < transactedInstaller.Installers.Count; ++index)
{
transactedInstaller.Installers[index].Install((IDictionary)null);
}
}
}
else if (!flag1)
{
IDictionary stateSaver = (IDictionary) new Hashtable();
transactedInstaller.Install(stateSaver);
}
else
{
transactedInstaller.Uninstall((IDictionary)null);
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>Handles the functionality of the Installutil.exe (Installer Tool).</summary>
/// <param name="args">The arguments passed to the Installer Tool.</param>
public static void InstallHelper(string[] args)
{
var doUninstall = false;
var shouldLoadByName = false;
var transactedInstaller = new TransactedInstaller();
var showHelp = false;
try
{
var arrayList = new ArrayList();
foreach (var arg in args)
{
if (arg.StartsWith("-", StringComparison.Ordinal))
{
var strA = arg.Substring(1);
if (string.Compare(strA, "u", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(strA, "uninstall", StringComparison.OrdinalIgnoreCase) == 0)
{
doUninstall = true;
}
else if (string.Compare(strA, "?", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(strA, "help", StringComparison.OrdinalIgnoreCase) == 0)
{
showHelp = true;
}
else if (string.Compare(strA, "AssemblyName", StringComparison.OrdinalIgnoreCase) == 0)
{
shouldLoadByName = true;
}
else
{
arrayList.Add(arg);
}
}
else
{
Assembly assembly;
try
{
assembly = shouldLoadByName ? Assembly.Load(arg) : Assembly.LoadFrom(arg);
}
catch (Exception innerException)
{
if (arg.IndexOf('=') != -1)
{
throw new ArgumentException(Res.GetString("InstallFileDoesntExistCommandLine", arg), innerException);
}
throw;
}
var value = new AssemblyInstaller(assembly, (string[])arrayList.ToArray(typeof(string)));
transactedInstaller.Installers.Add(value);
}
}
if (showHelp || transactedInstaller.Installers.Count == 0)
{
showHelp = true;
transactedInstaller.Installers.Add(new AssemblyInstaller());
throw new InvalidOperationException(GetHelp(transactedInstaller));
}
transactedInstaller.Context = new InstallContext("InstallUtil.InstallLog", (string[])arrayList.ToArray(typeof(string)));
}
catch (Exception ex)
{
if (showHelp)
{
throw ex;
}
throw new InvalidOperationException(Res.GetString("InstallInitializeException", ex.GetType().FullName, ex.Message));
}
var installType = transactedInstaller.Context.Parameters["installtype"];
if (installType != null && string.Compare(installType, "notransaction", StringComparison.OrdinalIgnoreCase) == 0)
{
var action = transactedInstaller.Context.Parameters["action"];
if (action != null && string.Compare(action, "rollback", StringComparison.OrdinalIgnoreCase) == 0)
{
transactedInstaller.Context.LogMessage(Res.GetString("InstallRollbackNtRun"));
for (var j = 0; j < transactedInstaller.Installers.Count; j++)
{
transactedInstaller.Installers[j].Rollback(null);
}
}
else if (action != null && string.Compare(action, "commit", StringComparison.OrdinalIgnoreCase) == 0)
{
transactedInstaller.Context.LogMessage(Res.GetString("InstallCommitNtRun"));
for (var k = 0; k < transactedInstaller.Installers.Count; k++)
{
transactedInstaller.Installers[k].Commit(null);
}
}
else if (action != null && string.Compare(action, "uninstall", StringComparison.OrdinalIgnoreCase) == 0)
{
transactedInstaller.Context.LogMessage(Res.GetString("InstallUninstallNtRun"));
for (var l = 0; l < transactedInstaller.Installers.Count; l++)
{
transactedInstaller.Installers[l].Uninstall(null);
}
}
else
{
transactedInstaller.Context.LogMessage(Res.GetString("InstallInstallNtRun"));
for (var m = 0; m < transactedInstaller.Installers.Count; m++)
{
transactedInstaller.Installers[m].Install(null);
}
}
}
else if (!doUninstall)
{
IDictionary stateSaver = new Hashtable();
transactedInstaller.Install(stateSaver);
}
else
{
transactedInstaller.Uninstall(null);
}
}
/// <include file='doc\ManagedInstaller.uex' path='docs/doc[@for="ManagedInstallerClass.InstallHelper"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public static void InstallHelper(string[] args)
{
bool uninstall = false;
bool isAssemblyName = false;
TransactedInstaller topLevelInstaller = new TransactedInstaller();
bool showHelp = false;
try {
/*
* StreamWriter stream = new StreamWriter("c:\\installutilargs.txt", true);
* stream.WriteLine("----------");
* for (int i = 0; i < args.Length; i++)
* stream.WriteLine(args[i]);
* stream.Close();
*/
// strategy: Use a TransactedInstaller to manage the top-level installation work.
// It will perform rollback/commit as necessary. Go through the assemblies on the
// command line and add an AssemblyInstaller for each of them to the TransactedInstaller's
// Installers collection.
//
// as we walk the parameters, we'll encounter either a filename or a
// parameter. If we get to a filename, create an assembly installer with
// all of the parameters we've seen _so far_. This way parameters can
// be different for the different assemblies.
ArrayList parameters = new ArrayList();
for (int i = 0; i < args.Length; i++)
{
if (args[i].StartsWith("/") || args[i].StartsWith("-"))
{
string str = args[i].Substring(1);
if (string.Compare(str, "u", true, CultureInfo.InvariantCulture) == 0 || string.Compare(str, "uninstall", true, CultureInfo.InvariantCulture) == 0)
{
uninstall = true;
}
else if (string.Compare(str, "?", true, CultureInfo.InvariantCulture) == 0 || string.Compare(str, "help", true, CultureInfo.InvariantCulture) == 0)
{
showHelp = true;
}
else if (string.Compare(str, "AssemblyName", true, CultureInfo.InvariantCulture) == 0)
{
isAssemblyName = true;
}
else
{
parameters.Add(args[i]);
}
}
else
{
Assembly asm = null;
try {
if (isAssemblyName)
{
asm = Assembly.Load(args[i]);
}
else
{
asm = Assembly.LoadFrom(args[i]);
}
}
catch (Exception e) {
if (args[i].IndexOf('=') != -1)
{
// probably a mistake where /key=value was written as key=value,
// try to explain that
throw new ArgumentException(Res.GetString(Res.InstallFileDoesntExistCommandLine, args[i]), e);
}
else
{
// the assembly.Load{From} gives a good descriptive error - pass it up
throw;
}
}
AssemblyInstaller installer = new AssemblyInstaller(asm, (string[])parameters.ToArray(typeof(string)));
topLevelInstaller.Installers.Add(installer);
}
}
if (showHelp || topLevelInstaller.Installers.Count == 0)
{
// we may have seen some options, but they didn't tell us to do any
// work. Or they gave us /? or /help. Show the help screen.
showHelp = true;
topLevelInstaller.Installers.Add(new AssemblyInstaller());
throw new InvalidOperationException(GetHelp(topLevelInstaller));
}
topLevelInstaller.Context = new InstallContext("InstallUtil.InstallLog", (string[])parameters.ToArray(typeof(string)));
}
catch (Exception e) {
if (showHelp)
{
// it's just the help message
throw e;
}
else
{
throw new InvalidOperationException(Res.GetString(Res.InstallInitializeException, e.GetType().FullName, e.Message));
}
}
try {
// MSI mode.
// If the parameter /installtype=notransaction is specified, then we don't want to run
// a TransactedInstaller. Instead, we just use that installer as a container for all
// the AssemblyInstallers we want to run.
string installType = topLevelInstaller.Context.Parameters["installtype"];
if (installType != null && string.Compare(installType, "notransaction", true, CultureInfo.InvariantCulture) == 0)
{
// this is a non-transacted install. Check the value of the Action parameter
// to see what to do
string action = topLevelInstaller.Context.Parameters["action"];
if (action != null && string.Compare(action, "rollback", true, CultureInfo.InvariantCulture) == 0)
{
topLevelInstaller.Context.LogMessage(Res.GetString(Res.InstallRollbackNtRun));
for (int i = 0; i < topLevelInstaller.Installers.Count; i++)
{
topLevelInstaller.Installers[i].Rollback(null);
}
return;
}
if (action != null && string.Compare(action, "commit", true, CultureInfo.InvariantCulture) == 0)
{
topLevelInstaller.Context.LogMessage(Res.GetString(Res.InstallCommitNtRun));
for (int i = 0; i < topLevelInstaller.Installers.Count; i++)
{
topLevelInstaller.Installers[i].Commit(null);
}
return;
}
if (action != null && string.Compare(action, "uninstall", true, CultureInfo.InvariantCulture) == 0)
{
topLevelInstaller.Context.LogMessage(Res.GetString(Res.InstallUninstallNtRun));
for (int i = 0; i < topLevelInstaller.Installers.Count; i++)
{
topLevelInstaller.Installers[i].Uninstall(null);
}
return;
}
// they said notransaction, and they didn't tell us to do rollback, commit,
// or uninstall. They must mean install.
topLevelInstaller.Context.LogMessage(Res.GetString(Res.InstallInstallNtRun));
for (int i = 0; i < topLevelInstaller.Installers.Count; i++)
{
topLevelInstaller.Installers[i].Install(null);
}
return;
}
// transacted mode - we'll only get here if /installtype=notransaction wasn't specified.
if (!uninstall)
{
IDictionary stateSaver = new Hashtable();
topLevelInstaller.Install(stateSaver);
// we don't bother writing out the saved state for this guy, because each assembly
// we're installing gets its own saved-state file.
}
else
{
topLevelInstaller.Uninstall(null);
}
}
catch (Exception e) {
/*
* StreamWriter stream = new StreamWriter("c:\\installutilargs.txt", true);
* stream.WriteLine("Caught exception: " + e.GetType().FullName + ": " + e.Message);
* stream.WriteLine(e.StackTrace);
* stream.Close();
*/
throw e;
}
/*
* StreamWriter stream2 = new StreamWriter("c:\\installutilargs.txt", true);
* stream2.WriteLine("Caught no exceptions. Returning 0.");
* stream2.Close();
*/
return;
}
public static void InstallHelper(string[] args)
{
bool flag = false;
bool flag2 = false;
TransactedInstaller installerWithHelp = new TransactedInstaller();
bool flag3 = false;
try
{
ArrayList list = new ArrayList();
for (int i = 0; i < args.Length; i++)
{
if (args[i].StartsWith("/", StringComparison.Ordinal) || args[i].StartsWith("-", StringComparison.Ordinal))
{
string strA = args[i].Substring(1);
if ((string.Compare(strA, "u", StringComparison.OrdinalIgnoreCase) == 0) || (string.Compare(strA, "uninstall", StringComparison.OrdinalIgnoreCase) == 0))
{
flag = true;
}
else if ((string.Compare(strA, "?", StringComparison.OrdinalIgnoreCase) == 0) || (string.Compare(strA, "help", StringComparison.OrdinalIgnoreCase) == 0))
{
flag3 = true;
}
else if (string.Compare(strA, "AssemblyName", StringComparison.OrdinalIgnoreCase) == 0)
{
flag2 = true;
}
else
{
list.Add(args[i]);
}
}
else
{
Assembly assembly = null;
try
{
if (flag2)
{
assembly = Assembly.Load(args[i]);
}
else
{
assembly = Assembly.LoadFrom(args[i]);
}
}
catch (Exception exception)
{
if (args[i].IndexOf('=') != -1)
{
throw new ArgumentException(Res.GetString("InstallFileDoesntExistCommandLine", new object[] { args[i] }), exception);
}
throw;
}
AssemblyInstaller installer2 = new AssemblyInstaller(assembly, (string[])list.ToArray(typeof(string)));
installerWithHelp.Installers.Add(installer2);
}
}
if (flag3 || (installerWithHelp.Installers.Count == 0))
{
flag3 = true;
installerWithHelp.Installers.Add(new AssemblyInstaller());
throw new InvalidOperationException(GetHelp(installerWithHelp));
}
installerWithHelp.Context = new InstallContext("InstallUtil.InstallLog", (string[])list.ToArray(typeof(string)));
}
catch (Exception exception2)
{
if (flag3)
{
throw exception2;
}
throw new InvalidOperationException(Res.GetString("InstallInitializeException", new object[] { exception2.GetType().FullName, exception2.Message }));
}
try
{
string str2 = installerWithHelp.Context.Parameters["installtype"];
if ((str2 != null) && (string.Compare(str2, "notransaction", StringComparison.OrdinalIgnoreCase) == 0))
{
string str3 = installerWithHelp.Context.Parameters["action"];
if ((str3 != null) && (string.Compare(str3, "rollback", StringComparison.OrdinalIgnoreCase) == 0))
{
installerWithHelp.Context.LogMessage(Res.GetString("InstallRollbackNtRun"));
for (int j = 0; j < installerWithHelp.Installers.Count; j++)
{
installerWithHelp.Installers[j].Rollback(null);
}
}
else if ((str3 != null) && (string.Compare(str3, "commit", StringComparison.OrdinalIgnoreCase) == 0))
{
installerWithHelp.Context.LogMessage(Res.GetString("InstallCommitNtRun"));
for (int k = 0; k < installerWithHelp.Installers.Count; k++)
{
installerWithHelp.Installers[k].Commit(null);
}
}
else if ((str3 != null) && (string.Compare(str3, "uninstall", StringComparison.OrdinalIgnoreCase) == 0))
{
installerWithHelp.Context.LogMessage(Res.GetString("InstallUninstallNtRun"));
for (int m = 0; m < installerWithHelp.Installers.Count; m++)
{
installerWithHelp.Installers[m].Uninstall(null);
}
}
else
{
installerWithHelp.Context.LogMessage(Res.GetString("InstallInstallNtRun"));
for (int n = 0; n < installerWithHelp.Installers.Count; n++)
{
installerWithHelp.Installers[n].Install(null);
}
}
}
else if (!flag)
{
IDictionary stateSaver = new Hashtable();
installerWithHelp.Install(stateSaver);
}
else
{
installerWithHelp.Uninstall(null);
}
}
catch (Exception exception3)
{
throw exception3;
}
}
