Вопросы Теги

Quartz.NET 3.0, кажется, запускает все задания в одной области

Я согласен, что правильный инструмент для синтаксического анализа XML и , особенно HTML , является синтаксическим анализатором, а не механизмом регулярных выражений. Однако, как указывали другие, иногда использование регулярного выражения выполняется быстрее, проще и выполняется, если вы знаете формат данных.

Microsoft фактически имеет раздел Рекомендации по регулярным выражениям в .NET Framework и, в частности, говорит о . Рассмотрим [вход] источника входного сигнала .

Регулярные выражения имеют ограничения, но вы считали следующее?

.NET framework уникален, когда речь заходит о регулярных выражениях в том, что он поддерживает Определения балансировочной группы .

По этой причине я считаю, что вы можете анализировать XML с помощью регулярных выражений. Обратите внимание, однако, что он должен быть достоверным. XML ( браузеры очень прощают HTML и допускают плохой синтаксис XML внутри HTML ). Это возможно, так как «Определение балансировки группы» позволит механизму регулярных выражений действовать как КПК.

Цитата из статьи 1, процитированной выше:

.NET Regular Expression Двигатель

Как описано выше, правильно сбалансированные конструкции не могут быть описаны регулярным выражением. Тем не менее, механизм регулярного выражения .NET предоставляет несколько конструкций, которые позволяют распознавать сбалансированные конструкции.

  • (?) - выталкивает захваченный результат в стек захвата с помощью группы имен.
  • (?<-group>) - отображает верхний захват с группой имен с захвата stack.
  • (?(group)yes|no) - соответствует дате, если существует группа с группой имен, в противном случае не соответствует какой-либо детали.

Эти конструкции допускают регулярную .NET выражение для подражания ограниченному КПК, по существу позволяя простые версии операций стека: push, pop и empty. Простые операции в значительной степени эквивалентны приращению, уменьшению и сравнению с нулем соответственно. Это позволяет механизму регулярного выражения .NET распознавать подмножество контекстно-свободных языков, в частности тех, которые требуют простого счетчика. Это, в свою очередь, позволяет нетрадиционным регулярным выражениям .NET распознавать индивидуально правильно сбалансированные конструкции.

blockquote>

Рассмотрим следующее регулярное выражение: 

(?=)
(?>
                     |
   <[^>]*/>                      |
   (?<(?!/)[^>]*[^/]>)  |
   (?<-opentag>]*[^/]>)     |
   [^<>]*
)*
(?(opentag)(?!))

Использовать флаги :

  • Singleline
  • IgnorePatternWhitespace (необязательно, если вы сбрасываете регулярное выражение и удаляете все пробелы)
  • IgnoreCase (необязательно)

Объяснение регулярного выражения (inline) 

(?=) # match start with 
                                            # atomic group / don't backtrack (faster)
                    |          # match xml / html comment
   <[^>]*/>                     |          # self closing tag
   (?<(?!/)[^>]*[^/]>) |          # push opening xml tag
   (?<-opentag>]*[^/]>)    |          # pop closing xml tag
   [^<>]*                                  # something between tags
)*                                         # match as many xml tags as possible
(?(opentag)(?!))                           # ensure no 'opentag' groups are on stack

Вы можете попробовать это на A Better .NET Regular Expression Tester .

Я использовал источник выборки: 





   

   
    
      
  • stuff...
    • 
      
  • more stuff
    • 
      
  • 
          
    
               still more
               
      
                    
    • Another >ul<, oh my!
      • 
                    
    • ...
      • 
               
    
          
    
      
    •

Это нашло совпадение: 

   
    
      
  • stuff...
    • 
      
  • more stuff
    • 
      
  • 
          
    
               still more
               
      
                    
    • Another >ul<, oh my!
      • 
                    
    • ...
      • 
               
    
          
    
      
    •

, хотя оно получилось так: 

               
  • stuff...
    •            
  • more stuff
    •            
  •                
                        still more                    
                               
    • Another >ul<, oh my!
      •                          
    • ...
      •                     
                   
               
    •

Наконец, Мне очень понравилась статья Джеффа Этвуда: Parsing Html Путь Ктулху . Забавно, он цитирует ответ на этот вопрос, который в настоящее время имеет более 4 кв голосов.

1
задан Rabban 18 March 2019 в 11:26
поделиться

1 ответ

Как я знаю, это невозможно с Кварцем, я боролся с теми же проблемами, и единственное решение, которое я нашел, было использовать ServiceLocator и явно создать область действия в Задании.

Я закончил с чем-то вроде этого: 

// Pseudo-Code
public class MyJob : IJob
{
    private readonly IServiceLocator _serviceLocator;

    public MyJob(IServiceLocator serviceLocator)
    {
        _serviceLocator = serviceLocator;
    }

    public async Task Execute(JobExecutionContext context)
    {
        using(_serviceLocator.BeginScope())
        {
            var worker = _serviceLocator.GetService<MyWorker>();
            await worker.DoWorkAsync();
        }
    }
}

В этом случае ваш работник все еще ограничен, но работа больше не. Таким образом, вы по-прежнему можете использовать ваш Worker в других местах вашего решения, и область все еще работает. Вам необходимо внедрить ServiceLocator самостоятельно в зависимости от используемого вами DI, и IServiceLocator также должен быть вами определен.

Редактировать

В одном из наших проектов мы используем это: 

/// <summary>
/// A simple service locator to hide the real IOC Container.
/// Lowers the anti-pattern of service locators a bit.
/// </summary>
public interface IServiceLocator
{
    /// <summary>
    /// Begins an new async scope.
    /// The scope should be disposed explicitly.
    /// </summary>
    /// <returns></returns>

    IDisposable BeginAsyncScope();
    /// <summary>
    /// Gets an instance of the given <typeparamref name="TService" />.
    /// </summary>
    /// <typeparam name="TService">Type of the requested service.</typeparam>
    /// <returns>The requested service instance.</returns>
    TService GetInstance<TService>() where TService : class;
}

Мы используем в основном SimpleInjector с этой реализацией: 

/// <summary>
/// SimpleInjector implementation of the service locator.
/// </summary>
public class ServiceLocator : IServiceLocator
{
    #region member vars

    /// <summary>
    /// The SimpleInjector container.
    /// </summary>
    private readonly Container _container;

    #endregion

    #region constructors and destructors

    public ServiceLocator(Container container)
    {
        _container = container;
    }

    #endregion

    #region explicit interfaces

    /// <inheritdoc />
    public IDisposable BeginAsyncScope()
    {
        return AsyncScopedLifestyle.BeginScope(_container);
    }

    /// <inheritdoc />
    public TService GetInstance<TService>()
        where TService : class
    {
        return _container.GetInstance<TService>();
    }
}
[1110 ] Как видите, это простая оболочка, которая помогает скрыть настоящую DI Framework от потребителей. Я надеюсь, что это поможет немного понять вашу необходимую реализацию.

0
ответ дан Rabban 18 March 2019 в 11:26
поделиться
Другие вопросы по тегам:

Похожие вопросы: