Разбор методов реализованных в проекте и разьяснение части кода - C#

 /// <summary>
        /// Цикл построчного чтения логов
        /// </summary>
        private void ReadLoop(CancellationToken token)
        {
            Task.Factory.StartNew(() =>
            {
                try
                {
                    while (!_reader.EndOfStream)
                    {
                        if (token.IsCancellationRequested)
                        {
                            return;
                        }
 
                        if (_rawLogs.Count >= _logOptions.ReadAmount)
                        {
                            continue;
                        }
                        _rawLogs.Add(_reader.ReadLine(), token);
                    }
                }
                catch (ObjectDisposedException)
                {
 
                }
            }, token);
        }

       /// <summary>
        /// Цикл склеивания записей логов
        /// </summary>
        private void StickLoop(CancellationToken token)
        {
            Task.Factory.StartNew(() =>
            {
                string logEntry = string.Empty;
                while (true)
                {
                    try
                    {
                        if (token.IsCancellationRequested)
                        {
                            break;
                        }
 
                        if (_stuckLogs.Count >= _logOptions.ReadAmount)
                        {
                            continue;
                        }
                        
                        string logLine;
                        if (!_rawLogs.TryTake(out logLine)) continue;
 
                        if (_logFilter.IsLogHeadLine(logLine))
                        {
                            _stuckLogs.Add(logEntry, token);
                            logEntry = logLine;
                        }
                        else
                        {
                            logEntry += $"{Environment.NewLine}{logLine}";
                        }
                    }
                    catch (ObjectDisposedException)
                    {
 
                    }
                }
            }, token);
        }

 public LogFilter(string timeFilter, string typeFilter, string systemFilter)
        {
            _isLogLineRegex = new Regex(LogPattern);//Инициализирует новый экземпляр Regex для указанного регулярного выражения.
 
            if (timeFilter == null && typeFilter == null && systemFilter == null)
            {
                _isMatchFilter = s => true;
                return;
            }
 
            if (timeFilter != null && typeFilter == null && systemFilter == null)
            {
                _isMatchFilter = s => s.StartsWith(timeFilter);
                return;
            }
 
            if (!string.IsNullOrEmpty(typeFilter) && typeFilter.Length > 1)
            {
                _isMatchFilter = s => false;
                return;
            }
 
            _isMatchFilter = s =>
            {
                var groups = _isLogLineRegex.Match(s).Groups;
                
                return groups[2].Value.StartsWith(timeFilter ?? string.Empty) &&
                       (string.IsNullOrEmpty(typeFilter) || groups[3].Value == typeFilter) &&
                       groups[4].Value.StartsWith(systemFilter ?? string.Empty);
            };
        }