Part 1: http://shujaatsiddiqi.blogspot.com/2011/01/wpf-performance-improvement-for-mvvm.html
Part 2: http://shujaatsiddiqi.blogspot.com/2011/02/wpf-performance-improvement-for-mvvm.html
In this post we will be discussing how we can use Caching to improve the performance of an application. Support of Caching in desktop application is a new feature of .net framework 4.0.
Assembly and Namespace:
Most of the classes used for caching feature are available in System.Runtime.Caching namespace available in System.Runtime.Caching assembly. We need to add an assembly reference of this assembly in order to use these types.
Extensible Caching Implementation:
The cache system available in .net 4.0 has been implemented from ground up to be an extensible concept. A Cache provider must inherit from ObjectCache available in System.Runtime.Caching namespace. The cache provider available with .net is MemoryCache. It represents an in-memory cache. This is similar to ASP.net cache but you don't need to use System.Web.Caching as it is available in the same System.Runtime.Caching namespace in System.Runtime.Caching assembly. The other benefit is that we can create multiple instances of MemoryCache in the same AppDomain.
Simple Caching Usage for temporal locality of reference:
Let's consider an example of a WPF application using this. In this example we would be utilizing the idea of temporal locality of reference. We would be reading the contents of a File. Since I/O is a time consuming operation, we will be caching the contents of the file. We will be using this cached content from other window, where we would be showing it in a TextBlock. The definition of MainWindow is as follows:
<Window x:Class="WpfApp_MVVM_Caching.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="clr-namespace:WpfApp_MVVM_Caching"
Title="MainWindow" Height="350" Width="525">
<Window.DataContext>
<local:MainWindowViewModel />
</Window.DataContext>
<Grid>
<TextBlock Height="81" HorizontalAlignment="Left" Margin="12,17,0,0"
Name="textBlock1" Text="{Binding FileContents}" VerticalAlignment="Top" Width="468" />
<Button Content="Open Child Window" Height="26" HorizontalAlignment="Left" Margin="12,273,0,0" Name="btnOpenChildWindow"
VerticalAlignment="Top" Width="134" Click="btnOpenChildWindow_Click" />
</Grid>
</Window>This window has a TextBlock to display the contents of the file. The Text property of this TextBlock is bound to FileContents property of DataContext. The window also has a button. The definition of click event handler [btnOpenChildWindow_Click] from the code behind is as follows:private void btnOpenChildWindow_Click(object sender, RoutedEventArgs e)
{
new ChildWindow().Show();
}This is just opening the ChildWindow as a modeless window using its Show method. MainWindow is using MainWindowViewModel instance as its DataContext. It is constructing its instance as part of its initialization code. The definition of MainWindowViewModel is as follows:class MainWindowViewModel : INotifyPropertyChanged
{
public MainWindowViewModel()
{
string localfileContents = File.ReadAllText(@"C:\Users\shujaat\Desktop\s.txt");
FileContents = localfileContents;
MemoryCache.Default.Set("filecontents", localfileContents, DateTimeOffset.MaxValue);
}
#region Properties
private string _fileContents;
public string FileContents
{
get { return _fileContents; }
set
{
_fileContents = value;
OnPropertyChanged("FileContents");
}
}
#endregion
#region INotifyPropertyChanged implementation
public event PropertyChangedEventHandler PropertyChanged = delegate { };
private void OnPropertyChanged(string propertyName)
{
PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
}
#endregion INotifyPropertyChanged implementation
}As expected by the view, It just has a property FileContents. In the constructor, the contents of a file is read and assigned to this property. Since this is based on INotifyPropertyChanged, the changes are propagated to the view using PropertyChanged event. Additionally, we are copying the data read from the file to MemoryCache.Default with Key 'fileconents'.The definition of ChildWindow is as follows:
<Window x:Class="WpfApp_MVVM_Caching.ChildWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="clr-namespace:WpfApp_MVVM_Caching"
Title="Child Window" Height="300" Width="300">
<Window.DataContext>
<local:ChildWindowViewModel />
</Window.DataContext>
<Grid>
<TextBlock Height="61" HorizontalAlignment="Left" Margin="36,49,0,0" Name="textBlock1"
VerticalAlignment="Top" Width="206" Text="{Binding CacheEntryValue}" />
</Grid>
</Window>It has a TextBlock whose Text property is bound to CacheEntryValue property from the DataContext. The DataContext is an instance of ChildWindowViewModel. Its definition is as follows:class ChildWindowViewModel : INotifyPropertyChanged
{
private string _cacheEntryValue;
public string CacheEntryValue
{
get { return _cacheEntryValue; }
set
{
_cacheEntryValue = value;
OnPropertyChanged("CacheEntryValue");
}
}
public ChildWindowViewModel()
{
CacheEntryValue = MemoryCache.Default["filecontents"] as string;
}
#region INotifyPropertyChanged implementation
public event PropertyChangedEventHandler PropertyChanged = delegate { };
private void OnPropertyChanged(string propertyName)
{
PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
}
#endregion INotifyPropertyChanged implementation
}We are just copying the contents of the cache entry defined in the MainWindow to the Text property of the TextBlock. Using the value is achieved using the idea of temporal locality of Caching technology. Let's run the application and open child window.
As you might already have guessed, the contents of the file are: "Muhammad Shujaat Siddiqi".
Changes in Underlying DataSource:
Cache keeps the data available in an application for faster data access when it is needed. The user of this cache might or might not know about the actual data source. The caching feature available in .net framework 4.0 keeps track of this is through the provision of ChangeMonitor. This is basically kind of implementation of Observer design pattern. So when underlying datasource is changed, the ChangeMonitor notifies the ObjectCache implemenation [MemoryCache] about this change. ObjectCache implementation then takes any action about this change. It might even nullify the Cache entry as it is invalid now [Like the case of MemoryCache].
Let us create a new Window to present an example of a WPF application using ChangeMonitor. The Window below is a similar window as the above example. It just has an extra TextBox and a Button.
<Window x:Class="WpfApp_MVVM_Caching.MainWindowChangeMonitorExample"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="clr-namespace:WpfApp_MVVM_Caching"
Title="MainWindow" Height="350" Width="525">
<Window.DataContext>
<local:MainWindowChangeMonitorExampleViewModel />
</Window.DataContext>
<Grid>
<TextBlock Height="81" HorizontalAlignment="Left" Margin="12,17,0,0"
Name="textBlock1" Text="{Binding FileContents}" VerticalAlignment="Top" Width="468" />
<TextBox Height="138" HorizontalAlignment="Left" Margin="279,125,0,0" Name="textBoxCachedFileContents"
VerticalAlignment="Top" Width="212" Text="{Binding Path=MessageToDataSource, UpdateSourceTrigger=PropertyChanged}" />
<Button Content="Update Data Source" Height="30" HorizontalAlignment="Left"
Margin="314,269,0,0" Name="btnUpdateDataSource" VerticalAlignment="Top"
Width="177" Command="{Binding UpdateDataSourceCommand}" />
<Button Content="Open Child Window" Height="26" HorizontalAlignment="Left" Margin="12,273,0,0" Name="btnOpenChildWindow"
VerticalAlignment="Top" Width="134" Click="btnOpenChildWindow_Click" />
</Grid>
</Window>The above view is using a new instance of MainWindowChangeMonitorExampleViewModel as its DataContext. It is expecting a string property FileContents to bind to the Text property of the TextBlock. Additionally, it is also expecting the DataContext to have MessageToDataSource property to bind to the Text property of the only TextBox. When a user clicks the Update button the contents of TextBox should be updated to the DataSource (File). Since FileContents are invalid now, it should be updated to the latest contents. For that, the view model should use ChangeMonitor. But first look at the code behind of this view.public partial class MainWindowChangeMonitorExample : Window
{
public MainWindowChangeMonitorExample()
{
InitializeComponent();
}
private void btnOpenChildWindow_Click(object sender, RoutedEventArgs e)
{
new ChildWindow().Show();
}
}
This is similar to the view in the previous examples. When user clicks "Open Child Window", a new instance of ChildWindow is shown in a modeless fashion. Now we have a look at the View Model. Get ready to see Change Monitors in action...class MainWindowChangeMonitorExampleViewModel : INotifyPropertyChanged
{
#region Fields
List<string> filePaths = new List<string>();
#endregion Fields
#region Constructors
public MainWindowChangeMonitorExampleViewModel()
{
filePaths.Add(@"C:\Users\shujaat\Desktop\s.txt");
string localfileContents = File.ReadAllText(@"C:\Users\shujaat\Desktop\s.txt");
FileContents = localfileContents;
var changeMonitor = new HostFileChangeMonitor(filePaths);
var policy = new CacheItemPolicy();
MemoryCache.Default.Set("filecontents", localfileContents, policy);
policy.ChangeMonitors.Add(changeMonitor);
changeMonitor.NotifyOnChanged(OnDataSourceUpdated);
}
#endregion Constructors
#region Change Monitor Callback
private void OnDataSourceUpdated(Object State)
{
//Get file contents
FileInfo file = new FileInfo(@"C:\Users\shujaat\Desktop\s.txt");
using (FileStream stream = file.OpenRead())
{
using (StreamReader reader = new StreamReader(stream))
{
string updatedFileContents = reader.ReadToEnd();
reader.Close();
FileContents = updatedFileContents;
}
}
//Update Cache Entry
MemoryCache.Default["filecontents"] = FileContents;
//Update change monitor for further changes in file contents
var policy = new CacheItemPolicy();
var changeMonitor = new HostFileChangeMonitor(filePaths);
policy.ChangeMonitors.Add(changeMonitor);
changeMonitor.NotifyOnChanged(OnDataSourceUpdated);
}
#endregion Change Monitor Callback
#region Properties
private string _fileContents;
public string FileContents
{
get { return _fileContents; }
set
{
_fileContents = value;
OnPropertyChanged("FileContents");
}
}
private string _messageToDataSource;
public string MessageToDataSource
{
get { return _messageToDataSource; }
set
{
_messageToDataSource = value;
OnPropertyChanged("MessageToDataSource");
}
}
#endregion
#region INotifyPropertyChanged implementation
public event PropertyChangedEventHandler PropertyChanged = delegate { };
private void OnPropertyChanged(string propertyName)
{
PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
}
#endregion INotifyPropertyChanged implementation
#region Commands
ICommand _updateDataSourceCommand;
public ICommand UpdateDataSourceCommand
{
get
{
if (_updateDataSourceCommand == null)
{
_updateDataSourceCommand = new RelayCommand(
param => this.UpdateDataSource(),
param => this.CanUpdateDataSource
);
}
return _updateDataSourceCommand;
}
}
public void UpdateDataSource()
{
FileInfo file = new FileInfo(@"C:\Users\shujaat\Desktop\s.txt");
using (FileStream stream = file.OpenWrite())
{
using (StreamWriter writer = new StreamWriter(stream) { AutoFlush = true })
{
writer.Write(MessageToDataSource);
writer.Close();
}
}
}
bool CanUpdateDataSource
{
get { return true; }
}
#endregion Commands
}In the constructor, like in the previous example, it is reading the contents of a text file and adding it to the cache. Additionally, it is creating a HostFileChangeMonitor and adds it the CacheItemPolicy's list of ChangeMonitors. This policy is being used for keeping a watch on the contents of the files specified by the ChangeMonitors. If there is an update, it executes the callback as specified by the ChangeMonitor. HostFileChangeMonitor is a descendent of ChangeMonitor through FileChangeMonitor. In non ASP.net applications, it uses internally FileSystemWatcher to monitor files. It must be remembered that it does not support relative paths.As expected by the view, it has two string properties FileContents and MessageToDataSource. It also has a RelayCommand object UpdateDataSourceCommand. This command is executed when user clicks Update Data Source button. In the execute method [UpdateDataSource] of this command, we are just updating the contents of the file using StreamWriter.
The soul of this example is OnDataSourceUpdated method specified as the callback for change notification in the monitored data sources by HostFileChangeMonitor. When the contents of the file are updated, this method gets called. In this method we are updating the Cache Entry and the string property bound to the text block in the view showing the contents of the file.
Now specify the new view as startup view of the project in App.xaml and run the application. The view appears as follows:
Now let us update the contents of the TextBox and click "Update Data Source" button. As the contents of the file are updated, the callback is called by the ChangeMonitor which updates the cache entry and the FileContent property with updated contents of the file. Since this is bound to a TextBlock.TextProperty in the view, the view shows this update.
Now we open the child window using "Open Child Window" button. The child window uses the same cache entry. The child window appears as follows:
Now update the contents of file again by updating the contents of the TextBox and hitting "Update Data Source" button. This should be done when the ChildWindow is still shown. We are updating the contents with one of Jalal Uddin Rumi's great quote.
Cache Entry Change Monitor:
As you can see that clicking Update Source button after updating the contents of the TextBox updates the TextBlock on the main window but it does not appear to update the contents of second window. This is because the ChildWindow does not know that the cache entry value it used for its TextBlock has been updated. If ChildWindow has some means to get notification for this cache entry update then it could update its logic. For this purpose we can use another ChangeMonitor, called CacheEntryChangeMonitor.
Let's update the constructor of ChildWindowViewModel as follows:
public ChildWindowViewModel()
{
CacheEntryValue = MemoryCache.Default["filecontents"] as string;
MemoryCache.Default.CreateCacheEntryChangeMonitor(
new string[] { "filecontents" }.AsEnumerable<string>()).NotifyOnChanged((a) =>
{
CacheEntryValue = MemoryCache.Default["filecontents"] as string;
}
);
}
Here we have just added an instane CacheEntryChangeMonitor to the code. Again we are using the same cache entry but the only difference we have added a NotifyOnChanged callback for this. As the entry gets updated this callback is called and it updates the property bound to the TextBlock.Text property in the view refreshing this.
Download Code:
No comments:
Post a Comment