You should not implement this kind of view related logic in your view model class. The scroll logic must be part of your control.
Furthermore, Run is a pure view class. It extends FrameworkElement, which should give you a hint to avoid handling this UI element in your view model if possible.
The following snippet scrolls the RichTextBox document to the bottom on text changes:
<RichTextBox TextChanged="OnTextChanged" />
private void OnTextChanged(object sender, TextChangedEventArgs e)
=> this.Dispatcher.InvokeAsync((sender as RichTextBox).ScrollToEnd, DispatcherPriority.Background);
Since you are implementing a simple message view, RichTextBox is not the right control. TextBlock would be more appropriate (it also supports Inline elements like Run to color text).
Now that you want to show multiple lines of text, you should implement your view based on a ListBox that renders its items with the help of a TextBlock.
The main advantage of this approach is the far superior performance. In case of displaying a significant amount of messages, the ListBox provides you with UI virtualization right out of the box - it will always scroll smoothly. The heavy RichTextBox becomes sluggish very quick.
Since your view model must only handle data, first step is to introduce a data model e.g. LogMessageand its related types:
LogMessage.cs
// If you plan to modify existing messages e.g. in order to append text,
// the Message property must have a set() and must raise the PropertyChanged event.
public class LogMessage : INotifyPropertyChanged
{
public LogMessage(string message, LogLevel logLevel)
{
this.Message = message;
this.LogLevel = logLevel;
}
public string Message { get; }
public LogLevel LogLevel { get; }
public bool IsNewLine { get; init; }
public event PropertyChangedEventHandler PropertyChanged;
}
LogLevel.cs
public enum LogLevel
{
Default = 0,
Debug,
Info
}
MainViewModel.cs
class MainViewModel : INotifyPropertyChanged
{
public ObservableCollection<LogMessage> LogMessages { get; }
public event PropertyChangedEventHandler PropertyChanged;
public MainViewModel()
{
this.LogMessages = new ObservableCollection<LogMessage>();
WriteLine("Debug test message.", LogLevel.Debug);
WriteLine("Info test message.", LogLevel.Info);
}
// To implement Write() to avoid line breaks,
// simply append the new message text to the previous message.
public void WriteLine(string message, LogLevel logLevel)
{
var newMessage = new LogMessage(message, logLevel) { IsNewLine = true };
this.LogMessages.Add(newMessage);
}
}
Then implement the view that displays the messages. Although this example uses a UserControl, I highly recommend to create a custom control by extending Control instead:
LogLevelToBrushConverter.cs
public class LogLevelToBrushConverter : IValueConverter
{
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
return value switch
{
LogLevel.Debug => Brushes.Blue,
LogLevel.Info => Brushes.Gray,
_ => Brushes.Black
};
}
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
=> throw new NotSupportedException();
}
LogMessageBox.xaml.cs
public partial class LogMessageBox : UserControl
{
public IList<object> LogMessagesSource
{
get => (IList<object>)GetValue(LogMessagesSourceProperty);
set => SetValue(LogMessagesSourceProperty, value);
}
public static readonly DependencyProperty LogMessagesSourceProperty = DependencyProperty.Register(
"LogMessagesSource",
typeof(IList<object>),
typeof(LogMessageBox),
new PropertyMetadata(default(IList<object>), OnLogMessagesSourceChanged));
public LogMessageBox()
{
InitializeComponent();
}
private static void OnLogMessagesSourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
=> (d as LogMessageBox).OnLogMessagesSourceChanged(e.OldValue as IList<object>, e.NewValue as IList<object>);
// Listen to CollectionChanged events
// in order to always keep the last and latest item in view.
protected virtual void OnLogMessagesSourceChanged(IList<object> oldMessages, IList<object> newMessages)
{
if (oldMessages is INotifyCollectionChanged oldObservableCollection)
{
oldObservableCollection.CollectionChanged -= OnLogMessageCollectionChanged;
}
if (newMessages is INotifyCollectionChanged newObservableCollection)
{
newObservableCollection.CollectionChanged += OnLogMessageCollectionChanged;
}
}
private void OnLogMessageCollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
{
object lastMessageItem = this.LogMessagesSource.LastOrDefault();
ListBox listBox = this.Output;
Dispatcher.InvokeAsync(
() => listBox.ScrollIntoView(lastMessageItem),
DispatcherPriority.Background);
}
}
LogMessageBox.xaml
<UserControl>
<ListBox x:Name="Output"
ItemsSource="{Binding RelativeSource={RelativeSource AncestorType=UserControl}, Path=LogMessagesSource}">
<ListBox.ItemContainerStyle>
<Style TargetType="ListBoxItem">
<Setter Property="IsHitTestVisible"
Value="False" />
</Style>
</ListBox.ItemContainerStyle>
</ListBox>
</UserControl>
Usage example
MainWindow.xaml
<Window>
<Window.DataContext>
<MainViewModel />
</Window.DataContext>
<Window.Resources>
<local:LogLevelToBrushConverter x:Key="LogLevelToBrushConverter" />
<DataTemplate DataType="{x:Type local:LogMessage}">
<!-- If you expect Message to change, adjust the Binding.Mode to OneWay.
Otherwise leave it as OneTime to improve performance
-->
<TextBlock Text="{Binding Message, Mode=OneTime}"
Foreground="{Binding LogLevel, Mode=OneTime, Converter={StaticResource LogLevelToBrushConverter}}" />
</DataTemplate>
</Window.Resources>
<LogMessageBox LogMessagesSource="{Binding LogMessages}" />
</Window>
