[ C# ] Log파일 만들기

intro) 웹 풀스택 개발자로서의 길과 응용 프로그래머로써의 길을 둘다 걷게 됐어...😂

뜬끔없이 C# 카테고리가 생기더니 뜬끔없이 기초도 아닌 Log파일 만들기 포스팅 이다. ㅋㅋ

적으면서도 얼마나 신기하고 웃긴지...

포스팅을 하면서 공부와 이해를 동시에 하고 있는 것이므로 잘못된 정보는 댓글로 달아주면 너무너무 감사하겠다! 😊 ( + 저의 코드가 아닌 사수의 코드를 분석하면서 공부하는 것입니다! )

쨌든 이번에 공부할 내용은 Log파일을 텍스트 파일로 저장하는 방법이다. 아래와 같이..!

우선 log4net이라는 다양한 방법으로 로깅할 수 있는 라이브러리 친구를 사용해볼 것이다.

참조 : http://www.csharpstudy.com/Practical/Prac-log4net.aspx

01. 나는 우선 Log폴더에 LogSystem폴더를 Logs폴더에 Logger4net이라는 클래스를 만들어 주었다.

이제 각각의 클래스들을 살펴 보려고한다. 

02. 실행 할때 먼저 실행 되는 친구는 LogSystem 클래스이다.

코드가 길어서 중복정의 해서 쓰는 함수와 인스턴스는 지웠다.

namespace Log
{
    public class LogSystem
    {
        private const int FILE_SIZE = 10 * 1024; //KB : 10MB
        private Logger4net logger; // 로깅 라이브러리
 
        private LogSystem()
        {
            string logxml = @"LogSystem.xml";
            if (File.Exists(logxml)) 
            {
                // 파일이 이미 존재하면 해당 파일을 불러와 셋팅
                FileSetup(logxml);
            }
            else
            {
                // 파일이 없다면 만들어 줘야지 :)
                string strFilePath = UIUtil.GetCurrentPath() + "\\Logs"; // 로그 파일이 있을 경로
                Initialize(strFilePath, FILE_SIZE);
            }
        }
 
        
        internal void Initialize(string logpath, int nSize)
        {
            ProgramSetup(logpath, nSize);
            DebugLog(this, "LogSystem Init");
        }
        
 
        private void ProgramSetup(string filepath, int nSizeKB)
        {
            logger = Logger4net.AddNewLogger4net("LogSystem", filepath, true, nSizeKB);
        }
 
        private void FileSetup(string logxml)
        {
            XmlConfigurator.Configure(new System.IO.FileInfo(logxml));
        }
 
        public void InfoLog(object obj, string msg)
        {
            if (logger.IsInfoEnabled) logger.Info(obj.GetType().Name + " : " + msg);
        }
 
        public void DebugLog(string title, string msg)
        {
            if (logger.IsDebugEnabled) logger.Debug(title + " : " + msg);
        }
    }
}

일단 나는 instance를 사용해서 로그를 남기는데 어찌됐든 먼저 실행 되는것은 생성자 일이다.

log4net 참초글을 보면 xml로 이루어진 설정 파일이 있는데 코드로도 만질 수 있다하니 우선은 생성자에서 이 설정 파일을 검사한다. 설정 파일이 있다면 이 설정 파일을 셋팅하는 함수를 실행 하고, 없다면 당연히 만들어 설정해줘야겠다!

파일이 없을 때의 코드를 한번 따라 가보려 한다.

ProgramSetUp 함수를 실행하면서 Logger4net 클래스를 사용하니 Logger4net친구를 한번 만나보자😏

02. Logger4net 클래스

파일이 없을 때 LogSystem > Initialize > ProgramSetUp > Logger4net의 AddNewLogger4net 함수 순으로 호출 되었다. 아래는 Logger4net 클래스이다.

간단히 정리만 하자면 파일 정보를 설정하고 ( 경로 크기 등등 ) 생성해주고 있다.

namespace crawlingTester.Logs
{
    class Logger4net
    {
        private static ConcurrentDictionary<string, Logger4net> ServicesNames = new ConcurrentDictionary<string, Logger4net>();
        private ILog _logger;
        private string _serviceName;
        private string _configFileName;
        private bool bUseFileSize;
        private int nFileSize;//MB
 
        public bool IsInfoEnabled
        {
            get
            {
                return _logger.IsInfoEnabled;
            }
        }
 
        public bool IsDebugEnabled
        {
            get
            {
                return _logger.IsDebugEnabled;
            }
        }
 
        public bool IsErrorEnabled
        {
            get
            {
                return _logger.IsErrorEnabled;
            }
        }
 
        private Logger4net(string ServiceName, string strFilePath, bool bUseFileSize = false, int nFileSize = 0)
        {
            this.bUseFileSize = bUseFileSize;
            this.nFileSize = nFileSize;
 
            ServiceName = ServiceName.Trim();
 
            _serviceName = ServiceName;
            _configFileName = string.Format("{0}\\", strFilePath);
 
            if (ServicesNames.ContainsKey(ServiceName))
            {
                Logger4net log;
                ServicesNames.TryGetValue(ServiceName, out log);
                _logger = log._logger;
                //throw new Exception(string.Format("Service {0} exists", ServiceName));
                return;
            }
            else
            {
                ServicesNames.TryAdd(ServiceName, this);
            }
        }
 
        private RollingFileAppender GetNewFileApenderDate()
        {
            log4net.Appender.RollingFileAppender appender = new log4net.Appender.RollingFileAppender();
 
            appender.Name = _serviceName;
            appender.File = _configFileName;
            appender.AppendToFile = true;
            appender.DatePattern = "yyyyMMdd\\\\'" + _serviceName + "_'yyyyMMdd'.log'";
            //appender.MaxSizeRollBackups = 10;
            //appender.MaximumFileSize = "10MB";
            appender.StaticLogFileName = false;
            appender.RollingStyle = RollingFileAppender.RollingMode.Date;
 
            var layout = new log4net.Layout.PatternLayout("%d %m%n");
            appender.Layout = layout;
 
            layout.ActivateOptions();
            appender.ActivateOptions();
            return appender;
        }
 
        //nSize = MB
        private RollingFileAppender GetNewFileApenderFileSize(int nSize)
        {
            log4net.Appender.RollingFileAppender appender = new log4net.Appender.RollingFileAppender();
 
            appender.Name = _serviceName;
            appender.File = _configFileName;
            appender.AppendToFile = true;
            appender.DatePattern = "yyyyMMdd\\\\'" + _serviceName + "_'yyyyMMdd'.log'";
            appender.MaxSizeRollBackups = -1;
            if (nSize <= 0)
                nSize = 1024;
            appender.MaximumFileSize = nSize.ToString() + "KB";
            appender.StaticLogFileName = false;
            appender.RollingStyle = RollingFileAppender.RollingMode.Composite;
 
            var layout = new log4net.Layout.PatternLayout("%d %m%n");
            appender.Layout = layout;
 
            layout.ActivateOptions();
            appender.ActivateOptions();
            return appender;
        }
 
        public static Logger4net AddNewLogger4net(string ServiceName, string strFilePath, bool bUseFileSize = false, int nFileSize = 0)
        {
            Logger4net result = new Logger4net(ServiceName, strFilePath, bUseFileSize, nFileSize); // 생성
 
            if (result._logger == null)
                result._logger = log4net.LogManager.GetLogger(ServiceName);
 
            Logger l = (Logger)result._logger.Logger;
 
            RollingFileAppender newappender = (RollingFileAppender)l.GetAppender(ServiceName);
            bool bInit = false;
            if (newappender == null)
            {
                bInit = false;
                if (bUseFileSize)
                    newappender = result.GetNewFileApenderFileSize(nFileSize);
                else
                    newappender = result.GetNewFileApenderDate();
 
                log4net.Config.BasicConfigurator.Configure(newappender);
            }
            else
            {
                bInit = true;
                newappender.MaximumFileSize = nFileSize.ToString() + "KB";
            }
 
            var layout = new log4net.Layout.PatternLayout("%d %m%n");
 
 
            if (bUseFileSize == false)
            {
                ConsoleAppender consoleAppender = new ConsoleAppender();
                consoleAppender.Layout = layout;
                consoleAppender.ActivateOptions();
 
                //l.AddAppender(trace);
                l.AddAppender(consoleAppender); // 파일 
            }
            if (bInit == false)
            {
                l.AddAppender(newappender);
            }
            l.Additivity = false;
            l.Repository.Configured = true;
 
            return result;
        }
 
        public void Info(string message)
        {
            _logger.Info("INFO," + message);
        }
 
        public void Debug(string message)
        {
            Trace.WriteLine("## DEBUG ## :" + message);
            _logger.Debug("DEBUG," + message);
        }
 
        public void Error(string message)
        {
            Trace.WriteLine("%% ERROR %% :" + message);
            _logger.Error("ERROR," + message);
        }
    }
}