A big thank you to everyone who responded to my Twitter poll on what Pluralsight learning path to do next. It was a close run contest but C# deep dive got more votes than the other options and is what I have studied. Now that I have completed this I will move on to the second most requested learning path which is on the JavaScript language.

This is the second learning path that I have done this year (previous one being CompTIA Security+).

The aim of this learning path is to gain in-depth C# skills.

This learning path has the same number of courses, but is slightly longer at 20 hours and 11 minutes. This learning path is taught by five different Pluralsight authors, all of whom are very good.
Mike Woodring has more details here

C# Interfaces by Jeremy Clark

See my review here

C# Generics by Scott Allen

C# Generics is a fairly long course, at 4 hours 20 minutes and featuring 7 modules.

C# Generics – Why Generics?

Working with Generic Collections

Generic Classes and Interfaces

Generic Methods and Delegates

Constraints, Covariance, and Contravariance

Explains covariance and contravariance. Covers the interface constraint.

Generics and Reflection

This module creates a basic IoC container using Generics and reflection.

Generic Odds & Ends

These are miscellaneous topics that don’t fit into any other module.

Related courses:
The Reflection module shows you how to build a basic inversion of control (IoC) container using Generics.
The fourth module of Jon Skeet’s C# Design Strategies course also shows you how to write an IoC container.
For more information on IoC, check out Inversion of Control by John Sonmez or Practical IoC with ASP.NET MVC 4 which is also by John Sonmez.

For more information on Reflection see Practical Reflection in .NET by Jeremy Clark

There is further coverage of Constraining Generics in “C# Tips & Traps 2” later on in the C# learning path.

Exercise files (pluralsight plus subscribers only) contains: slides and code (before and after) for each module.

C# Events, Delegates & Lambdas by Dan Wahlin

See my review here

C# Tips & Traps by Jason Roberts

This is unusual for a Pluralsight course because in most courses each subsequent video clip builds on knowledge from the previous one. This course is a collection of different pieces of advice. Each video clip is a self contained lesson and the course could be watched in any order.

I have been coding in C# for about 6 years, and watched approximately different 100 Pluralsight courses featuring C#, but I saw a number of things for the first time in this course.

Your mileage from this course will vary according to how you like to use Visual Studio and the type of work you do.

Some pieces of advice will be useful immediately, and others will become useful months or years down the line.

Not much previous knowledge is required in order to understand this course. None of the previous courses on this learning path are prerequisites. You only need to have a very basic understanding of C# and Visual Studio.

The 4th module is mainly about data validation, particularly DateTime validation. If you are interested in thoroughly learning the DateTime format in .NET, check out course number 7 in my Top 10 Pluralsight courses article.

Productivity Tip: Each module in this course has a module overview and a module summary. The module overviews just name the video clips that follow next and the module summaries name the video clips that you have just watched. So you can save yourself a decent amount of time (more than 20 minutes at 1x speed) by skipping past these.

Note Taking Tip: I’ve mentioned in my Making The Most Of Pluralsight article that Visual Studio Code is a good text editor for taking notes. Regardless of which text editor you use for C#, you’ll want to set it to C# mode while taking notes for this course, because you’ll be mostly writing code, rather than English.

Recommended speed: 1.6x

C# Tips & Traps 2 by Jason Roberts

This is volume 2 of Jason’s compendium of Tips and Tricks. It is shorter than the first volume with only four modules. The same productivity and note taking tips for C# Tips & Traps also apply to this course.

Part 1

This module builds on what you learned two of the previous courses in this learning path.

Dan Wahlin’s coverage of Delegates will come back into mind as Jason teaches Multicast Delegates, and Compatibility and Equality of Delegates.

In Scott Allen’s C# Generics course you will have seen some of the ways in which you can constrain Generics. In Part 1 of this C# Tips & Traps 2, you will see all of the ways in which you can constrain them: by base class, by interface, by value type and by parameterless constructor. Jason also shows how to use these constraints in combination with each other.

Part 2

Jason shows that when structs contain only value members, performance of equality checks is much faster. This is because reflection is used to determine equality for reference types. The MSDN documentation for ValueType.Equals Method explains more. Overriding the equals method is a technique for dramatically improving performance.

Then Jason shows that conditional operators such as && or || are short circuited (or lazy evaluated) but the & and | operators are not short circuited.

Enumerable.Range is introduced. This is also featured in the Practical LINQ course, and is useful for auto-generating a sequence of Integer values.

If you have an enumerable sequence of strings, such as name, and a sequence of integers, such as ages, you might want to merge them together into one sequence. Jason demonstrates that using a lambda can protect you in cases where the length of the two sequences are not the same.

You might also want to perform set operations on your sequence, such as Concat, Union, Intersect and Except. This tip is covered both here and also in the Practical LINQ course.

A LINQ tip that is not covered in the Practical LINQ course, is how to do custom aggregation. Jason uses an overload of Aggregate specifying a seed value.

I had never seen interface members explicitly implemented before, always implementing them implicitly. It was good to learn this, but it seems like a strange thing to do and I don’t plan to start using this technique.

Task.Delay can be a better alternative than Thread.Sleep, and Jason demonstrates how this is used.

The last tip in this module is how to use the SortedSet, SortedList and SortedDictionary classes.

For a more in-depth look at Sets in C#, see module 9 of Simon Robinson’s C# Collections Fundamentals course.

Part III

Customizing The Display of An Object in The Debugger Window with the DebuggerTypeProxy attribute

Recreating Hidden Files Without Exceptions

Working with Zip Files – System.IO.Compression and System.IO.Compression.FileSystem

Compressing and Decompressing in-memory Streams

Working with URIs

Part IV

Using Generic Methods in Non-Generic Classes

Deferring Creation of Resource Intensive Objects Until Use https://msdn.microsoft.com/en-us/library/dd997286.aspx

Automatically Skip Code When Debugging with the [DebuggerStepThrough] attribute

Subscribing to File Changed Events with System.IO.FileSystemWatcher

Nullable Value Types and Ambient Properties

 

Recommended speed: 1.6x

Practical LINQ by Deborah Kurata

This course is composed of six modules but the first is just a 5 overview of the course and the last is a 2 min summary of the course.
There are several Pluralsight courses on LINQ, and I previously watched Scott Allen’s three courses which teach LINQ in some depth.
This course is a faster route to getting up and running quickly with LINQ and can reasonably be watched and understood in under 3 hours.

Even if you don’t have a Pluralsight subscription, you can find many useful LINQ examples on Deborah’s blog

LINQ By Example

Covers the main terminology: Lambdas, Extension methods, LINQ syntax vs Method syntax etc. Covers basic examples such as refactoring a for each loop into a more terse and expressive LINQ statement that finds a particular value of interest.

More LINQ Examples

Examples include:

Sorting – OrderBy/ThenBy/OrderByDescending and Reverse

Creating – Enumerable.Range (as featured in C# Tips and Traps but paired with .Select) and Enumerable.Repeat

Comparing/combining – the Set operators Intersect, Except, Union, Distinct, Concat

Transforming with projections – this is a long 23 minute clip which includes Anonymous types, some of the pros and cons of the dynamic keyword, and examples of working with relational databases.

Working with parent/child data using the SelectMany operator. Deborah explains the shortcomings of the Select operator and why SelectMany is sometimes preferred.

Data Binding

Data binding is a technique for connecting a data source to a user interface control. This module covers data binding in two Microsoft desktop technologies: Windows Forms, and Windows Presentation layer. Each clip is nearly half an hour long so you will probably only want to watch the clip covering the technology that you use in your own applications.

The Windows Forms DataGrid works with a retrieve method in a repository class “like magic” and is editable, but has no sorting functionality or other useful user friendly features. The earlier examples created our sort methods, and these are easily made to work with a DataGrid if we remember to execute our LINQ query by using .ToList()

This video clip covers one of the potential problems with using the dynamic keyword that was introduced in the previous module, and how to make it work correctly.

Deborah warns that using Anonymous types is going to lead to a DataGrid control that is not editable.

Also covered is binding to a ComboBox. This example also uses the dynamic keyword. Then we see how to display a DataGrid based on our selection in our ComboBox. This makes uses of the Find example from the first module.

I found this to be a nice, simple application. If the business needs are simple enough, you could use these techniques to write a real world application in less than an hour.

Doing this in Windows Presentation Foundation (WPF) requires a bit more setup work, due to the Model-View-ViewModel architecture that it uses. Using the dynamic keyword no longer works when we want updatable data and we need to create a new class for our model.

However WPF gives you greater control than Windows Forms (in a similar way to how ASP.NET MVC gives you greater control than Web Forms) and the resulting application looks more aesthetically pleasing than our Windows Forms application.

So if you are not already using Windows Forms, and you want to get started as a Windows desktop application developer, it may be worth the effort needed to learn more modern technology than Windows Forms. If you are new to WPF, there are several other Pluralsight courses available that teach it from scratch. An even more modern technology is Windows 10 universal apps, which like WPF is based on XAML (XML Application Markup Language)

Analyzing Data

This covers Totalling, Grouping and Averaging data.

Totalling is done by using the .Sum extension method.

The GroupBy method allows us to either group by a single property, by multiple properties, or by a parent property. This module shows all of these techniques. We all see how to show the results in a WPF pie chart.

The video clip on averaging data shows us that the .Average method returns a mean average. We also see algorithms for calculating the median and mode of a list of values.

Learning Path Review

The aim of this course was to gain in-depth C# skills. I feel that this learning path has achieved that. There are a number of areas of the language where my knowledge has expanded and made my reconsider my style of C# code in some areas. It covers a wide range of topics in C# and .NET, and many of the examples I have seen are useful.

I did not enjoy this learning path as much as I enjoyed CompTIA Security+. This is just a personal feeling which many would disagree with. It could be that I have already seen so many C# courses that it is much more familiar to me than CompTIA Security+ which could be considered the start of a different career path.

If you don’t have time to watch all of the courses in this learning path, my favorite two courses were “C# Events, Delegates & Lambdas” and “Practical LINQ”. I found them to be the most applicable to the everyday coding that you’re likely to do in C#, and easy to follow without being too basic.

All of the courses in this learning path were produced in 2013. So while the material in this learning path is certainly still relevant, it doesn’t cover the C#6 features. If you want to learn those, there is What’s New in C# 6 by Scott Allen and Exploring C# 6 with Jon Skeet featuring Rob Conery.

There are a number of other C# learning paths available and I expect that I will do at least one more C# learning path this year. C# is a well designed language that is easy to get productive with, but it is a very long road to true mastery.

I am now looking forward to doing the JavaScript learning path. Although there are some aspects of JavaScript that I consider to be terrible, the more I learn about the language the more I find techniques that are more powerful than anything you can do in languages such as C#, and ES 2015 is a huge improvement.

So thank you very much for reading this review, and I hope that you will join me again for the JavaScript learning path review.