천객만래 [千客萬來] (It has an interminable succession of visitors)

Windows XP Service Pack 3 필요?


Win XP SP3 가 필요합니다.

Win XP Home 또는 Win XP Embedded OS에서 이런 메시지를 발견하면

.NET 등이 필요하기 때문일 때가 많다.

이런 경우 아래의 사이트로 방문하여 설치 파이을 다운로드 받고 해결하자.


ni.com/info/




Installing NI Software on Windows XP Embedded Touch Panel Computers



Primary Software: LabVIEW Development Systems
Primary Software Version: 2013
Primary Software Fixed Version: N/A
Secondary Software: N/A


Problem:

When installing the LabVIEW Runtime Engine 2013 and other NI software on a Windows XP Embedded touch panel computer, I get the following error message: "This installation requires Windows XP Service Pack 3 or later."


How do I install NI software on a Windows XP Embedded touch panel computer?

Solution:

The minimal requirement for National Instruments software after August 2013 on Windows XP is Windows XP Service Pack 3. This requirement exists because some National Instruments software relies on Microsoft .NET Framework 4.0 which states a requirement on Windows XP Service Pack 3. To learn more about the NI LabVIEW operating system support roadmap, visit ni.com/labview/os-support.

National Instruments touch panel computers (TPC) with the Windows XP Embedded (XPe) operating system are equivalent to Windows XP Service Pack 2. No direct upgrade is available for Windows XP Embedded Service Pack 3. This issue impacts NI touch panel computers, including NI TPC-2206, NI TPC-2212, NI TPC-2215, NI TPC-2512, and NI TPC-2515.

Note Windows Embedded Standard 7 is the recommended operating system on TPCs for new designs and is available on all current TPC models.

To install NI software after August 2013 on Windows XP Embedded touch panel computers, complete the following steps:

  1. For all National Instruments software products you wish to install on the touch panel computer, copy all National Instruments installer files to a location where you can modify the files.
  2. For each product you want to install, navigate to the product directory and open setup.ini in a text editor, such as Notepad. If you have a multiproduct installer, such as the LabVIEW Platform DVD or NI Developer Suite, navigate to the Distributions directory and then open setup.ini in a text editor.
  3. Modify the [OS] section of the setup.ini file by modifying the line according to the following figures:

    The following figure displays the section of the setup.ini file to modify, circled in red.

    The following figure displays the same setup.ini file after modification, circled in red.

  4. Click setup.exe for each software installer to install the software.

Note Microsoft .NET Framework 4.0 is a requirement for some NI software. When installing NI software, you may be prompted to install the Windows Imaging Component (WIC) which is required to install Microsoft .NET Framework 4.0. Visit ni.com/info and enter the Info Code MSWIC to download and install WIC.

If you have questions about this issue, contact technical support at ni.com/support.



출처 : http://digital.ni.com/public.nsf/allkb/B683A3FDEF7199C986257B8D002A01AA
2013-06-17


Posted by SB패밀리

서비스 응용 프로그램의 일부로 존재할 서비스에 기본 클래스를 제공합니다. ServiceBase는 새 서비스 클래스를 만들 때 파생되어야 합니다.

네임스페이스: System.ServiceProcess
어셈블리: System.ServiceProcess(system.serviceprocess.dll)
언어 : C# / C++ 
// C# language example
C#
public class ServiceBase : Component
// C++ language example
C++
public ref class ServiceBase : public Component


설명


서비스 응용 프로그램에 있는 서비스 클래스를 정의할 때 ServiceBase에서 파생됩니다. 임의의 유용한 서비스가 OnStartOnStop 메서드를 재정의합니다. 추가 기능의 경우, 서비스 상태의 변경 내용에 대한 특정 동작을 사용하여 OnPauseOnContinue를 재정의할 수 있습니다.

서비스는 사용자 인터페이스를 지원하지 않는 장기 실행 파일이며, 사용자 계정으로 로그온한 상태에서는 실행되지 않습니다. 이 서비스는 컴퓨터에 로그온 중인 사용자 없이도 실행될 수 있습니다.

기본적으로 서비스는 System 계정으로 실행됩니다. System 계정은 Administrator 계정과는 다르며, System 계정의 권한은 변경할 수 없습니다. 또한 ServiceProcessInstaller를 사용하여 서비스를 실행할 사용자 계정을 지정할 수 있습니다.

실행 파일은 두 가지 이상의 서비스를 포함할 수 있지만 각 서비스에 대해 별도의 ServiceInstaller를 포함해야 합니다. ServiceInstaller 인스턴스는 서비스를 시스템에 등록합니다. 설치 관리자는 또한 각 서비스를 서비스 명령을 기록하는 데 사용할 수 있는 이벤트 로그와 연결합니다. 실행 파일에 있는 main() 함수는 실행할 서비스를 정의합니다. 서비스의 현재 작업 디렉터리는 실행 파일이 있는 디렉터리가 아니라 시스템 디렉터리입니다.

서비스가 시작되면 시스템에서는 실행 파일을 찾아 해당 파일 내에 포함된 서비스에 대한 OnStart 메서드를 실행시킵니다. 그러나 서비스를 실행하는 것과 실행 파일을 실행하는 것은 다릅니다. 실행 파일은 서비스를 로드만 하지만, 서비스는 서비스 제어 관리자를 통해 시작 및 중지하는 방법으로 액세스됩니다.

사용자가 서비스에서 시작 명령을 처음으로 호출하면 실행 파일에서 ServiceBase 파생 클래스의 생성자를 호출합니다. OnStart 명령 처리 메서드는 생성자가 실행된 직후에 호출됩니다. 생성자는 서비스가 처음 로드된 이후에 다시 실행되지 않으므로 생성자에서 수행한 프로세스와 OnStart에서 수행한 프로세스를 구분해야 합니다. OnStop을 사용하여 해제할 수 있는 리소스는 OnStart를 사용하여 만들어야 합니다. OnStop에서 리소스를 해제한 다음 서비스를 다시 시작하면 생성자에서 리소스를 만들 때 리소스가 제대로 만들어지지 않습니다.

SCM(서비스 제어 관리자)은 서비스와 상호 작용하는 방법을 제공합니다. SCM을 사용하여 시작, 중지, 일시 중지, 계속 또는 사용자 지정 명령을 서비스에 전달할 수 있습니다. SCM은 CanStopCanPauseAndContinue의 값을 사용하여 서비스에서 중지, 일시 중지 또는 계속 명령을 허용할지 여부를 결정합니다. 서비스 클래스에 있는 해당 속성인 CanStop 또는 CanPauseAndContinuetrue인 경우에만 SCM의 상황에 맞는 메뉴에서 중지, 일시 중지 및 계속을 사용할 수 있습니다. 명령을 사용할 수 있는 경우, 명령은 서비스에 전달되고 OnStop, OnPause 또는 OnContinue가 호출됩니다. CanStop, CanShutdown 또는 CanPauseAndContinuefalse이면 OnStop과 같은 해당 명령 처리 메서드가 구현되어 있어도 처리되지 않습니다.

SCM이 사용자 인터페이스를 사용하여 수행하는 작업을 ServiceController 클래스를 사용하여 프로그래밍 방식으로 수행할 수 있습니다. 콘솔에서 사용할 수 있는 작업을 자동화할 수 있습니다. CanStop, CanShutdown 또는 CanPauseAndContinuetrue이지만 해당 명령 처리 메서드(예: OnStop)를 구현하지 않은 경우 시스템에서 예외가 throw되고 해당 명령이 무시됩니다.

ServiceBase에 있는 OnStart, OnStop 또는 다른 메서드는 구현하지 않아도 됩니다. 그러나 서비스의 동작이 OnStart에 설명되어 있으므로 이 멤버를 재정의해야 합니다. 실행 파일의 main() 함수에 서비스의 이름을 설정해야 합니다. main()에 설정한 서비스 이름은 서비스 설치 관리자의 ServiceName 속성과 정확하게 일치해야 합니다.

InstallUtil.exe를 사용하여 시스템에 서비스를 설치할 수 있습니다.


예제


다음 예제에서는 ServiceBase 클래스에서 간단한 서비스 구현을 파생합니다. 이 서비스는 중지, 시작, 일시 중지, 계속 및 사용자 지정 명령을 포함한 다양한 서비스 명령을 처리합니다.

C#

// Turn on logging to the event log.
#define LOGEVENTS
using System;
using System.IO;
using System.Threading;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.ServiceProcess;
using System.Text;
using Microsoft.Win32;
using System.Runtime.InteropServices;
using System.Windows.Forms;
namespace ServiceSample
{
    // Define custom commands for the SimpleService.
    public enum SimpleServiceCustomCommands { StopWorker = 128, RestartWorker, CheckWorker };
    [StructLayout(LayoutKind.Sequential)]
    public struct SERVICE_STATUS
    {
        public int serviceType;
        public int currentState;
        public int controlsAccepted;
        public int win32ExitCode;
        public int serviceSpecificExitCode;
        public int checkPoint;
        public int waitHint;
    }
    public enum State
    {
        SERVICE_STOPPED = 0x00000001,
        SERVICE_START_PENDING = 0x00000002,
        SERVICE_STOP_PENDING = 0x00000003,
        SERVICE_RUNNING = 0x00000004,
        SERVICE_CONTINUE_PENDING = 0x00000005,
        SERVICE_PAUSE_PENDING = 0x00000006,
        SERVICE_PAUSED = 0x00000007,
    }
    // Define a simple service implementation.
    public class SimpleService : System.ServiceProcess.ServiceBase
    {
        private static int userCount = 0;
        private static ManualResetEvent pause = new ManualResetEvent(false);
        [DllImport("ADVAPI32.DLL", EntryPoint = "SetServiceStatus")]
        public static extern bool SetServiceStatus(
                        IntPtr hServiceStatus,
                        SERVICE_STATUS lpServiceStatus
                        );
        private SERVICE_STATUS myServiceStatus;
        private Thread workerThread = null;
        public SimpleService()
        {
            CanPauseAndContinue = true;
            CanHandleSessionChangeEvent = true;
            ServiceName = "SimpleService";
        }
        static void Main()
        {
#if LOGEVENTS
            EventLog.WriteEntry("SimpleService.Main", DateTime.Now.ToLongTimeString() +
                " - Service main method starting...");
#endif
            // Load the service into memory.
            System.ServiceProcess.ServiceBase.Run(new SimpleService());
#if LOGEVENTS
            EventLog.WriteEntry("SimpleService.Main", DateTime.Now.ToLongTimeString() +
                " - Service main method exiting...");
#endif
        }
        private void InitializeComponent()
        {
            // Initialize the operating properties for the service.
            this.CanPauseAndContinue = true;
            this.CanShutdown = true;
            this.CanHandleSessionChangeEvent = true;
            this.ServiceName = "SimpleService";
        }
        // Start the service.
        protected override void OnStart(string[] args)
        {
            IntPtr handle = this.ServiceHandle;
            myServiceStatus.currentState = (int)State.SERVICE_START_PENDING;
            SetServiceStatus(handle, myServiceStatus);
            // Start a separate thread that does the actual work.
            if ((workerThread == null) ||
                ((workerThread.ThreadState &
                 (System.Threading.ThreadState.Unstarted | System.Threading.ThreadState.Stopped)) != 0))
            {
#if LOGEVENTS
                EventLog.WriteEntry("SimpleService.OnStart", DateTime.Now.ToLongTimeString() +
                    " - Starting the service worker thread.");
#endif
                workerThread = new Thread(new ThreadStart(ServiceWorkerMethod));
                workerThread.Start();
            }
            if (workerThread != null)
            {
#if LOGEVENTS
                EventLog.WriteEntry("SimpleService.OnStart", DateTime.Now.ToLongTimeString() +
                    " - Worker thread state = " +
                    workerThread.ThreadState.ToString());
#endif
            }
            myServiceStatus.currentState = (int)State.SERVICE_RUNNING;
            SetServiceStatus(handle, myServiceStatus);
        }
        // Stop this service.
        protected override void OnStop()
        {
            // New in .NET Framework version 2.0.
            this.RequestAdditionalTime(4000);
            // Signal the worker thread to exit.
            if ((workerThread != null) && (workerThread.IsAlive))
            {
#if LOGEVENTS
                EventLog.WriteEntry("SimpleService.OnStop", DateTime.Now.ToLongTimeString() +
                    " - Stopping the service worker thread.");
#endif
                pause.Reset();
                Thread.Sleep(5000);
                workerThread.Abort();
            }
            if (workerThread != null)
            {
#if LOGEVENTS
                EventLog.WriteEntry("SimpleService.OnStop", DateTime.Now.ToLongTimeString() +
                    " - OnStop Worker thread state = " +
                    workerThread.ThreadState.ToString());
#endif
            }
            // Indicate a successful exit.
            this.ExitCode = 0;
        }
        // Pause the service.
        protected override void OnPause()
        {
            // Pause the worker thread.
            if ((workerThread != null) &&
                (workerThread.IsAlive) &&
                ((workerThread.ThreadState &
                 (System.Threading.ThreadState.Suspended | System.Threading.ThreadState.SuspendRequested)) == 0))
            {
#if LOGEVENTS
                EventLog.WriteEntry("SimpleService.OnPause", DateTime.Now.ToLongTimeString() +
                    " - Pausing the service worker thread.");
#endif
                pause.Reset();
                Thread.Sleep(5000);
            }
            if (workerThread != null)
            {
#if LOGEVENTS
                EventLog.WriteEntry("SimpleService.OnPause", DateTime.Now.ToLongTimeString() +
                    " OnPause - Worker thread state = " +
                    workerThread.ThreadState.ToString());
#endif
            }
        }
        // Continue a paused service.
        protected override void OnContinue()
        {
            // Signal the worker thread to continue.
            if ((workerThread != null) &&
                ((workerThread.ThreadState &
                 (System.Threading.ThreadState.Suspended | System.Threading.ThreadState.SuspendRequested)) != 0))
            {
#if LOGEVENTS
                EventLog.WriteEntry("SimpleService.OnContinue", DateTime.Now.ToLongTimeString() +
                    " - Resuming the service worker thread.");
#endif
                pause.Set();
            }
            if (workerThread != null)
            {
#if LOGEVENTS
                EventLog.WriteEntry("SimpleService.OnContinue", DateTime.Now.ToLongTimeString() +
                    " OnContinue - Worker thread state = " +
                    workerThread.ThreadState.ToString());
#endif
            }
        }
        // Handle a custom command.
        protected override void OnCustomCommand(int command)
        {
#if LOGEVENTS
            EventLog.WriteEntry("SimpleService.OnCustomCommand", DateTime.Now.ToLongTimeString() +
                " - Custom command received: " +
                command.ToString());
#endif
            // If the custom command is recognized,
            // signal the worker thread appropriately.
            switch (command)
            {
                case (int)SimpleServiceCustomCommands.StopWorker:
                    // Signal the worker thread to terminate.
                    // For this custom command, the main service
                    // continues to run without a worker thread.
                    OnStop();
                    break;
                case (int)SimpleServiceCustomCommands.RestartWorker:
                    // Restart the worker thread if necessary.
                    OnStart(null);
                    break;
                case (int)SimpleServiceCustomCommands.CheckWorker:
#if LOGEVENTS
                    // Log the current worker thread state.
                    EventLog.WriteEntry("SimpleService.OnCustomCommand", DateTime.Now.ToLongTimeString() +
                        " OnCustomCommand - Worker thread state = " +
                        workerThread.ThreadState.ToString());
#endif
                    break;
                default:
#if LOGEVENTS
                    EventLog.WriteEntry("SimpleService.OnCustomCommand",
                        DateTime.Now.ToLongTimeString());
#endif
                    break;
            }
        }
        // Handle a session change notice
        protected override void OnSessionChange(SessionChangeDescription changeDescription)
        {
#if LOGEVENTS
            EventLog.WriteEntry("SimpleService.OnSessionChange", DateTime.Now.ToLongTimeString() +
                " - Session change notice received: " +
                changeDescription.Reason.ToString() + "  Session ID: " +
                changeDescription.SessionId.ToString());
#endif
            switch (changeDescription.Reason)
            {
                case SessionChangeReason.SessionLogon:
                    userCount += 1;
#if LOGEVENTS
                    EventLog.WriteEntry("SimpleService.OnSessionChange",
                        DateTime.Now.ToLongTimeString() +
                        " SessionLogon, total users: " +
                        userCount.ToString());
#endif
                    break;
                case SessionChangeReason.SessionLogoff:
                    userCount -= 1;
#if LOGEVENTS
                    EventLog.WriteEntry("SimpleService.OnSessionChange",
                        DateTime.Now.ToLongTimeString() +
                        " SessionLogoff, total users: " +
                        userCount.ToString());
#endif
                    break;
                case SessionChangeReason.RemoteConnect:
                    userCount += 1;
#if LOGEVENTS
                    EventLog.WriteEntry("SimpleService.OnSessionChange",
                        DateTime.Now.ToLongTimeString() +
                        " RemoteConnect, total users: " +
                        userCount.ToString());
#endif
                    break;
                case SessionChangeReason.RemoteDisconnect:
                    userCount -= 1;
#if LOGEVENTS
                    EventLog.WriteEntry("SimpleService.OnSessionChange",
                        DateTime.Now.ToLongTimeString() +
                        " RemoteDisconnect, total users: " +
                        userCount.ToString());
#endif
                    break;
                case SessionChangeReason.SessionLock:
#if LOGEVENTS
                    EventLog.WriteEntry("SimpleService.OnSessionChange",
                        DateTime.Now.ToLongTimeString() +
                        " SessionLock");
#endif
                    break;
                case SessionChangeReason.SessionUnlock:
#if LOGEVENTS
                    EventLog.WriteEntry("SimpleService.OnSessionChange",
                        DateTime.Now.ToLongTimeString() +
                        " SessionUnlock");
#endif
                    break;
                default:
                    break;
            }
        }
        // Define a simple method that runs as the worker thread for
        // the service. 
        public void ServiceWorkerMethod()
        {
#if LOGEVENTS
            EventLog.WriteEntry("SimpleService.WorkerThread", DateTime.Now.ToLongTimeString() +
                " - Starting the service worker thread.");
#endif
            try
            {
                do
                {
                    // Simulate 4 seconds of work.
                    Thread.Sleep(4000);
                    // Block if the service is paused or is shutting down.
                    pause.WaitOne();
#if LOGEVENTS
                    EventLog.WriteEntry("SimpleService.WorkerThread", DateTime.Now.ToLongTimeString() +
                        " - heartbeat cycle.");
#endif
                }
                while (true);
            }
            catch (ThreadAbortException)
            {
                // Another thread has signalled that this worker
                // thread must terminate.  Typically, this occurs when
                // the main service thread receives a service stop
                // command.
                // Write a trace line indicating that the worker thread
                // is exiting.  Notice that this simple thread does
                // not have any local objects or data to clean up.
#if LOGEVENTS
                EventLog.WriteEntry("SimpleService.WorkerThread", DateTime.Now.ToLongTimeString() +
                    " - Thread abort signaled.");
#endif
            }
#if LOGEVENTS
            EventLog.WriteEntry("SimpleService.WorkerThread", DateTime.Now.ToLongTimeString() +
                " - Exiting the service worker thread.");
#endif
        }
    }
}


// C++ language example
// Turn on the constant for trace output.
#define TRACE

#using <System.ServiceProcess.dll>
#using <System.dll>

using namespace System;
using namespace System::ComponentModel;
using namespace System::IO;
using namespace System::ServiceProcess;
using namespace System::Threading;
using namespace System::Diagnostics;

// Define custom commands for the SimpleService.
public enum class SimpleServiceCustomCommands
{
    StopWorker = 128,
    RestartWorker, CheckWorker
};


// Define a simple service implementation.
public ref class SimpleService: public System::ServiceProcess::ServiceBase
{
private:
    Thread^ workerThread;
    int userCount;
public:
    SimpleService()
    {
        CanPauseAndContinue = true;
        ServiceName = "SimpleService";
        workerThread = nullptr;
        CanHandleSessionChangeEvent = true;
    }

private:

    void InitializeComponent()
    {
        // Initialize the operating properties for the service.
        this->CanPauseAndContinue = true;
        this->CanShutdown = true;
        this->ServiceName = "SimpleService";
        this->CanHandleSessionChangeEvent = true;
    }

    // Start the service.
protected:
    virtual void OnStart( array<String^>^  ) override
    {
        // Start a separate thread that does the actual work.
        if ( (workerThread == nullptr) || ((workerThread->ThreadState & (System::Threading::ThreadState::Unstarted | System::Threading::ThreadState::Stopped)) != (System::Threading::ThreadState)0) )
        {
            Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Starting the service worker thread.", "OnStart" );
            workerThread = gcnew Thread( gcnew ThreadStart( this,&SimpleService::ServiceWorkerMethod ) );
            workerThread->Start();
        }

        if ( workerThread != nullptr )
        {
            Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Worker thread state = " + workerThread->ThreadState.ToString(), "OnStart" );
        }
    }

    // Stop this service.
protected:
    virtual void OnStop() override
    {
        // Signal the worker thread to exit.
        if ( (workerThread != nullptr) && (workerThread->IsAlive) )
        {
            Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Stopping the service worker thread.", "OnStop" );
            workerThread->Abort();

            // Wait up to 500 milliseconds for the thread to terminate.
            workerThread->Join( 500 );
        }

        if ( workerThread != nullptr )
        {
            Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Worker thread state = " + workerThread->ThreadState.ToString(), "OnStop" );
        }
    }

    // Pause the service.
protected:
    virtual void OnPause() override
    {
        // Pause the worker thread.
        if ( (workerThread != nullptr) && (workerThread->IsAlive) && ((workerThread->ThreadState & (System::Threading::ThreadState::Suspended | System::Threading::ThreadState::SuspendRequested)) == (System::Threading::ThreadState)0) )
        {
            Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Suspending the service worker thread.", "OnPause" );
            workerThread->Suspend();
        }

        if ( workerThread != nullptr )
        {
            Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Worker thread state = " + workerThread->ThreadState.ToString(), "OnPause" );
        }
    }

    // Continue a paused service.
protected:
    virtual void OnContinue() override
    {
        // Signal the worker thread to continue.
        if ( (workerThread != nullptr) && ((workerThread->ThreadState & (System::Threading::ThreadState::Suspended | System::Threading::ThreadState::SuspendRequested)) != (System::Threading::ThreadState)0) )
        {
            Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Resuming the service worker thread.", "OnContinue" );
            workerThread->Resume();
        }

        if ( workerThread != nullptr )
        {
            Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Worker thread state = " + workerThread->ThreadState.ToString(), "OnContinue" );
        }
    }

    // Handle a custom command.
protected:
    virtual void OnCustomCommand( int command ) override
    {
        Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Custom command received: " + command, "OnCustomCommand" );

        // If the custom command is recognized,
        // signal the worker thread appropriately.
        switch ( command )
        {
        case (int)SimpleServiceCustomCommands::StopWorker:

            // Signal the worker thread to terminate.
            // For this custom command, the main service
            // continues to run without a worker thread.
            OnStop();
            break;

        case (int)SimpleServiceCustomCommands::RestartWorker:

            // Restart the worker thread if necessary.
            OnStart( nullptr );
            break;

        case (int)SimpleServiceCustomCommands::CheckWorker:

            // Log the current worker thread state.
            Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Worker thread state = " + workerThread->ThreadState.ToString(), "OnCustomCommand" );
            break;

        default:
            Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Unrecognized custom command ignored!", "OnCustomCommand" );
            break;
        }
    }
protected:
    virtual void OnSessionChange(SessionChangeDescription changeDescription) override
    {
        Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Change description received: "
            + changeDescription.ToString(), "OnSessionChange" );

        switch (changeDescription.Reason)
        {
        case SessionChangeReason::SessionLogon:
            userCount += 1;
            Trace::WriteLine( DateTime::Now.ToLongTimeString() +
                " SessionLogon, total users: " +
                userCount.ToString(), "OnSessionChange" );
            break;
        case SessionChangeReason::SessionLogoff:
            userCount -= 1;
            Trace::WriteLine( DateTime::Now.ToLongTimeString() +
                " SessionLogoff, total users: " +
                userCount.ToString(), "OnSessionChange" );
            break;
        case SessionChangeReason::RemoteConnect:
            userCount += 1;
            Trace::WriteLine( DateTime::Now.ToLongTimeString() +
                " RemoteConnect, total users: " +
                userCount.ToString(), "OnSessionChange" );
            break;
        case SessionChangeReason::RemoteDisconnect:
            userCount -= 1;
            Trace::WriteLine( DateTime::Now.ToLongTimeString() +
                " RemoteDisconnect, total users: " +
                userCount.ToString(), "OnSessionChange" );
            break;
        case SessionChangeReason::SessionLock:
            Trace::WriteLine( DateTime::Now.ToLongTimeString() +
                " SessionLock", "OnSessionChange" );
            break;
        case SessionChangeReason::SessionUnlock:
Trace::WriteLine( DateTime::Now.ToLongTimeString() +
                " SessionUnlock", "OnSessionChange" );
            break;

        default:
            Trace::WriteLine( DateTime::Now.ToLongTimeString() +
                " - Unhandled session change event.", "OnSessionChange" );
            break;
        }
    }
    // Define a simple method that runs as the worker thread for
    // the service. 
public:
    void ServiceWorkerMethod()
    {
        Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Starting the service worker thread.", "Worker" );
        try
        {
            for ( ; ;  )
            {

                // Wake up every 10 seconds and write
                // a message to the trace output.
                Thread::Sleep( 10000 );
                Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - heartbeat cycle.", "Worker" );
            }
        }
        catch ( ThreadAbortException^ )
        {
            // Another thread has signalled that this worker
            // thread must terminate.  Typically, this occurs when
            // the main service thread receives a service stop
            // command.
            // Write a trace line indicating that the worker thread
            // is exiting.  Notice that this simple thread does
            // not have any local objects or data to clean up.
            Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Thread abort signaled.", "Worker" );
        }

        Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Exiting the service worker thread.", "Worker" );
    }
};

int main()
{
    String^ logFile = "C:\\service_log.txt";
    TextWriterTraceListener^ serviceTraceListener = nullptr;

    // Create a log file for trace output.
    // A new file is created each time.  If a
    // previous log file exists, it is overwritten.
    StreamWriter^ myFile = File::CreateText( logFile );

    // Create a new trace listener that writes to the text file,
    // and add it to the collection of trace listeners.
    serviceTraceListener = gcnew TextWriterTraceListener( myFile );
    Trace::Listeners->Add( serviceTraceListener );
    Trace::AutoFlush = true;
    Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Service main method starting...", "Main" );

    // Load the service into memory.
    System::ServiceProcess::ServiceBase::Run( gcnew SimpleService );
    Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Service main method exiting...", "Main" );

    // Remove and close the trace listener for this service.
    Trace::Listeners->Remove( serviceTraceListener );
    serviceTraceListener->Close();
    serviceTraceListener = nullptr;
    myFile->Close();
}

상속 계층 구조

System.Object
   System.MarshalByRefObject
     System.ComponentModel.Component
      System.ServiceProcess.ServiceBase
스레드로부터의 안전성

이 형식의 모든 public static(Visual Basic의 경우 Shared) 멤버는 스레드로부터 안전합니다. 인터페이스 멤버는 스레드로부터 안전하지 않습니다.

플랫폼

Windows 98, Windows 2000 SP4, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework에서 모든 플래폼의 모든 버전을 지원하지는 않습니다. 지원되는 버전의 목록은 시스템 요구 사항을 참조하십시오.

버전 정보

.NET Framework

2.0, 1.1, 1.0에서 지원

참고항목

Servicebase 멤버
System.ServiceProcess 네임스페이스
ServiceProcessInstaller
ServiceInstaller



출처 : http://msdn.microsoft.com/ko-kr/library/system.serviceprocess.servicebase(v=VS.80).aspx
Posted by SB패밀리
기존에 대충 알고 있고 설명도 못하고 있던 것을 아래 출처에서 보고 더 정리할 수 있어서 고맙습니다.



Visual Studio 와 .NET Framework 의 관계를 알아보자.

 Visual Studio .NET = .NET 1.0

 Visual Studio 2003 = .NET 1.1

 Visual Studio 2005 = .NET 2.0  + .NET 3.0

 Visual Studio 2008 = .NET 3.5                         (Code Name : Orcas )

 Visual Studio 2010 = .NET 4.0                         (09년10월 현재 Bate2) 

  

NET Framework별 의 주요 기능

.NET 2.0  =  Generic(C#언어에 도입) 

.NET 3.0  =  WCF, WPF, XAML

.NET 3.5  =  LINQ, Silverlight

.NET 4.0  =  PLINQ  

  

간단 용어 정리 및 기능

 Generic

- 제네릭은 2.0 버전의 C# 언어와 CLR(공용 언어 런타임)에 새로 도입된 기능입니다. 제네릭을 통해 .NET Framework에 형식 매개 변수라는 개념이 처음 소개되었습니다. 형식 매개 변수를 사용하면 클라이언트 코드에서 클래스나 메서드를 선언하고 인스턴스화할 때까지 하나 이상의 형식 지정을 연기하는 클래스와 메서드를 디자인할 수 있습니다. 예를 들어, 다음과 같이 제네릭 형식 매개 변수 T를 사용하면 런타임 캐스트나 boxing 작업에 따른 비용이나 위험을 초래하지 않은 채 다른 클라이언트 코드에서 사용 가능한 단일 클래스를 작성할 수 있습니다.

 WPF(Windows Presentation Foundation)

- WPF의 핵심 기능은 최신 그래픽 하드웨어를 활용하도록 만들어진 해상도 독립적인 벡터 기반 렌더링 엔진입니다. WPF에서는 XAML(Extensible Application Markup Language), 컨트롤, 데이터 바인딩, 레이아웃, 2차원 및 3차원 그래픽, 애니메이션, 스타일, 템플릿, 문서, 미디어, 텍스트, 입력 체계 등의 광범위한 응용 프로그램 개발 기능으로 이 핵심 기능을 확장합니다. WPF는 Microsoft .NET Framework에 포함되므로 .NET Framework 클래스 라이브러리의 다른 요소가 통합된 응용 프로그램을 만들 수 있습니다.

 WCF(Windows Communication Foundation)

-  WCF는 새로운 서비스 기반 프로그래밍 모델을 통해 관련된 응용 프로그램의 개발을 단순화합니다. WCF는 계층화된 아키텍처를 제공하여 다양한 스타일의 분산 응용 프로그램 개발을 지원합니다. 기본적으로 WCF 채널 아키텍처는 비동기식 형식화되지 않은 메시지 전달 형식을 제공합니다. 이와 같은 기반을 바탕으로 안전하고 안정적이며 트랜잭션된 데이터 교환을 위한 프로토콜 기능과 다양한 전송 및 인코딩 옵션이 제공됩니다.

 형식화된 프로그래밍 모델(서비스 모델)은 분산 응용 프로그램의 개발을 쉽게 하고, 개발자에게 ASP.NET 웹 서비스, .NET Framework remoting 및 엔터프라이즈 서비스에 대한 전문 지식과 WCF 사용자에게 익숙한 개발 경험을 제공하도록 디자인되었습니다. 서비스 모델의 특징은 Visual C# 또는 Visual Basic과 같은 언어로 서비스 구현에 대한 유연하고 확장 가능한 메시지 매핑을 포함하여 웹 서비스 개념을 .NET Framework CLR(공용 언어 런타임)의 개념에 바로 매핑할 수 있다는 것입니다. 여기에는 느슨한 결합과 버전 관리를 사용할 수 있는 serialization 기능이 포함되어 있으며 통합 및 상호 운용성을 위해 MSMQ(메시지 큐), COM+, ASP.NET 웹 서비스, WSE(Web Services Enhancements) 및 다양한 기타 기능과 같은 기존의 .NET Framework 분산 시스템 기술을 제공합니다.

 XAML(Extensible Application Markup Language)

- XAML은 선언적 응용 프로그래밍을 위한 태그 언어로 WPF(Windows Presentation Foundation) 프로그래밍 모델의 UI 작성을 간단하게 만듭니다. 

 Silverlight

- Microsoft Silverlight는 웹에서 사용할 차세대 미디어 환경 및 RIA(풍부한 대화형 응용 프로그램)를 만들고 제공하기 위한 .NET Framework의 다중 브라우저, 다중 플랫폼 구현입니다. Silverlight에는 서버, 웹 및 데스크톱의 기능, 관리 코드 및 동적 언어의 기능, 선언적 및 기존 프로그래밍의 기능 및 WPF(Windows Presentation Foundation) 기능이 통합되어 있습니다.

http://www.microsoft.com/silverlight/silverlight/demos/Perspective3D/default.html

  LINQ(Language Integrated Query)

- LINQ는 .NET 기반 프로그래밍 언어에서 탐색, 필터 및 프로젝션 작업을 선언적으로 직접 표현할 수 있도록 하는 쿼리 연산자 집합을 정의하는 쿼리 구문입니다.

  • LINQ to SQL : SQL Server 데이터베이스

  • LINQ to XML : XML 문서

  • LINQ to DataSet : ADO.NET 데이터 집합

  • LINQ to Object : .NET 컬렉션, 파일, 문자열 등 

     

    PLINQ(Parallel Language Integrated Query)

    - PLINQ는 다중코어에서 병열 쿼리실행한다.

     
    정리된 것 감사합니다.
    출처: http://cafe.daum.net/dgprogram/AYv3/10?docid=1J2wr|AYv3|10|20091022173059&q=WCF%20WPF&srchid=CCB1J2wr|AYv3|10|20091022173059

  • Posted by SB패밀리

    파워빌더 호출 사용 예

    Function Integer LogonUserA(String lpszUsername,String lpszDomain,String lpszPassword,integer dwLogonType,Integer dwLogonProvider,REF long phToken) Library "advapi32.dll"
    또는 이렇게 선언해서 사용해도 된다.

    Function boolean LogonUser(String lpszUsername,String lpszDomain,String lpszPassword, ulong dwLogonType,ulong dwLogonProvider,REF ulong phToken) Library "advapi32.dll" alias for "LogonUserA"


    ulong lul_token
    boolean lb_ret

    // command button clicked event
    lb_ret LogonUser(username,domainname,LOGON32_LOGON_NETWORK,LOGON32_PROVIDER_DEFAULT, lul_token)

    if lb_ret  then
      messagebox("","logon success")
    else
      messagebox("","login failed")
    end if

    ================================================

    C#

    네트웍 공유 폴더 를 사용 할때 사용자별 자격증명을 하기 위하여 사용된다.
    (이는 System.IO Control을 사용할 때 유용하다)

    === Class 생성 ===

     using System;
    using System.Drawing;
    using System.Collections.Generic;
    using System.Text;
    using System.IO;
    using System.Runtime.InteropServices;
    using System.ComponentModel;
    using System.Security.Principal;

    namespace M.Lib.WndLogin {
        /// <summary>
        /// 로그온 타입
        /// </summary>
        public enum LogonType {
            LOGON32_LOGON_INTERACTIVE = 2,
            LOGON32_LOGON_NETWORK = 3,
            LOGON32_LOGON_BATCH = 4,
            LOGON32_LOGON_SERVICE = 5,
            LOGON32_LOGON_UNLOCK = 7,
            LOGON32_LOGON_NETWORK_CLEARTEXT = 8,
            LOGON32_LOGON_NEW_CREDENTIALS = 9
        }

        /// <summary>
        /// 로그온 제공자
        /// </summary>
        public enum LogonProvider {
            LOGON32_PROVIDER_DEFAULT = 0,
            LOGON32_PROVIDER_WINNT35 = 1,
            LOGON32_PROVIDER_WINNT40 = 2,
            LOGON32_PROVIDER_WINNT50 = 3
        }

        public class WndLogin {
            /// <summary>
            /// 로그온
            /// </summary>
            /// <param name="lpszUsername">사용자 계정</param>
            /// <param name="lpszDomain">도메인</param>
            /// <param name="lpszPassword">암호</param>
            /// <param name="dwLogonType">로그온 조류</param>
            /// <param name="dwLogonProvider">로그온 프로바이더</param>
            /// <param name="phToken">엑세스 토큰</param>
            /// <returns></returns>
            [DllImport!("advapi32.dll", EntryPoint = "LogonUser", SetLastError = true)]
            private static extern bool _LogonUser(string lpszUsername, string lpszDomain, string lpszPassword,
                int dwLogonType, int dwLogonProvider, out int phToken);

            /// <summary>
            /// 주어진 사용자 ID로 로그온하고 액세스 토큰을 반환
            /// </summary>
            /// <param name="userName">사용자 계정</param>
            /// <param name="password">암호</param>
            /// <param name="domainName">도메인 이름</param>
            /// <param name="logonType">로그온 종류</param>
            /// <param name="logonProvider">로그온 프로바이더</param>
            /// <returns>엑세스 토큰</returns>
            public static IntPtr LogonUser(string userName, string password, string domainName,
                LogonType logonType, LogonProvider logonProvider) {
                int token = 0;
                bool logonSuccess = _LogonUser(userName, domainName, password,
                    (int)logonType, (int)logonProvider, out token);

                if (logonSuccess)
                    return new IntPtr(token);

                int retval = Marshal.GetLastWin32Error();
                throw new Win32Exception(retval);
            }
        }
    }

      === 사용방법 ===

    using M.Lib.WndLogin;

     IntPtr token = WndLogin.LogonUser("계정", "암호", ".",
                LogonType.LOGON32_LOGON_NETWORK_CLEARTEXT, LogonProvider.LOGON32_PROVIDER_DEFAULT);
            WindowsIdentity identity = new WindowsIdentity(token);
            WindowsImpersonationContext ctx = identity.Impersonate();


    ================
    다른 적용 예

    const int ERROR_INSUFFICIENT_BUFFER = 122;

      [DllImport("advapi32.dll", EntryPoint = "LogonUser", SetLastError = true)]
      private static extern bool _LogonUser(string lpszUsername, string lpszDomain, string lpszPassword, int dwLogonType, int dwLogonProvider, out int phToken);

      /// <summary>
      /// 주어진 사용자 ID로 로그온하여 액세스 토큰을 반환한다.
      /// </summary>
      /// <param name="userName">사용자 ID</param>
      /// <param name="password">암호</param>
      /// <param name="domainName">도메인 이름</param>
      /// <param name="logonType">로그온 종류</param>
      /// <param name="logonProvider">로그온 프로바이더</param>
      /// <returns></returns>
      public static WindowsImpersonationContext LogonUser(string userName, string password, string domainName, LogonType logonType, LogonProvider logonProvider)
      {
       int token = 0;
       bool logonSuccess = _LogonUser(userName, domainName, password, (int)logonType, (int)logonProvider, out token);
       if (logonSuccess)
        return WindowsIdentity.Impersonate(new IntPtr(token));

       int retval = Marshal.GetLastWin32Error();
       throw new Win32Exception(retval);
      }

      /// <summary>
      /// 로그인사용자 로그오프
      /// </summary>
      /// <param name="ctx"></param>
      public static void LogoutUser(WindowsImpersonationContext ctx)
      {
       ctx.Undo();
      }

     


     /// <summary>
     /// LogonUser API에서 사용하는 로그온 타입
     /// </summary>
     public enum LogonType
     {
      LOGON32_LOGON_INTERACTIVE = 2,
      LOGON32_LOGON_NETWORK = 3,
      LOGON32_LOGON_BATCH = 4,
      LOGON32_LOGON_SERVICE = 5,
      LOGON32_LOGON_UNLOCK = 7,
      LOGON32_LOGON_NETWORK_CLEARTEXT = 8,
      LOGON32_LOGON_NEW_CREDENTIALS = 9
     }

     public enum LogonProvider
     {
      LOGON32_PROVIDER_DEFAULT = 0,
      LOGON32_PROVIDER_WINNT35 = 1,
      LOGON32_PROVIDER_WINNT40 = 2,
      LOGON32_PROVIDER_WINNT50 = 3
     }

     

     

     


    WindowsImpersonationContext ctx = null;

      if (!logonUserID.Equals("")) ctx = COasisPC.LogonUser(logonUserID, logonPasswd, ".", LogonType.LOGON32_LOGON_NETWORK_CLEARTEXT, LogonProvider.LOGON32_PROVIDER_DEFAULT);

       .. 일반코드

       // 사용자 인증에서 인터넷사용자 인증으로 변경
       if (ctx != null) COasisPC.LogoutUser(ctx);

    Posted by SB패밀리