घटना दर्शक

Question

से कोई ईवेंट लिखें मैं सी # कैसे ईवेंट व्यूअर के लिए नए इवेंट में जोड़ने के लिए एक उदाहरण मिल गया। लेकिन, मुझे सी ++ (.NET नहीं) में लिखा गया एक उदाहरण चाहिए जो "एप्लिकेशन" भाग के तहत इवेंट व्यूअर में नया ईवेंट बनाएं।

Answer 1

आप WINAPI से इन तीन कार्यों का उपयोग कर सकते हैं:

• RegisterEventSource
• ReportEvent
• DeregisterEventSource

यहाँ कैसे इन का उपयोग करने की एक त्वरित उदाहरण है और संदेश सही ढंग से प्रदर्शित करने के लिए इवेंट लॉग में (ब्रेकटी के लिए ज्यादातर अनदेखा त्रुटि प्रबंधन)।

निम्नलिखित Event_log.mc फ़ाइल से संदेश जानकारी containg एक संसाधन बनाएँ:

mc.exe -A -b -c -h . -r resources Event_log.mc 
rc.exe -foresources/Event_log.res resources/Event_log.rc 

यह एक हेडर फाइल बनाएगा:

;#ifndef _EXAMPLE_EVENT_LOG_MESSAGE_FILE_H_ 
;#define _EXAMPLE_EVENT_LOG_MESSAGE_FILE_H_ 

MessageIdTypeDef=DWORD 


SeverityNames=(Success=0x0:STATUS_SEVERITY_SUCCESS 
       Informational=0x1:STATUS_SEVERITY_INFORMATIONAL 
       Warning=0x2:STATUS_SEVERITY_WARNING 
       Error=0x3:STATUS_SEVERITY_ERROR 
       ) 

LanguageNames=(EnglishUS=0x401:MSG00401 
       Dutch=0x113:MSG00113 
       Neutral=0x0000:MSG00000 
       ) 

MessageId=0x0 SymbolicName=MSG_INFO_1 
Severity=Informational 
Facility=Application 
Language=Neutral 
%1 
. 

MessageId=0x1 SymbolicName=MSG_WARNING_1 
Severity=Warning 
Facility=Application 
Language=Neutral 
%1 
. 

MessageId=0x2 SymbolicName=MSG_ERROR_1 
Severity=Error 
Facility=Application 
Language=Neutral 
%1 
. 

MessageId=0x3 SymbolicName=MSG_SUCCESS_1 
Severity=Success 
Facility=Application 
Language=Neutral 
%1 
. 


;#endif 

.mc फ़ाइल और .res संसाधन फ़ाइल का निर्माण करने के लिए मैं निम्नलिखित निष्पादित मौजूदा निर्देशिका में Event_log.h कहा जाता है और एक फ़ाइल युक्त एक resources निर्देशिका Event_log.res नामित जो आप अपने आवेदन करने के लिए लिंक होना चाहिए द्विआधारी।

उदाहरण main.cpp:

#include <windows.h> 
#include "Event_log.h" 

void install_event_log_source(const std::string& a_name) 
{ 
    const std::string key_path("SYSTEM\\CurrentControlSet\\Services\\" 
           "EventLog\\Application\\" + a_name); 

    HKEY key; 

    DWORD last_error = RegCreateKeyEx(HKEY_LOCAL_MACHINE, 
             key_path.c_str(), 
             0, 
             0, 
             REG_OPTION_NON_VOLATILE, 
             KEY_SET_VALUE, 
             0, 
             &key, 
             0); 

    if (ERROR_SUCCESS == last_error) 
    { 
     BYTE exe_path[] = "C:\\path\\to\\your\\application.exe"; 
     DWORD last_error; 
     const DWORD types_supported = EVENTLOG_ERROR_TYPE | 
             EVENTLOG_WARNING_TYPE | 
             EVENTLOG_INFORMATION_TYPE; 

     last_error = RegSetValueEx(key, 
            "EventMessageFile", 
            0, 
            REG_SZ, 
            exe_path, 
            sizeof(exe_path)); 

     if (ERROR_SUCCESS == last_error) 
     { 
      last_error = RegSetValueEx(key, 
             "TypesSupported", 
             0, 
             REG_DWORD, 
             (LPBYTE) &types_supported, 
             sizeof(types_supported)); 
     } 

     if (ERROR_SUCCESS != last_error) 
     { 
      std::cerr << "Failed to install source values: " 
       << last_error << "\n"; 
     } 

     RegCloseKey(key); 
    } 
    else 
    { 
     std::cerr << "Failed to install source: " << last_error << "\n"; 
    } 
} 

void log_event_log_message(const std::string& a_msg, 
          const WORD   a_type, 
          const std::string& a_name) 
{ 
    DWORD event_id; 

    switch (a_type) 
    { 
     case EVENTLOG_ERROR_TYPE: 
      event_id = MSG_ERROR_1; 
      break; 
     case EVENTLOG_WARNING_TYPE: 
      event_id = MSG_WARNING_1; 
      break; 
     case EVENTLOG_INFORMATION_TYPE: 
      event_id = MSG_INFO_1; 
      break; 
     default: 
      std::cerr << "Unrecognised type: " << a_type << "\n"; 
      event_id = MSG_INFO_1; 
      break; 
    } 

    HANDLE h_event_log = RegisterEventSource(0, a_name.c_str()); 

    if (0 == h_event_log) 
    { 
     std::cerr << "Failed open source '" << a_name << "': " << 
      GetLastError() << "\n"; 
    } 
    else 
    { 
     LPCTSTR message = a_msg.c_str(); 

     if (FALSE == ReportEvent(h_event_log, 
           a_type, 
           0, 
           event_id, 
           0, 
           1, 
           0, 
           &message, 
           0)) 
     { 
      std::cerr << "Failed to write message: " << 
       GetLastError() << "\n"; 
     } 

     DeregisterEventSource(h_event_log); 
    } 
} 

void uninstall_event_log_source(const std::string& a_name) 
{ 
    const std::string key_path("SYSTEM\\CurrentControlSet\\Services\\" 
           "EventLog\\Application\\" + a_name); 

    DWORD last_error = RegDeleteKey(HKEY_LOCAL_MACHINE, 
            key_path.c_str()); 

    if (ERROR_SUCCESS != last_error) 
    { 
     std::cerr << "Failed to uninstall source: " << last_error << "\n"; 
    } 
} 

int main(int a_argc, char** a_argv) 
{ 
    const std::string event_log_source_name("my-test-event-log-source"); 

    install_event_log_source(event_log_source_name); 

    log_event_log_message("hello, information", 
          EVENTLOG_INFORMATION_TYPE, 
          event_log_source_name); 

    log_event_log_message("hello, error", 
          EVENTLOG_ERROR_TYPE, 
          event_log_source_name); 

    log_event_log_message("hello, warning", 
          EVENTLOG_WARNING_TYPE, 
          event_log_source_name); 

    // Uninstall when your application is being uninstalled. 
    //uninstall_event_log_source(event_log_source_name); 

    return 0; 
} 

आशा इस पर विचार लेकिन मदद करता है कि इस दृष्टिकोण के रूप में @Cody ग्रे ने कहा मान्य नहीं है।

Answer 2

आप Windows Event Log API पर प्रलेखन के लिए देख रहे हैं। आप .NET Framework के रैपर का उपयोग करने के बजाय देशी Win32 API फ़ंक्शंस को कॉल करने की आवश्यकता होगी, क्योंकि आप अप्रबंधित C++ में लिख रहे हैं।

यदि आप Windows Vista (XP, Server 2003, आदि) से पहले ऑपरेटिंग सिस्टम को लक्षित कर रहे हैं, तो आपको इसके बजाय पुराने Event Logging API का उपयोग करना होगा।