c# 安装windows例子

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.Management;
using System.ServiceProcess;
using System.Text;

namespace KafkaService
{
    public partial class Service1 : ServiceBase
    {
        public Service1()
        {
            InitializeComponent();
        }

        protected override void OnStart(string[] args)
        {
            // TODO: 在此处添加代码以启动服务。
            System.IO.Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory);
            wLog("kafka Service Start");
            startKafka();
        }

        protected override void OnStop()
        {
            // TODO: 在此处添加代码以执行停止服务所需的关闭操作。
            //CloseKafka();
            KillProcessAndChildren(_kafkaProcess.Id);
            wLog("kafka  Service Stop\n");
        }

        Process proc = null;
        private Process _kafkaProcess;
        private void startKafka(Object sender = null, EventArgs e = null)
        {
            /* wLog("KafkaThread 开始");
             string currentDir = System.AppDomain.CurrentDomain.BaseDirectory;
             proc = new Process();
             proc.StartInfo.CreateNoWindow = true;
             proc.StartInfo.FileName = "cmd.exe";
             proc.StartInfo.UseShellExecute = false;
             proc.StartInfo.RedirectStandardError = true;
             proc.StartInfo.RedirectStandardInput = true;
             proc.StartInfo.RedirectStandardOutput = true;
             proc.Start();
             //启动kafka服务
             string volume = System.Windows.Forms.Application.StartupPath.Substring(0, System.Windows.Forms.Application.StartupPath.IndexOf(":"));
             proc.StandardInput.WriteLine("cd " + volume + ":\\kafka\\bin\\windows");
             wLog(volume + ":\\kafka\\bin\\windows");
             proc.StandardInput.WriteLine("kafka-server-start.bat server.properties");
             while (!proc.StandardOutput.EndOfStream)
             {
                 string line = proc.StandardOutput.ReadLine();
                 wLog(line);
             }
             wLog("KafkaThread 结束");
             proc.WaitForExit();*/
            _kafkaProcess = StartProcess(Constants.KafkaProcess);
        }

        private static Process StartProcess(string command)
        {
            var processInfo = new ProcessStartInfo("cmd.exe", "/c " + command)
            {
                CreateNoWindow = true,
                UseShellExecute = false,
                Verb = "runas"
            };

            return Process.Start(processInfo);
        }

        private static void KillProcessAndChildren(int pid)
        {
            using (var searcher = new ManagementObjectSearcher("Select * From Win32_Process Where ParentProcessID=" + pid))
            {
                var managementObjects = searcher.Get();

                foreach (var obj in managementObjects)
                {
                    var managementObject = (ManagementObject)obj;
                    KillProcessAndChildren(Convert.ToInt32(managementObject["ProcessID"]));
                }

                try
                {
                    var proc = Process.GetProcessById(pid);
                    proc.Kill();
                }
                catch (ArgumentException)
                {
                    // Process already exited.
                }
            }
        }

        private void CloseKafka()
        {
            wLog("Kill kafka 服务");
            if (null == proc)
                return;
            proc.Kill();
            proc.Close();
            proc = null;
        }
        private void wLog(string logStr, bool wTime = true)
        {
            using (System.IO.StreamWriter sw = new System.IO.StreamWriter(AppDomain.CurrentDomain.BaseDirectory + "\\autoService.log", true))
            {
                string timeStr = wTime == true ? DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss ") : "";
                sw.WriteLine(timeStr + logStr);
            }
        }

        private void MyProcOutputHandler(object sendingProcess, DataReceivedEventArgs outLine)
        {
            if (!String.IsNullOrEmpty(outLine.Data))
            {
                wLog(outLine.Data, false);
            }
        }
    }
}

namespace KafkaService
{
    public static class Constants
    {
        public static string KafkaVersion
        {
            get { return "0.10.2.1"; }
        }

        public static string KafkaScalaVersion
        {
            get { return "kafka_2.12-" + KafkaVersion; }
        }

        public static string DownloadUrl
        {
            get { return "http://apache.claz.org/kafka/" + KafkaVersion + "/" + KafkaScalaVersion + ".tgz"; }
        }

        public static string TarFileName
        {
            get { return KafkaScalaVersion + ".tgz"; }
        }

        public static string UncompressedTarFileName
        {
            get { return KafkaScalaVersion + ".tar"; }
        }

        public static string RootDirectory
        {
            get { return @"C:\";  }
        }

        public static string RootDirectoryLinux
        {
            get { return @"C:/"; }
        }

        public static string KafkaLocation
        {
            get { return RootDirectory + KafkaScalaVersion;  }
        }

        public static string ZookeeperProcess
        {
            get
            {

                return RootDirectory +
                    KafkaScalaVersion + @"\bin\windows\zookeeper-server-start.bat " + KafkaLocation + @"\config\zookeeper.properties";
            }
        }

        public static string KafkaProcess
        {
            get
            {
                string volume = System.Windows.Forms.Application.StartupPath.Substring(0, System.Windows.Forms.Application.StartupPath.IndexOf(":"));
                return volume + ":\\kafka\\bin\\windows\\kafka-server-start.bat " + volume + ":\\kafka\\config\\server.properties";
            }
        }

        public static string ZookeeperConfig
        {
            get { return RootDirectory + @"\" + KafkaScalaVersion + @"\config\zookeeper.properties"; }
        }

        public static string KafkaConfig
        {
            get { return RootDirectory + @"\" + KafkaScalaVersion + @"\config\server.properties"; }
        }

        public static string DataDir
        {
            get { return RootDirectory + KafkaScalaVersion + @"\data"; }
        }

        public static string LogDir
        {
            get { return RootDirectory + KafkaScalaVersion + @"\kafka-logs"; }
        }

        public static string DataDirLinux
        {
            get { return RootDirectoryLinux + KafkaScalaVersion + @"/data"; }
        }

        public static string LogDirLinux
        {
            get { return RootDirectoryLinux + KafkaScalaVersion + @"/kafka-logs"; }
        }
    }
}

#region

using KafkaService.Installer;
using System;
using System.Diagnostics;
using System.Management;

#endregion

namespace KafkaService
{
    public class KafkaServiceWrapper
    {
        private Process _zookeeperProcess;
        private Process _kafkaProcess;

        public void Start()
        {
            ApacheKafkaInstaller.Install();

            _zookeeperProcess = StartProcess(Constants.ZookeeperProcess);
            _kafkaProcess = StartProcess(Constants.KafkaProcess);
        }

        public void Stop()
        {
            KillProcessAndChildren(_kafkaProcess.Id);
            KillProcessAndChildren(_zookeeperProcess.Id);
        }

        private static Process StartProcess(string command)
        {
            var processInfo = new ProcessStartInfo("cmd.exe", "/c " + command)
            {
                CreateNoWindow = true,
                UseShellExecute = false,
                Verb = "runas"
            };

            return Process.Start(processInfo);
        }

        private static void KillProcessAndChildren(int pid)
        {
            using (var searcher = new ManagementObjectSearcher("Select * From Win32_Process Where ParentProcessID=" + pid))
            {
                var managementObjects = searcher.Get();

                foreach (var obj in managementObjects)
                {
                    var managementObject = (ManagementObject) obj;
                    KillProcessAndChildren(Convert.ToInt32(managementObject["ProcessID"]));
                }

                try
                {
                    var proc = Process.GetProcessById(pid);
                    proc.Kill();
                }
                catch (ArgumentException)
                {
                    // Process already exited.
                }
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Text.RegularExpressions;

namespace KafkaService.Installer
{
    /// <summary>
    /// Responsible for downloading and setting up Apache Kafka in the root directory of the program.
    /// </summary>
    public static class ApacheKafkaInstaller
    {
        private const string SEVENZIP_LOCATION = @"Lib\7z.exe";

        /// <summary>
        /// Downloads and sets up Apache Kafka locally in the root directory of the program.
        /// This ensures both Kafka and Zookeeper are configured to work within a Windows environment.
        /// </summary>
        public static void Install()
        {
            DownloadAndExtractKafka();
            SetupWindowsEnvironment();
        }

        private static void DownloadAndExtractKafka()
        {
            if (Directory.Exists(Constants.KafkaLocation))
            {
                Console.WriteLine("{0} already downloaded and extracted", Constants.KafkaLocation);
                return;
            }

            // Delete the extracted file so we can unzip it again.
            DeleteFileIfExists(Constants.UncompressedTarFileName);

            if (!File.Exists(Constants.TarFileName))
            {
                DownloadKafka();
            }

            ExtractKafka();
            MoveKafka();
            DeleteFileIfExists(Constants.UncompressedTarFileName);
            DeleteFileIfExists(Constants.TarFileName);
        }

        private static void DeleteFileIfExists(string filename)
        {
            if (File.Exists(filename))
            {
                File.Delete(filename);
            }
        }

        private static void DownloadKafka()
        {
            using (var client = new WebClient())
            {
                client.DownloadFile(Constants.DownloadUrl, Constants.TarFileName);
            }

            Console.WriteLine("Downloaded {0}", Constants.TarFileName);
        }

        private static void ExtractKafka()
        {
            Process.Start(SEVENZIP_LOCATION, "e " + Constants.TarFileName).WaitForExit();
            Process.Start(SEVENZIP_LOCATION, "x " + Constants.UncompressedTarFileName).WaitForExit();

            Console.WriteLine("Extracted {0} into {1}", Constants.TarFileName, Constants.KafkaScalaVersion);
        }

        private static void MoveKafka()
        {
            string sourceDirectory = Constants.KafkaScalaVersion;
            string destinationDirectory = Constants.KafkaLocation;

            MoveAcrossVolumes(sourceDirectory, destinationDirectory);
        }

        private static void MoveAcrossVolumes(string sourceDirectory, string destinationDirectory)
        {
            foreach (var file in Directory.GetFileSystemEntries(sourceDirectory, "*", SearchOption.AllDirectories))
            {
                var output = Regex.Replace(file, @"^" + sourceDirectory, destinationDirectory);
                if (File.Exists(file))
                {
                    File.Copy(file, output, true);
                }
                else
                {
                    Directory.CreateDirectory(output);
                }
            }
            Directory.Delete(sourceDirectory, true);
        }


        private static void SetupWindowsEnvironment()
        {
            //var dataDir = string.Format("{0}/data", Constants.KafkaScalaVersion);
            //var loggingDir = string.Format("{0}/kafka-logs", Constants.KafkaScalaVersion);

            CreateDirectoryIfNotExists(Constants.DataDir);
            CreateDirectoryIfNotExists(Constants.LogDir);

            ReplaceLineInFile(Constants.ZookeeperConfig, "dataDir=/tmp/zookeeper", "dataDir=" + Constants.DataDirLinux);
            ReplaceLineInFile(Constants.KafkaConfig, "log.dirs=/tmp/kafka-logs", "log.dirs=" + Constants.LogDirLinux);
        }

        private static void CreateDirectoryIfNotExists(string dir)
        {
            if (!Directory.Exists(dir))
            {
                Directory.CreateDirectory(dir);
            }
        }

        private static void ReplaceLineInFile(string filename, string lineToMatch, string replaceWith)
        {
            var fileToOutput = new List<string>();
            using (var inputStream = File.OpenRead(filename))
            using (var inputReader = new StreamReader(inputStream))
            {
                string currentLine;
                while ((currentLine = inputReader.ReadLine()) != null)
                {
                    if (currentLine == lineToMatch)
                    {
                        currentLine = replaceWith;
                    }

                    fileToOutput.Add(currentLine);
                }
            }

            File.WriteAllLines(filename, fileToOutput);
        }
    }
}