Exemple #1
0
        /// <summary>
        /// Adds a customized logger handler (e.g. log to file) to a specific level.
        /// Note: You can have (n log handlers assuming your system has the resources)
        /// </summary>
        /// <param name="level"></param>
        /// <param name="handler"></param>
        public void addSpecialLogger(int level, LoggerEventHandler handler)
        {
            if (level < levels)
            {
                if (leh[level] != null)
                {
                    int size = leh[level].Length + 1;
                    LoggerEventHandler[] temp = new LoggerEventHandler[size];

                    for (int i = 0; i < leh[level].Length; i++)
                    {
                        temp[i] = leh[level][i];
                    }

                    temp[size - 1] = handler;

                    leh[level] = temp;
                }
                else
                {
                    leh[level]    = new LoggerEventHandler[1];
                    leh[level][0] = handler;
                }
            }
        }
Exemple #2
0
        /// <summary>
        /// Adds a customized log handler to each log level
        /// </summary>
        /// <param name="handler"></param>
        public void addSpecialLoggerToAllLevels(LoggerEventHandler handler)
        {
            if (handler == null)
            {
                return;
            }

            for (int level = 0; level < this.levels; level++)
            {
                addSpecialLogger(level, handler);
            }
        }
Exemple #3
0
        /// <summary>
        /// Effectively the constructor (so no code would have to be repeated).  Consequently
        /// if one were to try to put this block inside the constructor matching the signature and
        /// then referenced it with :this(levels, defaultHandler) in the other constructors MS
        /// has a bit of a fit.  Dunno...this works, don't really care.
        /// </summary>
        /// <param name="levels"></param>
        /// <param name="defaultHandler"></param>
        private void init(uint levels, LoggerEventHandler defaultHandler)
        {
            this.levels         = levels;
            this.defaultHandler = defaultHandler;
            this.max            = levels - 1;

            leh = new LoggerEventHandler[levels][];

            LoggerEventHandler[] handler = new LoggerEventHandler[1];

            handler[0] = defaultHandler;

            for (int i = 0; i < levels; i++)
            {
                leh[i] = handler;
            }
        }
Exemple #4
0
 /// <summary>
 /// With this constructor the developer is responsible for defining what
 /// they want the logger to do (in the defaultHandler).
 /// </summary>
 /// <param name="levels"></param>
 /// <param name="defaultHandler"></param>
 public VSLogger(uint levels, LoggerEventHandler defaultHandler)
 {
     init(levels, defaultHandler);
 }