GetWildcartPatternFor() public static method

public static GetWildcartPatternFor ( string baseFileName ) : string
baseFileName string
return string
コード例 #1
0
        protected virtual string[] GetFilesForLogger(Logger logger)
        {
            string logFileName = GetLogFilePathFromLogger(logger);

            if (string.IsNullOrEmpty(logFileName))
            {
                return(Enumerable.Empty <string>().ToArray());
            }

            var directory = new DirectoryInfo(logFileName.GetDirectoryName());

            if (!directory.Exists)
            {
                return(Enumerable.Empty <string>().ToArray());
            }

            return(new[] { logFileName }
                   .Concat(directory
                           .GetFiles(ActivityLogFile.GetWildcartPatternFor(logFileName))
                           .Select(x => x.FullName))
                   .OrderBy(ActivityLogFile.GetOrder)
                   .ToArray());
        }
コード例 #2
0
        private IEnumerable <string> GetExistingFiles(string baseFilePath)
        {
            var    list = new List <string>();
            string path;

            using (SecurityContext.Impersonate(this))
            {
                string fullPath = Path.GetFullPath(baseFilePath);

                path = Path.GetDirectoryName(fullPath);

                if (Directory.Exists(path))
                {
                    string   fileName = Path.GetFileName(fullPath);
                    string[] files    = Directory.GetFiles(path, ActivityLogFile.GetWildcartPatternFor(fileName));

                    list.AddRange(files.Select(Path.GetFileName));
                }
            }

            LogLog.Debug("RollingFileAppender: Searched for existing files in [" + path + "]");

            return(list);
        }
コード例 #3
0
        protected void RollOverRenameFiles(string baseFileName, DateTime timeStamp)
        {
            if (_maxSizeRollBackups == 0)
            {
                return;
            }

            FileInfo[] logFiles;
            string     directoryName;
            string     backupFileName;

            using (SecurityContext.Impersonate(this))
            {
                directoryName = baseFileName.GetDirectoryName();
                logFiles      = new DirectoryInfo(directoryName)
                                .GetFiles(ActivityLogFile.GetWildcartPatternFor(baseFileName))
                                .OrderBy(x => ActivityLogFile.GetOrder(x.Name))
                                .ToArray();
                backupFileName = ActivityLogFile.ComposeFileName(baseFileName, timeStamp);
            }

            if (_countDirection < 0)
            {
                if (_curSizeRollBackups == _maxSizeRollBackups)
                {
                    DeleteFile(logFiles[_maxSizeRollBackups - 1].FullName);
                    --_curSizeRollBackups;
                }

                for (int index = _curSizeRollBackups; index > 0; --index)
                {
                    FileInfo file = logFiles[index];
                    string   newFileName;

                    using (SecurityContext.Impersonate(this))
                    {
                        newFileName = file.Name.GetFileNameWithoutExtension() + '.' + (index + 1);
                    }

                    RollFile(file.FullName, directoryName.Combine(newFileName));
                }

                ++_curSizeRollBackups;

                RollFile(baseFileName, directoryName.Combine(backupFileName + ".1"));
            }
            else
            {
                if (_curSizeRollBackups >= _maxSizeRollBackups && _maxSizeRollBackups > 0)
                {
                    int num = _curSizeRollBackups - _maxSizeRollBackups;

                    if (_staticLogFileName)
                    {
                        ++num;
                    }

                    DeleteFile(logFiles[num].FullName);
                }

                if (_staticLogFileName)
                {
                    ++_curSizeRollBackups;

                    RollFile(baseFileName, backupFileName + '.' + _curSizeRollBackups);
                }
            }
        }