One book that I recommend the reading is Clean Code, by Robert Martin. It is a well written book with wonderful techniques to create better code and improve your current programs, so they become easier to read, maintain and understand.

While going through it again, I found an excellent opportunity to improve my skills trying to do some refactoring: in listing 4.7 there is a prime generator function that he uses to show some refactoring concepts and turn int listing 4.8. I then thought do do the same and show my results here.

We can start with the listing converted to C#. This is a very easy task. The original program is written in  Java, but converting it to C# is just a matter of one or two small fixes:

```using System;

{
/**
* This class Generates prime numbers up to a user specified
* maximum. The algorithm used is the Sieve of Eratosthenes.
* <p>
* Eratosthenes of Cyrene, b. c. 276 BC, Cyrene, Libya --
* d. c. 194, Alexandria. The first man to calculate the
* circumference of the Earth. Also known for working on
* calendars with leap years and ran the library at Alexandria.
* <p>
* The algorithm is quite simple. Given an array of integers
* starting at 2. Cross out all multiples of 2. Find the next
* uncrossed integer, and cross out all of its multiples.
* Repeat untilyou have passed the square root of the maximum
* value.
*
* @author Alphonse
* @version 13 Feb 2002 atp
*/
public class GeneratePrimes
{
/**
* @param maxValue is the generation limit.
*/
public static int[] generatePrimes(int maxValue)
{
if (maxValue >= 2) // the only valid case
{
// declarations
int s = maxValue + 1; // size of array
bool[] f = new bool[s];
int i;

// initialize array to true.
for (i = 0; i < s; i++)
f[i] = true;
// get rid of known non-primes
f[0] = f[1] = false;
// sieve
int j;
for (i = 2; i < Math.Sqrt(s) + 1; i++)
{
if (f[i]) // if i is uncrossed, cross its multiples.
{
for (j = 2 * i; j < s; j += i)
f[j] = false; // multiple is not prime
}
}
// how many primes are there?
int count = 0;
for (i = 0; i < s; i++)
{
if (f[i])
count++; // bump count.
}
int[] primes = new int[count];
// move the primes into the result
for (i = 0, j = 0; i < s; i++)
{
if (f[i]) // if prime
primes[j++] = i;
}
return primes; // return the primes
}
else // maxValue < 2
return new int[0]; // return null array if bad input.
}
}
}```

The first step is to put in place some tests, so we can be sure that we are not breaking anything while refactoring the code. In the solution, I added a new Class Library project, named it GeneratePrimes.Tests and added the packages NUnit, NUnit3TestAdapter and FluentAssertions to get fluent assertions in a NUnit test project. Then I added these tests:

```using NUnit.Framework;
using FluentAssertions;

{
[TestFixture]
public class GeneratePrimesTests
{
[Test]
public void GeneratePrimes0ReturnsEmptyArray()
{
var actual = GeneratePrimes.generatePrimes(0);
actual.Should().BeEmpty();
}

[Test]
public void GeneratePrimes1ReturnsEmptyArray()
{
var actual = GeneratePrimes.generatePrimes(1);
actual.Should().BeEmpty();
}

[Test]
public void GeneratePrimes2ReturnsArrayWith2()
{
var actual = GeneratePrimes.generatePrimes(2);
actual.Should().BeEquivalentTo(new[] { 2 });
}

[Test]
public void GeneratePrimes10ReturnsArray()
{
var actual = GeneratePrimes.generatePrimes(10);
actual.Should().BeEquivalentTo(new[] { 2,3,5,7 });
}

[Test]
public void GeneratePrimes10000ReturnsArray()
{
var actual = GeneratePrimes.generatePrimes(10000);
actual.Should().HaveCount(1229).And.EndWith(9973);
}
}
}```

These tests check that there are no primes for 0 and 1, one prime for 2, the primes for 10 are 2, 3, 5, 7 and that there are 1229 primes less than 10,000 and the largest one is 9973. Once we run the tests, we can see that the pass and we can start doing our changes.

The easiest fix we can do is to revise the comments at the beginning. We don’t need the history of Erasthotenes (you can go to Wikipedia for that). We don’t need the author and version, thanks to source control technology :-). We don’t need either the initial comment:

```/**
* This class Generates prime numbers up to a user specified
* maximum. The algorithm used is the Sieve of Eratosthenes.
*  https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
*/
public class GeneratePrimes
{
public static int[] generatePrimes(int maxValue)
```

Then we can invert the initial test, to reduce nesting. If we hover the mouse in the line of the first if, an arrow appears at the border, indicating a quick fix:

We can do the quick fix, then eliminate the else clause (don’t forget to remove the extra comments that are not needed):

```public static int[] generatePrimes(int maxValue)
{
if (maxValue < 2)
return new int[0];

// declarations
int s = maxValue + 1; // size of array
bool[] f = new bool[s];
int i;
```

Save the code and check that all tests pass. The next step is to rename the variables:

• s can be renamed to sizeOfArray
• f can be renamed as isPrimeArray

Go to the declaration of s and press Ctrl-R-R to rename and rename it to sizeOfArray. Do the same with the f variable. Don’t forget to remove the comments (and to run the tests):

```int sizeOfArray = maxValue + 1;
bool[] isPrimeArray = new bool[sizeOfArray];
int i;```

To go to the next refactorings, we can use the comments as indicators for extracting methods. We can extract the InitializeArray method:

The extracted code isn’t what I expected, so I change it to:

```private static bool[] InitializeArray(int sizeOfArray)
{
bool[] isPrimeArray = new bool[sizeOfArray];
// initialize array to true.
for (var i = 0; i < sizeOfArray; i++)
isPrimeArray[i] = true;
return isPrimeArray;
}```

I can use the code like this:

`var isPrimeArray = InitializeArray(sizeOfArray);`

After passing the tests, I can refactor the code of InitializeArray to:

```private static bool[] InitializeArray(int sizeOfArray)
{
return Enumerable
.Range(0, sizeOfArray)
.Select(n => true)
.ToArray();
}```

The next step is the sieve:

The code for the sieve is really bad:

```private static void Sieve(int sizeOfArray, bool[] isPrimeArray,
out int i, out int j)
{
// get rid of known non-primes
isPrimeArray[0] = isPrimeArray[1] = false;
for (i = 2; i < Math.Sqrt(sizeOfArray) + 1; i++)
{
if (isPrimeArray[i]) // if i is uncrossed, cross its multiples.
{
for (j = 2 * i; j < sizeOfArray; j += i)
isPrimeArray[j] = false; // multiple is not prime
}
}
}
```

It has two out parameters (which, for me, is a code smell), and has an error (the out parameter j must be assigned) before exiting the method. So we can change it to remove the out parameters and remove the sizeOfArray parameter:

```private static void Sieve(bool[] isPrimeArray)
{
var sizeOfArray = isPrimeArray.Length;

isPrimeArray[0] = isPrimeArray[1] = false;

for (int i = 2; i < Math.Sqrt(sizeOfArray) + 1; i++)
{
if (isPrimeArray[i]) // if i is uncrossed, cross its multiples.
{
for (int j = 2 * i; j < sizeOfArray; j += i)
isPrimeArray[j] = false;
}
}
```

Then, we can extract the method to count primes:

CountPrimes has the same flaws as Sieve, so we change it to:

```private static int CountPrimes(bool[] isPrimeArray)
{
var sizeOfArray = isPrimeArray.Length;
var count = 0;
for (var i = 0; i < sizeOfArray; i++)
{
if (isPrimeArray[i])
count++;
}
return count;
}```

We can refactor it to:

```private static int CountPrimes(bool[] isPrimeArray) =>
isPrimeArray.Count(i => i);```

The next step is MovePrimes:

After we tweak the MovePrimes code, we get:

```private static int[] MovePrimes(bool[] isPrimeArray, int count)
{
var sizeOfArray = isPrimeArray.Length;
var primes = new int[count];
for (int i = 0, j = 0; i < sizeOfArray; i++)
{
if (isPrimeArray[i]) // if prime
primes[j++] = i;
}
return primes;
}```

Then we can refactor MovePrimes:

``` private static int[] MovePrimes(bool[] isPrimeArray, int count) =>
isPrimeArray
.Select((p, i) => new { Index = i, IsPrime = p })
.Where(v => v.IsPrime)
.Select(v => v.Index)
.ToArray();```

Notice that we aren’t using the primes count in this case, so we can remove the calculation of the count and the parameter. After some cleaning and name changing, we get:

```public static int[] GetPrimes(int maxValue)
{
if (maxValue < 2)
return new int[0];

bool[] isPrimeArray = InitializeArray(maxValue);
Sieve(isPrimeArray);
return MovePrimes(isPrimeArray);
}
```

Much cleaner, no? Now, it’s easier to read the method, the details are hidden, but the code still runs the same way. We have a more maintainable method, and it shows clearly what it does.

But there is a change we can do here: we are using static methods only. We can then use extension methods and add the keyword this to allow the methods to be used as extension methods. For example, if we change MovePrimes and Sieve to:

```private static int[] MovePrimes(this bool[] isPrimeArray) =>
isPrimeArray
.Select((p, i) => new { Index = i, IsPrime = p })
.Where(v => v.IsPrime)
.Select(v => v.Index)
.ToArray();

private static bool[] Sieve(this bool[] isPrimeArray)
{
var sizeOfArray = isPrimeArray.Length;

isPrimeArray[0] = isPrimeArray[1] = false;

for (int i = 2; i < Math.Sqrt(sizeOfArray) + 1; i++)
{
if (isPrimeArray[i]) // if i is uncrossed, cross its multiples.
{
for (int j = 2 * i; j < sizeOfArray; j += i)
isPrimeArray[j] = false;
}
}
return isPrimeArray;
```

We can have the GetPrimes method to be changed to:

```public static int[] PrimesSmallerOrEqual(this int maxValue)
{
if (maxValue < 2)
return new int[0];

return maxValue.InitializeArray()
.Sieve()
.MovePrimes();
}```

Cool, no? With this change, the tests become:

```public class GeneratePrimesTests
{
[Test]
public void GeneratePrimes0ReturnsEmptyArray()
{
0.PrimesSmallerOrEqual().Should().BeEmpty();
}

[Test]
public void GeneratePrimes1ReturnsEmptyArray()
{
1.PrimesSmallerOrEqual().Should().BeEmpty();
}

[Test]
public void GeneratePrimes2ReturnsArrayWith2()
{
2.PrimesSmallerOrEqual()
.Should().BeEquivalentTo(new[] { 2 });
}

[Test]
public void GeneratePrimes10ReturnsArray()
{
10.PrimesSmallerOrEqual()
.Should().BeEquivalentTo(new[] { 2, 3, 5, 7 });
}

[Test]
public void GeneratePrimes10000ReturnsArray()
{
10000.PrimesSmallerOrEqual()
.Should().HaveCount(1229).And.EndWith(9973);
}
}```

The full code is at https://github.com/bsonnino/PrimeNumbers. Each commit there is a phase of the refactoring.

Sometimes, when we open an Explorer window in the main computer, we see red bars in some disks, telling us that the disk is almost full and that we need to do some cleanup. We call the system cleanup, that removes some unused space, but this isn’t enough to  make things better.

So, we try to find the duplicate files in the disk to remove some extra space, but we have a problem: where are the duplicate files? The first answer is to check the files with the same name and size, but that isn’t enough – files can be renamed, and still be duplicates.

So, the best thing to do is to find a way to find and list all duplicates in the disk. But how can we do this?

The naive approach is to get all files with the same size and compare them one with the other. But this is really cumbersome, because if there are 100 files in the group, there will be 100!/(2!*98!) = 100*99/2 = 4950 comparisons and has a complexity of O(n^2).

One other approach is to get a checksum of the file and compare checksums. That way, you will still have the O(n^2) complexity, but you’ll have less data to compare (but you will have to compute the time to calculate the checksums). A third approach would be to use a dictionary to group the files with the same hash. The search in a dictionary has a O(1) complexity, so this would do a O(n) complexity.

Now, we only have to choose the checksum. Every checksum has a number of bits and, roughly, the larger the number of bits, the longer it takes to compute it. But the larger number of bits make it more difficult to get wrong results: if you are using CRC16 checksum (16 bits), you will have 65,535 combinations and the probability of two different files have the same checksum is very large. CRC32 allows 2,147,483,647 combinations and, thus, is more difficult to have a wrong result. You can use other algorithms, like MD5 (128 bits), SHA1 (196 bits) or SHA256 (256 bits), but computing these will be way longer than computing the CRC32 bits. As we are not seeking for huge accuracy, but for speed, we’ll use the CRC32 algorithm to compute the hashes. A fast implementation of this algorithm can be found here , and you can use it by installing the CRC32C.NET NuGet package.

From there, we can create our program to find and list the duplicates in the disk. In Visual Studio, create a new WPF application. In the Solution Explorer, right-click on the references node and select the WpfFolderBrowser and Crc32C.NET packages. Then add this code in MainWindow.xaml:

```<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="40"/>
<RowDefinition Height="*"/>
</Grid.RowDefinitions>
<Button Width="85" Height="30" Content="Start" Click="StartClick"
HorizontalAlignment="Right" Margin="5" Grid.Row="0"/>
<Grid Grid.Row="1">
<Grid.RowDefinitions>
<RowDefinition Height="*"/>
<RowDefinition Height="30"/>
</Grid.RowDefinitions>
<ScrollViewer HorizontalScrollBarVisibility="Disabled">
<ItemsControl x:Name="FilesList" HorizontalContentAlignment="Stretch">
<ItemsControl.ItemTemplate>
<DataTemplate>
<Grid HorizontalAlignment="Stretch">
<Grid.RowDefinitions>
<RowDefinition Height="30" />
<RowDefinition Height="Auto" />
</Grid.RowDefinitions>
<TextBlock Text="{Binding Value[0].Length, StringFormat=N0}"
Margin="5" FontWeight="Bold"/>
<TextBlock Text="{Binding Key, StringFormat=X}"
Margin="5" FontWeight="Bold" HorizontalAlignment="Right"/>
<ItemsControl ItemsSource="{Binding Value}" Grid.Row="1"
HorizontalAlignment="Stretch"
ScrollViewer.HorizontalScrollBarVisibility="Disabled"
Background="Aquamarine">
<ItemsControl.ItemTemplate>
<DataTemplate>
<TextBlock Text="{Binding FullName}" Margin="15,0"  />
</DataTemplate>
</ItemsControl.ItemTemplate>
</ItemsControl>
</Grid>
</DataTemplate>
</ItemsControl.ItemTemplate>
</ItemsControl>
</ScrollViewer>
<StackPanel Grid.Row="1" Orientation="Horizontal">
<TextBlock x:Name="TotalFilesText" Margin="5,0" VerticalAlignment="Center"/>
<TextBlock x:Name="LengthFilesText" Margin="5,0" VerticalAlignment="Center"/>
</StackPanel>
</Grid>
</Grid>
```

In the button’s click event handler, we will open a Folder browser dialog and, if the user selects a folder, we will process it, enumerating the files and  finding the ones that have the same size. Then, we calculate the Crc32 for these files and add them to a dictionary, grouped by hash:

```private async void StartClick(object sender, RoutedEventArgs e)
{
var fbd = new WPFFolderBrowserDialog();
if (fbd.ShowDialog() != true)
return;
FilesList.ItemsSource = null;
var selectedPath = fbd.FileName;

var files = await GetPossibleDuplicatesAsync(selectedPath);
FilesList.ItemsSource = await GetRealDuplicatesAsync(files);
}
```

The GetPossibleDuplicatesAsync will enumerate the files and group them by size, returning only the groups that have more than one file:

```private async Task<List<IGrouping<long, FileInfo>>> GetPossibleDuplicates(string selectedPath)
{
List<IGrouping<long, FileInfo>> files = null;
{
files = GetFilesInDirectory(selectedPath)
.OrderByDescending(f => f.Length)
.GroupBy(f => f.Length)
.Where(g => g.Count() > 1)
.ToList();
});
return files;
}
```

GetFilesInDirectory enumerates the files in the selected directory:

```private List<FileInfo> GetFilesInDirectory(string directory)
{
var files = new List<FileInfo>();
try
{
var directories = Directory.GetDirectories(directory);
try
{
var di = new DirectoryInfo(directory);
}
catch
{
}
foreach (var dir in directories)
{
}
}
catch
{
}

return files;
}
```

After we have the duplicate files grouped, we can search the real duplicates with GetRealDuplicatesAsync:

```private static async Task<Dictionary<uint,List<FileInfo>>> GetRealDuplicatesAsync(
List<IGrouping<long, FileInfo>> files)
{
var dictFiles = new Dictionary<uint, List<FileInfo>>();
{
foreach (var file in files.SelectMany(g => g))
{
var hash = GetCrc32FromFile(file.FullName);
if (hash == 0)
continue;
if (dictFiles.ContainsKey(hash))
else
dictFiles.Add(hash, new List<FileInfo>(new[] { file }));
}
});
return dictFiles.Where(p => p.Value.Count > 1).ToDictionary(p => p.Key, p => p.Value);
}

```

The GetCrc32FromFile method with use the Crc32C library to compute the Crc32 hash from the file. Note that we can’t compute the hash in one pass, by reading the whole file, as this will fail with files with more than 2Gb. So, we read chunks of 10,000 bytes and process them.

```public static uint GetCrc32FromFile(string fileName)
{
try
{
using (FileStream file = new FileStream(fileName, FileMode.Open))
{
const int NumBytes = 10000;
var bytes = new byte[NumBytes];
return 0;
var crc = Crc32CAlgorithm.Compute(bytes, 0, numRead);
{
}
return crc;
}
}
catch (Exception ex) when (ex is UnauthorizedAccessException || ex is IOException)
{
return 0;
}
}
```

Now, when you run the app, you will get something like this:

You can then verify the files you want to remove and then go to Explorer and remove them. But there is one thing to do here: the time to compute the hash is very large, especially if you have a lot of data to process (large files, large number of files or both). Could it be improved?

This issue is somewhat complicated to solve. Fortunately, .NET provide us with an excellent tool to improve performance in this case: Parallel programming. By making a small change in the code, you can calculate the CRC of the files in parallel, thus improving the performance. But there is a catch: we are using classes that are not thread safe. If you use the common Dictionary and List to store the data, you will end up with wrong results. But, once again, .NET comes to rescue us: it provides the ConcurrentDictionary and ConcurrentBag to replace the common classes, so we can store the data in a thread safe way. We can then change the code to this:

```private static async Task<Dictionary<uint, List<FileInfo>>> GetRealDuplicatesAsync(
List<IGrouping<long, FileInfo>> files)
{
var dictFiles = new ConcurrentDictionary<uint, ConcurrentBag<FileInfo>>();
{
Parallel.ForEach(files.SelectMany(g => g), file =>
{
var hash = GetCrc32FromFile(file.FullName);
if (hash != 0)
{
if (dictFiles.ContainsKey(hash))
else
dictFiles.TryAdd(hash, new ConcurrentBag<FileInfo>(new[] { file }));
}
});
});
return dictFiles.Where(p => p.Value.Count > 1)
.OrderByDescending(p => p.Value.First().Length)
.ToDictionary(p => p.Key, p => p.Value.ToList());
}
```

When we do that and run our program again, we will see that more CPU is used for the processing and the times to get the list come to 46 seconds from 78 seconds (for 18GB of duplicate files).

## Conclusions

With this program, we can show the largest duplicates in a folder and see what can be safely deleted in our disk, thus retrieving some space (in our case, we would have potentially got 9Gb extra). We’ve done some optimization in the code by parallelizing the calculations using the parallel extensions in .NET.

Sometimes, you need to parse some html data to do some processing and present it to the user. That may be a daunting task, as some pages can become very complex and it may be difficult to do it.

For that, you can use an excellent tool, named HTML Agility Pack. With it, you can parse HTML from a string, a file, a web site or even from a WebBrowser: you can add a WebBrowser to your app, navigate to an URL and parse the data from there.

In this article, I’ll show how to make a query in Bing, retrieve and parse the response. For that, we need to create the query url and pass it to Bing. You may ask why I’m querying Bing and not Google – I’m doing that because Google makes it difficult to get its data, and I want to show you how to use HTML Agility Pack, and not how to retrieve data from Google :-). The query should be something like this:

`https://www.bing.com/search?q=html+agility+pack&count=100`

We will use the Query (q) and the number of results (count) parameters. With them, we can create our program. We will create a WPF program that gets the query text, parses it and presents the results in a Listbox.

Create a new WPF program and name it BingSearch.

The next step is to add the HTML Agility Pack to the project. Right-click the References node in the Solution Explorer and select Manage NuGet Packages. Then add the Html Agility Pack to the project.

Then, in the main window, add this XAML code:

```<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="40"/>
<RowDefinition Height="*"/>
</Grid.RowDefinitions>
<StackPanel Grid.Row="0" Orientation ="Horizontal"
Margin="5,0" VerticalAlignment="Center">
<TextBlock Text="Search" VerticalAlignment="Center"/>
<TextBox x:Name="TxtSearch" Width="300" Height="30"
Margin="5,0" VerticalContentAlignment="Center"/>
</StackPanel>
<Button Grid.Row="0" HorizontalAlignment="Right"
Content="Search" Margin="5,0" VerticalAlignment="Center"
Width="65" Height="30" Click="SearchClick"/>
<ListBox Grid.Row="1" x:Name="LbxResults" />
</Grid>
```

Right click in the button’s click event handler in the XAML and press F12 to add the handler in code and go to it. Then, add this code to the handler:

```private async void SearchClick(object sender, RoutedEventArgs e)
{
if (string.IsNullOrWhiteSpace(TxtSearch.Text))
return;
var queryString = WebUtility.UrlEncode(TxtSearch.Text);
var htmlWeb = new HtmlWeb();
var query = \$"https://bing.com/search?q={queryString}&count=100";
var response = doc.DocumentNode.SelectSingleNode("//ol[@id='b_results']");
var results = response.SelectNodes("//li[@class='b_algo']");
if (results == null)
{
LbxResults.ItemsSource = null;
return;
}
var searchResults = new List<SearchResult>();
foreach (var result in results)
{
var refNode = result.Element("h2").Element("a");
var url = refNode.Attributes["href"].Value;
var text = refNode.InnerText;
var description = result.Element("div").Element("p").InnerText;
}
LbxResults.ItemsSource = searchResults;
}```

Initially we encode the text to search to add it to the query and create the query string. Then we call the LoadFromWebAsync method to load the HTML data from the query response. When the response comes, we get the response node, from the ordered list with id b_results and extract from it the individual results. Finally, we parse each result and add it to a list of SearchResult, and assign the list to the items in the ListBox. You can note that we can finde the nodes using XPath, like in

`var results = response.SelectNodes("//li[@class='b_algo']");`

Or we can traverse the elements and get the text of the resulting node with something like:

```var refNode = result.Element("h2").Element("a");
var url = refNode.Attributes["href"].Value;
var text = refNode.InnerText;
var description = WebUtility.HtmlDecode(
result.Element("div").Element("p").InnerText);
```

SearchResult is declared as:

```internal class SearchResult
{
public string Text { get; }
public string Url { get; }
public string Description { get; }

public SearchResult(string text, string url, string description)
{
Text = text;
Url = url;
Description = description;
}
}
```

if you run the program, you will see something like this:

The data isn’t displayed because we haven’t defined any data template for the list items. You can define an item template like that in the XAML:

```<ListBox.ItemTemplate>
<DataTemplate>
<StackPanel Margin="0,3">
<TextBlock Text="{Binding Text}" FontWeight="Bold"/>
<TextBlock >
<TextBlock Text="{Binding Url}"/>
</TextBlock>
<TextBlock Text="{Binding Description}" TextWrapping="Wrap"/>
</StackPanel>
</DataTemplate>
</ListBox.ItemTemplate>```

```private void LinkNavigate(object sender, RequestNavigateEventArgs e)
{
System.Diagnostics.Process.Start(e.Uri.AbsoluteUri);
}
```

Now, when you run the program, you will get something like this:

You can click on the hyperlink and it will open a browser window with the selected page. We can even go further and add a WebBrowser to our app that will show the selected page when you click on an item. For that, you have to modify the XAML code with something like this:

```<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="40"/>
<RowDefinition Height="*"/>
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*"/>
<ColumnDefinition Width="*"/>
</Grid.ColumnDefinitions>
<StackPanel Grid.Row="0" Orientation ="Horizontal"
Margin="5,0" VerticalAlignment="Center">
<TextBlock Text="Search" VerticalAlignment="Center"/>
<TextBox x:Name="TxtSearch" Width="300" Height="30"
Margin="5,0" VerticalContentAlignment="Center"/>
</StackPanel>
<Button Grid.Row="0" HorizontalAlignment="Right"
Content="Search" Margin="5,0" VerticalAlignment="Center"
Width="65" Height="30" Click="SearchClick"/>
<ListBox Grid.Row="1" x:Name="LbxResults"
ScrollViewer.HorizontalScrollBarVisibility="Disabled"
<ListBox.ItemTemplate>
<DataTemplate>
<StackPanel Margin="0,3">
<TextBlock Text="{Binding Text}" FontWeight="Bold"/>
<TextBlock >
<TextBlock Text="{Binding Url}"/>
</TextBlock>
<TextBlock Text="{Binding Description}" TextWrapping="Wrap"/>
</StackPanel>
</DataTemplate>
</ListBox.ItemTemplate>
</ListBox>
<WebBrowser Grid.Column="1" Grid.RowSpan="2" x:Name="WebPage"  />
</Grid>```

We’ve added a second column to the window and added a WebBrwser to it, then added a SelectionChanged event to the listbox, so we can navigate to the selected page.

The SelectionChanged event handler is:

```private void LinkChanged(object sender, SelectionChangedEventArgs e)
{
{
}
}
```

Now, when you run the app and click on a result, it will show the page in the WebBrowser. One thing that happened is that, sometimes a Javascript error pops up. To remove these errors, I used the solution obtained from here:

```public MainWindow()
{
InitializeComponent();
WebPage.Navigated += (s, e) => SetSilent(WebPage, true);
}

public static void SetSilent(WebBrowser browser, bool silent)
{
if (browser == null)
throw new ArgumentNullException("browser");

// get an IWebBrowser2 from the document
IOleServiceProvider sp = browser.Document as IOleServiceProvider;
if (sp != null)
{
Guid IID_IWebBrowserApp = new Guid("0002DF05-0000-0000-C000-000000000046");
Guid IID_IWebBrowser2 = new Guid("D30C1661-CDAF-11d0-8A3E-00C04FC9E26E");

object webBrowser;
sp.QueryService(ref IID_IWebBrowserApp, ref IID_IWebBrowser2, out webBrowser
if (webBrowser != null)
{
webBrowser.GetType().InvokeMember("Silent",
BindingFlags.Instance | BindingFlags.Public |
BindingFlags.PutDispProperty, null, webBrowser,
new object[] { silent });
}
}
}

[ComImport, Guid("6D5140C1-7436-11CE-8034-00AA006009FA"),
InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
private interface IOleServiceProvider
{
[PreserveSig]
int QueryService([In] ref Guid guidService, [In] ref Guid riid,
[MarshalAs(UnmanagedType.IDispatch)] out object ppvObject);
}
```

With this code, the Javascript errors disappear and when you run the app, you will see something like this:

As you can see, the HTML Agility Pack makes it easy to process and parse HTML Pages, allowing you to manipulate them the way you want.

Some time ago I wrote a post about converting a WPF application into .NET Core. One thing that called my attention in this Build 2019 talk was that the performance for file enumerations was enhanced in the .NET core apps. So I decided to check this with my own app and see what happens in my machine.

I added some measuring data in the app, so I could see what happens there:

```private async void StartClick(object sender, RoutedEventArgs e)
{
var fbd = new WPFFolderBrowserDialog();
if (fbd.ShowDialog() != true)
return;
FilesList.ItemsSource = null;
ExtList.ItemsSource = null;
ExtSeries.ItemsSource = null;
AbcList.ItemsSource = null;
AbcSeries.ItemsSource = null;
var selectedPath = fbd.FileName;
Int64 minSize;
if (!Int64.TryParse(MinSizeBox.Text, out minSize))
return;
List<FileInfo> files = null;
var sw = new Stopwatch();
var timeStr = "";
{
sw.Start();
files = GetFilesInDirectory(selectedPath).ToList();
timeStr = \$" {sw.ElapsedMilliseconds} for enumeration";
sw.Restart();
files = files.Where(f => f.Length >= minSize)
.OrderByDescending(f => f.Length)
.ToList();
timeStr += \$" {sw.ElapsedMilliseconds} for ordering and filtering";
});
var totalSize = files.Sum(f => f.Length);
TotalFilesText.Text = \$"# Files: {files.Count}";
LengthFilesText.Text = \$"({totalSize:N0} bytes)";
sw.Restart();
FilesList.ItemsSource = files;
var extensions = files.GroupBy(f => f.Extension)
.Select(g => new { Extension = g.Key, Quantity = g.Count(), Size = g.Sum(f => f.Length) })
.OrderByDescending(t => t.Size).ToList();
ExtList.ItemsSource = extensions;
ExtSeries.ItemsSource = extensions;
var tmp = 0.0;
var abcData = files.Select(f =>
{
tmp += f.Length;
return new { f.Name, Percent = tmp / totalSize * 100 };
}).ToList();
AbcList.ItemsSource = abcData;
AbcSeries.ItemsSource = abcData.OrderBy(d => d.Percent).Select((d, i) => new { Item = i, d.Percent });
timeStr += \$"  {sw.ElapsedMilliseconds} to fill data";
TimesText.Text = timeStr;
}

```

That way, I could measure two things: the time to enumerate the files and the times to sort, filter and assign the files to the lists. Then, I run the two programs, to see what happened.

The machine I’ve run is a Virtual machine with a Core I5 and 4 virtual processors and a virtualized hard disk, with 12,230 files (93.13 GB of data). The measures may vary on your machine, but the differences should be comparable. To avoid bias, I ran 3 times each program (in Admin mode), then rebooted and run the other one.

Here are the results I’ve got:

 Run Enumerate Sort/Filter Assign .NET 1 137031 96 43 2 58828 56 9 3 59474 55 8 Avg 85111 69 20 .NET Core 1 91105 120 32 2 33422 90 14 3 32907 87 20 Avg 52478 99 22

As you can see by the numbers, the .NET Core application improved a lot the times for file enumeration, but still lacks some effort for sorting/filtering and assigning data to the UI lists. But that’s not bad for a platform still in preview!

If you do some testingfor the performance, I’m curious to see what you’ve got, you can put your results and comments in the Comments section.

One thing that I use a lot is sample data. Every article I write needs some data to explain the concepts, I need some data to see how it fits in my designs or even sample data for testing. This is a real trouble, as I must find some reliable data for my programs. Sometimes, I go to databases (Northwind and AdventureWorks are my good friends), sometimes, I use Json or XML data and other times I create the sample data by myself.

None of them are perfect, and it’s not consistent. Every time I get a new way of accessing data (yes, it can be good for learning purposes, but it’s a nightmare for maintenance). Then, looking around, I found Bogus (https://github.com/bchavez/Bogus), It’s a simple data generator for C#. All you have to do is create rules for your data and generate it. Simple as that! Then, you’ve got the data to use in your programs. It can be fixed (every time you run your program, you have the same data) or variable (every time you get a different set of data), and once you got it, you can serialize it to whichever data format you want: json files, databases, xml or plain text files.

## Generating sample data

The first step to generate sample data is to create your classes. Create a new console app and add these two classes:

```public class Customer
{
public Guid Id { get; set; }
public string Name { get; set; }
public string Address { get; set; }
public string City { get; set; }
public string Country { get; set; }
public string ZipCode { get; set; }
public string Phone { get; set; }
public string Email { get; set; }
public string ContactName { get; set; }
public IEnumerable<Order> Orders { get; set; }
}```
```public class Order
{
public Guid Id { get; set; }
public DateTime Date { get; set; }
public Decimal OrderValue { get; set; }
public bool Shipped { get; set; }
}```

Once you’ve got the classes, you can add the repositories to get the sample data. To use the sample data generator, you must add the Bogus NuGet package to your project, with the command Install-Package Bogus, in the package manager console. Then we can add the repository class to retrieve the data. Add a new class to the project and name it SampleCustomerRepository. Then add this code in the class:

```public IEnumerable<Customer> GetCustomers()
{
Randomizer.Seed = new Random(123456);
var ordergenerator = new Faker<Order>()
.RuleFor(o => o.Id, Guid.NewGuid)
.RuleFor(o => o.Date, f => f.Date.Past(3))
.RuleFor(o => o.OrderValue, f => f.Finance.Amount(0, 10000))
.RuleFor(o => o.Shipped, f => f.Random.Bool(0.9f));
var customerGenerator = new Faker<Customer>()
.RuleFor(c => c.Id, Guid.NewGuid())
.RuleFor(c => c.Name, f => f.Company.CompanyName())
.RuleFor(c => c.City, f => f.Address.City())
.RuleFor(c => c.Country, f => f.Address.Country())
.RuleFor(c => c.ZipCode, f => f.Address.ZipCode())
.RuleFor(c => c.Phone, f => f.Phone.PhoneNumber())
.RuleFor(c => c.Email, f => f.Internet.Email())
.RuleFor(c => c.ContactName, (f, c) => f.Name.FullName())
.RuleFor(c => c.Orders, f => ordergenerator.Generate(f.Random.Number(10)).ToList());
return customerGenerator.Generate(100);
}```

In line 3, we have set the Randomizer.Seed to a fixed seed, so the data is always the same for all runs. If we don’t want it, we just don’t need to set it up. Then we set the rules for the order and customer generation. Then we call the Generate method to generate the sample data. Easy as that.

As you can see, the generator has a lot of classes to generate data. For example, the Company  class generates data for the company, like CompanyName. You can use this data as sample data for your programs. I can see some uses for it:

• Test data for unit testing
• Sample data for design purposes
• Sample data for prototypes

but I’m sure you can find some more.

To use the data, you can add this code in the main program:

```static void Main(string[] args)
{
var repository = new SampleCustomerRepository();
var customers = repository.GetCustomers();
Console.WriteLine(JsonConvert.SerializeObject(customers,
Formatting.Indented));
}```

We are serializing the data to Json, so you must add the Newtonsoft.Json Nuget package to your project. When you run this project, you will see something like this:

As you can see, it generated a whole set of customers with their orders, so you can use in your programs.

You may say that this is just dummy data, it will be cluttering your project, and it this data will remain unused when the program goes to production, and you’re right. But that’s not the way I would recommend to use this kind of data. It is disposable and will clutter the project. So, a better way would be create another project, a class library with the repository. That solves one problem, the maintenance one. When entering in production, you replace the sample dll with the real repository and you’re done. Or no? Not too fast. If you see the code in the main program, you will see that we are instantiating an instance of the SampleCustomerRepository, that won’t exist anymore. That way, you must also change the code for the main program. Not a good solution.

You can use conditional compilation to instantiate the repository you want, like this:

```        static void Main(string[] args)
{
#if SAMPLEREPO
var repository = new SampleCustomerRepository();
#else
var repository = new CustomerRepository();
#endif
var customers = repository.GetCustomers();
Console.WriteLine(JsonConvert.SerializeObject(customers,
Formatting.Indented));
}```

That’s better, but still not optimal: you need to compile the program twice: one time to use the sample data and the other one for going to production. With automated builds that may be less than a problem, but if you need to deploy by yourself, it can be a nightmare.

The solution? Dependency injection. Just create an interface for the repository, use a dependency injection framework (I like to use Unity or Ninject, but there are many others out there, just check this list). That way, the code will be completely detached from the data and you won’t need to recompile the project to use this or that data. Just add the correct dll and you are using the data you want. This is a nice approach, but the topic gives space for another post, just wait for it!

Once upon a time, in the old days, when WPF was a little new baby and people needed a tool to fiddle around with the new design language, Microsoft released a tool named XAMLPad, and things were all good: you didn’t need Visual Studio to try your designs, you could learn XAML without having to start a new project and you could try as much as you wanted, the UI changed as you changed the XAML code.

Then, time has passed. WPF is old news, many new XAML platforms appeared and XAMLPad faded out and all that remained from it was an old page.

Although it was not there, the need remained: how to do quick tests on your XAML? How to do them for the new platforms, like UWP? Then, a Microsoft Engineer decided to revive this and XAML Studio was born.

XAML Studio is a UWP app that allows you to fiddle with the XAML code in UWP and even debug the bindings! You can get the app from the Windows Store and install it in your machine for free.

Once you install and open it, you will get a window like this:

The app has a tabbed interface and you can create a new page and start typing your code. When you create a new page, a new tab will open, like this one:

You can start changing things immediately and the changes will reflect on the top pane. For example, if you change the color of the first run of text to Navy, the top pane will reflect that. If  you make a typing mistake, a pink box will be shown in the top pane, indicating the compilation error:

The last icon in the navigation bar is the toolbox. When you select it, you will have all available components to insert in your code. You can filter the items you want by typing in the search box at the top:

In this post, I’ve shown how to use the NavigationView in UWP. With XAML Studio, we don’t need to use Visual Studio to test the code, we can just type it in the code window and the UI will be shown in the top pane. If you type something like:

```<Page
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"
mc:Ignorable="d" xmlns:winui="using:Microsoft.UI.Xaml.Controls">
<TextBlock>
<Run FontSize="24" Foreground="Navy">Get Started with XAML Studio</Run><LineBreak/>
<Run> Modify this text below to see a live preview.</Run>
</TextBlock>
</Grid>
</Page>```

You will get something like this:

You can even use controls from Telerik or from the Microsoft Community Toolkit. For example, if you want to add a Radial Gauge to your UI, you can use something like this:

```<Page
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"
mc:Ignorable="d" xmlns:winui="using:Microsoft.UI.Xaml.Controls"
xmlns:controls="using:Microsoft.Toolkit.Uwp.UI.Controls">
<Grid.RowDefinitions>
<RowDefinition Height="Auto" />
<RowDefinition Height="*" />
</Grid.RowDefinitions>
<TextBlock>
<Run FontSize="24" Foreground="Navy">Get Started with XAML Studio</Run><LineBreak/>
<Run> Modify this text below to see a live preview.</Run>
</TextBlock>
TrailBrush="Green"
Grid.Row="1" Width="200"
Height="200" Foreground="Green"/>
</Grid>
</Page>```

One thing very interesting that can be done is to use data bindings in your code. You can create a Json Data Source or use a remote data source to bind to your data. For example, if you go to the second icon (Data Source) and add something like this:

```{
'Title' : 'Using XAML Studio',
'Subtitle' : 'By Bruno Sonnino',
'GaugeValue' : 35,
'GaugeUnit' : 'km/h',
'GaugeNeedle' : 'DarkGreen'
}```

You can bind to your code with something like this:

```<Page
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"
mc:Ignorable="d" xmlns:winui="using:Microsoft.UI.Xaml.Controls"
xmlns:controls="using:Microsoft.Toolkit.Uwp.UI.Controls">
<Grid.RowDefinitions>
<RowDefinition Height="Auto" />
<RowDefinition Height="*" />
</Grid.RowDefinitions>
<TextBlock>
<Run FontSize="24" Foreground="Navy" Text="{Binding Title}"/><LineBreak/>
<Run Text="{Binding Subtitle}"/>
</TextBlock>
NeedleBrush="{Binding GaugeNeedle}"
TrailBrush="Green"
Grid.Row="1" Width="200"
Height="200" Foreground="Green"/>
</Grid>
</Page>```

You can also bind to a remote data source, using an URL to a JSON service. For example, we can bind to the European Currency Exchange service to get the quotes of the currencies against the Euro. Just go to the Data Source option and select the Remote Data Source and enter this URL:

`https://api.exchangeratesapi.io/latest`

Then you can show the values for the currencies in a DataGrid with this code:

```<Page
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"
mc:Ignorable="d" xmlns:controls="using:Microsoft.Toolkit.Uwp.UI.Controls">
<Grid.RowDefinitions>
<RowDefinition Height="Auto" />
<RowDefinition Height="*" />
</Grid.RowDefinitions>
<StackPanel Orientation="Horizontal" Margin="0,10">
<TextBlock Text="Base" Margin="5,0"/>
<TextBlock Text="{Binding base}" Margin="5,0"/>
<TextBlock Text="Date" Margin="5,0"/>
<TextBlock Text="{Binding date}" Margin="5,0"/>
</StackPanel>
<controls:DataGrid ItemsSource="{Binding rates}" Grid.Row="1"/>
</Grid>
</Page>```

One nice feature is that you can debug your bindings. In the code window, you can notice a green background in the bindings. If you hover the mouse in the binding, it will show you the current value:

When you go to the third menu item (Debug Bindings), you can even get more information, like the history for the binding or the values for all bindings at once:

## Conclusions

As you can see XAML Studio has a lot of features for who wants to try some XAML code or even learn XAML. You don’t need to fire Visual Studio to test your XAML code and see what happens if you change something. It’s still a work in progress and has a lot of room for improvement, but with no doubt it’s a very nice tool to have in your toolbox.

Many times I need to enumerate the files in my disk or in a folder and subfolders, but that always has been slow. All the file enumeration techniques go through the disk structures querying the file names and going to the next one. With the Windows file indexing, this has gone to another level of speed: you can query and filter your data almost instantaneously, with one pitfall: it only works in the indexed parts of the disk (usually the libraries and Windows folders), being unusable for your data folders, unless you add them to the indexer:

Wouldn’t it be nice to have a database that stores all files in the system and is updated as the files change? Some apps, like Copernic Desktop Search or X1 Search do exactly that: they have a database that indexes your system and can do fast queries for you. The pitfall is that you don’t have an API to integrate to your programs, so the only way you have is to query the files is to use their apps.

At some time, Microsoft thought of doing something like a database of files, creating what was called WinFS – Windows Future Storage, but the project was cancelled. So, we have to stick with our current APIs to query files. Or no? As a matter of fact there is something in the Windows system that allows us to query the files in a very fast way, and it’s called the NTFS MFT (NT file system master file table).

The NTFS MFT is a file structure use internally by Windows that allows querying files in a very fast way. It was designed to be fast and safe (there are two copies of the MFT, in case one of them gets corrupt), and we can access it to get our files enumerated. But some things should be noted when accessing the MFT:

• The MFT is only available for NTFS volumes. So, you cannot access FAT drives with this API
• To access the MFT structures, you must have elevated privileges – a normal user won’t be able to access it
• With great power comes great responsibility (this is a SpiderMan comic book quote), so you should know that accessing the internal NTFS structures may harm you system irreversively – use the code with care, and don’t blame me if something goes wrong (but here’s a suggestion to Windows API designers: why not create some APIs that query the NTFS structures safely for normal users? That could be even be added to UWP programming).

## Acessing the MFT structure

There is no formal API to access the MFT structure. You will have to decipher the structure (there is a lot of material here) and access the data using raw disk data read (that’s why you need elevated privileges). This is a lot of work and hours of trial and error.

Fortunately, there are some libraries that do that in C#, and I’ve used this one, which is licensed as LGPL. You can use the library in your compiled work as a library, with no restriction. If you include the library source code in your code, it will be “derived work” and you must distribute all code as LGPL.

We will create a WPF program that will show the disk usage. It will enumerate all files and show them in the list, so you can see what’s taking space in your disk. You will be able to select any of the NTFS disks in your machine.

Open Visual Studio with administrative rights (this is very important, or you won’t be able to debug your program). Then create a new WPF project and add a new item. Choose Application Manifest File, you will have an app.manifest file added to your project. Then, you must change the requestedExecutionLevel tag of the file to:

`<requestedExecutionLevel level="requireAdministrator" uiAccess="false" />`

The next step is to detect the NTFS disks in your system. This is done with this code:

```var ntfsDrives = DriveInfo.GetDrives()
.Where(d => d.DriveFormat == "NTFS").ToList();```

Then, add the NtfsReader project to the solution and add a reference to it in the WPF project. Then, add the following UI in MainWindow.xaml.cs:

```<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="40"/>
<RowDefinition Height="*"/>
<RowDefinition Height="30"/>
</Grid.RowDefinitions>
<StackPanel Orientation="Horizontal" Margin="5">
<TextBlock Text="Drive" VerticalAlignment="Center"/>
<ComboBox x:Name="DrvCombo" Margin="5,0" Width="100"
VerticalContentAlignment="Center"/>
</StackPanel>
<ListBox x:Name="FilesList" Grid.Row="1"
VirtualizingPanel.IsVirtualizing="True"
VirtualizingPanel.IsVirtualizingWhenGrouping="True"
>
<ListBox.ItemTemplate>
<DataTemplate>
<StackPanel Orientation="Horizontal">
<TextBlock Text="{Binding FullName}"
Margin="5,0" Width="450"/>
<TextBlock Text="{Binding Size,StringFormat=N0}"
Margin="5,0" Width="150" TextAlignment="Right"/>
<TextBlock Text="{Binding LastChangeTime, StringFormat=g}"
Margin="5,0" Width="200"/>
</StackPanel>
</DataTemplate>
</ListBox.ItemTemplate>
</ListBox>
<TextBlock x:Name="StatusTxt" Grid.Row="2" HorizontalAlignment="Center" Margin="5"/>
</Grid>```

We will have a combobox with all drives in the first row and a listbox with the files. The listbox has an ItemTemplate that will show the name, size and date of last change of each file. To fill this data, you will have to add this code in MainWindow.xaml.cs:

```public MainWindow()
{
InitializeComponent();
var ntfsDrives = DriveInfo.GetDrives()
.Where(d => d.DriveFormat == "NTFS").ToList();
DrvCombo.ItemsSource = ntfsDrives;
DrvCombo.SelectionChanged += DrvCombo_SelectionChanged;
}

private void DrvCombo_SelectionChanged(object sender,
System.Windows.Controls.SelectionChangedEventArgs e)
{
if (DrvCombo.SelectedItem != null)
{
var driveToAnalyze = (DriveInfo) DrvCombo.SelectedItem;
var nodes =
.Where(n => (n.Attributes &
(Attributes.Hidden | Attributes.System |
Attributes.Temporary | Attributes.Device |
Attributes.Directory | Attributes.Offline |
Attributes.ReparsePoint | Attributes.SparseFile)) == 0)
.OrderByDescending(n => n.Size);
FilesList.ItemsSource = nodes;
}
}```

It gets all NTFS drives in your system and fills the combobox. In the SelectionChanged event handler, the reader gets all nodes in the drive. These nodes are filtered to remove all that are not normal files and then ordered descending by size and added to the listbox.

If you run the program you will see some things:

• If you look at the output window in Visual Studio, you will see these debug messages:
```1333.951 MB of volume metadata has been read in 26.814 s at 49.748 MB/s
1324082 nodes have been retrieved in 2593.669 ms```

This means that it took 2.6s to read and analyze all files in the disk (pretty fast for 1.3 million files, no?).

• When you change the drive in the combobox, the program will freeze for some time and the list will be filled with the files. The freezing is due to the fact that you are blocking the main thread while you are analyzing the disk. To avoid this, you should run the code in a secondary thread, like this code:
```private async void DrvCombo_SelectionChanged(object sender,
System.Windows.Controls.SelectionChangedEventArgs e)
{
if (DrvCombo.SelectedItem != null)
{
var driveToAnalyze = (DriveInfo) DrvCombo.SelectedItem;
DrvCombo.IsEnabled = false;
StatusTxt.Text = "Analyzing drive";
List<INode> nodes = null;
{
nodes =
.Where(n => (n.Attributes &
(Attributes.Hidden | Attributes.System |
Attributes.Temporary | Attributes.Device |
Attributes.Directory | Attributes.Offline |
Attributes.ReparsePoint | Attributes.SparseFile)) == 0)
.OrderByDescending(n => n.Size).ToList();
});
FilesList.ItemsSource = nodes;
DrvCombo.IsEnabled = true;
StatusTxt.Text = \$"{nodes.Count} files listed. " +
\$"Total size: {nodes.Sum(n => (double)n.Size):N0}";
}
}
```

This code creates a task and runs the analyzing code in it, and doesn’t freeze the UI. I just took care of disabling the combobox and putting a warning for the user. After the code is run, the nodes list is assigned to the listbox and the UI is re-enabled.

This code can show you the list of the largest files in your disk, but you may want to analyze it by other ways, like grouping by extension or by folder. WPF has an easy way to group and show data: the CollectionViewSource. With it, you can do grouping and sorting in the ListBox. We will change our UI to add a new ComboBox to show the new groupings:

```<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="40"/>
<RowDefinition Height="*"/>
<RowDefinition Height="30"/>
</Grid.RowDefinitions>
<StackPanel Orientation="Horizontal" Margin="5">
<TextBlock Text="Drive" VerticalAlignment="Center"/>
<ComboBox x:Name="DrvCombo" Margin="5,0" Width="100"
VerticalContentAlignment="Center"/>
</StackPanel>
<StackPanel Grid.Row="0" HorizontalAlignment="Right" Orientation="Horizontal" Margin="5">
<TextBlock Text="Sort" VerticalAlignment="Center"/>
<ComboBox x:Name="SortCombo" Margin="5,0" Width="100"
VerticalContentAlignment="Center" SelectedIndex="0"
SelectionChanged="SortCombo_OnSelectionChanged">
<ComboBoxItem>Size</ComboBoxItem>
<ComboBoxItem>Extension</ComboBoxItem>
<ComboBoxItem>Folder</ComboBoxItem>
</ComboBox>
</StackPanel>
<ListBox x:Name="FilesList" Grid.Row="1"
VirtualizingPanel.IsVirtualizing="True"
VirtualizingPanel.IsVirtualizingWhenGrouping="True" >
<ListBox.ItemTemplate>
<DataTemplate>
<StackPanel Orientation="Horizontal">
<TextBlock Text="{Binding FullName}"
Margin="5,0" Width="450"/>
<TextBlock Text="{Binding Size,StringFormat=N0}"
Margin="5,0" Width="150" TextAlignment="Right"/>
<TextBlock Text="{Binding LastChangeTime, StringFormat=g}"
Margin="5,0" Width="200"/>
</StackPanel>
</DataTemplate>
</ListBox.ItemTemplate>
<ListBox.GroupStyle>
<GroupStyle>
<DataTemplate>
<StackPanel Orientation="Horizontal">
<TextBlock Text="{Binding Name}" FontSize="15" FontWeight="Bold"
Margin="5,0"/>
<TextBlock Text="(" VerticalAlignment="Center" Margin="5,0,0,0" />
<TextBlock Text="{Binding Items.Count}" VerticalAlignment="Center"/>
<TextBlock Text=" files - " VerticalAlignment="Center"/>
<TextBlock Text="{Binding Items,
Converter={StaticResource ItemsSizeConverter}, StringFormat=N0}"
VerticalAlignment="Center"/>
<TextBlock Text=" bytes)" VerticalAlignment="Center"/>
</StackPanel>
</DataTemplate>
</GroupStyle>
</ListBox.GroupStyle>
</ListBox>
<TextBlock x:Name="StatusTxt" Grid.Row="2" HorizontalAlignment="Center" Margin="5"/>
</Grid>```

The combobox has three options, Size, Extension and Folder. The first one is the same thing we’ve had until now; the second will group the files by extension and the third will group the files by top folder. We’ve also added a GroupStyle to the listbox. If we don’t do that, the data will be grouped, but the groups won’t be shown. If you notice the GroupStyle, you will see that we’re adding the name, then the count of the items (number of files in the group), then we have a third TextBox where we pass the Items and a converter. That’s because we want to show the total size in bytes of the group. For that, I’ve created a converter that converts the Items in the group to the sum of the bytes of the file:

```public class ItemsSizeConverter : IValueConverter
{
public object Convert(object value, Type targetType, object parameter,
CultureInfo culture)
{
var items = value as ReadOnlyObservableCollection<object>;
return items?.Sum(n => (double) ((INode)n).Size);
}

public object ConvertBack(object value, Type targetType, object parameter,
CultureInfo culture)
{
throw new NotImplementedException();
}
}```

The code for the SelectionChanged for the sort combobox is:

```private void SortCombo_OnSelectionChanged(object sender,
SelectionChangedEventArgs e)
{
if (_view == null)
return;
_view.GroupDescriptions.Clear();
_view.SortDescriptions.Clear();
switch (SortCombo.SelectedIndex)
{
case 1:
new FileExtConverter()));
break;
case 2:
ListSortDirection.Ascending));
new FilePathConverter()));
break;
}
}```

We add GroupDescriptions for each kind of group. As we don’t have the extension and top path properties in the nodes shown in the listbox, I’ve created two converters to get these from the full name. The converter that gets the extension from the name is:

```class FileExtConverter : IValueConverter
{
public object Convert(object value, Type targetType, object parameter,
CultureInfo culture)
{
var fileName = value as string;
return string.IsNullOrWhiteSpace(fileName) ?
null :
Path.GetExtension(fileName).ToLowerInvariant();
}

public object ConvertBack(object value, Type targetType, object parameter,
CultureInfo culture)
{
throw new NotImplementedException();
}
}```

The converter that gets the top path of the file is:

```class FilePathConverter :IValueConverter
{
public object Convert(object value, Type targetType, object parameter,
CultureInfo culture)
{
var fileName = value as string;
return string.IsNullOrWhiteSpace(fileName) ?
null :
GetTopPath(fileName);
}

private string GetTopPath(string fileName)
{
var paths = fileName.Split(Path.DirectorySeparatorChar).Take(2);
return string.Join(Path.DirectorySeparatorChar.ToString(), paths);
}

public object ConvertBack(object value, Type targetType, object parameter,
CultureInfo culture)
{
throw new NotImplementedException();
}
}```

One last thing is to create the _view field, when we are filling the listbox:

``` private async void DrvCombo_SelectionChanged(object sender,
System.Windows.Controls.SelectionChangedEventArgs e)
{
if (DrvCombo.SelectedItem != null)
{
var driveToAnalyze = (DriveInfo) DrvCombo.SelectedItem;
DrvCombo.IsEnabled = false;
StatusTxt.Text = "Analyzing drive";
List<INode> nodes = null;
{
nodes =
.Where(n => (n.Attributes &
(Attributes.Hidden | Attributes.System |
Attributes.Temporary | Attributes.Device |
Attributes.Directory | Attributes.Offline |
Attributes.ReparsePoint | Attributes.SparseFile)) == 0)
.OrderByDescending(n => n.Size).ToList();
});
FilesList.ItemsSource = nodes;
_view = (CollectionView)CollectionViewSource.GetDefaultView(FilesList.ItemsSource);

DrvCombo.IsEnabled = true;
StatusTxt.Text = \$"{nodes.Count} files listed. " +
\$"Total size: {nodes.Sum(n => (double)n.Size):N0}";
}
else
{
_view = null;
}
}```

With all these in place, you can run the app and get a result like this:

## Conclusions

As you can see, there is a way to get fast file enumeration for your NTFS disks, but you must have admin privileges to use it. We’ve created a WPF program that uses this kind of enumeration and allows you to group the data in different ways, using the WPF resources. If you need to enumerate  your files very fast, you can consider this way to do it.

One thing that has been recently announced by Microsoft is the availability of .NET Core 3. With it, you will be able to create WPF and Winforms apps with .NET Core. And one extra bonus is that both WPF and Winforms are being open sourced. You can check these in https://github.com/dotnet/wpf and https://github.com/dotnet/winforms.

The first step to create a .NET Core WPF program is to download the .NET Core 3.0 preview from https://dotnet.microsoft.com/download/dotnet-core/3.0. Once you have it installed, you can check that it was installed correctly by open a Command Line window and typing dotnet –info and seeing the installed version:

:

With that in place, you can change the current folder to a new folder and type

```dotnet new wpf
dotnet run```

This will create a new .NET Core 3.0 WPF project and will compile and run it. You should get something like this:

If you click on the Exit button, the application exits. If you take a look at the folder, you will see that it generated the WPF project file, App.xaml and App.xaml.cs, MainWindow.xaml and MainWindow.xaml.cs. The easiest way to edit these files is to use Visual Studio Code. Just open Visual Studio Code and go to menu File/Open Folder and open the folder for the project. There you will see the project files and will be able to run and debug your code:

A big difference can be noted in the csproj file. If you open it, you will see something like this:

```<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">

<PropertyGroup>
<OutputType>WinExe</OutputType>
<TargetFramework>netcoreapp3.0</TargetFramework>
<UseWPF>true</UseWPF>
</PropertyGroup>

</Project>```

That’s very simple and there’s nothing else in the project file. There are some differences between this project and other types of .NET Core, like the console one:

• The output type is WinExe, and not Exe, in the console app
• The UseWPF clause is there and it’s set to true

Now, you can modify and run the project inside VS Code. Modify MainWindow.xaml and put this code in it:

```<Window x:Class="DotNetCoreWPF.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:DotNetCoreWPF" mc:Ignorable="d" Title="MainWindow" Height="450" Width="800">
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="*"/>
<RowDefinition Height="40"/>
</Grid.RowDefinitions>
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="40"/>
<RowDefinition Height="40"/>
<RowDefinition Height="40"/>
<RowDefinition Height="40"/>
<RowDefinition Height="40"/>
<RowDefinition Height="40"/>
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*"/>
<ColumnDefinition Width="2*"/>
</Grid.ColumnDefinitions>

<TextBlock Text="Id"      Grid.Column="0" Grid.Row="0" Margin="5" VerticalAlignment="Center"/>
<TextBlock Text="Name"    Grid.Column="0" Grid.Row="1" Margin="5" VerticalAlignment="Center"/>
<TextBlock Text="Address" Grid.Column="0" Grid.Row="2" Margin="5" VerticalAlignment="Center"/>
<TextBlock Text="City"    Grid.Column="0" Grid.Row="3" Margin="5" VerticalAlignment="Center"/>
<TextBlock Text="Email"   Grid.Column="0" Grid.Row="4" Margin="5" VerticalAlignment="Center"/>
<TextBlock Text="Phone"   Grid.Column="0" Grid.Row="5" Margin="5" VerticalAlignment="Center"/>
<TextBox Grid.Column="1" Grid.Row="0" Margin="5"/>
<TextBox Grid.Column="1" Grid.Row="1" Margin="5"/>
<TextBox Grid.Column="1" Grid.Row="2" Margin="5"/>
<TextBox Grid.Column="1" Grid.Row="3" Margin="5"/>
<TextBox Grid.Column="1" Grid.Row="4" Margin="5"/>
<TextBox Grid.Column="1" Grid.Row="5" Margin="5"/>
</Grid>
<Button Content="Submit" Width="65" Height="35" Grid.Row="1" HorizontalAlignment="Right" VerticalAlignment="Center" Margin="5,0"/>
</Grid>
</Window>```

Now, you can compile and run the app in VS Code with F5, and you will get something like this:

If you don’t want to use Visual Studio Code, you can edit your project in Visual Studio 2019. The first preview still doesn’t have a visual editor for the XAML file, but you can edit the XAML file in the editor, it will work fine.

## Porting a WPF project to .NET Core

To port a WPF project to .NET Core, you should run the Portability Analyzer tool first, to see what problems you will find before porting it to .NET Core. This tool can be found here. You can download it and run on your current application, and check what APIs that are not portable.

I will be porting my DiskAnalisys project. This is a simple project, that uses the File.IO functions to enumerate the files in a folder and uses two NuGet packages to add a Folder Browser and Charts to WPF. The first step is to run the portability analysis on it. Run the PortabilityAnalizer app and point it to the folder where the executable is located:

When you click on the Analyze button, it will analyze the executable and generate an Excel spreadsheet with the results:

As you can see, all the code is compatible with .NET Core 3.0. So, let’s port it to .NET Core 3.0. I will show you three ways to do it: creating a new project, updating the .csproj file and using a tool.

## Upgrading by Creating a new project

This way needs the most work, but it’s the simpler to fix. Just create a new folder and name it DiskAnalysisCorePrj. Then open a command line window and change the directory to the folder you’ve created. Then, type these commands:

```dotnet new wpf
dotnet run```

These commands will create the WPF project, add the two required NuGet packages and run the default app. You may see a warning like this:

```D:\Documentos\Artigos\Artigos\CSharp\WPFCore\DiskAnalysisCorePrj\DiskAnalysisCorePrj.csproj : warning NU1701: Package 'DotNetProjects.Wpf.Toolkit 5.0.43' was restored using '.NETFramework,Version=v4.6.1' instead of the project target framework '.NETCoreApp,Version=v3.0'. This package may not be fully compatible with your project.
D:\Documentos\Artigos\Artigos\CSharp\WPFCore\DiskAnalysisCorePrj\DiskAnalysisCorePrj.csproj : warning NU1701: Package 'WPFFolderBrowser 1.0.2' was restored using '.NETFramework,Version=v4.6.1' instead of the project target framework '.NETCoreApp,Version=v3.0'. This package may not be fully compatible with your project.
D:\Documentos\Artigos\Artigos\CSharp\WPFCore\DiskAnalysisCorePrj\DiskAnalysisCorePrj.csproj : warning NU1701: Package 'DotNetProjects.Wpf.Toolkit 5.0.43' was restored using '.NETFramework,Version=v4.6.1' instead of the project target framework '.NETCoreApp,Version=v3.0'. This package may not be fully compatible with your project.
D:\Documentos\Artigos\Artigos\CSharp\WPFCore\DiskAnalysisCorePrj\DiskAnalysisCorePrj.csproj : warning NU1701: Package 'WPFFolderBrowser 1.0.2' was restored using '.NETFramework,Version=v4.6.1' instead of the project target framework '.NETCoreApp,Version=v3.0'. This package may not be fully compatible with your project.```

This means that the NuGet packages weren’t converted to .NET Core 3.0, but they are still usable (remember, the compatibility report showed 100% compatibility). Then, copy MainWindow.xaml and MainWindow.xaml.cs from the original folder to the new one. We don’t need to copy any other files, as no other files were changed. Then, type

`dotnet run`

and the program is executed:

## Converting by Changing the .csproj file

This way is very simple, just changing the project file, but can be challenging, especially for very large projects. Just create a new folder and name it DiskAnalysisCoreCsp. Copy all files from the main folder of the original project (there’s no need of copying the Properties folder) and edit the .csproj file, changing it to:

```<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
<PropertyGroup>
<OutputType>WinExe</OutputType>
<TargetFramework>netcoreapp3.0</TargetFramework>
<UseWPF>true</UseWPF>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="dotnetprojects.wpf.toolkit" Version="5.0.43" />
<PackageReference Include="wpffolderbrowser" Version="1.0.2" />
</ItemGroup>
</Project>```

Then, type

`dotnet run`

and the program is executed.

## Converting using a tool

The third way is to use a tool to convert the project. You must install the conversion extension created by Brian Lagunas, from here. Then, open your WPF project in Visual Studio, right-click in the project and select “Convert Project to .NET Core 3”.

That’s all. You now have a NET Core 3 app. If you did that in Visual Studio 2017, you won’t be able to open the project, you will need to compile it with dotnet run, or open it in Visual Studio code.

## Conclusions

As you can see, although this is the first preview of WPF .NET Core, it has a lot of work done, and you will be able to port most of your WPF projects to .NET Core.

In a previous post, I’ve shown how to publish your Delphi app to the Windows Store. If it is a paid app, you can start getting money with it as soon as it starts to sell. But sometimes, you don’t want to make it a paid app, but you still want to earn money with it.

One way to do it is to do the same that many games do: to use In-app purchases. You can offer a free basic version and put some paid add-ins in the app, so the user must pay to get the premium features. Even if it’s a paid app, you can also give the user a trial period, so, the user can use the premium version for some time and then, if he doesn’t want to pay for the app, he can still use the basic features.

Delphi 10.3 introduced a new component, TWindowsStore, that allows you to control the store features (add-ins, trial version) and enable or disable features depending on what the user pays. In this article, I will show how to use the TWindowsStore component to control the features and set the In-app purchases.

We will use the same Financial Calculator we’ve used in the previous article, but we’ll do some changes:

• The basic calculator will be able to calculate only the Present Value of the investment. The other calculators won’t be available.
• The user will have a trial period where all the calculators are available. Once the trial period is expired, the app will revert to the basic version
• The user will be able to buy calculators as add-in purchases. He won’t need to buy all, he will be able to buy just the ones he needs as add-in purchases.

## Developing the trial and in-app purchases

The first step in the development of the trial version is to add a TWindowsStore component in the main window of the calculator. Then, we will change the app to show the basic features for the app. To do this, change the PageIndex of the calculators:

• Present Value – 0
• Future Value – 1
• Payments – 2
• Return Rate – 3

Put a panel with a button over each calculator, except the first one, with this text: “To open this calculator, click on the button”. Change the ParentBackground property to false. Add another TabSheet, with a label with a caption with text “Trial version – % days remaining”. If you run the app, you should have something like this:

Now, let’s program the trial version. When the user is in trial period, he will be able to use all calculators. To do that, we’ll do something like this:

```procedure TForm1.CheckIfTrial;
begin
Label21.Caption := Format(Label21.Caption, [RemainingDays]);
EnableFullVersion;
end
end
else begin
CheckBoughtCalculators;
end;
end;```

The CheckIfTrial pocedure will be called in the OnCreate handler of the form, thus setting the UI accordingly at start. The EnableFullVersion procedure will hide all trial panels:

```procedure TForm1.EnableFullVersion;
begin
Panel1.Visible := False;
Panel2.Visible := False;
Panel3.Visible := False;
end;```

The CheckBoughtCalculators will only hide the panels for the add-ons that had been bought:

```procedure TForm1.CheckBoughtCalculators;
begin
Panel1.Visible := not WindowsStore1.UserHasBought('FutureCalc');
Panel2.Visible := not WindowsStore1.UserHasBought('PaymentCalc');
Panel3.Visible := not WindowsStore1.UserHasBought('RateCalc');
end;```

```function TForm1.PurchaseItem(Item: string) : string;
begin
LogMessage('Will purchase item: ' +Item);
for var i := 0 to WindowsStore1.AppProducts.Count - 1 do
if TWindowsString.HStringToString(WindowsStore1.AppProducts[i].InAppOfferToken) = Item then begin
exit;
end;
end;

begin
try
var status := WindowsStore1.PurchaseProduct(Product);
LogMessage('Got status: '+Integer(status).ToString);
if status = StorePurchaseStatus.Succeeded then begin
LogMessage('Item ' +TWindowsString.HStringToString(Product.Title)+' bought');
CheckBoughtCalculators();
end
else begin
ShowMessage('Item could not be purchased. Error: '+Integer(status).ToString);
end;
except
On e : Exception do
E.ClassName+', with message : '+E.Message);
end;
end;
```

The code for the buttons is:

```procedure TForm1.Button1Click(Sender: TObject);
begin
PurchaseItem('FutureCalc');
end;```

While developing the app, I found that this code generates an exception, there is something in the code that doesn’t like the Delphi Window handle and crashes the app when the code is run. Not a good experience for a paid app. So, I searched the web for an alternative and found this article that shows how to create a dll in C# that can be used in Delphi, to allow buying add-in purchases in the Windows Store. If you follow the instructions there and compile the dll, you will have the IAPWrapper.dll that can be used in our Delphi program.

This dll exposes a function, Purchase, that makes the purchase of an add-in. It’s different than the TWindowsStore’s PurchaseProduct, because it receives the item id as a parameter and not the item itself. That way, we must add the dll to the project, declare the Purchase function and change the BuyProduct method:

```function Purchase(StoreId : PAnsiChar) : PAnsiChar; stdcall; external 'IAPWrapper.dll';

begin
try
var status := Purchase(PAnsiChar(AnsiString(TWindowsString.HStringToString(Product.StoreId))));
LogMessage('Got status: '+status);
if status = 'Succeeded' then begin
LogMessage('Item ' +TWindowsString.HStringToString(Product.Title)+' bought');
CheckBoughtCalculators();
end
else begin
ShowMessage('Item could not be purchased. Error: '+Integer(status).ToString);
end;
except
On e : Exception do
E.ClassName+', with message : '+E.Message);
end;
end;

```

With this code, you can put your app in the store and monetize with it. When the user wants a calculator, he can buy the item and it will be available forever. You could also make it consumable, so it can be bought again at anytime, but for our purposes, that’s fine.

## Creating the add-ins in the store

Once you have the program developed, you must create your add-ins in the store. Go to the Windows Development Center, select the app you have developed for the store and click on the “Create a new add-on” button.

There you can create many types of add-ons:

• Developer-managed consumable – this kind of add-on is managed by your app, like some kind of strength. If this consumable is used on your app, the user can buy it again.
• Store-managed consumable – this kind of add-on is managed by the store, like some kind of gun. You can query the store to know how many guns the user has bought
• Durable – this kind of add-on is bought once and it is available until its lifetime
• Subscription – this kind of add-on needs periodic payment to keep using it

Our add-ons will all be durable, once the user buys a calculator, he won’t need to buy it again. Create a new durable add-on and name it FutureCalc. Then start the submission for it:

Set the properties for the add-on, with a product lifetime Forever and Content type as Software as service:

Then, set the price and availability of the add-on:

We won’t change anything here – we will leave the add-in for free, so you just need to click the Save button.

The next step is to add the store listings. Add a new language and select English (United States) and edit it:

Set the title and description and click on the Save button. When you have everything set, just click on the Submit to the store to submit it. Do the same thing with the PaymentCalc and RateCalc add-ons.

The next step is to create a new flight for the package. Just change the version to 1.1 and compile the app for the store (don’t forget to change the Provisioning data to Store). Then, create a new flight for the submission and send the package there. It will be available to download as soon as it passes certification. It will show that it has in-app purchases:

Once you’ve installed it, it will show you the new version, and you can unlock the calculator you want:

## Conclusions

As you can see you can send your Delphi apps to the Windows store and get some money with them The TWindowsStore component allows you to interact with the add-ins you’ve set in the store, so you can earn money by creating a paid version or even by adding purchases in the app. While developing the app, I’ve shown that you can also create a dll in C# that interacts with your Delphi program in the same way that a Win32 dll does. You can use this dll in the store to buy add-ins and monetize your app.

In the a previous post, I’ve told that you should use controls that are responsive to ease your work of creating an UI that adapts to the screen size. One of the controls that can help you a lot in this task is the Navigation View. In fact, if you do nothing and create something like:

```<Grid>
</Grid>```

You will have a full featured UI with a navigation pane, a content pane and a settings button:

And this UI adapts itself to the screen size. If you resize your screen to decrease its height, the navigation pane will collapse and, if you decrease a little more, it will collapse, remaining only the Hamburger and Back buttons:

This is a great bonus for you: you don’t need to worry about adapting to the device – the control does that automatically for you. In this article, I will show you how to use the Navigation View to show your content and navigate between pages.

```<Grid>
</Grid>```

You will get this UI:

Although it seems good when the navigation pane is open, when it’s closed, it doesn’t work so well:

You need to add an icon to the items. This is done with the Icon property. You can set it directly using an enumeration for the symbol (see all enumerations here) or you can set the icon from an image. If you want to set a symbol form the Segoe MDL2 Assets font, you can use a FontIcon. This code shows how this is done:

```<NavigationView>
<FontIcon Glyph="" FontFamily="Segoe UI Symbol"/>
<FontIcon Glyph="" FontFamily="Segoe UI Symbol"/>
<PathIcon HorizontalAlignment="Center" VerticalAlignment="Center"
Data="M 0,0 L20,0 40,70 140,70 140,74 36,74 20,4z
M25,12 L150,12 140,50 37,55z
M70,82 A10,10 360 1 1 70,81.99z
M120,82 A10,10 360 1 1 120,81.99z" />
<FontIcon Glyph=""/>
<PathIcon Data="M0,0 L1.25,0 1.25,18 18,18 18,19.25 0,19.25z
M0,18 L18,0 19.25,0 19.25,1.25z" />
<FontIcon Glyph=""/>

In the code above, there are some different ways to set the icon to the item:

• The Customers and Orders items use the named icons from the MDL2 Assets
• The Customers and Orders reports use font glyphs from the Segoe UI Symbol font. The Glyph property is the unicode number of the glyph
• The Sales report doesn’t have a FontIcon, but a PathIcon, that has a Data property that creates the icon as a geometry
• The Sales by Customers chart uses a glyph from the MDL2 Assets, but uses the unicode number of the gliph. In this case, you don’t need the FontFamily property

This code shows something like this:

## Navigating between pages

When you are using this control, two events are key for the navigation: ItemInvoked  and SelectionChanged. ItemInvoked is called when an item is selected by a user interaction (tap, pointer, mouse), and it can be called even if the item is already selected. SelectionChanged is only called if the current item has effectively changed and can be triggered programatically (in this case, ItemInvoked is not called). In the handler, you have to find out which is the item selected and take the according action, usually changing the content of the control. This code shows how to handle this:

```private NavigationViewItem _lastItem;

{
var item = args.InvokedItemContainer as NavigationViewItem;
if (item == null)
{
NavView.Content = null;
return;
}
if (item == _lastItem)
return;
var textSelected = item.Content?.ToString() ?? "";
var grid = new Grid();
var text = new TextBlock
{
Text = textSelected,
FontFamily = new FontFamily("Arial"),
FontSize = 24,
HorizontalAlignment = HorizontalAlignment.Center,
VerticalAlignment = VerticalAlignment.Center
};
NavView.Content = grid;
_lastItem = item;
}```

We are checking the selected item, if it is a different one, we create a grid with a textblock that shows the text of the selected option and set it as the content for the NavigationView. This works fine, but there is more that can be done here: we can also handle the back button and act if it’s clicked (until now it’s been disabled. If you don’t want to show it, just set the IsBackButtonVisible property to False).

We could manage the content and navigation by ourselves. In this case, we would need a navigation mechanism, that handles the back navigation and replaces the content in the NavigationView. But we can do it by adding a single control: the Frame. It can control the back navigation and even replace the content with a transition. This can be done with something like this:

```<NavigationView x:Name="NavView"
BackRequested="NavView_OnBackRequested"
IsBackEnabled="{Binding ElementName=ContentFrame, Path=CanGoBack}">
....
<Frame x:Name="ContentFrame"

The IsBackEnabled property of the NavigationView is bound to the CanGoBack property of the frame. In the previous version of the code, I’ve used the title of the navigation item, but I think this option is less than optimal, because if we change the title, the code breaks. In this case, I think it’s better to use the Tag property, a property that can store any object. In our case, we will store an unique string that will point to the view, so we can navigate to it. Our code will be something like this:

```<NavigationView.MenuItems>
<FontIcon Glyph="" FontFamily="Segoe UI Symbol"/>
<FontIcon Glyph="" FontFamily="Segoe UI Symbol"/>
<PathIcon HorizontalAlignment="Center" VerticalAlignment="Center"
Data="M 0,0 L20,0 40,70 140,70 140,74 36,74 20,4z
M25,12 L150,12 140,50 37,55z
M70,82 A10,10 360 1 1 70,81.99z
M120,82 A10,10 360 1 1 120,81.99z" />
<FontIcon Glyph=""/>
<PathIcon Data="M0,0 L1.25,0 1.25,18 18,18 18,19.25 0,19.25z
M0,18 L18,0 19.25,0 19.25,1.25z" />
<FontIcon Glyph=""/>

Now, we must create the views for each item. Create a new folder named Views and, in this folder, create new pages, one for each item: CustView, OrderView, CustRepoView,OrderRepoView, SalesRepoView, SalesCustChartView, SalesProdChartView and SalesDateChartView.

With the views in place, we can create the ItemInvoked handler:

```private NavigationViewItem _lastItem;
{
var item = args.InvokedItemContainer as NavigationViewItem;
if (item == null || item == _lastItem)
return;
var clickedView = item.Tag?.ToString();
if (!NavigateToView(clickedView)) return;
_lastItem = item;
}```

The NavigateToView method is:

```private bool NavigateToView(string clickedView)
{
var view = Assembly.GetExecutingAssembly()

if (string.IsNullOrWhiteSpace(clickedView) || view == null)
{
return false;
}

return true;
}```

This method uses reflection to get the type corresponding to the view name that’s in the Tag property and navigates to it. If you run the program, you will see something like this when you click an item:

This code has one problem: if you click the Settings item, you will get an error. That’s because the Settings item doesn’t have a valid Tag. So, we must create the SettingsView page in the Views folder and change the ItemInvoked handler:

```private void NavigationView_OnItemInvoked(
{
var item = args.InvokedItemContainer as NavigationViewItem;
if (item == null || item == _lastItem)
return;
var clickedView = item.Tag?.ToString() ?? "SettingsView";
if (!NavigateToView(clickedView)) return;
_lastItem = item;
}```

If the tag is null, we will navigate to the SettingsView. With this change, the code works fine and you can click on the Settings item. There is only one thing that can be made, here: manage when the back button is clicked. We do this in the BackRequested handler:

```private void NavView_OnBackRequested(
{
if (ContentFrame.CanGoBack)
ContentFrame.GoBack();
}```

With this code, the back button is also handled with very little code.

## Conclusions

As you can see, the NavigationView allows you to create easily a responsive UI, with lots of features and many different ways to handle navigation. There are some features that I didn’t mention in the article, like the fact that you can stick to a view and make it not respond to size changes, you can change the stops where the view changes, you can add a header or footer to the page or you can even put the items at the top, just by changing a property – If you set the PaneDisplayMode to Top, you will get this UI:

This is a very powerful control and a nice improvement for your UI.

The full source code for this project is at https://github.com/bsonnino/NavigationView