• Win32 简单日志实现

    简介

    个人实现的轻量化日志助手类, 实现了日志常用功能, 目的是使用简便快捷,  直接包含头文件和源文件即可使用

    功能

    1.可设置日志文件存放路径以及文件名前缀

    2.可设置单个日志文件最大容量, 到限后自动转储到下一个日志文件

    3.可设置日志自动保存, 按照时间间隔或日志缓存条目数量

    4.可设置最多保存的日志文件数量, 超限会自动删除最旧的日志文件

    5.可设置管道模式, 在管道模式下可使用另一个进程来处理日志转存

    日志代码gitee源码

    使用示例

    调用: CLogUtils::LOG_INFO(_T("%d %s"), 1024, _T("FlameCyclone"));

    日志文件输出内容: 2023-10-25 16:44:57.379  INFO [29288:32416] [E:\gitee\c-log-utils\CLogUtils\CLogUtils\main.cpp:20] [wmain] 1024 FlameCyclone

    性能测试

    配置1:

    CPU: AMD Ryzen 7 6800U with Radeon Graphics 

    内存: 8GB(6400Mhz) * 2

    Release x64 默认模式下速度 50万条 / 秒

    a37af2377fc5484380bb7277c8f1daf4.png

    Release x64 管道模式下速度 5万条 / 秒

    898bf78476e94fcbabc426031f741c1c.png

    配置2:

    CPU: Intel(R) Core(TM) i9-14900K 

    内存: 16GB(6000Mhz) * 2

    Release x64 默认模式下 140万条 / 秒

    6e3d6fa0fe4a4de898711a75c34e4c68.png

    Release x64 管道模式 54万条 / 秒

    1885219fb22647b4b65768ae46a83b32.png

    CLogUtils.h

    1. #pragma once
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. //请在VS项目属性页 -> C/C++ -> 预处理器 中 添加如下宏指定日志根目录, 用于截取源码文件路径相对路径
    12. //LOG_ROOT_DIR=R"($(ProjectDir))"
    13. //效果: 
    14. //添加宏之前: 2023-11-22 13:14:39.644  INFO [34688:22188] [D:\Gitee_FlameCyclone\c-log-utils\CLogUtils\CLogUtils\main.cpp:155] [CLogUtilsTest] 1024 FlameCyclone
    15. //添加宏之后: 2023-11-22 12:31:33.45  INFO [20884:7996] [.\main.cpp:133] [CLogUtilsTest] 1024 FlameCyclone
    16.  
    17. #ifdef _UNICODE
    18. using _tstring = std::wstring;
    19. #else
    20. using _tstring = std::string;
    21. #endif
    22.  
    23. #pragma warning(disable:4200)
    24.  
    25. namespace CLogUtils
    26. {
    27.     class CNamedPipe;
    28.  
    29. #define STRING_CONTENT_BUFFER_ENABLE    (1)                 //使用字符串作为日志缓冲
    30. #define LOG_FILE_COUNT                  (16)                //最多日志文件历史数量
    31. #define LOG_TIMEOUT                     (1000 * 60)         //自动保存超时时间(毫秒)
    32. #define LOG_FILE_SIZE                   (1024 * 1024 * 16)  //单个日志文件大小阈值(字节)
    33. #define LOG_BUF_COUNT                   (10000)             //日志缓冲大小阈值
    34.  
    35. #define LOG_INFO(format, ...)\
    36.     GetInstance().Logging(_T(" INFO"), _T(__FILE__), _T(__FUNCTION__), __LINE__, format, ##__VA_ARGS__);
    37.  
    38. #ifdef _DEBUG
    39. #define LOG_DEBUG(format, ...)\
    40.     GetInstance().Logging(_T("DEBUG"), _T(__FILE__), _T(__FUNCTION__), __LINE__, format, ##__VA_ARGS__);
    41. #else
    42. #define LOG_DEBUG(format, ...)\
    43.     GetInstance().DoNothing();
    44. #endif
    45.  
    46. #define LOG_WARN(format, ...)\
    47.     GetInstance().Logging(_T(" WARN"), _T(__FILE__), _T(__FUNCTION__), __LINE__, format, ##__VA_ARGS__);
    48.  
    49. #define LOG_ERROR(format, ...)\
    50.     GetInstance().Logging(_T("ERROR"), _T(__FILE__), _T(__FUNCTION__), __LINE__, format, ##__VA_ARGS__);
    51.  
    52.     class CLogHelper
    53.     {
    54.  
    55.     public:
    56.  
    57. #define Info(format, ...)\
    58.     Logging(_T(" INFO"), _T(__FILE__), _T(__FUNCTION__), __LINE__, format, ##__VA_ARGS__);
    59.  
    60. #ifdef _DEBUG
    61. #define Debug(format, ...)\
    62.     Logging(_T("DEBUG"), _T(__FILE__), _T(__FUNCTION__), __LINE__, format, ##__VA_ARGS__);
    63. #else
    64. #define Debug(format, ...)\
    65.     DoNothing();
    66. #endif
    67.  
    68. #define Warn(format, ...)\
    69.     Logging(_T(" WARN"), _T(__FILE__), _T(__FUNCTION__), __LINE__, format, ##__VA_ARGS__);
    70.  
    71. #define Error(format, ...)\
    72.     Logging(_T("ERROR"), _T(__FILE__), _T(__FUNCTION__), __LINE__, format, ##__VA_ARGS__);
    73.  
    74.     public:
    75.  
    76.         //默认构造
    77.         CLogHelper();
    78.  
    79.         //删除拷贝构造与赋值重载
    80.         CLogHelper(const CLogHelper&) = delete;
    81.  
    82.         //删除赋值重载
    83.         CLogHelper& operator = (const CLogHelper&) = delete;
    84.  
    85.         //析构
    86.         ~CLogHelper();
    87.  
    88.         //
    89.         // @brief: 初始化
    90.         // @param: bPipeMode    管道模式 true: 管道模式 false: 默认模式
    91.         // @param: strPipeName  管道名
    92.         // @param: strDir       存放目录
    93.         // @param: strPreName   文件名前缀
    94.         // @param: nFileSize    单个日志文件大小阈值(字节), 到达限制转储到下一个文件
    95.         // @param: nTempCount   日志缓存条目限制(到达限制转储到文件)
    96.         // @param: nTimeout     自动存储时间间隔(毫秒), 到达限制转储到文件
    97.         // @param: nFileCount   日志文件数量限制, 到达限制删除最旧的日志文件
    98.         // @ret: bool 执行结果
    99.         bool Initialize(
    100.             bool bPipeMode = false,
    101.             const _tstring& strPipeName = _T(""),
    102.             const _tstring& strDir = _T(""),
    103.             const _tstring& strPreName = _T(""),
    104.             DWORD nFileSize = LOG_FILE_SIZE,
    105.             DWORD nFileCount = LOG_FILE_COUNT,
    106.             DWORD nTempCount = LOG_BUF_COUNT,
    107.             DWORD nTimeout = LOG_TIMEOUT
    108.         );
    109.  
    110.         //
    111.         // @brief: 反初始化
    112.         // @ret: void
    113.         void Uninitialize();
    114.  
    115.         //
    116.         // @brief: 记录一条日志
    117.         // @param: pstrLevel    日志等级
    118.         // @param: pstrFile     源码文件
    119.         // @param: pstrFunc     源码函数
    120.         // @param: nLine        行数
    121.         // @param: pstrFormat   格式化字符串
    122.         // @param: ...          可变参数
    123.         // @ret: void
    124.         void Logging(
    125.             LPCTSTR pstrLevel,
    126.             LPCTSTR pstrFile,
    127.             LPCTSTR pstrFunc,
    128.             UINT nLine,
    129.             LPCTSTR pstrFormat,
    130.             ...
    131.         );
    132.  
    133.         //
    134.         // @brief: 清空已经存储的日志文件
    135.         // @ret: void
    136.         void Clear();
    137.  
    138.         //
    139.         // @brief: 刷新日志缓冲(输出日志到文件)
    140.         // @ret: bool 执行结果
    141.         bool FlushBuffers();
    142.  
    143.         //
    144.         // @brief: 啥也不干
    145.         // @ret: void
    146.         void DoNothing();
    147.  
    148.     private:
    149.  
    150.         //
    151.         // @brief: 获取目录下文件路径
    152.         // @ret: std::vector<_tstring> 日志文件列表
    153.         std::map<int64_t, _tstring> _GetLogFileList(const _tstring& strDir);
    154.  
    155.         //
    156.         // @brief: 调整日志文件数量
    157.         // @param: void
    158.         // @ret: void
    159.         void _AdjustLogFile();
    160.  
    161.         //
    162.         // @brief: 通过管道处理日志
    163.         // @ret: bool 执行结果
    164.         bool _ProcessByPipe();
    165.  
    166.         //
    167.         // @brief: 超时保存处理
    168.         // @ret: bool 执行结果
    169.         bool _ProcessTimeoutSave();
    170.  
    171.         //
    172.         // @brief: 管道方式记录日志
    173.         // @ret: bool 执行结果
    174.         bool _LoggingByPipe(const _tstring& strLogContent);
    175.  
    176.         //
    177.         // @brief: 刷新日志缓冲(输出日志到文件)
    178.         // @ret: bool 执行结果
    179.         bool _FlushLogBuffers();
    180.  
    181.         //
    182.         // @brief: 记录日志
    183.         // @ret: bool 执行结果
    184.         bool _LoggingContent(const _tstring& strLogContent);
    185.  
    186.         //
    187.         // @brief: 初始化
    188.         // @param: void
    189.         // @ret: bool 执行结果
    190.         bool _Initialize();
    191.  
    192.         //
    193.         // @brief: 取消初始化
    194.         // @param: void
    195.         // @ret: void
    196.         void _Uninitialize();
    197.  
    198.         //
    199.         // @brief: 初始化日志文件
    200.         // @param: void
    201.         // @ret: int 日志文件索引
    202.         void _InitLogFile();
    203.  
    204.         //
    205.         // @brief: 生成日志转储文件路径
    206.         // @param: void
    207.         // @ret: void
    208.         void _GenerateLogFilePath();
    209.  
    210.         //
    211.         // @brief: 获取默认日志管道名
    212.         // @param: void
    213.         // @ret: _tstring 管道名
    214.         _tstring _GetDefaultPipeName() const;
    215.  
    216.     private:
    217.  
    218.         std::vector<_tstring> m_logList;            //日志记录缓冲
    219.         std::map<int64_t, _tstring> m_logFileList;  //日志文件记录, 按照时间戳排序
    220.         std::thread m_tAutoSaveTask;                //超时自动保存任务线程
    221.         std::thread m_tPipeRecvTask;                //管道接收任务线程
    222.         std::mutex  m_Lock;                         //线程安全锁
    223.         CNamedPipe* m_pRecvPipe = nullptr;          //日志接收管道
    224.         CNamedPipe* m_pSendPipe = nullptr;          //日志发送管道
    225.  
    226.         HANDLE m_hEvent = nullptr;                  //通知事件, 使用自动转储的超时等待
    227.         HANDLE m_hFile = INVALID_HANDLE_VALUE;      //文件句柄, 日志文件写入使用
    228.         int64_t  m_nFileTimetamp = 0;               //日志文件时间戳
    229.         _tstring m_strSaveDir;                      //日志存放目录
    230.         _tstring m_strSaveName;                     //日志文件名
    231.         _tstring m_strFilePath;                     //当前日志文件路径
    232.         _tstring m_strLogContent;                   //日志内容
    233.         _tstring m_strPipeName;                     //管道名
    234.         bool m_bStop = false;                       //停止标记
    235.         bool m_bFirst = false;                      //首次记录日志标记
    236.         bool m_bPipeMode = false;                   //管道模式
    237.  
    238.         DWORD m_nFileSize = 0;                      //文件大小限制(到达限制则转储到文件)
    239.         DWORD m_nTempCount = 0;                     //缓存条目限制(到达限制则转储到文件)
    240.         DWORD m_nFileCount = 0;                     //历史文件数量限制(超限则删除旧文件)
    241.         DWORD m_nTimeout = 0;                       //自动保存超时限制(超时则转储到文件)
    242.         DWORD m_nCurFileSize = 0;                   //日志文件统计
    243.         DWORD m_nNextItemSize = 0;                  //下一条日志大小
    244.         DWORD m_nLogItemCount = 0;                  //日志缓冲统计
    245.     };
    246.  
    247.     class CNamedPipe
    248.     {
    249.     public:
    250.         CNamedPipe();
    251.  
    252.         ~CNamedPipe();
    253.  
    254.         CNamedPipe(const CNamedPipe& r) = delete;
    255.         CNamedPipe& operator = (const CNamedPipe& r) = delete;
    256.  
    257.         //
    258.         // @brief: 创建命名管道
    259.         // @param: lpName           管道名
    260.         // @ret: bool               true: 创建成功 false: 创建失败
    261.         bool Create(LPCTSTR lpName);
    262.  
    263.         //
    264.         // @brief: 等待客户端连接命名管道
    265.         // @param: nTimeOut         超时等待(毫秒)
    266.         // @ret: bool               true: 连接成功 false: 连接失败
    267.         bool WaitConnect(DWORD nTimeOut = INFINITE);
    268.  
    269.         //
    270.         // @brief: 关闭由Create 创建的管道
    271.         // @param: void
    272.         // @ret: bool               true: 关闭 成功 false: 关闭 失败
    273.         bool Disconnect();
    274.  
    275.         //
    276.         // @brief: 打开已存在的命名管道
    277.         // @param: lpName           管道名
    278.         // @ret: bool               true: 打开成功 false: 打开失败
    279.         bool Open(LPCTSTR lpName, DWORD nTimeOut = INFINITE);
    280.  
    281.         //
    282.         // @brief: 管道是否有效
    283.         // @param: void
    284.         // @ret: bool               true: 可用 false: 无效
    285.         bool IsValid();
    286.  
    287.         //
    288.         // @brief: 关闭管道
    289.         // @param: void
    290.         // @ret: void
    291.         void Close(void);
    292.  
    293.         //
    294.         // @brief: 从读取管道数据
    295.         // @param: lpData           数据存放缓冲
    296.         // @param: nSize            缓冲大小(字节)
    297.         // @param: lpBytesRead      指向实际读取大小(字节)的指针
    298.         // @param: nTimeOut         读取超时(毫秒)
    299.         // @ret: bool               true: 读取成功 false: 读取失败
    300.         bool Read(LPVOID lpData, DWORD nSize, LPDWORD lpBytesRead = nullptr, DWORD nTimeOut = INFINITE);
    301.  
    302.         //
    303.         // @brief: 向管道写入数据
    304.         // @param: lpData           写入数据指针
    305.         // @param: nSize            写入数据大小(字节)
    306.         // @param: lpBytesWritten   指向实际写入大小(字节)的指针
    307.         // @param: nTimeOut         写入超时(毫秒)
    308.         // @ret: bool               true: 写入成功 false: 写入失败
    309.         bool Write(LPCVOID lpData, DWORD nSize, LPDWORD lpBytesWritten = nullptr, DWORD nTimeOut = INFINITE);
    310.  
    311.     private:
    312.  
    313.         //
    314.         // @brief: 初始化对象占用
    315.         // @param: void
    316.         // @ret: void
    317.         bool Initialize();
    318.  
    319.         //
    320.         // @brief: 释放对象占用
    321.         // @param: void
    322.         // @ret: void
    323.         void Uninitialize();
    324.  
    325.     private:
    326.         HANDLE m_hNamedPipe = INVALID_HANDLE_VALUE;
    327.         HANDLE m_hReadEvent = NULL;
    328.         HANDLE m_hWriteEvent = NULL;
    329.         HANDLE m_hConnectEvent = NULL;
    330.         LPVOID m_pBuffer = nullptr;
    331.         bool m_bInit = false;
    332.         bool m_bConnected = false;
    333.     };
    334.  
    335.     //
    336.     // @brief: 格式化字符串
    337.     // @param: void
    338.     // @ret: bool 执行结果
    339.     _tstring Format(LPCTSTR pstrFormat, ...);
    340.  
    341.     // 
    342.     // @brief: 获取当前进程完全路径
    343.     // @ret: 当前进程完全路径 如 D:\Software\HxDPortableSetup.exe
    344.     _tstring GetCurrentModulePath();
    345.  
    346.     // 
    347.     // @brief: 获取当前进程所在目录
    348.     // @ret: 当前进程所在目录 如 D:\Software
    349.     _tstring GetCurrentModuleDir();
    350.  
    351.     // 
    352.     // @brief: 获取当前进程名
    353.     // @ret: 当前进程名 如 HxDPortableSetup.exe
    354.     _tstring GetCurrentModuleName(bool bHasExt = false);
    355.  
    356.     // 
    357.     // @brief: 获取文件所在文件夹
    358.     // @param: strPath     文件名, 如: D:\Software\HxDPortableSetup.exe
    359.     // @ret: 文件夹        如 D:\Software
    360.     _tstring GetFileDir(const _tstring& strPath);
    361.  
    362.     // 
    363.     // @brief: 获取文件名
    364.     // @param: strPath     文件名, 如: D:\Software\HxDPortableSetup.exe
    365.     // @param: bHasExt     是否包含扩展名
    366.     // @ret: 文件夹        如 HxDPortableSetup
    367.     _tstring GetFileName(const _tstring& strPath, bool bHasExt = false);
    368.  
    369.     // 
    370.     // @brief: 检查文件是否存在
    371.     // @param: strPath     文件名, 如: D:\Software\HxDPortableSetup.exe
    372.     // @ret: 是否存在      存在返回 true
    373.     bool IsDirectory(const _tstring& strPath);
    374.  
    375.     //
    376.     // @brief: 创建目录(递归)
    377.     // @param: strPath      路径
    378.     // @ret: 成功返回true
    379.     bool CreateDir(const _tstring& strPath);
    380.  
    381.     //
    382.     // @brief: 删除文件
    383.     // @param: strPath      路径
    384.     // @ret: 成功返回true
    385.     bool DeleteArchive(const _tstring& strPath);
    386.  
    387.     //
    388.     // @brief: 获取当前时间戳字符串
    389.     // @param: void
    390.     // @ret: _tstring 时间戳字符串          如: 2023-10-11 17:43:00.617
    391.     _tstring GetCurrentTimeString();
    392.  
    393.     //
    394.     // @brief: 获取当前时间戳
    395.     // @param: void
    396.     // @ret: 时间戳(单位: 毫秒)    如: 1697017380617
    397.     int64_t GetCurrentTimestamp();
    398.  
    399.     //
    400.     // @brief: 时间戳转字符串  
    401.     // @param: strFormat    格式化字符串 如: "%04d-%02d-%02d %02d:%02d:%02d.03%d"
    402.     // @param: timestamp    时间戳 如: 1697017380617
    403.     // @ret: 时间字符串            如: 2023-10-11 17:43:00.617
    404.     _tstring TimestampToString(
    405.         int64_t timestamp = 0,
    406.         const _tstring& strFormat = _T("%04d-%02d-%02d %02d:%02d:%02d.03%d")
    407.     );
    408.  
    409.     //
    410.     // @brief: 获取文件大小
    411.     // @param: strPath      路径
    412.     // @ret: 文件大小
    413.     unsigned long long GetFileSize(const _tstring& strPath);
    414.  
    415.     CLogHelper& GetInstance();
    416. }

    CLogUtils.cpp

    1. #include "CLogUtils.h"
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. #pragma comment(lib, "Shlwapi.lib")
    8.  
    9. namespace CLogUtils
    10. {
    11. #define DEFAULT_LOG_FILE_COUNT_MIN                  (4)                     //默认最少日志文件历史数量
    12. #define DEFAULT_LOG_TIMEOUT_MIN                     (1000 * 5)              //默认自动保存超时时间(毫秒)
    13. #define DEFAULT_LOG_FILE_SIZE_MIN                   (1024 * 1024 * 1)       //默认单个日志文件大小阈值(字节)
    14. #define DEFAULT_LOG_BUF_COUNT_MIN                   (256)                   //默认日志缓冲数量阈值
    15.  
    16. #define DEFAULT_LOG_FILE_COUNT_MAX                  (256)                   //默认最多日志文件历史数量
    17. #define DEFAULT_LOG_TIMEOUT_MAX                     (1000 * 60)             //默认自动保存超时时间(毫秒)
    18. #define DEFAULT_LOG_FILE_SIZE_MAX                   (1024 * 1024 * 256)     //默认单个日志文件大小阈值(字节)
    19. #define DEFAULT_LOG_BUF_COUNT_MAX                   (1024 * 4)              //默认日志缓冲数量阈值
    20.  
    21. #define PIPE_NAME_PREFIX                            TEXT(R"(\\.\pipe\)")    //管道前缀名
    22. #define PIPE_MAX_TIMEOUT                            (3000)                  //管道打开超时
    23. #define PIPE_BUF_MAX_SIZE                           (1024 * 1024)           //管道发送缓冲大小(字节)
    24. #define PIPE_MAX_CONNECT                            (1)                     //管道最大实例数量
    25.  
    26.     typedef struct _PIPE_DATA
    27.     {
    28.         DWORD dwSize = 0;
    29.         BYTE data[0];
    30.     }PIPE_DATA, * PPIPE_DATA;
    31.  
    32.     //全局实例构造
    33.     static CLogHelper g_Instance;
    34.  
    35.     CLogHelper::CLogHelper() :
    36.         m_bPipeMode(false),
    37.         m_strPipeName(_T("")),
    38.         m_strSaveDir(_T("")),
    39.         m_strSaveName(_T("")),
    40.         m_nFileSize(LOG_FILE_SIZE),
    41.         m_nTempCount(LOG_BUF_COUNT),
    42.         m_nTimeout(LOG_TIMEOUT),
    43.         m_nFileCount(LOG_FILE_COUNT)
    44.     {
    45.     }
    46.  
    47.     CLogHelper::~CLogHelper()
    48.     {
    49.         this->Uninitialize();
    50.     }
    51.  
    52.     void CLogHelper::DoNothing()
    53.     {
    54.     }
    55.  
    56.     bool CLogHelper::Initialize(
    57.         bool bPipeMode/* = false*/,
    58.         const _tstring& strPipeName/* = _T("")*/,
    59.         const _tstring& strDir/* = _T("")*/,
    60.         const _tstring& strPreName/* = _T("")*/,
    61.         DWORD nFileSize/* = LOG_FILE_SIZE*/,
    62.         DWORD nFileCount/* = LOG_FILE_COUNT*/,
    63.         DWORD nTmpCount/* = LOG_BUF_COUNT*/,
    64.         DWORD nTimeout/* = LOG_TIMEOUT*/
    65.     )
    66.     {
    67.         m_bPipeMode = bPipeMode;
    68.         m_strPipeName = strPipeName;
    69.         m_strSaveDir = strDir;
    70.         m_strSaveName = strPreName;
    71.         m_nFileSize = nFileSize;
    72.         m_nTempCount = nTmpCount;
    73.         m_nTimeout = nTimeout;
    74.         m_nFileCount = nFileCount;
    75.  
    76.         //最小参数限制
    77.         if (m_nFileSize < DEFAULT_LOG_FILE_SIZE_MIN)
    78.         {
    79.             m_nFileSize = DEFAULT_LOG_FILE_SIZE_MIN;
    80.         }
    81.  
    82.         if (m_nFileCount < DEFAULT_LOG_FILE_COUNT_MIN)
    83.         {
    84.             m_nFileCount = DEFAULT_LOG_FILE_COUNT_MIN;
    85.         }
    86.  
    87.         if (m_nTempCount < DEFAULT_LOG_BUF_COUNT_MIN)
    88.         {
    89.             m_nTempCount = DEFAULT_LOG_BUF_COUNT_MIN;
    90.         }
    91.  
    92.         if (m_nTimeout < DEFAULT_LOG_TIMEOUT_MIN)
    93.         {
    94.             m_nTimeout = DEFAULT_LOG_TIMEOUT_MIN;
    95.         }
    96.  
    97.         //最大参数限制
    98.         if (m_nFileSize > DEFAULT_LOG_FILE_SIZE_MAX)
    99.         {
    100.             m_nFileSize = DEFAULT_LOG_FILE_SIZE_MAX;
    101.         }
    102.  
    103.         if (m_nFileCount > DEFAULT_LOG_FILE_COUNT_MAX)
    104.         {
    105.             m_nFileCount = DEFAULT_LOG_FILE_COUNT_MAX;
    106.         }
    107.  
    108.         if (m_nTempCount > DEFAULT_LOG_BUF_COUNT_MAX)
    109.         {
    110.             m_nTempCount = DEFAULT_LOG_BUF_COUNT_MAX;
    111.         }
    112.  
    113.         if (m_nTimeout > DEFAULT_LOG_TIMEOUT_MAX)
    114.         {
    115.             m_nTimeout = DEFAULT_LOG_TIMEOUT_MAX;
    116.         }
    117.  
    118.         //默认目录为当前进程目录
    119.         if (m_strSaveDir.empty())
    120.         {
    121.             m_strSaveDir = GetCurrentModuleDir();
    122.         }
    123.  
    124.         //默认文件名为当前进程名
    125.         if (m_strSaveName.empty())
    126.         {
    127.             m_strSaveName = GetCurrentModuleName(true);
    128.         }
    129.  
    130.         //目录不存在就创建目录
    131.         if (!IsDirectory(m_strSaveDir))
    132.         {
    133.             CreateDir(m_strSaveDir);
    134.         }
    135.  
    136.         if (m_strPipeName.empty())
    137.         {
    138.             m_strPipeName = _GetDefaultPipeName();
    139.         }
    140.  
    141.         return this->_Initialize();
    142.     }
    143.  
    144.     void CLogHelper::Uninitialize()
    145.     {
    146.         _Uninitialize();
    147.     }
    148.  
    149.     bool CLogHelper::_Initialize()
    150.     {
    151.         _Uninitialize();
    152.  
    153.         // 管道模式
    154.         if (m_bPipeMode)
    155.         {
    156.             m_pRecvPipe = new (std::nothrow) CNamedPipe;
    157.             m_pSendPipe = new (std::nothrow) CNamedPipe;
    158.  
    159.             if (nullptr == m_pRecvPipe)
    160.             {
    161.                 return false;
    162.             }
    163.  
    164.             if (nullptr == m_pSendPipe)
    165.             {
    166.                 return false;
    167.             }
    168.  
    169.             std::promise<bool> m;
    170.             std::future<bool> p = m.get_future();
    171.  
    172.             m_tPipeRecvTask = std::move(
    173.                 std::thread([this, &m]() -> void
    174.                     {
    175.                         m.set_value(true);
    176.                         _ProcessByPipe();
    177.                     }
    178.                 )
    179.             );
    180.  
    181.             //等待线程启动完毕
    182.             p.get();
    183.         }
    184.  
    185.         // 超时自动保存任务
    186.         {
    187.             if (NULL == m_hEvent)
    188.             {
    189.                 m_hEvent = ::CreateEvent(nullptr, false, false, nullptr);
    190.             }
    191.  
    192.             if (NULL == m_hEvent)
    193.             {
    194.                 return false;
    195.             }
    196.  
    197.             std::promise<bool> m;
    198.             std::future<bool> p = m.get_future();
    199.  
    200.             m_tAutoSaveTask = std::move(
    201.                 std::thread([this, &m]()
    202.                     {
    203.                         m.set_value(true);
    204.                         _ProcessTimeoutSave();
    205.                     }
    206.                 )
    207.             );
    208.  
    209.             //等待线程启动完毕
    210.             p.get();
    211.         }
    212.  
    213.         return true;
    214.     }
    215.  
    216.     void CLogHelper::_Uninitialize()
    217.     {
    218.         if (!m_logList.empty() || !m_strLogContent.empty())
    219.         {
    220.             FlushBuffers();
    221.         }
    222.  
    223.         if (INVALID_HANDLE_VALUE != m_hFile)
    224.         {
    225.             ::CloseHandle(m_hFile);
    226.             m_hFile = INVALID_HANDLE_VALUE;
    227.         }
    228.  
    229.         if (NULL != m_hEvent)
    230.         {
    231.             m_bStop = true;
    232.             ::SetEvent(m_hEvent);
    233.         }
    234.  
    235.         if (m_tAutoSaveTask.joinable())
    236.         {
    237.             m_tAutoSaveTask.join();
    238.         }
    239.  
    240.         if (NULL != m_hEvent)
    241.         {
    242.             ::CloseHandle(m_hEvent);
    243.             m_hEvent = NULL;
    244.         }
    245.  
    246.         if (m_bPipeMode)
    247.         {
    248.             if (m_pRecvPipe)
    249.             {
    250.                 m_pRecvPipe->Close();
    251.             }
    252.  
    253.             if (m_pSendPipe)
    254.             {
    255.                 m_pSendPipe->Close();
    256.             }
    257.  
    258.             if (m_tPipeRecvTask.joinable())
    259.             {
    260.                 m_tPipeRecvTask.join();
    261.             }
    262.         }
    263.  
    264.         if (nullptr != m_pRecvPipe)
    265.         {
    266.             delete m_pRecvPipe;
    267.             m_pRecvPipe = nullptr;
    268.         }
    269.  
    270.         if (nullptr != m_pSendPipe)
    271.         {
    272.             delete m_pSendPipe;
    273.             m_pSendPipe = nullptr;
    274.         }
    275.  
    276.         m_bFirst = false;
    277.         m_bStop = false;
    278.     }
    279.  
    280.     bool CLogHelper::_LoggingByPipe(const _tstring& strLogContent)
    281.     {
    282.         bool bSuccess = false;
    283.  
    284.         if (nullptr == m_pSendPipe)
    285.         {
    286.             return false;
    287.         }
    288.  
    289.         if (!m_pSendPipe->IsValid())
    290.         {
    291.             if (!m_pSendPipe->Open(m_strPipeName.c_str(), 1000))
    292.             {
    293.                 return false;
    294.             }
    295.         }
    296.  
    297.         //写入日志内容到管道, 交给另一端处理(可用跨进程)
    298.         bSuccess = m_pSendPipe->Write(strLogContent.c_str(), (DWORD)((strLogContent.size() + 1) * sizeof(TCHAR)));
    299.         if (!bSuccess)
    300.         {
    301.             m_pSendPipe->Close();
    302.         }
    303.  
    304.         return bSuccess;
    305.     }
    306.  
    307.     bool CLogHelper::_FlushLogBuffers()
    308.     {
    309.         DWORD dwNumberOfBytesWrite = 0;
    310.         bool bSuccess = false;
    311.  
    312.         if (INVALID_HANDLE_VALUE == m_hFile)
    313.         {
    314.             return false;
    315.         }
    316.  
    317. #if STRING_CONTENT_BUFFER_ENABLE
    318.         //没有需要写入的日志
    319.         if (m_strLogContent.empty())
    320.         {
    321.             return true;
    322.         }
    323.  
    324.         bSuccess = ::WriteFile(m_hFile, m_strLogContent.c_str(), (DWORD)(m_strLogContent.size() * sizeof(TCHAR)), &dwNumberOfBytesWrite, NULL);
    325.         m_strLogContent.clear();
    326. #else
    327.         //没有需要写入的日志
    328.         if (m_logList.empty())
    329.         {
    330.             return true;
    331.         }
    332.  
    333.         for (const auto& item : m_logList)
    334.         {
    335.             bSuccess = ::WriteFile(m_hFile, item.c_str(), (DWORD)(item.size() * sizeof(TCHAR)), &dwNumberOfBytesWrite, NULL);
    336.             if (!bSuccess)
    337.             {
    338.                 break;
    339.             }
    340.         }
    341.  
    342. #endif
    343.  
    344.         return bSuccess;
    345.     }
    346.  
    347.     bool CLogHelper::_LoggingContent(const _tstring& strLogContent)
    348.     {
    349.         //获取单行日志内容 + 固定前缀内容 + 真实内容
    350.         m_nNextItemSize = (DWORD)(strLogContent.size() * sizeof(TCHAR));
    351.  
    352.         std::lock_guard lock(m_Lock);
    353.  
    354.         //首次启动时, 重置大小统计
    355.         if (!m_bFirst)
    356.         {
    357.             _InitLogFile();
    358.             _AdjustLogFile();
    359.             m_nCurFileSize = (DWORD)GetFileSize(m_strFilePath);
    360.             m_bFirst = true;
    361.         }
    362.  
    363.         //单个日志文件大小即将达到或超过阈值则输出到文件, 启用新的文件存储
    364.         if ((m_nCurFileSize + m_nNextItemSize) >= m_nFileSize)
    365.         {
    366.             _FlushLogBuffers();
    367.             m_logList.clear();
    368.  
    369.             ::CloseHandle(m_hFile);
    370.             m_hFile = INVALID_HANDLE_VALUE;
    371.  
    372.             (void)_GenerateLogFilePath();
    373.             m_nCurFileSize = (DWORD)GetFileSize(m_strFilePath);
    374.             _AdjustLogFile();
    375.         }
    376.  
    377.         //已缓存条目达到阈值则输出到文件
    378. #if STRING_CONTENT_BUFFER_ENABLE
    379.         else if (m_nLogItemCount >= m_nTempCount)
    380.         {
    381.             _FlushLogBuffers();
    382.             m_strLogContent.clear();
    383.             m_nLogItemCount = 0;
    384.         }
    385. #else
    386.         else if (m_logList.size() >= m_nTempCount)
    387.         {
    388.             _FlushLogBuffers();
    389.             m_logList.clear();
    390.         }
    391.  
    392. #endif
    393.  
    394. #if STRING_CONTENT_BUFFER_ENABLE
    395.         m_strLogContent += strLogContent;
    396.         m_nLogItemCount++;
    397. #else
    398.         m_logList.emplace_back(strLogContent);
    399. #endif
    400.  
    401.         //累加统计单个日志文件大小
    402.         m_nCurFileSize += m_nNextItemSize;
    403.         return true;
    404.     }
    405.  
    406.     bool CLogHelper::_ProcessTimeoutSave()
    407.     {
    408.         while (!m_bStop)
    409.         {
    410.             DWORD dwWait = ::WaitForSingleObject(m_hEvent, m_nTimeout);
    411.             switch (dwWait)
    412.             {
    413.             case WAIT_TIMEOUT:
    414.             case WAIT_OBJECT_0:
    415.             {
    416.                 std::lock_guard lock(m_Lock);
    417.                 this->_FlushLogBuffers();
    418.                 m_logList.clear();
    419.             }
    420.             break;
    421.             default:
    422.                 break;
    423.             }
    424.         }
    425.  
    426.         return true;
    427.     }
    428.  
    429.     bool CLogHelper::_ProcessByPipe()
    430.     {
    431.         if (m_pRecvPipe->IsValid())
    432.         {
    433.             return true;
    434.         }
    435.  
    436.         if (!m_pRecvPipe->Create(m_strPipeName.c_str()))
    437.         {
    438.             return false;
    439.         }
    440.  
    441.         DWORD dwPipeBufSize = PIPE_BUF_MAX_SIZE;
    442.         LPTSTR lpData = nullptr;
    443.         bool bFailed = false;
    444.  
    445.         lpData = (LPTSTR)::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, dwPipeBufSize);
    446.         if (nullptr == lpData)
    447.         {
    448.             return false;
    449.         }
    450.  
    451.         while (!m_bStop && !bFailed)
    452.         {
    453.             if (!m_pRecvPipe->WaitConnect())
    454.             {
    455.                 _tprintf(_T("WaitConnect failed!\r\n"));
    456.                 break;
    457.             }
    458.  
    459.             while (!m_bStop)
    460.             {
    461.                 bool isSuccess = m_pRecvPipe->Read(lpData, dwPipeBufSize);
    462.                 if (isSuccess)
    463.                 {
    464.                     _LoggingContent(lpData);
    465.                 }
    466.  
    467.                 if (ERROR_BROKEN_PIPE == ::GetLastError())
    468.                 {
    469.                     m_pRecvPipe->Disconnect();
    470.                     if (!m_pRecvPipe->WaitConnect())
    471.                     {
    472.                         _tprintf(_T("WaitConnect failed!\r\n"));
    473.                         bFailed = true;
    474.                         break;
    475.                     }
    476.                 }
    477.  
    478.                 if (!m_pRecvPipe->IsValid())
    479.                 {
    480.                     break;
    481.                 }
    482.             }
    483.         }
    484.  
    485.         this->_FlushLogBuffers();
    486.         m_logList.clear();
    487.  
    488.         if (nullptr != lpData)
    489.         {
    490.             ::HeapFree(::GetProcessHeap(), 0, lpData);
    491.             lpData = nullptr;
    492.         }
    493.  
    494.         return true;
    495.     }
    496.  
    497.     void CLogHelper::Logging(
    498.         LPCTSTR pstrLevel,
    499.         LPCTSTR pstrFile,
    500.         LPCTSTR pstrFunc,
    501.         UINT nLine,
    502.         LPCTSTR pstrFormat,
    503.         ...
    504.     )
    505.     {
    506.         if (nullptr == pstrFormat)
    507.         {
    508.             return;
    509.         }
    510.  
    511.         TCHAR szBuf[MAX_PATH] = { 0 };
    512.         DWORD dwPid = ::GetCurrentProcessId();
    513.         DWORD dwTid = ::GetCurrentThreadId();
    514.         _tstring strLogContent;
    515.         SYSTEMTIME st = { 0 };
    516.         (void)::GetLocalTime(&st);
    517.  
    518. #ifdef LOG_ROOT_DIR
    519.  
    520.         //日志格式前缀 [时间] [等级] [十进制进程ID:十进制线程ID] [源码位置:行数] [函数名]
    521.         //相对路径显示源码文件路径
    522.  
    523.         _TCHAR szRelativePath[MAX_PATH] = { 0 };
    524.         if (::PathRelativePathTo(szRelativePath, _T(LOG_ROOT_DIR), FILE_ATTRIBUTE_DIRECTORY, pstrFile, 0))
    525.         {
    526.             ::StringCchPrintf(
    527.                 szBuf,
    528.                 _countof(szBuf),
    529.                 _T("%04d-%02d-%02d %02d:%02d:%02d.%03d %s [%d:%d] [%s:%d] [%s] "),
    530.                 st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond, st.wMilliseconds,
    531.                 pstrLevel,
    532.                 dwPid,
    533.                 dwTid,
    534.                 szRelativePath,
    535.                 nLine,
    536.                 pstrFunc
    537.             );
    538.         }
    539.         else
    540.         {
    541.             ::StringCchPrintf(
    542.                 szBuf,
    543.                 _countof(szBuf),
    544.                 _T("%04d-%02d-%02d %02d:%02d:%02d.%03d %s [%d:%d] [%s:%d] [%s] "),
    545.                 st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond, st.wMilliseconds,
    546.                 pstrLevel,
    547.                 dwPid,
    548.                 dwTid,
    549.                 pstrFile,
    550.                 nLine,
    551.                 pstrFunc
    552.             );
    553.         }
    554.  
    555. #else
    556.         //日志格式前缀 [时间] [等级] [十进制进程ID:十进制线程ID] [源码位置:行数] [函数名]
    557.         ::StringCchPrintf(
    558.             szBuf,
    559.             _countof(szBuf),
    560.             _T("%04d-%02d-%02d %02d:%02d:%02d.%03d %s [%d:%d] [%s:%d] [%s] "),
    561.             st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond, st.wMilliseconds,
    562.             pstrLevel,
    563.             dwPid,
    564.             dwTid,
    565.             pstrFile,
    566.             nLine,
    567.             pstrFunc
    568.         );
    569.  
    570. #endif
    571.  
    572.         strLogContent = szBuf;
    573.  
    574.         va_list args;
    575.         va_start(args, pstrFormat);
    576.  
    577.         LPTSTR pFormatBuf = nullptr;              //格式化日志缓冲
    578.         DWORD dwFormatBufCch = MAX_PATH;          //格式化日志缓冲大小
    579.  
    580.         do
    581.         {
    582.             //分配缓冲
    583.             pFormatBuf = (LPTSTR)::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, dwFormatBufCch * sizeof(TCHAR));
    584.             if (nullptr == pFormatBuf)
    585.             {
    586.                 break;
    587.             }
    588.  
    589.             //成功则赋值字符串并终止循环
    590.             if (-1 != _vsntprintf_s(pFormatBuf, dwFormatBufCch, _TRUNCATE, pstrFormat, args))
    591.             {
    592.                 strLogContent += pFormatBuf;
    593.                 break;
    594.             }
    595.  
    596.             //释放缓冲, 待下次重新分配
    597.             ::HeapFree(::GetProcessHeap(), 0, pFormatBuf);
    598.             pFormatBuf = nullptr;
    599.  
    600.             //超限终止处理
    601.             if (dwFormatBufCch >= INT32_MAX)
    602.             {
    603.                 break;
    604.             }
    605.  
    606.             dwFormatBufCch *= 2;
    607.  
    608.         } while (true);
    609.         va_end(args);
    610.  
    611.         //释放缓冲
    612.         if (nullptr != pFormatBuf)
    613.         {
    614.             ::HeapFree(::GetProcessHeap(), 0, pFormatBuf);
    615.             pFormatBuf = nullptr;
    616.         }
    617.  
    618.         strLogContent += _T("\r\n");
    619.  
    620.         if (m_bPipeMode)
    621.         {
    622.             _LoggingByPipe(strLogContent);
    623.         }
    624.         else
    625.         {
    626.             _LoggingContent(strLogContent);
    627.         }
    628.     }
    629.  
    630.     void CLogHelper::Clear()
    631.     {
    632.         std::lock_guard lock(m_Lock);
    633.  
    634.         if (INVALID_HANDLE_VALUE != m_hFile)
    635.         {
    636.             ::CloseHandle(m_hFile);
    637.             m_hFile = INVALID_HANDLE_VALUE;
    638.         }
    639.  
    640.         m_logFileList = _GetLogFileList(m_strSaveDir);
    641.         for (const auto& item : m_logFileList)
    642.         {
    643.             DeleteArchive(item.second);
    644.         }
    645.  
    646.         m_logFileList.clear();
    647.     }
    648.  
    649.     bool CLogHelper::FlushBuffers()
    650.     {
    651.         std::lock_guard lock(m_Lock);
    652.         return _FlushLogBuffers();
    653.     }
    654.  
    655.     void CLogHelper::_AdjustLogFile()
    656.     {
    657.         //检查文件数量是否到达阈值, 到达的话删除前面的文件
    658.         if (m_logFileList.size() > m_nFileCount)
    659.         {
    660.             size_t nDeleteCount = m_logFileList.size() - m_nFileCount;
    661.  
    662.             //从日志文件记录列表中删除
    663.             for (size_t i = 0; i < nDeleteCount; i++)
    664.             {
    665.                 auto itBegin = m_logFileList.begin();
    666.                 DeleteArchive(itBegin->second);
    667.                 m_logFileList.erase(m_logFileList.begin());
    668.             }
    669.         }
    670.     }
    671.  
    672.     void CLogHelper::_InitLogFile()
    673.     {
    674.         //如果上次最后一个日志文件大小还能存储日志, 就沿用上次的日志文件
    675.         m_logFileList = _GetLogFileList(m_strSaveDir);
    676.         if (!m_logFileList.empty())
    677.         {
    678.             auto itLast = m_logFileList.end();
    679.             itLast--;
    680.  
    681.             m_nFileTimetamp = itLast->first;
    682.             m_strFilePath = itLast->second;
    683.  
    684.             //上次最后一个日志文件不能存储更多日志, 则生成新的日志文件路径
    685.             unsigned long long ullFileSize = (DWORD)GetFileSize(m_strFilePath);
    686.             if ((ullFileSize + m_nNextItemSize) >= m_nFileSize)
    687.             {
    688.                 (void)_GenerateLogFilePath();
    689.             }
    690.             else
    691.             {
    692.                 //打开文件以续写日志
    693.                 m_hFile = CreateFile(
    694.                     m_strFilePath.c_str(),
    695.                     GENERIC_WRITE,
    696.                     FILE_SHARE_READ,
    697.                     NULL,
    698.                     OPEN_ALWAYS,
    699.                     FILE_ATTRIBUTE_NORMAL,
    700.                     NULL
    701.                 );
    702.  
    703.                 //在文件末尾追加内容
    704.                 LARGE_INTEGER  liDistanceToMove = { 0 };
    705.                 ::SetFilePointerEx(m_hFile, liDistanceToMove, NULL, FILE_END);
    706.             }
    707.         }
    708.         else
    709.         {
    710.             (void)_GenerateLogFilePath();
    711.         }
    712.     }
    713.  
    714.     //
    715.     // @brief: 获取日志管道名
    716.     // @param: void
    717.     // @ret: _tstring 管道名
    718.     _tstring CLogHelper::_GetDefaultPipeName() const
    719.     {
    720.         return Format(_T("%s_%s"), m_strSaveDir.c_str(), m_strSaveName.c_str());
    721.     }
    722.  
    723.     void CLogHelper::_GenerateLogFilePath()
    724.     {
    725.         //得到日志文件时间戳
    726.         m_nFileTimetamp = GetCurrentTimestamp();
    727.  
    728.         //得到日志文件路径
    729.         m_strFilePath = Format(_T("%s\\%s_%s.log"),
    730.             m_strSaveDir.c_str(),
    731.             m_strSaveName.c_str(),
    732.             TimestampToString(m_nFileTimetamp, _T("%04d-%02d-%02d_%02d-%02d-%02d-%03d")).c_str()
    733.         );
    734.  
    735.         //创建一下文件(防止在资源管理器中看不到新的日志文件)
    736.         m_hFile = CreateFile(
    737.             m_strFilePath.c_str(),
    738.             GENERIC_WRITE,
    739.             FILE_SHARE_READ,
    740.             NULL,
    741.             OPEN_ALWAYS,
    742.             FILE_ATTRIBUTE_NORMAL,
    743.             NULL
    744.         );
    745.  
    746.         //在文件末尾追加内容
    747.         LARGE_INTEGER  liDistanceToMove = { 0 };
    748.         ::SetFilePointerEx(m_hFile, liDistanceToMove, NULL, FILE_END);
    749.  
    750.         m_logFileList.insert(std::make_pair(m_nFileTimetamp, m_strFilePath));
    751.     }
    752.  
    753.     CNamedPipe::CNamedPipe() :
    754.         m_pBuffer(nullptr),
    755.         m_hNamedPipe(INVALID_HANDLE_VALUE),
    756.         m_hReadEvent(NULL),
    757.         m_hWriteEvent(NULL),
    758.         m_bConnected(false),
    759.         m_bInit(false)
    760.     {
    761.         //初始化读写缓冲与事件句柄
    762.         Initialize();
    763.     }
    764.  
    765.     CNamedPipe::~CNamedPipe()
    766.     {
    767.         //释放读写缓冲与事件句柄
    768.         Uninitialize();
    769.     }
    770.  
    771.     bool CNamedPipe::Create(LPCTSTR lpName)
    772.     {
    773.         TCHAR szPipeName[MAX_PATH];
    774.         SECURITY_ATTRIBUTES sa = { 0 };
    775.         SECURITY_DESCRIPTOR sd = { 0 };
    776.         bool isSuccess = false;
    777.  
    778.         sa.nLength = sizeof(sa);
    779.         sa.bInheritHandle = FALSE;
    780.         sa.lpSecurityDescriptor = &sd;
    781.  
    782.         if (INVALID_HANDLE_VALUE != m_hNamedPipe)
    783.         {
    784.             return true;
    785.         }
    786.  
    787.         //设置权限, 防止低权限进程不能打开高权限进程创建的管道
    788.         (void)::InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);
    789.         (void)::SetSecurityDescriptorDacl(&sd, TRUE, NULL, FALSE);
    790.         (void)::StringCchPrintf(szPipeName, _countof(szPipeName), TEXT("%s%s"), PIPE_NAME_PREFIX, lpName);
    791.  
    792.         do
    793.         {
    794.             m_hNamedPipe = ::CreateNamedPipe(
    795.                 szPipeName,
    796.                 PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
    797.                 PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
    798.                 PIPE_MAX_CONNECT,
    799.                 PIPE_BUF_MAX_SIZE,
    800.                 PIPE_BUF_MAX_SIZE,
    801.                 PIPE_MAX_TIMEOUT,
    802.                 &sa
    803.             );
    804.  
    805.             if (INVALID_HANDLE_VALUE == m_hNamedPipe)
    806.             {
    807.                 break;
    808.             }
    809.  
    810.             isSuccess = true;
    811.  
    812.         } while (false);
    813.  
    814.         if (!isSuccess)
    815.         {
    816.             this->Close();
    817.         }
    818.  
    819.         return isSuccess;
    820.     }
    821.  
    822.     bool CNamedPipe::Open(LPCTSTR lpName, DWORD nTimeOut/* = INFINITE*/)
    823.     {
    824.         TCHAR szPipeName[MAX_PATH] = { 0 };
    825.         bool isSuccess = false;
    826.  
    827.         (void)::StringCchPrintf(szPipeName, _countof(szPipeName), TEXT("%s%s"), PIPE_NAME_PREFIX, lpName);
    828.  
    829.         if (INVALID_HANDLE_VALUE != m_hNamedPipe)
    830.         {
    831.             return true;
    832.         }
    833.  
    834.         ULONGLONG ullCurTick = ::GetTickCount64();
    835.  
    836.         do
    837.         {
    838.             m_hNamedPipe = ::CreateFile(
    839.                 szPipeName,
    840.                 GENERIC_READ | GENERIC_WRITE,
    841.                 0,
    842.                 NULL,
    843.                 OPEN_EXISTING,
    844.                 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
    845.                 NULL
    846.             );
    847.  
    848.             //管道句柄有效则终止循环
    849.             if (INVALID_HANDLE_VALUE != m_hNamedPipe)
    850.             {
    851.                 isSuccess = true;
    852.                 break;
    853.             }
    854.  
    855.             //若错误原因不是因为所有管道范例都在使用中, 则退出循环
    856.             if (ERROR_PIPE_BUSY != ::GetLastError())
    857.             {
    858.                 break;
    859.             }
    860.  
    861.             //等待命名管道的实例可用于连接
    862.             if (::WaitNamedPipe(szPipeName, 1000))
    863.             {
    864.                 continue;
    865.             }
    866.  
    867.             //无限等待则不需要检查超时
    868.             if (INFINITE == nTimeOut)
    869.             {
    870.                 continue;
    871.             }
    872.  
    873.             //执行操作超时则退出循环
    874.             if (::GetTickCount64() - ullCurTick > nTimeOut)
    875.             {
    876.                 break;
    877.             }
    878.  
    879.         } while (INVALID_HANDLE_VALUE == m_hNamedPipe);
    880.  
    881.         if (!isSuccess)
    882.         {
    883.             this->Close();
    884.         }
    885.  
    886.         return isSuccess;
    887.     }
    888.  
    889.     bool CNamedPipe::WaitConnect(DWORD nTimeOut)
    890.     {
    891.         OVERLAPPED Overlapped = { 0 };
    892.         bool isConnected = false;
    893.  
    894.         if (INVALID_HANDLE_VALUE == m_hNamedPipe)
    895.         {
    896.             return false;
    897.         }
    898.  
    899.         Overlapped.hEvent = m_hConnectEvent;
    900.         isConnected = ::ConnectNamedPipe(m_hNamedPipe, &Overlapped);
    901.         if (!isConnected)
    902.         {
    903.             DWORD dwError = ::GetLastError();
    904.  
    905.             //管道关闭中
    906.             if (ERROR_NO_DATA == dwError)
    907.             {
    908.                 isConnected = false;
    909.             }
    910.             else if (ERROR_IO_PENDING == dwError)//操作处于挂起状态
    911.             {
    912.                 if (WAIT_OBJECT_0 == ::WaitForSingleObject(Overlapped.hEvent, nTimeOut))
    913.                 {
    914.                     isConnected = true;
    915.                 }
    916.             }
    917.             else if (ERROR_PIPE_CONNECTED == dwError)//管道已经连接
    918.             {
    919.                 isConnected = true;
    920.             }
    921.         }
    922.  
    923.         m_bConnected = isConnected;
    924.  
    925.         return isConnected;
    926.     }
    927.  
    928.     bool CNamedPipe::Disconnect()
    929.     {
    930.         if (INVALID_HANDLE_VALUE == m_hNamedPipe)
    931.         {
    932.             return false;
    933.         }
    934.  
    935.         //参数句柄必须由 CreateNamedPipe 函数创建
    936.         return ::DisconnectNamedPipe(m_hNamedPipe);
    937.     }
    938.  
    939.     void CNamedPipe::Close()
    940.     {
    941.         if (INVALID_HANDLE_VALUE != m_hNamedPipe)
    942.         {
    943.             if (m_bConnected)
    944.             {
    945.                 ::FlushFileBuffers(m_hNamedPipe);
    946.                 ::DisconnectNamedPipe(m_hNamedPipe);
    947.                 m_bConnected = false;
    948.             }
    949.             ::CloseHandle(m_hNamedPipe);
    950.             m_hNamedPipe = INVALID_HANDLE_VALUE;
    951.         }
    952.  
    953.         if (m_hReadEvent)
    954.         {
    955.             ::SetEvent(m_hReadEvent);
    956.             ::CloseHandle(m_hReadEvent);
    957.             m_hReadEvent = NULL;
    958.         }
    959.  
    960.         if (m_hWriteEvent)
    961.         {
    962.             ::SetEvent(m_hWriteEvent);
    963.             ::CloseHandle(m_hWriteEvent);
    964.             m_hWriteEvent = NULL;
    965.         }
    966.  
    967.         if (m_hConnectEvent)
    968.         {
    969.             ::SetEvent(m_hConnectEvent);
    970.             ::CloseHandle(m_hConnectEvent);
    971.             m_hConnectEvent = NULL;
    972.         }
    973.     }
    974.  
    975.     bool CNamedPipe::IsValid()
    976.     {
    977.         return INVALID_HANDLE_VALUE != m_hNamedPipe;
    978.     }
    979.  
    980.     bool CNamedPipe::Read(LPVOID lpData, DWORD nSize, LPDWORD lpBytesRead/* = nullptr*/, DWORD nTimeOut)
    981.     {
    982.         OVERLAPPED Overlapped = { 0 };
    983.         Overlapped.hEvent = m_hReadEvent;
    984.         DWORD dwBytesTransferred = 0;
    985.         bool isSuccess = false;
    986.  
    987.         if (nullptr == m_pBuffer ||
    988.             nullptr == lpData ||
    989.             0 == nSize ||
    990.             nSize > PIPE_BUF_MAX_SIZE
    991.             )
    992.         {
    993.             return false;
    994.         }
    995.  
    996.         PPIPE_DATA pData = reinterpret_cast(m_pBuffer);
    997.         if (!::ReadFile(m_hNamedPipe, &pData->dwSize, sizeof(PIPE_DATA), NULL, &Overlapped))
    998.         {
    999.             //管道已结束
    1000.             if (ERROR_BROKEN_PIPE == ::GetLastError())
    1001.             {
    1002.                 return false;
    1003.             }
    1004.  
    1005.             if (ERROR_IO_PENDING != ::GetLastError())
    1006.             {
    1007.                 return false;
    1008.             }
    1009.  
    1010.             if (WAIT_OBJECT_0 != ::WaitForSingleObject(Overlapped.hEvent, nTimeOut))
    1011.             {
    1012.                 return false;
    1013.             }
    1014.         }
    1015.  
    1016.         if (pData->dwSize > PIPE_BUF_MAX_SIZE)
    1017.         {
    1018.             return false;
    1019.         }
    1020.  
    1021.         if (!::ReadFile(m_hNamedPipe, pData->data, pData->dwSize, NULL, &Overlapped))
    1022.         {
    1023.             if (ERROR_IO_PENDING != ::GetLastError())
    1024.             {
    1025.                 return false;
    1026.             }
    1027.  
    1028.             if (WAIT_OBJECT_0 != ::WaitForSingleObject(Overlapped.hEvent, nTimeOut))
    1029.             {
    1030.                 return false;
    1031.             }
    1032.         }
    1033.  
    1034.         if (::GetOverlappedResult(m_hNamedPipe, &Overlapped, &dwBytesTransferred, true))
    1035.         {
    1036.             isSuccess = true;
    1037.             if (lpBytesRead)
    1038.             {
    1039.                 *lpBytesRead = dwBytesTransferred;
    1040.             }
    1041.         }
    1042.  
    1043.         if (isSuccess)
    1044.         {
    1045.             if (nSize < pData->dwSize)
    1046.             {
    1047.                 ::memcpy_s(lpData, nSize, pData->data, nSize);
    1048.             }
    1049.             else
    1050.             {
    1051.                 ::memcpy_s(lpData, nSize, pData->data, pData->dwSize);
    1052.             }
    1053.         }
    1054.  
    1055.         return isSuccess;
    1056.     }
    1057.  
    1058.     bool CNamedPipe::Write(LPCVOID lpData, DWORD nSize, LPDWORD lpBytesWritten/* = nullptr*/, DWORD nTimeOut)
    1059.     {
    1060.         OVERLAPPED Overlapped = { 0 };
    1061.         Overlapped.hEvent = m_hWriteEvent;
    1062.         DWORD dwBytesTransferred = 0;
    1063.         bool isSuccess = false;
    1064.  
    1065.         if (nullptr == m_pBuffer ||
    1066.             nullptr == lpData ||
    1067.             0 == nSize ||
    1068.             nSize > PIPE_BUF_MAX_SIZE
    1069.             )
    1070.         {
    1071.             return false;
    1072.         }
    1073.  
    1074.         PPIPE_DATA pData = reinterpret_cast(m_pBuffer);
    1075.         DWORD dwBytesToWrite = nSize + sizeof(PIPE_DATA);
    1076.         pData->dwSize = nSize;
    1077.         ::memcpy_s(pData->data, PIPE_BUF_MAX_SIZE, lpData, nSize);
    1078.  
    1079.         if (::WriteFile(m_hNamedPipe, pData, dwBytesToWrite, NULL, &Overlapped))
    1080.         {
    1081.             return true;
    1082.         }
    1083.  
    1084.         //管道正在被关闭
    1085.         if (ERROR_NO_DATA == ::GetLastError())
    1086.         {
    1087.             return false;
    1088.         }
    1089.  
    1090.         //管道已结束
    1091.         if (ERROR_BROKEN_PIPE == ::GetLastError())
    1092.         {
    1093.             return false;
    1094.         }
    1095.  
    1096.         //重叠
    1097.         if (ERROR_IO_PENDING != ::GetLastError())
    1098.         {
    1099.             return false;
    1100.         }
    1101.  
    1102.         if (WAIT_OBJECT_0 != ::WaitForSingleObject(Overlapped.hEvent, nTimeOut))
    1103.         {
    1104.             return false;
    1105.         }
    1106.  
    1107.         if (::GetOverlappedResult(m_hNamedPipe, &Overlapped, &dwBytesTransferred, true))
    1108.         {
    1109.             isSuccess = true;
    1110.             if (lpBytesWritten)
    1111.             {
    1112.                 *lpBytesWritten = dwBytesTransferred;
    1113.             }
    1114.         }
    1115.  
    1116.         return isSuccess;
    1117.     }
    1118.  
    1119.     bool CNamedPipe::Initialize()
    1120.     {
    1121.         bool isSuccess = false;
    1122.  
    1123.         if (m_bInit)
    1124.         {
    1125.             return true;
    1126.         }
    1127.  
    1128.         do
    1129.         {
    1130.             if (nullptr == m_pBuffer)
    1131.             {
    1132.                 m_pBuffer = ::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, PIPE_BUF_MAX_SIZE + sizeof(PIPE_DATA));
    1133.             }
    1134.  
    1135.             if (NULL == m_hReadEvent)
    1136.             {
    1137.                 m_hReadEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);
    1138.             }
    1139.  
    1140.             if (NULL == m_hWriteEvent)
    1141.             {
    1142.                 m_hWriteEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);
    1143.             }
    1144.  
    1145.             if (NULL == m_hConnectEvent)
    1146.             {
    1147.                 m_hConnectEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);
    1148.             }
    1149.  
    1150.             //任意事件创建失败则终止
    1151.             if ((NULL == m_hReadEvent) || (NULL == m_hWriteEvent) || (NULL == m_hConnectEvent) )
    1152.             {
    1153.                 break;
    1154.             }
    1155.  
    1156.             isSuccess = true;
    1157.  
    1158.         } while (false);
    1159.  
    1160.         if (!isSuccess)
    1161.         {
    1162.             Uninitialize();
    1163.         }
    1164.  
    1165.         m_bInit = isSuccess;
    1166.  
    1167.         return m_bInit;
    1168.     }
    1169.  
    1170.     void CNamedPipe::Uninitialize()
    1171.     {
    1172.         if (!m_bInit)
    1173.         {
    1174.             return;
    1175.         }
    1176.  
    1177.         //关闭管道
    1178.         this->Close();
    1179.  
    1180.         //释放读写缓冲
    1181.         if (nullptr != m_pBuffer)
    1182.         {
    1183.             ::HeapFree(::GetProcessHeap(), 0, m_pBuffer);
    1184.             m_pBuffer = nullptr;
    1185.         }
    1186.  
    1187.         m_bInit = false;
    1188.     }
    1189.  
    1190.     std::map<int64_t, _tstring> CLogHelper::_GetLogFileList(const _tstring& strDir)
    1191.     {
    1192.         std::map<int64_t, _tstring> fileList;
    1193.  
    1194.         WIN32_FIND_DATA findData = { 0 };
    1195.         HANDLE hFindHandle = INVALID_HANDLE_VALUE;
    1196.         hFindHandle = FindFirstFile((strDir + _T("\\*.*")).c_str(), &findData);
    1197.         if (INVALID_HANDLE_VALUE == hFindHandle)
    1198.         {
    1199.             return fileList;
    1200.         }
    1201.  
    1202.         do
    1203.         {
    1204.             _tstring strName = findData.cFileName;
    1205.  
    1206.             //非目录
    1207.             if (!(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
    1208.             {
    1209.                 //检查输入规则
    1210.                 int nConverted = 0;
    1211.                 SYSTEMTIME st = { 0 };
    1212.  
    1213.                 _tstring strPath = strDir + _T("\\") + strName;
    1214.                 _tstring strPrefix = Format(_T("%s_%%4hd-%%2hd-%%2hd_%%2hd-%%2hd-%%2hd-%%3hd.log"), m_strSaveName.c_str());
    1215.                 nConverted = _stscanf_s(findData.cFileName, strPrefix.c_str(),
    1216.                     &st.wYear, &st.wMonth, &st.wDay, &st.wHour,
    1217.                     &st.wMinute, &st.wSecond, &st.wMilliseconds);
    1218.  
    1219.                 //检查文件名规则是否符合要求
    1220.                 if (7 == nConverted)
    1221.                 {
    1222.                     FILETIME ftFile = { 0 };
    1223.                     FILETIME ftLocal = { 0 };
    1224.                     int64_t timestamp = 0;
    1225.  
    1226.                     ::SystemTimeToFileTime(&st, &ftLocal);
    1227.                     ::LocalFileTimeToFileTime(&ftLocal, &ftFile);
    1228.  
    1229.                     timestamp = ((int64_t)ftFile.dwHighDateTime << 32) | ftFile.dwLowDateTime;
    1230.                     timestamp = (timestamp - 116444736000000000) / 10000;
    1231.  
    1232.                     fileList.insert(std::make_pair(timestamp, strPath));
    1233.                 }
    1234.             }
    1235.  
    1236.             //上一级目录与当前目录跳过
    1237.             if (0 == _tcscmp(findData.cFileName, _T(".")) || 0 == _tcscmp(findData.cFileName, _T("..")))
    1238.             {
    1239.                 continue;
    1240.             }
    1241.  
    1242.         } while (::FindNextFile(hFindHandle, &findData));
    1243.  
    1244.         ::FindClose(hFindHandle);
    1245.  
    1246.         return fileList;
    1247.     }
    1248.  
    1249.     _tstring CLogUtils::Format(LPCTSTR pstrFormat, ...)
    1250.     {
    1251.         _tstring strResult;
    1252.         LPTSTR lpBuf = nullptr;
    1253.         DWORD dwCchCount = MAX_PATH;
    1254.  
    1255.         if (nullptr == pstrFormat)
    1256.         {
    1257.             return strResult;
    1258.         }
    1259.  
    1260.         va_list args;
    1261.         va_start(args, pstrFormat);
    1262.         do
    1263.         {
    1264.             //分配缓冲
    1265.             lpBuf = (LPTSTR)::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, dwCchCount * sizeof(TCHAR));
    1266.             if (nullptr == lpBuf)
    1267.             {
    1268.                 break;
    1269.             }
    1270.  
    1271.             //成功则赋值字符串并终止循环
    1272.             if (-1 != _vsntprintf_s(lpBuf, dwCchCount, _TRUNCATE, pstrFormat, args))
    1273.             {
    1274.                 strResult = lpBuf;
    1275.                 break;
    1276.             }
    1277.  
    1278.             //释放缓冲, 待下次重新分配
    1279.             ::HeapFree(::GetProcessHeap(), 0, lpBuf);
    1280.             lpBuf = nullptr;
    1281.  
    1282.             //缓冲字符数在合理范围内则扩大2倍
    1283.             if (dwCchCount < INT32_MAX)
    1284.             {
    1285.                 dwCchCount *= 2;
    1286.             }
    1287.             else
    1288.             {
    1289.                 //超限终止处理
    1290.                 break;
    1291.             }
    1292.  
    1293.         } while (true);
    1294.         va_end(args);
    1295.  
    1296.         //释放缓冲
    1297.         if (nullptr != lpBuf)
    1298.         {
    1299.             ::HeapFree(::GetProcessHeap(), 0, lpBuf);
    1300.             lpBuf = nullptr;
    1301.         }
    1302.  
    1303.         return strResult;
    1304.     }
    1305.  
    1306.     _tstring CLogUtils::GetCurrentTimeString()
    1307.     {
    1308.         TCHAR szBuf[MAX_PATH] = { 0 };
    1309.         SYSTEMTIME st = { 0 };
    1310.         (void)::GetLocalTime(&st);
    1311.  
    1312.         ::StringCchPrintf(
    1313.             szBuf,
    1314.             _countof(szBuf),
    1315.             _T("%04d-%02d-%02d %02d:%02d:%02d.%03d"),
    1316.             st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond, st.wMilliseconds
    1317.         );
    1318.  
    1319.         return szBuf;
    1320.     }
    1321.  
    1322.     int64_t CLogUtils::GetCurrentTimestamp()
    1323.     {
    1324.         int64_t timeStamp = 0;
    1325.         (void)::GetSystemTimeAsFileTime((FILETIME*)&timeStamp);
    1326.         return (timeStamp - 116444736000000000) / 10000;
    1327.     }
    1328.  
    1329.     _tstring CLogUtils::TimestampToString(int64_t timestamp, const _tstring& strFormat)
    1330.     {
    1331.         TCHAR szBuf[MAX_PATH] = { 0 };
    1332.         SYSTEMTIME st = { 0 };
    1333.         FILETIME ftFile = { 0 };
    1334.         FILETIME ftLocal = { 0 };
    1335.  
    1336.         timestamp = timestamp * 10000 + 116444736000000000;
    1337.         ftFile.dwLowDateTime = timestamp & 0xFFFFFFFF;
    1338.         ftFile.dwHighDateTime = timestamp >> 32;
    1339.  
    1340.         ::FileTimeToLocalFileTime(&ftFile, &ftLocal);
    1341.         ::FileTimeToSystemTime(&ftLocal, &st);
    1342.  
    1343.         ::StringCchPrintf(
    1344.             szBuf,
    1345.             _countof(szBuf),
    1346.             strFormat.c_str(),
    1347.             st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond, st.wMilliseconds
    1348.         );
    1349.  
    1350.         return szBuf;
    1351.     }
    1352.  
    1353.     _tstring CLogUtils::GetCurrentModulePath()
    1354.     {
    1355.         TCHAR szCurPath[MAX_PATH] = { 0 };
    1356.         ::GetModuleFileName(NULL, szCurPath, _countof(szCurPath));
    1357.  
    1358.         _tstring strResult = szCurPath;
    1359.         return strResult;
    1360.     }
    1361.  
    1362.     _tstring CLogUtils::GetCurrentModuleDir()
    1363.     {
    1364.         return GetFileDir(GetCurrentModulePath());
    1365.     }
    1366.  
    1367.     _tstring CLogUtils::GetCurrentModuleName(bool bHasExt/* = true*/)
    1368.     {
    1369.         return GetFileName(GetCurrentModulePath(), bHasExt);
    1370.     }
    1371.  
    1372.     _tstring CLogUtils::GetFileDir(const _tstring& strPath)
    1373.     {
    1374.         _tstring strResult;
    1375.         size_t nIndex = strPath.find_last_of(_T('\\'));
    1376.         if (nIndex != _tstring::npos)
    1377.         {
    1378.             strResult = strPath.substr(0, nIndex);
    1379.         }
    1380.  
    1381.         return strResult;
    1382.     }
    1383.  
    1384.     _tstring CLogUtils::GetFileName(const _tstring& strPath, bool bHasExt/* = true*/)
    1385.     {
    1386.         _tstring strResult = strPath;
    1387.         size_t nIndex = strResult.find_last_of(_T('\\'));
    1388.         if (nIndex != _tstring::npos)
    1389.         {
    1390.             strResult = strResult.substr(nIndex + 1);
    1391.         }
    1392.  
    1393.         if (!bHasExt)
    1394.         {
    1395.             nIndex = strResult.find_last_of(_T('.'));
    1396.             if (nIndex != _tstring::npos)
    1397.             {
    1398.                 return strResult.substr(0, nIndex);
    1399.             }
    1400.         }
    1401.  
    1402.         return strResult;
    1403.     }
    1404.  
    1405.     bool CLogUtils::IsDirectory(const _tstring& strPath)
    1406.     {
    1407.         WIN32_FILE_ATTRIBUTE_DATA attr = { 0 };
    1408.         if (!::GetFileAttributesEx(strPath.c_str(), GetFileExInfoStandard, &attr))
    1409.         {
    1410.             return false;
    1411.         }
    1412.  
    1413.         return attr.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
    1414.     }
    1415.  
    1416.     bool CLogUtils::CreateDir(const _tstring& strPath)
    1417.     {
    1418.         _tstring strDriver;              //驱动器号, 如 D:
    1419.         _tstring strSubPath = strPath;   //路径, 如 Test\1\2\3
    1420.  
    1421.         if (strPath.empty())
    1422.         {
    1423.             return false;
    1424.         }
    1425.  
    1426.         //获取盘符
    1427.         do
    1428.         {
    1429.             size_t nFindIndex = strPath.find_first_of(':');  //检查是否有驱动器号
    1430.             if (nFindIndex == _tstring::npos)
    1431.             {
    1432.                 break;
    1433.             }
    1434.  
    1435.             strDriver = strPath.substr(0, nFindIndex + 1); //得到驱动器号, 如 D:
    1436.             nFindIndex = strPath.find(_T("\\"), nFindIndex);
    1437.             if (nFindIndex == _tstring::npos)
    1438.             {
    1439.                 break;
    1440.             }
    1441.  
    1442.             strSubPath = strPath.substr(nFindIndex + 1); //得到路径, 如 Test\1\2\3
    1443.         } while (false);
    1444.  
    1445.         _tstring strDestDir;
    1446.         size_t nFindBegin = 0;
    1447.         size_t nFindIndex = 0;
    1448.         do
    1449.         {
    1450.             nFindIndex = strSubPath.find(_T("\\"), nFindBegin);
    1451.             if (nFindIndex != _tstring::npos)
    1452.             {
    1453.                 strDestDir = strSubPath.substr(0, nFindIndex);
    1454.                 nFindBegin = nFindIndex + 1;
    1455.             }
    1456.             else
    1457.             {
    1458.                 strDestDir = strSubPath;
    1459.             }
    1460.  
    1461.             if (!strDriver.empty())
    1462.             {
    1463.                 strDestDir = strDriver + _T("\\") + strDestDir;
    1464.             }
    1465.  
    1466.             if (!::CreateDirectory(strDestDir.c_str(), NULL) && ERROR_ALREADY_EXISTS != ::GetLastError())
    1467.             {
    1468.                 return false;
    1469.             }
    1470.  
    1471.         } while (nFindIndex != _tstring::npos);
    1472.  
    1473.         return true;
    1474.     }
    1475.  
    1476.     bool CLogUtils::DeleteArchive(const _tstring& strPath)
    1477.     {
    1478.         if (strPath.empty())
    1479.         {
    1480.             return false;
    1481.         }
    1482.  
    1483.         return ::DeleteFile(strPath.c_str());
    1484.     }
    1485.  
    1486.     unsigned long long CLogUtils::GetFileSize(const _tstring& strPath)
    1487.     {
    1488.         unsigned long long ullSize = 0;
    1489.         WIN32_FILE_ATTRIBUTE_DATA attr = { 0 };
    1490.         if (!::GetFileAttributesEx(strPath.c_str(), GetFileExInfoStandard, &attr))
    1491.         {
    1492.             return 0;
    1493.         }
    1494.  
    1495.         ullSize = (unsigned long long)attr.nFileSizeHigh << 32 | attr.nFileSizeLow;
    1496.  
    1497.         return ullSize;
    1498.     }
    1499.  
    1500.     CLogHelper& GetInstance()
    1501.     {
    1502.         return g_Instance;
    1503.     }
    1504. }

    使用

    main.cpp

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include "CLogUtils.h"
    6.  
    7. void PrintHelp();
    8. void PrintHelp_en_us();
    9. void PrintHelp_zh_cn();
    10. void CLogUtilsTest(int nTestCount, _tstring strPipe, _tstring strDir, _tstring strName, int nFileCount, int nFileSize, int nBufCount, int nTimeOut);
    11.  
    12. int _tmain(int argc, LPCTSTR argv[])
    13. {
    14.     ::setlocale(LC_ALL, "");
    15.  
    16.     _tstring strLogDir;
    17.     _tstring strLogName;
    18.     _tstring strPipeName;
    19.     DWORD nTestCount = 100000;
    20.     DWORD nFileSize = 1024 * 1024 * 4;
    21.     DWORD nTempCount = 1000;
    22.     DWORD nTimeout = 5000;
    23.     DWORD nFileCount = 16;
    24.     bool bSrv = true;
    25.  
    26.     if (argc <= 1)
    27.     {
    28.         PrintHelp();
    29.         //return -1;
    30.     }
    31.  
    32.     for (int i = 1; i < argc; i++)
    33.     {
    34.         _tstring strSwitchValue = argv[i];
    35.  
    36.         if (!(_T('-') == strSwitchValue[0] || _T('/') == strSwitchValue[0]))
    37.         {
    38.             continue;
    39.         }
    40.  
    41.         _tstring strHelp = strSwitchValue.substr(1);
    42.         if (strHelp == _T("help") || strHelp == _T("?"))
    43.         {
    44.             PrintHelp();
    45.             return 0;
    46.         }
    47.  
    48.         size_t nEqual = strSwitchValue.find(_T('='));
    49.         if (_tstring::npos == nEqual)
    50.         {
    51.             continue;
    52.         }
    53.  
    54.         _tstring strName = strSwitchValue.substr(1, nEqual - 1);
    55.         _tstring strValue = strSwitchValue.substr(nEqual + 1);
    56.  
    57.         std::transform(strName.begin(), strName.end(), strName.begin(), [](TCHAR ch)->TCHAR {
    58.             if (ch >= _T('A') && ch <= _T('Z')) ch &= ~0x20;
    59.             return ch;
    60.             });
    61.  
    62.         if (strName == _T("d"))
    63.         {
    64.             strLogDir = strValue;
    65.             continue;
    66.         }
    67.  
    68.         if (strName == _T("n"))
    69.         {
    70.             strLogName = strValue;
    71.             continue;
    72.         }
    73.  
    74.         if (strName == _T("a"))
    75.         {
    76.             _stscanf_s(strValue.c_str(), _T("%d"), &nTestCount);
    77.             continue;
    78.         }
    79.  
    80.         if (strName == _T("p"))
    81.         {
    82.             strPipeName = strValue;
    83.             continue;
    84.         }
    85.  
    86.         if (strName == _T("f"))
    87.         {
    88.             _stscanf_s(strValue.c_str(), _T("%d"), &nFileCount);
    89.             continue;
    90.         }
    91.  
    92.         if (strName == _T("s"))
    93.         {
    94.             _stscanf_s(strValue.c_str(), _T("%d"), &nFileSize);
    95.             continue;
    96.         }
    97.  
    98.         if (strName == _T("c"))
    99.         {
    100.             _stscanf_s(strValue.c_str(), _T("%d"), &nTempCount);
    101.             continue;
    102.         }
    103.  
    104.         if (strName == _T("t"))
    105.         {
    106.             _stscanf_s(strValue.c_str(), _T("%d"), &nTimeout);
    107.             continue;
    108.         }
    109.  
    110.         if (strName == _T("srv"))
    111.         {
    112.             bSrv = _tcstoul(strValue.c_str(), nullptr, 10) != 0;
    113.             continue;
    114.         }
    115.     }
    116.  
    117.     if (bSrv)
    118.     {
    119.         CLogUtils::GetInstance().Initialize(true, _T("1"), _T(""), _T("Srv"), nFileSize, nFileCount, nTempCount, nTimeout * 1000);
    120.         system("pause");
    121.     }
    122.     else
    123.     {
    124.         while (true)
    125.         {
    126.             CLogUtilsTest(nTestCount, strPipeName, strLogDir, strLogName, nFileSize, nFileCount, nTempCount, nTimeout * 1000);
    127.             system("pause");
    128.         }
    129.     }
    130.  
    131.     return 0;
    132. }
    133.  
    134. void CLogUtilsTest(int nTestCount, _tstring strPipe, _tstring strDir, _tstring strName, int nFileSize, int nFileCount, int nBufCount, int nTimeOut)
    135. {
    136.     uint64_t uBegin = 0;
    137.     uint64_t uEnd = 0;
    138.     uint64_t uCost = 0;
    139.     double lfSpeed = 0.0f;
    140.  
    141.     if (!strPipe.empty())
    142.     {
    143.         CLogUtils::GetInstance().Initialize(true, strPipe, strDir, strName, nFileSize, nFileCount, nBufCount, nTimeOut);
    144.         uBegin = CLogUtils::GetCurrentTimestamp();
    145.  
    146.         for (int i = 0; i < nTestCount; i++)
    147.         {
    148.             CLogUtils::GetInstance().Info(_T("%d %s"), 1024, _T("FlameCyclone"));
    149.         }
    150.         CLogUtils::GetInstance().FlushBuffers();
    151.  
    152.         uEnd = CLogUtils::GetCurrentTimestamp();
    153.         uCost = uEnd - uBegin;
    154.         lfSpeed = (double)nTestCount * 1000 / (uCost);
    155.  
    156.         _tprintf(
    157.             _T("Repeat %d tims, cost time: %lld, speed: %lf/S\r\n"),
    158.             nTestCount,
    159.             uCost,
    160.             lfSpeed
    161.         );
    162.     }
    163.     else
    164.     {
    165.         CLogUtils::GetInstance().Initialize(false, strPipe, strDir, strName, nFileSize, nFileCount, nBufCount, nTimeOut);
    166.         uBegin = CLogUtils::GetCurrentTimestamp();
    167.  
    168.         for (int i = 0; i < nTestCount; i++)
    169.         {
    170.             CLogUtils::GetInstance().Info(_T("%d %s"), 1024, _T("FlameCyclone"));
    171.         }
    172.         CLogUtils::GetInstance().FlushBuffers();
    173.  
    174.         uEnd = CLogUtils::GetCurrentTimestamp();
    175.         uCost = uEnd - uBegin;
    176.         lfSpeed = (double)nTestCount * 1000 / (uCost);
    177.  
    178.         _tprintf(
    179.             _T("Repeat %d tims, cost time: %lld, speed: %lf/S\r\n"),
    180.             nTestCount,
    181.             uCost,
    182.             lfSpeed
    183.         );
    184.     }
    185. }
    186.  
    187. void PrintHelp()
    188. {
    189.     LANGID langID = ::GetThreadUILanguage();
    190.  
    191.     if (LANG_CHINESE == PRIMARYLANGID(langID))
    192.     {
    193.         PrintHelp_zh_cn();
    194.     }
    195.     else
    196.     {
    197.         PrintHelp_en_us();
    198.     }
    199. }
    200.  
    201. void PrintHelp_en_us()
    202. {
    203.     std::wcout << _T("How to use:") << std::endl;
    204.     std::wcout << _T("CLogUtils -options=value") << std::endl;
    205.     std::wcout << std::endl;
    206.  
    207.     std::wcout << _T("-p=[number]:        Enable pipe mode and specify the pipe name.") << std::endl;
    208.     std::wcout << _T("-a=[number]:        Number of test output logs.") << std::endl;
    209.     std::wcout << _T("-d=[string]:        The log file output directory.") << std::endl;
    210.     std::wcout << _T("-n=[string]:        The log file name prefix.") << std::endl;
    211.     std::wcout << _T("-f=[number]:        Number of log files.") << std::endl;
    212.     std::wcout << _T("-s=[number]:        Single log file size(bytes).") << std::endl;
    213.     std::wcout << _T("-c=[number]:        Number of log caches.") << std::endl;
    214.     std::wcout << _T("-t=[number]:        Automatically save logs to a file timeout value(seconds).") << std::endl;
    215.     std::wcout << _T("-?/-help:           Help for CLogSrv.") << std::endl;
    216. }
    217.  
    218. void PrintHelp_zh_cn()
    219. {
    220.     std::wcout << _T("使用方法:") << std::endl;
    221.     std::wcout << _T("CLogUtils.exe -选项=值") << std::endl;
    222.     std::wcout << std::endl;
    223.  
    224.     std::wcout << _T("-p=[字符串]:        启用管道模式并指定管道名.") << std::endl;
    225.     std::wcout << _T("-a=[整数]:          测试输出日志数量.") << std::endl;
    226.     std::wcout << _T("-d=[字符串]:        日志输出目录.") << std::endl;
    227.     std::wcout << _T("-n=[字符串]:        日志文件名前缀.") << std::endl;
    228.     std::wcout << _T("-f=[整数]:          日志文件数量.") << std::endl;
    229.     std::wcout << _T("-s=[整数]:          单个日志文件大小(字节).") << std::endl;
    230.     std::wcout << _T("-c=[整数]:          日志缓冲数量.") << std::endl;
    231.     std::wcout << _T("-t=[整数]:          自动保存超时间隔(秒).") << std::endl;
    232.     std::wcout << _T("-?/-help:           日志单元帮助.") << std::endl;
    233. }

  • 相关阅读:
    05 proxy_pass 携带有 uri 的场景下面的处理
    vue项目seo优化-预渲染prerender-spa-plugin配置
    优化算法 -AdGrad算法
    java-net-php-python-jsp网上飞机票订票管理系统计算机毕业设计程序
    儿童台灯怎么选对眼睛好？分享央视推荐的护眼灯
    Requests之不同类型的参数，发送请求接口！
    如何使用 Git 进行多人协作开发（全流程图解）
    Springboot+实验课程辅助管理系统 毕业设计-附源码191113
    vscode下ssh免密登录linux服务器
    黑马瑞吉外卖之员工账号的禁用和启用以及编辑修改
  • 原文地址：https://blog.csdn.net/Flame_Cyclone/article/details/133933740