InstallUtil.exe ছাড়া একটি .NET জানালা পরিষেবা ইনস্টল করুন


166

আমার কাছে সি স্ট্যান্ডার্ড .NET উইন্ডোজ পরিষেবা লিখিত আছে।

এটি ইনস্টলটুল ব্যবহার না করে নিজেই ইনস্টল করতে পারে? আমার কি পরিষেবা ইনস্টলার ক্লাসটি ব্যবহার করা উচিত? আমার এটি কীভাবে ব্যবহার করা উচিত?

আমি নিম্নলিখিতগুলিতে কল করতে সক্ষম হতে চাই:

MyService.exe -install

এবং এটি কল করার মতোই প্রভাব ফেলবে:

InstallUtil MyService.exe

1
আমি কেবল এই প্রশ্নটি জুড়ে এসেছি, তবে এখানে উত্তরগুলি কিছুটা পুরানো। এখন (কমপক্ষে 2015 সাল থেকে) আমরা উইন্ডোজ পরিষেবাটি ইনস্টল করতে কেবল এসসি কমান্ডটি ব্যবহার করতে পারি, এখানে বর্ণিত স্ট্যাকওভারফ্লো . com/a/34220957/512993 । দাবি অস্বীকার: আমি উত্তরটি লিখেছি।
হোং লং

উত্তর:


158

হ্যাঁ, এটি সম্পূর্ণরূপে সম্ভব (যেমন আমি ঠিক এটি করি); আপনাকে কেবল সঠিক dll (System.ServiceProcess.dll) উল্লেখ করতে হবে এবং একটি ইনস্টলার শ্রেণি যুক্ত করতে হবে ...

এখানে একটি উদাহরণ:

[RunInstaller(true)]
public sealed class MyServiceInstallerProcess : ServiceProcessInstaller
{
    public MyServiceInstallerProcess()
    {
        this.Account = ServiceAccount.NetworkService;
    }
}

[RunInstaller(true)]
public sealed class MyServiceInstaller : ServiceInstaller
{
    public MyServiceInstaller()
    {
        this.Description = "Service Description";
        this.DisplayName = "Service Name";
        this.ServiceName = "ServiceName";
        this.StartType = System.ServiceProcess.ServiceStartMode.Automatic;
    }
}

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);
                }
            }
            catch
            {
                try
                {
                    inst.Rollback(state);
                }
                catch { }
                throw;
            }
        }
    }
    catch (Exception ex)
    {
        Console.Error.WriteLine(ex.Message);
    }
}


5
@ মার্কগ্রাভেল আপনার সম্ভবত কোডটি এখানে অন্তর্ভুক্ত করা উচিত, কারণ এটি উত্তর ব্যতীত খুব কার্যকর নয়।
রিচার্ড জাজলে 22

@ মার্কগ্রাভেল আপনার লিঙ্কযুক্ত উদাহরণে static void Install(bool undo, string[] args)কোনও শ্রেণির (ইত্যাদি) সংজ্ঞার বাইরে রয়েছে। আপনি কীভাবে এটি প্রয়োগ করেছেন তা আপনি পরিষ্কার করতে পারেন?
খারগুশ

39

ম্যানেজডইনস্টলার শ্রেণীর ইনস্টলহেল্পার পদ্ধতিটি একবার দেখুন । আপনি এটি ব্যবহার করে কোনও পরিষেবা ইনস্টল করতে পারেন:

string[] args;
ManagedInstallerClass.InstallHelper(args);

ইনস্টলটুল ঠিক এটিই করে। আর্গুমেন্ট ইনস্টলটুলের মতো।

এই পদ্ধতির সুবিধা হ'ল এটিতে রেজিস্ট্রিতে কোনও গোলমাল জড়িত নয় এবং এটি ইনস্টলটুলের মতো একই পদ্ধতি ব্যবহার করে।



13
যখন ডক্স বলছে এটি ব্যবহারকারীর কোড দ্বারা কল করার জন্য নয় তবে আপনি কেন এটিকে পরামর্শ দিচ্ছেন?
লিকস এবং লিকস

6
আমি এই পদ্ধতিটি ব্যবহার করি কারণ 1. এটি সহজ 2 2. InstallUtilx86 / x64 4 এ ইনস্টলারটি পরিবর্তন করার দরকার নেই 4.. নেট এর বেশ কয়েকটি সংস্করণে এটি পরিবর্তন হয়নি - এটি যদি হয় তবে , এটি পরীক্ষায় নেওয়া হবে এবং আমি এটি ঠিক করব then
adrianbanks

19

আপনি সর্বদা ভাল পুরানো উইনএপিআই কলগুলিতে ফিরে যেতে পারেন, যদিও এতে জড়িত কাজের পরিমাণ অল্প-তুচ্ছ। .NET- সচেতনতামূলক ব্যবস্থার মাধ্যমে নেট নেটওয়ার্কগুলি ইনস্টল করার দরকার নেই।

স্থাপন করা:

  • এর মাধ্যমে সার্ভিস ম্যানেজারটি খুলুন OpenSCManager
  • CreateServiceপরিষেবাটি নিবন্ধ করার জন্য কল করুন ।
  • ChangeServiceConfig2একটি বিবরণ সেট করতে ptionচ্ছিকভাবে কল করুন ।
  • পরিষেবা এবং পরিষেবা পরিচালকের সাথে হ্যান্ডলগুলি বন্ধ করুন CloseServiceHandle

আনইনস্টল করতে:

  • এর মাধ্যমে সার্ভিস ম্যানেজারটি খুলুন OpenSCManager
  • ব্যবহার করে পরিষেবাটি খুলুন OpenService
  • DeleteServiceফিরে আসা হ্যান্ডেলটিতে কল করে পরিষেবাটি মুছুন OpenService
  • পরিষেবা এবং পরিষেবা পরিচালকের সাথে হ্যান্ডলগুলি বন্ধ করুন CloseServiceHandle

ServiceInstaller/ এর ব্যবহারের চেয়ে বেশি পছন্দ করার মূল কারণটি ServiceProcessInstallerহ'ল আপনি নিজের কাস্টম কমান্ড লাইনের যুক্তি দিয়ে পরিষেবাটি নিবন্ধিত করতে পারেন। উদাহরণস্বরূপ, আপনি এটি হিসাবে এটি নিবন্ধভুক্ত করতে "MyApp.exe -service"পারেন, তারপরে ব্যবহারকারী যদি কোনও যুক্তি ছাড়াই আপনার অ্যাপ্লিকেশন চালান তবে আপনি পরিষেবাটি ইনস্টল / সরানোর জন্য তাদের একটি ইউআই অফার করতে পারেন।

চলমান রিফ্লেক্টর ServiceInstallerএই সংক্ষিপ্ত ব্যাখ্যা থেকে অনুপস্থিত বিশদটি পূরণ করতে পারে।

PS স্পষ্টতই এর "কলিংয়ের মতো একই প্রভাব থাকবে না: ইনস্টলটুইল মাই সার্ভিস.এক্সই" - বিশেষত, আপনি ইনস্টলটুলটি ব্যবহার করে আনইনস্টল করতে পারবেন না। তবে মনে হয় এটি সম্ভবত আপনার পক্ষে সত্যিকারের কঠোর প্রয়োজন ছিল না।


আপনার পদক্ষেপগুলি আশ্চর্যের সাথে অনুসরণ করা সহজ। এমএসডিএন উইন এপিআই ডকুমেন্টেশনগুলিতে অবতরণের জন্য কিছুটা অতিরিক্ত গুগলিং এবং এটি কার্যত নিজের লেখায়!
মাইকেল প্লুটজ

9

পরিষেবাগুলি লেখার সময় আমি এখানে একটি ক্লাস ব্যবহার করি। আমার কাছে একটি ইন্টারেক্টিভ স্ক্রিন থাকে যা পরিষেবাটি কল করা না হলে আসে up সেখান থেকে ক্লাসটি প্রয়োজন মতো ব্যবহার করি। এটি একই মেশিনে ইনস্ট্যান্সআইডি ক্ষেত্রের একাধিক নামকরণের জন্য অনুমতি দেয়

নমুনা কল

  IntegratedServiceInstaller Inst = new IntegratedServiceInstaller();
  Inst.Install("MySvc", "My Sample Service", "Service that executes something",
                    _InstanceID,
// System.ServiceProcess.ServiceAccount.LocalService,      // this is more secure, but only available in XP and above and WS-2003 and above
  System.ServiceProcess.ServiceAccount.LocalSystem,       // this is required for WS-2000
  System.ServiceProcess.ServiceStartMode.Automatic);
  if (controller == null)
  {
    controller = new System.ServiceProcess.ServiceController(String.Format("MySvc_{0}", _InstanceID), ".");
                }
                if (controller.Status == System.ServiceProcess.ServiceControllerStatus.Running)
                {
                    Start_Stop.Text = "Stop Service";
                    Start_Stop_Debugging.Enabled = false;
                }
                else
                {
                    Start_Stop.Text = "Start Service";
                    Start_Stop_Debugging.Enabled = true;
                }

ক্লাস নিজেই

using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using Microsoft.Win32;

namespace MySvc
{
    class IntegratedServiceInstaller
    {
        public void Install(String ServiceName, String DisplayName, String Description,
            String InstanceID,
            System.ServiceProcess.ServiceAccount Account, 
            System.ServiceProcess.ServiceStartMode StartMode)
        {
            //http://www.theblacksparrow.com/
            System.ServiceProcess.ServiceProcessInstaller ProcessInstaller = new System.ServiceProcess.ServiceProcessInstaller();
            ProcessInstaller.Account = Account;

            System.ServiceProcess.ServiceInstaller SINST = new System.ServiceProcess.ServiceInstaller();

            System.Configuration.Install.InstallContext Context = new System.Configuration.Install.InstallContext();
            string processPath = Process.GetCurrentProcess().MainModule.FileName;
            if (processPath != null && processPath.Length > 0)
            {
                System.IO.FileInfo fi = new System.IO.FileInfo(processPath);

                String path = String.Format("/assemblypath={0}", fi.FullName);
                String[] cmdline = { path };
                Context = new System.Configuration.Install.InstallContext("", cmdline);
            }

            SINST.Context = Context;
            SINST.DisplayName = String.Format("{0} - {1}", DisplayName, InstanceID);
            SINST.Description = String.Format("{0} - {1}", Description, InstanceID);
            SINST.ServiceName = String.Format("{0}_{1}", ServiceName, InstanceID);
            SINST.StartType = StartMode;
            SINST.Parent = ProcessInstaller;

            // http://bytes.com/forum/thread527221.html
            SINST.ServicesDependedOn = new String[] { "Spooler", "Netlogon", "Netman" };

            System.Collections.Specialized.ListDictionary state = new System.Collections.Specialized.ListDictionary();
            SINST.Install(state);

            // http://www.dotnet247.com/247reference/msgs/43/219565.aspx
            using (RegistryKey oKey = Registry.LocalMachine.OpenSubKey(String.Format(@"SYSTEM\CurrentControlSet\Services\{0}_{1}", ServiceName, InstanceID), true))
            {
                try
                {
                    Object sValue = oKey.GetValue("ImagePath");
                    oKey.SetValue("ImagePath", sValue);
                }
                catch (Exception Ex)
                {
                    System.Windows.Forms.MessageBox.Show(Ex.Message);
                }
            }

        }
        public void Uninstall(String ServiceName, String InstanceID)
        {
            //http://www.theblacksparrow.com/
            System.ServiceProcess.ServiceInstaller SINST = new System.ServiceProcess.ServiceInstaller();

            System.Configuration.Install.InstallContext Context = new System.Configuration.Install.InstallContext("c:\\install.log", null);
            SINST.Context = Context;
            SINST.ServiceName = String.Format("{0}_{1}", ServiceName, InstanceID);
            SINST.Uninstall(null);
        }
    }
}

Thedavejay.com/2012/04/… সম্পর্কে কি ?
কিকিনেট

এটি "প্যাসিভলি" একটি পৃথক এক্সিকিউটেবলকে নিবন্ধিত করতেও ব্যবহার করা যেতে পারে, আমি সেই GetCurrentProcessঅংশটি একটি প্যারামিটার দিয়ে প্রতিস্থাপন করেছি এবং এটি সফলভাবে ব্যবহার করেছি। দুর্দান্ত কাজ!
সিই ম্যাকশারফেস

_InstanceID কি?
jjxtra

আমার একটি অ্যাপ্লিকেশন রয়েছে যেখানে আমি একই পরিষেবাটির একাধিক অনুলিপি ব্যবহার করি, বিভিন্ন ডাটাবেসগুলিতে নির্দেশিত। কনফিগারেশন ফাইলে সংরক্ষিত একটি ইনস্ট্যান্স আইডি দিয়ে আমি তাদের পার্থক্য করি। পরিষেবার জন্য একাধিক ভাড়াটে ...
ব্র্যাড ব্রুস

5

উপরের উদাহরণগুলি সত্যই আমার পক্ষে কার্যকর হয়নি এবং # 1 সমাধান হিসাবে ফোরামের লিঙ্কটি খনন করা ভয়ানক। এখানে আমি লিখেছি এমন একটি শ্রেণী রয়েছে (অংশে), এবং অন্য কিছুটি এই লিঙ্কটি থেকে একত্রিত হয়েছে যা আমি কোথাও কবর পেয়েছি

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using System.ServiceProcess;
using System.Runtime.InteropServices;

namespace SystemControl {
    class Services {

#region "Environment Variables"
        public static string GetEnvironment(string name, bool ExpandVariables=true) {
            if ( ExpandVariables ) {
                return System.Environment.GetEnvironmentVariable( name );
            } else {
                return (string)Microsoft.Win32.Registry.LocalMachine.OpenSubKey( @"SYSTEM\CurrentControlSet\Control\Session Manager\Environment\" ).GetValue( name, "", Microsoft.Win32.RegistryValueOptions.DoNotExpandEnvironmentNames );
            }
        }

        public static void SetEnvironment( string name, string value ) {
            System.Environment.SetEnvironmentVariable(name, value);
        }
#endregion

#region "ServiceCalls Native"
        public static ServiceController[] List { get { return ServiceController.GetServices(); } }

        public static void Start( string serviceName, int timeoutMilliseconds ) {
            ServiceController service=new ServiceController( serviceName );
            try {
                TimeSpan timeout=TimeSpan.FromMilliseconds( timeoutMilliseconds );

                service.Start();
                service.WaitForStatus( ServiceControllerStatus.Running, timeout );
            } catch {
                // ...
            }
        }

        public static void Stop( string serviceName, int timeoutMilliseconds ) {
            ServiceController service=new ServiceController( serviceName );
            try {
                TimeSpan timeout=TimeSpan.FromMilliseconds( timeoutMilliseconds );

                service.Stop();
                service.WaitForStatus( ServiceControllerStatus.Stopped, timeout );
            } catch {
                // ...
            }
        }

        public static void Restart( string serviceName, int timeoutMilliseconds ) {
            ServiceController service=new ServiceController( serviceName );
            try {
                int millisec1=Environment.TickCount;
                TimeSpan timeout=TimeSpan.FromMilliseconds( timeoutMilliseconds );

                service.Stop();
                service.WaitForStatus( ServiceControllerStatus.Stopped, timeout );

                // count the rest of the timeout
                int millisec2=Environment.TickCount;
                timeout=TimeSpan.FromMilliseconds( timeoutMilliseconds-( millisec2-millisec1 ) );

                service.Start();
                service.WaitForStatus( ServiceControllerStatus.Running, timeout );
            } catch {
                // ...
            }
        }

        public static bool IsInstalled( string serviceName ) {
            // get list of Windows services
            ServiceController[] services=ServiceController.GetServices();

            // try to find service name
            foreach ( ServiceController service in services ) {
                if ( service.ServiceName==serviceName )
                    return true;
            }
            return false;
        }
#endregion

#region "ServiceCalls API"
        private const int STANDARD_RIGHTS_REQUIRED = 0xF0000;
        private const int SERVICE_WIN32_OWN_PROCESS = 0x00000010;

        [Flags]
        public enum ServiceManagerRights {
            Connect = 0x0001,
            CreateService = 0x0002,
            EnumerateService = 0x0004,
            Lock = 0x0008,
            QueryLockStatus = 0x0010,
            ModifyBootConfig = 0x0020,
            StandardRightsRequired = 0xF0000,
            AllAccess = (StandardRightsRequired | Connect | CreateService |
            EnumerateService | Lock | QueryLockStatus | ModifyBootConfig)
        }

        [Flags]
        public enum ServiceRights {
            QueryConfig = 0x1,
            ChangeConfig = 0x2,
            QueryStatus = 0x4,
            EnumerateDependants = 0x8,
            Start = 0x10,
            Stop = 0x20,
            PauseContinue = 0x40,
            Interrogate = 0x80,
            UserDefinedControl = 0x100,
            Delete = 0x00010000,
            StandardRightsRequired = 0xF0000,
            AllAccess = (StandardRightsRequired | QueryConfig | ChangeConfig |
            QueryStatus | EnumerateDependants | Start | Stop | PauseContinue |
            Interrogate | UserDefinedControl)
        }

        public enum ServiceBootFlag {
            Start = 0x00000000,
            SystemStart = 0x00000001,
            AutoStart = 0x00000002,
            DemandStart = 0x00000003,
            Disabled = 0x00000004
        }

        public enum ServiceState {
            Unknown = -1, // The state cannot be (has not been) retrieved.
            NotFound = 0, // The service is not known on the host server.
            Stop = 1, // The service is NET stopped.
            Run = 2, // The service is NET started.
            Stopping = 3,
            Starting = 4,
        }

        public enum ServiceControl {
            Stop = 0x00000001,
            Pause = 0x00000002,
            Continue = 0x00000003,
            Interrogate = 0x00000004,
            Shutdown = 0x00000005,
            ParamChange = 0x00000006,
            NetBindAdd = 0x00000007,
            NetBindRemove = 0x00000008,
            NetBindEnable = 0x00000009,
            NetBindDisable = 0x0000000A
        }

        public enum ServiceError {
            Ignore = 0x00000000,
            Normal = 0x00000001,
            Severe = 0x00000002,
            Critical = 0x00000003
        }

        [StructLayout(LayoutKind.Sequential)]
        private class SERVICE_STATUS {
            public int dwServiceType = 0;
            public ServiceState dwCurrentState = 0;
            public int dwControlsAccepted = 0;
            public int dwWin32ExitCode = 0;
            public int dwServiceSpecificExitCode = 0;
            public int dwCheckPoint = 0;
            public int dwWaitHint = 0;
        }

        [DllImport("advapi32.dll", EntryPoint = "OpenSCManagerA")]
        private static extern IntPtr OpenSCManager(string lpMachineName, string lpDatabaseName, ServiceManagerRights dwDesiredAccess);
        [DllImport("advapi32.dll", EntryPoint = "OpenServiceA", CharSet = CharSet.Ansi)]
        private static extern IntPtr OpenService(IntPtr hSCManager, string lpServiceName, ServiceRights dwDesiredAccess);
        [DllImport("advapi32.dll", EntryPoint = "CreateServiceA")]
        private static extern IntPtr CreateService(IntPtr hSCManager, string lpServiceName, string lpDisplayName, ServiceRights dwDesiredAccess, int dwServiceType, ServiceBootFlag dwStartType, ServiceError dwErrorControl, string lpBinaryPathName, string lpLoadOrderGroup, IntPtr lpdwTagId, string lpDependencies, string lp, string lpPassword);
        [DllImport("advapi32.dll")]
        private static extern int CloseServiceHandle(IntPtr hSCObject);
        [DllImport("advapi32.dll")]
        private static extern int QueryServiceStatus(IntPtr hService, SERVICE_STATUS lpServiceStatus);
        [DllImport("advapi32.dll", SetLastError = true)]
        private static extern int DeleteService(IntPtr hService);
        [DllImport("advapi32.dll")]
        private static extern int ControlService(IntPtr hService, ServiceControl dwControl, SERVICE_STATUS lpServiceStatus);
        [DllImport("advapi32.dll", EntryPoint = "StartServiceA")]
        private static extern int StartService(IntPtr hService, int dwNumServiceArgs, int lpServiceArgVectors);

        /// <summary>
        /// Takes a service name and tries to stop and then uninstall the windows serviceError
        /// </summary>
        /// <param name="ServiceName">The windows service name to uninstall</param>
        public static void Uninstall(string ServiceName)
        {
            IntPtr scman = OpenSCManager(ServiceManagerRights.Connect);
            try
            {
                IntPtr service = OpenService(scman, ServiceName, ServiceRights.StandardRightsRequired | ServiceRights.Stop | ServiceRights.QueryStatus);
                if (service == IntPtr.Zero)
                {
                    throw new ApplicationException("Service not installed.");
                }
                try
                {
                    StopService(service);
                    int ret = DeleteService(service);
                    if (ret == 0)
                    {
                        int error = Marshal.GetLastWin32Error();
                        throw new ApplicationException("Could not delete service " + error);
                    }
                }
                finally
                {
                    CloseServiceHandle(service);
                }
            }
            finally
            {
                CloseServiceHandle(scman);
            }
        }

        /// <summary>
        /// Accepts a service name and returns true if the service with that service name exists
        /// </summary>
        /// <param name="ServiceName">The service name that we will check for existence</param>
        /// <returns>True if that service exists false otherwise</returns>
        public static bool ServiceIsInstalled(string ServiceName)
        {
            IntPtr scman = OpenSCManager(ServiceManagerRights.Connect);
            try
            {
                IntPtr service = OpenService(scman, ServiceName,
                ServiceRights.QueryStatus);
                if (service == IntPtr.Zero) return false;
                CloseServiceHandle(service);
                return true;
            }
            finally
            {
                CloseServiceHandle(scman);
            }
        }

        /// <summary>
        /// Takes a service name, a service display name and the path to the service executable and installs / starts the windows service.
        /// </summary>
        /// <param name="ServiceName">The service name that this service will have</param>
        /// <param name="DisplayName">The display name that this service will have</param>
        /// <param name="FileName">The path to the executable of the service</param>
        public static void InstallAndStart(string ServiceName, string DisplayName,
        string FileName)
        {
            IntPtr scman = OpenSCManager(ServiceManagerRights.Connect |
            ServiceManagerRights.CreateService);
            try
            {
                IntPtr service = OpenService(scman, ServiceName,
                ServiceRights.QueryStatus | ServiceRights.Start);
                if (service == IntPtr.Zero)
                {
                    service = CreateService(scman, ServiceName, DisplayName,
                    ServiceRights.QueryStatus | ServiceRights.Start, SERVICE_WIN32_OWN_PROCESS,
                    ServiceBootFlag.AutoStart, ServiceError.Normal, FileName, null, IntPtr.Zero,
                    null, null, null);
                }
                if (service == IntPtr.Zero)
                {
                    throw new ApplicationException("Failed to install service.");
                }
                try
                {
                    StartService(service);
                }
                finally
                {
                    CloseServiceHandle(service);
                }
            }
            finally
            {
                CloseServiceHandle(scman);
            }
        }

        /// <summary>
        /// Takes a service name and starts it
        /// </summary>
        /// <param name="Name">The service name</param>
        public static void StartService(string Name)
        {
            IntPtr scman = OpenSCManager(ServiceManagerRights.Connect);
            try
            {
                IntPtr hService = OpenService(scman, Name, ServiceRights.QueryStatus |
                ServiceRights.Start);
                if (hService == IntPtr.Zero)
                {
                    throw new ApplicationException("Could not open service.");
                }
                try
                {
                    StartService(hService);
                }
                finally
                {
                    CloseServiceHandle(hService);
                }
            }
            finally
            {
                CloseServiceHandle(scman);
            }
        }

        /// <summary>
        /// Stops the provided windows service
        /// </summary>
        /// <param name="Name">The service name that will be stopped</param>
        public static void StopService(string Name)
        {
            IntPtr scman = OpenSCManager(ServiceManagerRights.Connect);
            try
            {
                IntPtr hService = OpenService(scman, Name, ServiceRights.QueryStatus |
                ServiceRights.Stop);
                if (hService == IntPtr.Zero)
                {
                    throw new ApplicationException("Could not open service.");
                }
                try
                {
                    StopService(hService);
                }
                finally
                {
                    CloseServiceHandle(hService);
                }
            }
            finally
            {
                CloseServiceHandle(scman);
            }
        }

        /// <summary>
        /// Stars the provided windows service
        /// </summary>
        /// <param name="hService">The handle to the windows service</param>
        private static void StartService(IntPtr hService)
        {
            SERVICE_STATUS status = new SERVICE_STATUS();
            StartService(hService, 0, 0);
            WaitForServiceStatus(hService, ServiceState.Starting, ServiceState.Run);
        }

        /// <summary>
        /// Stops the provided windows service
        /// </summary>
        /// <param name="hService">The handle to the windows service</param>
        private static void StopService(IntPtr hService)
        {
            SERVICE_STATUS status = new SERVICE_STATUS();
            ControlService(hService, ServiceControl.Stop, status);
            WaitForServiceStatus(hService, ServiceState.Stopping, ServiceState.Stop);
        }

        /// <summary>
        /// Takes a service name and returns the <code>ServiceState</code> of the corresponding service
        /// </summary>
        /// <param name="ServiceName">The service name that we will check for his <code>ServiceState</code></param>
        /// <returns>The ServiceState of the service we wanted to check</returns>
        public static ServiceState GetServiceStatus(string ServiceName)
        {
            IntPtr scman = OpenSCManager(ServiceManagerRights.Connect);
            try
            {
                IntPtr hService = OpenService(scman, ServiceName,
                ServiceRights.QueryStatus);
                if (hService == IntPtr.Zero)
                {
                    return ServiceState.NotFound;
                }
                try
                {
                    return GetServiceStatus(hService);
                }
                finally
                {
                    CloseServiceHandle(scman);
                }
            }
            finally
            {
                CloseServiceHandle(scman);
            }
        }

        /// <summary>
        /// Gets the service state by using the handle of the provided windows service
        /// </summary>
        /// <param name="hService">The handle to the service</param>
        /// <returns>The <code>ServiceState</code> of the service</returns>
        private static ServiceState GetServiceStatus(IntPtr hService)
        {
            SERVICE_STATUS ssStatus = new SERVICE_STATUS();
            if (QueryServiceStatus(hService, ssStatus) == 0)
            {
                throw new ApplicationException("Failed to query service status.");
            }
            return ssStatus.dwCurrentState;
        }

        /// <summary>
        /// Returns true when the service status has been changes from wait status to desired status
        /// ,this method waits around 10 seconds for this operation.
        /// </summary>
        /// <param name="hService">The handle to the service</param>
        /// <param name="WaitStatus">The current state of the service</param>
        /// <param name="DesiredStatus">The desired state of the service</param>
        /// <returns>bool if the service has successfully changed states within the allowed timeline</returns>
        private static bool WaitForServiceStatus(IntPtr hService, ServiceState
        WaitStatus, ServiceState DesiredStatus)
        {
            SERVICE_STATUS ssStatus = new SERVICE_STATUS();
            int dwOldCheckPoint;
            int dwStartTickCount;

            QueryServiceStatus(hService, ssStatus);
            if (ssStatus.dwCurrentState == DesiredStatus) return true;
            dwStartTickCount = Environment.TickCount;
            dwOldCheckPoint = ssStatus.dwCheckPoint;

            while (ssStatus.dwCurrentState == WaitStatus)
            {
                // Do not wait longer than the wait hint. A good interval is
                // one tenth the wait hint, but no less than 1 second and no
                // more than 10 seconds.

                int dwWaitTime = ssStatus.dwWaitHint / 10;

                if (dwWaitTime < 1000) dwWaitTime = 1000;
                else if (dwWaitTime > 10000) dwWaitTime = 10000;

                System.Threading.Thread.Sleep(dwWaitTime);

                // Check the status again.

                if (QueryServiceStatus(hService, ssStatus) == 0) break;

                if (ssStatus.dwCheckPoint > dwOldCheckPoint)
                {
                    // The service is making progress.
                    dwStartTickCount = Environment.TickCount;
                    dwOldCheckPoint = ssStatus.dwCheckPoint;
                }
                else
                {
                    if (Environment.TickCount - dwStartTickCount > ssStatus.dwWaitHint)
                    {
                        // No progress made within the wait hint
                        break;
                    }
                }
            }
            return (ssStatus.dwCurrentState == DesiredStatus);
        }

        /// <summary>
        /// Opens the service manager
        /// </summary>
        /// <param name="Rights">The service manager rights</param>
        /// <returns>the handle to the service manager</returns>
        private static IntPtr OpenSCManager(ServiceManagerRights Rights)
        {
            IntPtr scman = OpenSCManager(null, null, Rights);
            if (scman == IntPtr.Zero)
            {
                throw new ApplicationException("Could not connect to service control manager.");
            }
            return scman;
        }

#endregion

    }
}

কোনও পরিষেবা ইনস্টল করতে, ইনস্টলএন্ডস্টার্ট কমান্ডটি নিম্নলিখিতভাবে চালান:

  SystemControl.InstallAndStart(
                                 "apache",
                                 "Apache Web Server",
                                 @"""c:\apache\bin\httpd.exe"" -k runservice"
  );

নিশ্চিত হয়ে নিন যে প্রোগ্রামটি চালাচ্ছে এমন অ্যাকাউন্টে পরিষেবাগুলি ইনস্টল করার অনুমতি রয়েছে। আপনি প্রোগ্রামটিতে সর্বদা 'প্রশাসক হিসাবে চালান' করতে পারেন।

আমি নন-এপি অ্যাক্সেসের জন্য বেশ কয়েকটি কমান্ডও অন্তর্ভুক্ত করেছি যা পরিষেবাগুলি ইনস্টল বা সরিয়ে দেয় না তবে আপনি সেগুলি তালিকাভুক্ত করতে পারেন এবং কয়েকটি নিয়ন্ত্রণ করতে পারেন (শুরু করুন, থামুন, পুনরায় চালু করুন)। পরিষেবাগুলি ইনস্টল বা অপসারণের জন্য আপনাকে কেবলমাত্র অনুমতিগুলি উন্নত করতে হবে।

সেখানে পেয়ে এবং যেমন পাশাপাশি এনভায়রনমেন্ট ভেরিয়েবলের মান স্থাপনার জন্য কমান্ড একটি দম্পতি আছে OPENSSL_CONFবা TEMP। বেশিরভাগ অংশের জন্য, পরামিতিগুলি এবং পদ্ধতির নামগুলি বেশ স্ব-বর্ণনামূলক হওয়া উচিত।


সার্ভিস স্টেট এনামে টাইপস রয়েছে। এটি হওয়া উচিত:Unknown = -1, NotFound = 0, Stopped = 1, StartPending = 2, StopPending = 3, Running = 4
সোহিল

2

উইন্ডোজ পরিষেবা হিসাবে একটি কমান্ড লাইন অ্যাপ্লিকেশন ইনস্টল করার চেষ্টা করার ক্ষেত্রে ' এনএসএসএম ' ইউটিলিটিটি ব্যবহার করে দেখুন। সম্পর্কিত সার্ভারফল্ট বিশদ এখানে পাওয়া গেছে


-3
Process QProc = new Process();
QProc.StartInfo.FileName = "cmd";
QProc.StartInfo.Arguments ="/c InstallUtil "+ "\""+ filefullPath +"\"";
QProc.StartInfo.WorkingDirectory = Environment.GetEnvironmentVariable("windir") + @"\Microsoft.NET\Framework\v2.0.50727\";
QProc.StartInfo.UseShellExecute = false;
// QProc.StartInfo.CreateNoWindow = true;
QProc.StartInfo.RedirectStandardOutput = true;
QProc.Start();
// QProc.WaitForExit();
QProc.Close();
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.