Баг при работе TextBox.GetLineText в .NET WPF

Недавно такая ситуация снова наступила у меня. И я решил, что пора просто взять и написать аккуратную утилиту. О самой утилите я расскажу в одной из ближайших статей, но об одной из проблем во время разработки расскажу сейчас.

Ошибка проявляется так – если в WPF приложении, в стандартный контрол TextBox воткнуть много строк текста, то вызовы функции GetLineText() начиная с некоторого индекса будут возвращать неправильные строки.

Неправильность заключается в том, что хоть строки будут из установленного текста, но расположенные дальше, фактически GetLineText() будет просто пропускать некоторые строки. Ошибка проявляется при очень большом количестве строк. Так я ее и встретил – попытался отобразить в TextBox’е 25 мегабайт текста. Работа с последними строками выявила неожиданный эффект.

Гугл подсказывает, что ошибка существует с 2011 года и Microsoft не особо торопится что-то исправлять.

Пример

Требований к версии .NET особо нет. Создаем стандартный проект WPF и заполняем файлы так:
MainWindow.xaml

<Window x:Class="wpf_textbox.MainWindow"         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"         xmlns:local="clr-namespace:wpf_textbox"         mc:Ignorable="d"         Title="WTF, WPF?" Height="350" Width="525">     <Grid>         <Grid.RowDefinitions>             <RowDefinition Height="*"/>             <RowDefinition Height="20"/>             <RowDefinition Height="20"/>         </Grid.RowDefinitions>         <TextBox Grid.Row="0" Margin="5" Name="txt" AcceptsReturn="True" AcceptsTab="True" />         <Button Grid.Row="1" Content="Fire 1!" Click="btn_OnClick" />         <Button Grid.Row="2" Content="Fire 2!" Click="btn2_OnClick" />     </Grid> </Window> 

MainWindow.cs (пропустив using и namespace)

public partial class MainWindow : Window {     public MainWindow()     {         InitializeComponent();     }      private void btn_OnClick(object sender, RoutedEventArgs e)     {         var sb = new StringBuilder();         for (int i = 0; i < 90009; i++)             sb.AppendLine($"{i}");         txt.Text = sb.ToString();     }      private void btn2_OnClick(object sender, RoutedEventArgs e)     {         var sb = new StringBuilder();         for (var i = 1; i < 7; i++)             sb.AppendLine("req: " + 150 * i + ", get: " + txt.GetLineText(150 * i).Trim());         for (var i = 1; i < 7; i++)             sb.AppendLine("req: " + 15000 * i + ", get: " + txt.GetLineText(15000 * i).Trim());         txt.Text = sb.ToString();     } } 

Приложение состоит из TextBox’а и двух кнопок. Нажимаем сначала “Fire 1!” (заполнит TextBox чиселками), затем “Fire 2!” (запросит строки по номерам и выведет).

Ожидаемый результат:

req: 150, get: 150
req: 300, get: 300
req: 450, get: 450
req: 600, get: 600
req: 750, get: 750
req: 900, get: 900
req: 15000, get: 15000
req: 30000, get: 30000
req: 45000, get: 45000
req: 60000, get: 60000
req: 75000, get: 75000
req: 90000, get: 90000

Реальность:

Видно, что для индексов меньше 1000 – все прекрасно, а для больших 15000 – пошли сдвиги. И чем дальше, тем больше.

Исследуем баг

Расчехляем ту часть решарпера, которая отвечает за просмотр исходного кода .NET и специальный класс «Расширитель возможностей и преодолятор ограничений на базе Reflection».

public static class ReflectionExtensions {     public static T GetFieldValue<T>(this object obj, string name)     {         var bindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;         var field = obj.GetType().GetField(name, bindingFlags);         if (field == null)             field = obj.GetType().BaseType.GetField(name, bindingFlags);         return (T)field?.GetValue(obj);     }      public static object InvokeMethod(this object obj, string methodName, params object[] methodParams)     {         var methodParamTypes = methodParams?.Select(p => p.GetType()).ToArray() ?? new Type[] { };         var bindingFlags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static;         MethodInfo method = null;         var type = obj.GetType();         while (method == null && type != null)         {             method = type.GetMethod(methodName, bindingFlags, Type.DefaultBinder, methodParamTypes, null);             var intfs = type.GetInterfaces();             if (method != null)                 break;             foreach (var intf in intfs)             {                 method = intf.GetMethod(methodName, bindingFlags, Type.DefaultBinder, methodParamTypes, null);                 if (method != null)                     break;             }             type = type.BaseType;         }         return method?.Invoke(obj, methodParams);     } } 

Опытным путем устанавливаем, что в конкретно взятом примере проблема начинается в районе 8510 строки. Если запросить txt.GetLineText(8510), то вернется “8510”. Для 8511 – 8511, а для 8512 – внезапно, 8513.

Смотрим на реализацию GetLineText() у TextBox:

Пропускаем проверки в первых строчках и видим вызов GetStartPositionOfLine(). Похоже, что проблема должна быть в этой функции, поскольку для неправильной строки должна вернуться неправильная позиция начала строки.

Вызываем в своем коде:

var o00 = txt.InvokeMethod("GetStartPositionOfLine", 8510); var o01 = txt.InvokeMethod("GetStartPositionOfLine", 8511); var o02 = txt.InvokeMethod("GetStartPositionOfLine", 8512); 

И правда – смещение первого объекта (начало 8510’ой строки) указано как 49950 символов, для второго объекта – 49956, а третьего – 49968. Между первыми двумя 6 символов, а между следующими 12. Непорядок — вот и пропущенная строка.

Идем внутрь GetStartPositionOfLine():

Снова пропускаем стартовые проверки и смотрим на реальные действия. Сначала высчитывается точка, которая должна попасть на строку с номером lineIndex. Берется высота всех строк и прибавляется половинка высоты строки – для того, чтобы попасть в ее центр. На this.VerticalOffset и this.HorizontalOffset не смотрим – они по нулям.
Считаем в своем коде:

var lineHeight = (double) txt.InvokeMethod("GetLineHeight", null); var y0 = lineHeight * (double)8510 + lineHeight / 2.0 - txt.VerticalOffset; var y1 = lineHeight * (double)8511 + lineHeight / 2.0 - txt.VerticalOffset; var y2 = lineHeight * (double)8512 + lineHeight / 2.0 - txt.VerticalOffset; 

Значения разумные, с логикой соотносятся, все в порядке. Идем дальше по коду GetStartPositionOfLine() – нас интересует следующая осмысленная строка (первая внутри условия), которая похожа на крокодила и оканчивается вызовом GetTextPositionFromPoint().
Раскрываем вызовы и дергаем их через рефлексию. Обратим внимание, что некоторые интерфейсы нам недоступны из-за ограничения видимости, поэтому приходится ссылаться на них, используя все тот же Reflection.

var renderScope = (txt.GetFieldValue<FrameworkElement>("_renderScope") as IServiceProvider); // 7 - тип интерфейся ITextView var textView = renderScope.GetService(renderScope.GetType().GetInterfaces()[7]); var o10 = textView.InvokeMethod("GetTextPositionFromPoint", new Point(-txt.HorizontalOffset, y0), true); var o11 = textView.InvokeMethod("GetTextPositionFromPoint", new Point(-txt.HorizontalOffset, y1), true); var o12 = textView.InvokeMethod("GetTextPositionFromPoint", new Point(-txt.HorizontalOffset, y2), true); 

Полученные объекты показывают все те же смещения – 49950, 49956, 49568. Идем глубже, в реализацию GetTextPositionFromPoint() внутри TextBoxView.

Во, GetLineIndexFromPoint() выглядит многообещающе. Вызываем в своем коде.

var o20 = textView.InvokeMethod("GetLineIndexFromPoint", new Point(-txt.HorizontalOffset, y0), true); var o21 = textView.InvokeMethod("GetLineIndexFromPoint", new Point(-txt.HorizontalOffset, y1), true); var o22 = textView.InvokeMethod("GetLineIndexFromPoint", new Point(-txt.HorizontalOffset, y2), true); 

Получаем 8510, 8511 и 8513 – бинго! К реализации:

Даже невооруженным взглядом видно, что это бинарный поиск. _lineMetrics – список характеристик строк (начало, длина, ширина границы). Радостно потираю ручки – я думал, что как это нередко бывает где-то забыли +1 воткнуть или поставили > вместо >=. Копируем функцию в код и отладим. Из-за закрытости типов _lineMetrics вытаскиваем через reflections, _lineHeight же мы уже достали раньше. Итого:

var lm = textView.GetFieldValue<object>("_lineMetrics"); var c = (int)lm.InvokeMethod("get_Count"); var lineMetrics = new List<Tuple<int,int,int,double>>(); for (var i = 0; i < c; i++) {     var arr_o = lm.InvokeMethod("get_Item", i);     var contLength = arr_o.GetFieldValue<int>("_contentLength");     var length = arr_o.GetFieldValue<int>("_length");     var offset = arr_o.GetFieldValue<int>("_offset");     var width = arr_o.GetFieldValue<double>("_width");     lineMetrics.Add(new Tuple<int, int, int, double>(contLength, length, offset, width)); } var o30 = GetLineIndexFromPoint(lineMetrics, lineHeight, new Point(-txt.HorizontalOffset, y0), true); var o31 = GetLineIndexFromPoint(lineMetrics, lineHeight, new Point(-txt.HorizontalOffset, y1), true); var o32 = GetLineIndexFromPoint(lineMetrics, lineHeight, new Point(-txt.HorizontalOffset, y2), true);  /*<...>*/  private int GetLineIndexFromPoint(List<Tuple<int, int, int, double>> lm, double _lineHeight, Point point, bool snapToText) {     if (point.Y < 0.0)         return !snapToText ? -1 : 0;     if (point.Y >= _lineHeight * (double)lm.Count)     {         if (!snapToText)             return -1;         return lm.Count - 1;     }     int index = -1;     int num1 = 0;     int num2 = lm.Count;     while (num1 < num2)     {         index = num1 + (num2 - num1) / 2;         var lineMetric = lm[index];             double num3 = _lineHeight * (double)index;         if (point.Y < num3)             num2 = index;         else if (point.Y >= num3 + _lineHeight)         {             num1 = index + 1;         }         else         {             if (!snapToText && (point.X < 0.0 || point.X >= lineMetric.Item4))             {                 index = -1;                 break;             }             break;         }     }     if (num1 >= num2)         return -1;     return index; } 

До отладки мы не добираемся. o30, o31 и o32 равны 8510, 8511 и 8512, соответственно. Такие какие и должны быть! Но o20, o21 и o22 с ними же не согласны. Как так? Мы же почти не поменяли код. Почти? И вот тут наступает озарение.

var lh = textView.GetFieldValue<double>("_lineHeight"); 

Вот она причина – разница 0.0009375. Причем если мы прикинем накопление ошибки — умножим на 8511, то получим 7.9790625. Это как раз около половины lineHeight, и поэтому при расчете координат точка вылетает за пределы нужной строки и попадает на следующую. Одна и та же переменная (по смыслу) подсчиталась двумя разными способами и, внезапно, не совпала.

На этом я решил остановиться. Возможно реально и докопаться почему высота столбца получилась разная, но я не вижу особого смысла. Сомнительно, что Microsoft будет это исправлять, поэтому смотрим на костыли для обхода. Reflection-костыль – устанавливать правильную _lineHeigh либо в одном, либо в другом месте. Звучит стремно, наверняка медленно и скорее всего ненадежно. Либо можно вести свой набор строк, параллельно TextBox’у и брать строки из него, благо получение номера строки по позиции курсора работает корректно.

Заключение

От начинающих программистов можно часто услышать что-то об ошибках в компиляторе или стандартных компонентах. В реальности они встречаются не так часто, но все же от них не застрахован никто. Не бойтесь заглянуть внутрь того инструмента, который вам нужен – это увлекательно и интересно.

Пишите хороший код!

Другие статьи блога

→ Машинное обучение в Offensive Security
Никакая машина меня не заменит. Мухаха-ха. Надеюсь.
→ Где вставить кавычку в IPv6
Ребята знают куда и что впихнуть, чтобы стало хорошо. После таких слов меня все-таки заменят роботом, наверняка. СР! УВЧ!