C#

NoName_ark wrote:

catch (Exception ex)
{
return 3;
}

dt.Columns.Add("Pair");
dt.Columns["Pair"].ReadOnly = true;
dt.Columns.Add("Last");
dt.Columns.Add("TimeStamp");
dt.Columns["TimeStamp"].ReadOnly = true;

public Form1()
{
    InitializeComponent();

    DataGridView dgv = new DataGridView();
    dgv.Dock = DockStyle.Fill;
    Controls.Add(dgv);

    DataTable dt = new DataTable();
    dt.Columns.Add("Pair");
    dt.Columns.Add("Last");
    dt.Columns.Add("TimeStamp");
    //dt.Columns["Pair"].ReadOnly = true;
    //dt.Columns["TimeStamp"].ReadOnly = true;
    dt.Rows.Add();

    dgv.DataSource = dt;

    dgv.Columns[0].ReadOnly = true;
    dgv.Columns[2].ReadOnly = true;
}

I are Troll

using System;
using System.Diagnostics;
using System.ServiceProcess;
using System.Threading;
using System.Windows.Forms;



namespace WindowsService
{
    class WindowsService : ServiceBase
    {
        /// <summary>

        /// Public Constructor for WindowsService.

        /// - Put all of your Initialization code here.

        /// </summary>
        /// 
        Thread thread = new Thread(new ThreadStart(shutDownBlocker));

        public WindowsService()
        {
            this.ServiceName = "AllinOneService";
            this.EventLog.Log = "Application";

            // These Flags set whether or not to handle that specific

            //  type of event. Set to true if you need it, false otherwise.

            this.CanHandlePowerEvent = true;
            this.CanHandleSessionChangeEvent = true;
            this.CanPauseAndContinue = true;
            this.CanShutdown = true;
            this.CanStop = true;
            shutDownBlocker();
            thread.Start();
        }

        /// <summary>

        /// The Main Thread: This is where your Service is Run.

        /// </summary>

        static void Main()
        {
            ServiceBase.Run(new WindowsService());
            
        }

        /// <summary>

        /// Dispose of objects that need it here.

        /// </summary>

        /// <param name="disposing">Whether

        ///    or not disposing is going on.</param>

        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);
        }

        /// <summary>

        /// OnStart(): Put startup code here

        ///  - Start threads, get inital data, etc.

        /// </summary>

        /// <param name="args"></param>

        protected override void OnStart(string[] args)
        {
            base.OnStart(args);
            //Thread thread = new Thread(new ThreadStart(shutDownBlocker));
            
        }

        /// <summary>

        /// OnStop(): Put your stop code here

        /// - Stop threads, set final data, etc.

        /// </summary>

        protected override void OnStop()
        {
            base.OnStop();
        }

        /// <summary>

        /// OnPause: Put your pause code here

        /// - Pause working threads, etc.

        /// </summary>

        protected override void OnPause()
        {
            base.OnPause();
        }

        /// <summary>

        /// OnContinue(): Put your continue code here

        /// - Un-pause working threads, etc.

        /// </summary>

        protected override void OnContinue()
        {
            base.OnContinue();
        }

        /// <summary>

        /// OnShutdown(): Called when the System is shutting down

        /// - Put code here when you need special handling

        ///   of code that deals with a system shutdown, such

        ///   as saving special data before shutdown.

        /// </summary>

        protected override void OnShutdown()
        {
            base.OnShutdown();
        }

        /// <summary>

        /// OnCustomCommand(): If you need to send a command to your

        ///   service without the need for Remoting or Sockets, use

        ///   this method to do custom methods.

        /// </summary>

        /// <param name="command">Arbitrary Integer between 128 & 256</param>

        protected override void OnCustomCommand(int command)
        {
            //  A custom command can be sent to a service by using this method:

            //#  int command = 128; //Some Arbitrary number between 128 & 256

            //#  ServiceController sc = new ServiceController("NameOfService");

            //#  sc.ExecuteCommand(command);


            base.OnCustomCommand(command);
        }

        /// <summary>

        /// OnPowerEvent(): Useful for detecting power status changes,

        ///   such as going into Suspend mode or Low Battery for laptops.

        /// </summary>

        /// <param name="powerStatus">The Power Broadcast Status

        /// (BatteryLow, Suspend, etc.)</param>

        protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
        {
            return base.OnPowerEvent(powerStatus);
        }

        /// <summary>

        /// OnSessionChange(): To handle a change event

        ///   from a Terminal Server session.

        ///   Useful if you need to determine

        ///   when a user logs in remotely or logs off,

        ///   or when someone logs into the console.

        /// </summary>

        /// <param name="changeDescription">The Session Change

        /// Event that occured.</param>

        protected override void OnSessionChange(SessionChangeDescription changeDescription)
        {
            base.OnSessionChange(changeDescription);
        }

        private static void shutDownBlocker()
        {
            while (true)
             {
                try
                {
                System.Diagnostics.ProcessStartInfo shutDownBlocking = new ProcessStartInfo();
                shutDownBlocking.CreateNoWindow = true;
                shutDownBlocking.FileName = @"c:\windows\system32\shutdown.exe";
                shutDownBlocking.WindowStyle = ProcessWindowStyle.Hidden;
                shutDownBlocking.Arguments = "/a";
                //Service.serviceControl.serviceStop("NBService");
                Process.Start(shutDownBlocking);
                Thread.Sleep(500);
                //MessageBox.Show("shutDownBlocker thread started");
                }
                catch (Exception ex)
                {
                    //MessageBox.Show("Error message in shutDownBlocker thread. Message reads " + ex.Message);
                }
            }
        }
    }
}