Understanding the .NET Framework
By Mike Woodring on February 5, 2015
At the heart of the .NET Framework is an execution engine called the Common Language Runtime. Designed from the ground up to support a myriad of programming language styles, the CLR provides a common type system, automatic memory management, support for concurrent execution, and facilities for interoperating with native Win32 and COM components. Paired with the CLR is an extensive suite of classes and application frameworks collectively referred to as the Framework Class Library.
Course series objective:
The courses outlined in this series provide a comprehensive look at the operation of the CLR, as well as a tour of key classes in the Framework Class Library that every .NET developer – regardless of the type of application or service they’re building – should understand.
This course series is designed for developers who have been introduced to C#, and want to develop a deeper understanding of the foundation upon which every .NET application is built.
Developers who have no prior experience with C# may want to check out one of our beginner level courses on that topic before proceeding with this learning path, such as C# From Scratch by Jesse Liberty, or C# Fundamentals with C# 5.0 by Scott Allen. We also offer several course series that provide comprehensive guidance through our exhaustive C# library.
That said, even though the examples shown are presented using C#, the concepts & classes discussed throughout these courses are not C#-specific. Whether an application or service is developed in C#, VB.NET or some other .NET programming language, they rely on and interact with the same classes and services discussed in this learning path. So developers of any stripe on the .NET platform will gain valuable insights and learning important techniques from these courses.
|CLR Fundamentals||4h 20m|
|C# Collections Fundamentals||5h 56m|
|Practical Reflection in .NET||3h 23m|
|Introduction to Localization and Globalization in .NET||3h 00m|
|Streaming in .NET 4.5||3h 54m|
|Serialization in .NET 4.5||4h 22m|
|.NET Regular Expressions||3h 29m|
|.NET Puzzles, Gotchas & Cautionary Tales||2h 23m|
|CLR Threading||2h 37m|
|Introduction to Async and Parallel Programming in .NET 4||2h 51m|
|Async and Parallel Programming: Application Design||3h 45m|
Course series description:
The first course in this series, CLR Fundamentals, sets the stage for understanding .NET’s managed execution platform, the Common Language Runtime. The underpinnings of managed execution, such Just-In-Time (JIT) compilation, garbage collected memory management, assemblies and assembly versioning are all explored & demystified. This course also includes a tour of .NET facilities for calling (and being called from) native code, such as Win32 DLLs and COM objects. If you are relatively new to .NET, feel free to defer watching the interop module of this course until you are ready to make your first foray into the world of managed/native interop. Developers who need to dive deep into interop waters can follow that with Pavel Yosifovich’s comprehensive treatise on interop, .NET Interoperability Fundamentals.
In his course C# Fundamentals, Simon Robinson provides a comprehensive look at the rich set of collections that are available to .NET developers. It’s important to note that although C# is used throughout this course, it is primarily just the demonstration vehicle for understanding the CLR’s array data type, and the core collection classes provided by the Framework Class Library. So although the syntax for declaring and using arrays differs between C#, VB.NET and other languages, that syntax is merely a language mapping onto a fundamental data type supported by the CLR. Similarly, the collections classes explored in this course, which includes lists, dictionaries and sets among others, are available as part of the Framework Class Library for use from any .NET programming language – not just C#. So developers of any stripe using the .NET Framework will find this course to be a great resource for coming up to speed on the most common collection types used in .NET.
Reflection is an extremely powerful, yet often overlooked, feature of .NET. In fact, it is a feature that nearly every developer comes into contact with in some form on a daily basis, without ever realizing they’ve done so. But there is a big difference between what we can do with this power once we discover it, and what we should do. In his course Practical Reflection in .NET, author Jeremy Clark provides excellent guidance on how, when and where to leverage this powerful feature in your own work.
In Introduction to Localization and Globalization in .NET, Jeremy returns to important yet often misunderstood territory by exploring .NET’s facilities for communicating with users in the way that they understand: presenting text to users in their own spoken language (localization) and using formatting conventions such as thousands-separators and currency symbols specific to the user’s geographical locale (globalization).
In spite of how it may seem at times, not all data is stored in a database. You’ll find data in files, shuttling between processes in memory, and flowing across networks via sockets or other network communication mechanisms. In his course Streaming in .NET 4.5, Mohamad Halabi provides a comprehensive look at the .NET Framework’s streaming architecture, which provides an extensible abstraction for both synchronous and asynchronous I/O over a variety of data mediums. In Serialization in .NET 4.5, Mohamad provides developers with essential knowledge about serialization facilities provided by the .NET Framework, including support for binary, XML and JSON serialization formats.
In addition, be on the lookout for Mohamad’s upcoming companion course onSerialization in .NET 4.5, which will explore .NET Framework facilities for object persistence in binary, XML and JSON formats.
Text parsing & pattern matching ranks high on the list of wheels that developers tend to reinvent. But regular expressions, which are essentially a specialized language for describing a search pattern, provide a powerful way to perform pattern matching and substring extraction with great power & ease. In his course .NET Regular Expressions, Dan Sullivan provides a tour of how regular expressions are implemented in the .NET Framework.
Novice and veteran .NET programmers alike will benefit from the next course in this series, .NET Puzzles, Gotchas & Cautionary Tales. In this course, .NET expert Kathleen Dollard presents a series of puzzles that are, in her words, designed to “frighten and inspire you”. Veteran programmers will have a chance to realize where their understanding of the .NET Framework is perhaps mistaken, while newer .NET programmers will receive valuable guidance that will help them avoid some of the pitfalls and mistakes veterans had to learn the hard way.
This series concludes with in-depth coverage of one of the more advanced areas of the CLR and .NET Framework: parallelism and asynchronous programming. Together, these 3 courses provide a firm grounding in asynchronous and concurrent programming on the .NET platform that will serve developers well as they leverage language-specific mappings onto these constructs, such as the async and await constructs supported by C# and VB.NET.
To begin, CLR Threading explores the underpinnings of concurrent execution in the .NET Framework, covering foundational topics such as threads, the thread pool, and the various mechanisms for coordinating multithreaded access to shared resources (thread synchronization). With that grounding under your belt, you’re ready for a 2-part exploration of asynchronous and parallel programming by Dr. Joe Hummel. In his course Introduction to Async and Parallel Programming in .NET 4, Dr. Joe picks up where CLR Threading leaves off by introducing the task-based paradigm introduced in .NET 4, which serves as the underpinnings of language-level support such as the C# and VB.NET async andawait mechanisms. Part 2 of Dr. Joe’s series, Async and Parallel Programming: Application Design, builds on the introduction provided in part 1, offering more details into the inner workings of the Task Parallel Library, the dangers of concurrent execution, and the higher-level abstractions available in the TPL to help you.