<local:HighlightTextBlock TextWrapping="Wrap">     <local:HighlightTextBlock.HighlightRules>         <local:HighlightRule HightlightedText="{Binding Filter, Source={x:Reference thisWindow}}">             <local:HighlightRule.Highlights>                 <local:HighlightBackgroung Brush="Yellow"/>                 <local:HighlightForeground Brush="Black"/>             </local:HighlightRule.Highlights>         </local:HighlightRule>     </local:HighlightTextBlock.HighlightRules>     <Run FontWeight="Bold">Property:</Run>     <Run Text="{Binding Property}"/> </local:HighlightTextBlock> 

    public partial class HighlightTextBlock : TextBlock     {         // Здесь сохраняется сериализованное оригинальное наполнение TextBlock          // (подсветка накладывается на оригинал и потом уже подставляется в TextBlock)         string _content;          // Это словарь для правил подсветки и соответствующих им очередей задач         Dictionary<HighlightRule, TaskQueue> _ruleTasks;          /// <summary>         /// Коллекция правил подсветки         /// </summary>         public HighlightRulesCollection HighlightRules         {             get             {                 return (HighlightRulesCollection)GetValue(HighlightRulesProperty);             }             set             {                 SetValue(HighlightRulesProperty, value);             }         }          public static readonly DependencyProperty HighlightRulesProperty =             DependencyProperty.Register("HighlightRules", typeof(HighlightRulesCollection), typeof(HighlightTextBlock), new FrameworkPropertyMetadata(null) { PropertyChangedCallback = HighlightRulesChanged });           static void HighlightRulesChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)         {             var col = e.NewValue as HighlightRulesCollection;             var tb = sender as HighlightTextBlock;             if (col != null && tb != null)             {                 col.CollectionChanged += tb.HighlightRules_CollectionChanged;                 foreach (var rule in col)                 {                     rule.HighlightTextChanged += tb.Rule_HighlightTextChanged;                 }             }         }          public HighlightTextBlock()         {             _ruleTasks = new Dictionary<HighlightRule, TaskQueue>();             HighlightRules = new HighlightRulesCollection();             InitializeComponent();         }          // Обработчик события на изменение коллекции правил подсветки         void HighlightRules_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)         {             switch (e.Action)             {                 case System.Collections.Specialized.NotifyCollectionChangedAction.Add:                     foreach (HighlightRule rule in e.NewItems)                     {                         _ruleTasks.Add(rule, new TaskQueue(1));                         SubscribeRuleNotifies(rule);                         BeginHighlight(rule);                     }                     break;                 case System.Collections.Specialized.NotifyCollectionChangedAction.Remove:                     foreach (HighlightRule rule in e.OldItems)                     {                         rule.HightlightedText = string.Empty;                         _ruleTasks.Remove(rule);                         UnsubscribeRuleNotifies(rule);                     }                     break;                 case System.Collections.Specialized.NotifyCollectionChangedAction.Reset:                     foreach (HighlightRule rule in e.OldItems)                     {                         rule.HightlightedText = string.Empty;                         _ruleTasks.Remove(rule);                         UnsubscribeRuleNotifies(rule);                     }                     break;             }         }          // Подписка на события правила подсветки         void SubscribeRuleNotifies(HighlightRule rule)         {             rule.HighlightTextChanged += Rule_HighlightTextChanged;         }          // Отписка от событий правила подсветки         void UnsubscribeRuleNotifies(HighlightRule rule)         {             rule.HighlightTextChanged -= Rule_HighlightTextChanged;         }          // Обработчик события, которое срабатывает, когда текст для подсветки изменился         void Rule_HighlightTextChanged(object sender, HighlightTextChangedEventArgs e)         {             BeginHighlight((HighlightRule)sender);         }          // Здесь запускается механизм подсвечивания в созданном мною диспетчере задач.         // Смысл в том, что если текст вводится/стирается слишком быстро,         // предыдущая подсветка не успеет закончить работу, поэтому новая подсветка         // добавляется в очередь. Если в очереди уже что то есть, то это удаляется из очереди         // и вставляется новая задача. Для каждого правила очередь своя.         void BeginHighlight(HighlightRule rule)         {             _ruleTasks[rule].Add(new Action(() => Highlight(rule)));         }          // Механизм подсветки         void Highlight(HighlightRule rule)         {             // Если передали не существующее правило, покидаем процедуру             if (rule == null)                 return;              // Так как правила у нас задаются в Xaml коде, они будут принадлежать основному потоку, в котором крутится форма,             // поэтому некоторые свойства можно достать/положить только таким образом             ObservableCollection<Highlight> highlights = null;             Application.Current.Dispatcher.Invoke(new ThreadStart(() =>             {                 highlights = rule.Highlights;             }));              // Даже если существует правило, но в нем не задано, чем подсвечивать, покидаем процедуру подсветки             if (highlights.Count == 0)                 return;              // Еще ряд условий для выхода из процедуры подсветки             var exitFlag = false;             exitFlag = exitFlag || string.IsNullOrWhiteSpace(_content);             Application.Current.Dispatcher.Invoke(new ThreadStart(() =>             {                 exitFlag = exitFlag || Inlines.IsReadOnly || Inlines.Count == 0 ||                  HighlightRules == null || HighlightRules.Count == 0;             }));              if (exitFlag)                 return;              // Создадим параграф. Все манипуляции будем проводить внутри него, потому что выделить что либо             // непосредственно в TextBlock нельзя, если это выделение затрагивает несколько элементов             var par = new Paragraph();              // Парсим _content, в котором у нас сериализованный Span с оригинальным содержимым TextBlock'a.             var parsedSp = (Span)XamlReader.Parse(_content);              // Сам Span нам не нужен, поэтому сливаем все его содержимое в параграф             par.Inlines.AddRange(parsedSp.Inlines.ToArray());              // Обозначаем стартовую позицию (просто для удобства) и выдергиваем из TextBlock'a голый текст.              // Искать вхождения искомой строки будем именно в нем             var firstPos = par.ContentStart;             var curText = string.Empty;             Application.Current.Dispatcher.Invoke(new ThreadStart(() =>             {                 curText = Text;             }));              // Выдергиваем из основного потока текст для подсветки             var hlText = string.Empty;             Application.Current.Dispatcher.Invoke(new ThreadStart(() =>             {                 hlText = rule.HightlightedText;             }));              // Если текст для подсветки не пустой и его длина не превышает длину текста, в котором ищем,              // то продолжим, иначе просто выведем в конце оригинал             if (!string.IsNullOrEmpty(hlText) && hlText.Length <= curText.Length)             {                 // Выдергиваем в основном потоке из правила свойство IgnoreCase.                 // Решил логику оставиьт в основном потоке, потому что нагрузка операции очень низкая                 // и не стоит моего пота :)                 var comparison = StringComparison.CurrentCulture;                 Application.Current.Dispatcher.Invoke(new ThreadStart(() =>                 {                     comparison = rule.IgnoreCase ? StringComparison.CurrentCultureIgnoreCase : StringComparison.CurrentCulture;                 }));                  // Формируем список индексов, откуда начинаются вхождения искомой строки в тексте                 var indexes = new List<int>();                 var ind = curText.IndexOf(hlText, comparison);                 while (ind > -1)                 {                     indexes.Add(ind);                     ind = curText.IndexOf(hlText, ind + hlText.Length, StringComparison.CurrentCultureIgnoreCase);                 }                  TextPointer lastEndPosition = null;                 // Проходим по всем индексам начала вхождения строки поиска в текст                 foreach (var index in indexes)                 {                     // Эта переменная нужна была в моих соисканиях наилучшего места для начала поиска,                     // ведь индекс положения в string не соответствует реальному положению TextPointer'a.                     // Поиск продолжается, поэтому переменную я оставил.                     var curIndex = index;                      // Начинаем поиск с последней найденной позиции либо перемещаем TextPointer вперед                      // на значение, равное индексу вхождения подстроки в текст                     var pstart = lastEndPosition ?? firstPos.GetInsertionPosition(LogicalDirection.Forward).GetPositionAtOffset(curIndex);                      // startInd является длиной текста между начальным TextPointer и текущей точкой начала подсветки                     var startInd = new TextRange(pstart, firstPos.GetInsertionPosition(LogicalDirection.Forward)).Text.Length;                      // В результате нам нужно, чтобы startInd был равен curIndex                     while (startInd != curIndex)                     {                         // Если честно, мне неще не встречались случаи, когда я обгонял startInd обгонял curIndex, однако                         // решил оставить продвижение назад на случай более оптимизированного алгоритма поиска                         if (startInd < curIndex)                         {                             // Смещаем точку начала подсветки на разницу curIndex - startInd                             var newpstart = pstart.GetPositionAtOffset(curIndex - startInd);                              // Иногда TextPointer оказывается между \r и \n, в этом случае начало подсветки                             // сдвигается вперед. Чтобы этого избежать, двигаем его в следующую позицию для вставки                             if (newpstart.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.ElementEnd)                                 newpstart = newpstart.GetInsertionPosition(LogicalDirection.Forward);                              var len = new TextRange(pstart, newpstart).Text.Length;                             startInd += len;                             pstart = newpstart;                         }                         else                         {                             var newpstart = pstart.GetPositionAtOffset(curIndex - startInd);                             var len = new TextRange(pstart, newpstart).Text.Length;                             startInd -= len;                             pstart = newpstart;                         }                     }                      // Ищем конечную точку подсветки аналогичным способом, как для начальной                     var pend = pstart.GetPositionAtOffset(hlText.Length);                     var delta = new TextRange(pstart, pend).Text.Length;                     while (delta != hlText.Length)                     {                         if (delta < hlText.Length)                         {                             var newpend = pend.GetPositionAtOffset(hlText.Length - delta);                             var len = new TextRange(pend, newpend).Text.Length;                             delta += len;                             pend = newpend;                         }                         else                         {                             var newpend = pend.GetPositionAtOffset(hlText.Length - delta);                             var len = new TextRange(pend, newpend).Text.Length;                             delta -= len;                             pend = newpend;                         }                     }                      // К сожалению, предложенным способом не получается разделить Hyperlink.                     // Скорее всего это придется делать вручную, но пока такой необходимости нет,                      // поэтому, если начальной или конечной частью подсветки мы режем гиперссылку,                     // то просто сдвигаем эти позиции. В общем ссылка либо полностью попадает в подсветку,                     // либо не попадает совсем                     var sHyp = (pstart?.Parent as Inline)?.Parent as Hyperlink;                     var eHyp = (pend?.Parent as Inline)?.Parent as Hyperlink;                     if (sHyp != null)                         pstart = pstart.GetNextContextPosition(LogicalDirection.Forward);                      if (eHyp != null)                         pend = pend.GetNextContextPosition(LogicalDirection.Backward);                      // Ну а тут применяем к выделению подсветки.                     if (pstart.GetOffsetToPosition(pend) > 0)                     {                         var sp = new Span(pstart, pend);                         foreach (var hl in highlights)                             hl.SetHighlight(sp);                     }                     lastEndPosition = pend;                 }             }              // Здесь сериализуем получившийся параграф и в основном потоке помещаем его содержимое в TextBlock             var parStr = XamlWriter.Save(par);             Application.Current.Dispatcher.BeginInvoke(new ThreadStart(() =>             {                 Inlines.Clear();                 Inlines.AddRange(((Paragraph)XamlReader.Parse(parStr)).Inlines.ToArray());             })).Wait();         }          void TextBlock_Loaded(object sender, RoutedEventArgs e)         {             // Здесь дергаем наполнение TextBlock'a и сериализуем его в строку,             // чтобы накатывать подсветку всегда на оригинал.             // Это лучше вынести в отдельный поток, но пока и так сойдет.             var sp = new Span();             sp.Inlines.AddRange(Inlines.ToArray());             var tr = new TextRange(sp.ContentStart, sp.ContentEnd);             using (var stream = new MemoryStream())             {                 tr.Save(stream, DataFormats.Xaml);                 stream.Position = 0;                 using(var reader = new StreamReader(stream))                 {                     _content = reader.ReadToEnd();                 }             }             Inlines.AddRange(sp.Inlines.ToArray());              // Запускаем подсветку для всех правил             foreach (var rule in HighlightRules)                 BeginHighlight(rule);         }     } 

    public class TaskQueue     {         Task _worker;         Queue<Action> _queue;         int _maxTasks;         bool _deleteOld;         object _lock = new object();          public TaskQueue(int maxTasks, bool deleteOld = true)         {             if (maxTasks < 1)                 throw new ArgumentException("TaskQueue: максимальное число задач должно быть больше 0");             _maxTasks = maxTasks;             _deleteOld = deleteOld;             _queue = new Queue<Action>(maxTasks);         }          public bool Add(Action action)         {             if (_queue.Count() < _maxTasks)             {                 _queue.Enqueue(action);                 DoWorkAsync();                 return true;             }             if (_deleteOld)             {                 _queue.Dequeue();                 return Add(action);             }             return false;         }          void DoWorkAsync()         {             if(_queue.Count>0)                 _worker = Task.Factory.StartNew(DoWork);         }          void DoWork()         {             lock (_lock)             {                 if (_queue.Count > 0)                 {                     var currentTask = Task.Factory.StartNew(_queue.Dequeue());                     currentTask.Wait();                     DoWorkAsync();                 }             }         }     }  

    public class HighlightRulesCollection : DependencyObject, INotifyCollectionChanged, ICollectionViewFactory, IList, IList<HighlightRule>     {         ObservableCollection<HighlightRule> _items;          public HighlightRulesCollection()         {             _items = new ObservableCollection<HighlightRule>();             _items.CollectionChanged += _items_CollectionChanged;         }          public HighlightRule this[int index]         {             get             {                 return ((IList<HighlightRule>)_items)[index];             }              set             {                 ((IList<HighlightRule>)_items)[index] = value;             }         }          object IList.this[int index]         {             get             {                 return ((IList)_items)[index];             }              set             {                 ((IList)_items)[index] = value;             }         }          public int Count         {             get             {                 return ((IList<HighlightRule>)_items).Count;             }         }          public bool IsFixedSize         {             get             {                 return ((IList)_items).IsFixedSize;             }         }          public bool IsReadOnly         {             get             {                 return ((IList<HighlightRule>)_items).IsReadOnly;             }         }          public bool IsSynchronized         {             get             {                 return ((IList)_items).IsSynchronized;             }         }          public object SyncRoot         {             get             {                 return ((IList)_items).SyncRoot;             }         }          public event NotifyCollectionChangedEventHandler CollectionChanged;          public int Add(object value)         {             return ((IList)_items).Add(value);         }          public void Add(HighlightRule item)         {             ((IList<HighlightRule>)_items).Add(item);         }          public void Clear()         {             ((IList<HighlightRule>)_items).Clear();         }          public bool Contains(object value)         {             return ((IList)_items).Contains(value);         }          public bool Contains(HighlightRule item)         {             return ((IList<HighlightRule>)_items).Contains(item);         }          public void CopyTo(Array array, int index)         {             ((IList)_items).CopyTo(array, index);         }          public void CopyTo(HighlightRule[] array, int arrayIndex)         {             ((IList<HighlightRule>)_items).CopyTo(array, arrayIndex);         }          public ICollectionView CreateView()         {             return new CollectionView(_items);         }          public IEnumerator<HighlightRule> GetEnumerator()         {             return ((IList<HighlightRule>)_items).GetEnumerator();         }          public int IndexOf(object value)         {             return ((IList)_items).IndexOf(value);         }          public int IndexOf(HighlightRule item)         {             return ((IList<HighlightRule>)_items).IndexOf(item);         }          public void Insert(int index, object value)         {             ((IList)_items).Insert(index, value);         }          public void Insert(int index, HighlightRule item)         {             ((IList<HighlightRule>)_items).Insert(index, item);         }          public void Remove(object value)         {             ((IList)_items).Remove(value);         }          public bool Remove(HighlightRule item)         {             return ((IList<HighlightRule>)_items).Remove(item);         }          public void RemoveAt(int index)         {             ((IList<HighlightRule>)_items).RemoveAt(index);         }          IEnumerator IEnumerable.GetEnumerator()         {             return ((IList<HighlightRule>)_items).GetEnumerator();         }          void _items_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)         {             CollectionChanged?.Invoke(this, e);         }      } 

    public class HighlightRule : DependencyObject     {         public delegate void HighlightTextChangedEventHandler(object sender, HighlightTextChangedEventArgs e);          public event HighlightTextChangedEventHandler HighlightTextChanged;          public HighlightRule()         {             Highlights = new ObservableCollection<Highlight>();         }          /// <summary>         /// Текст, который нужно подсветить         /// </summary>         public string HightlightedText         {             get { return (string)GetValue(HightlightedTextProperty); }             set { SetValue(HightlightedTextProperty, value); }         }          public static readonly DependencyProperty HightlightedTextProperty =             DependencyProperty.Register("HightlightedText", typeof(string), typeof(HighlightRule), new FrameworkPropertyMetadata(string.Empty, HighlightPropertyChanged));          public static void HighlightPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)         {             var me = d as HighlightRule;             if (me != null)                 me.HighlightTextChanged?.Invoke(me, new HighlightTextChangedEventArgs((string)e.OldValue, (string)e.NewValue));         }          /// <summary>         /// Игнорировать регистр?          /// </summary>         public bool IgnoreCase         {             get { return (bool)GetValue(IgnoreCaseProperty); }             set { SetValue(IgnoreCaseProperty, value); }         }          public static readonly DependencyProperty IgnoreCaseProperty =             DependencyProperty.Register("IgnoreCase", typeof(bool), typeof(HighlightRule), new PropertyMetadata(true));           /// <summary>         /// Коллекция подсветок         /// </summary>         public ObservableCollection<Highlight> Highlights         {             get             {                 return (ObservableCollection<Highlight>)GetValue(HighlightsProperty);             }             set { SetValue(HighlightsProperty, value); }         }          public static readonly DependencyProperty HighlightsProperty =             DependencyProperty.Register("Highlights", typeof(ObservableCollection<Highlight>), typeof(HighlightRule), new PropertyMetadata(null));       }      public class HighlightTextChangedEventArgs : EventArgs     {         public string OldText { get; }          public string NewText { get; }          public HighlightTextChangedEventArgs(string oldText,string newText)         {             OldText = oldText;             NewText = newText;         }     } 

    public class HighlightBackgroung : Highlight     {         public override void SetHighlight(Span span)         {             Brush brush = null;             Application.Current.Dispatcher.BeginInvoke(new ThreadStart(() =>             {                 brush = Brush;             })).Wait();             span.Background = brush;         }          public override void SetHighlight(TextRange range)         {             Brush brush = null;             Application.Current.Dispatcher.BeginInvoke(new ThreadStart(() =>             {                 brush = Brush;             })).Wait();             range.ApplyPropertyValue(TextElement.BackgroundProperty, brush);         }          /// <summary>         /// Кисть для подсветки фона         /// </summary>         public Brush Brush         {             get             {                 return (Brush)GetValue(BrushProperty);             }             set { SetValue(BrushProperty, value); }         }          public static readonly DependencyProperty BrushProperty =             DependencyProperty.Register("Brush", typeof(Brush), typeof(HighlightBackgroung), new PropertyMetadata(Brushes.Transparent));       } 

    public class HighlightForeground : Highlight     {         public override void SetHighlight(Span span)         {             Brush brush = null;             Application.Current.Dispatcher.BeginInvoke(new ThreadStart(() =>             {                 brush = Brush;             })).Wait();             span.Foreground = brush;         }          public override void SetHighlight(TextRange range)         {             Brush brush = null;             Application.Current.Dispatcher.BeginInvoke(new ThreadStart(() =>             {                 brush = Brush;             })).Wait();             range.ApplyPropertyValue(TextElement.ForegroundProperty, brush);         }          /// <summary>         /// Кисть для цвета текста         /// </summary>         public Brush Brush         {             get { return (Brush)GetValue(BrushProperty); }             set { SetValue(BrushProperty, value); }         }          public static readonly DependencyProperty BrushProperty =             DependencyProperty.Register("Brush", typeof(Brush), typeof(HighlightForeground), new PropertyMetadata(Brushes.Black));     }