Outline of the course "API in C#: The Best Practices of Design and Implementation".

In this lecture you'll learn what characteristics of API are important.

In this lecture you'll learn the difference between public API and private API.

In this lecture you'll learn the main development principles of API.

The conclusion for the introduction into the course "API in C#: The Best Practices of Design and Implementation".

The outline of the module about naming of API members.

You'll learn abour intention-revealing names, disinformative names, easily readable names, encodings, domain names, scope and length rule and other.

Learn about standard .NET naming conventions.

Conclusion for the module about naming API members.

The outline of the module where you'll learn how to design and implement types and their members in C#.

You'll learn the difference between class and structure in C#.

You'll learn the difference between an abstract class and an interface in C#.

You'll learn the caveats of abstract classes implementation in C#.

You'll learn how to choose between property and method in C#.

You'll learn the caveats of constructors implementation in C#.

You'll learn when to prefer a creational pattern over a constructor in C#.

You'll learn about the "Tester-Doer" pattern in C#.

You'll learn how to choose between implementing either a conversion operator or casting operator in C#.

You'll learn about the caveats of implementing method's parameters in C#.

You'll learn about the caveats of implementing the "Dispose" pattern in C#.

The conclusion for the module where you learned how to design and implement types (API) and their members in C#.

The outline of the module where you'll learn the typical implementation smells of API in C#.

You'll learn about mysterious, meaningless, shortened, ambiguous names and other naming smells.

You'll learn about the violation of naming conventions. How to impose the rules of naming by harnessing the power of modern tools.

You'll learn about the smell of declaring variable on top of methods.

You'll learn about the smell of magic numbers. You'll see how to refactor them.

You'll learn abou the technique "Extract Till You Drop" which was introduced by Robert Martin (aka Uncle Bob). You'll learn the pros and cons of that technique.

You'll learn about the right using of ternary operators and how to avoid abusing them.

You'll learn about the smell of out-parameters and how refactor them out.

You'll learn about the smell of silly comments.

You'll learn about the smell of double negative if-statements.

The conclusion for the module where you learned the common smells of API implementation in C#.

The outline of the module where you'll learn about common architectural smells in C#.

You'll learn about the primitives obsession, when developers inappropriately use primitive types for representing higher-level concepts.

You'll learn about hidden dependencies by the example of inappropriate use of the Service Locator pattern.

You'll learn the Law of Demeter and you'll see the example of the violation of that law in C#.

You'll learn about the smell of temporal coupling and how to avoid it.

In this lecture, you'll learn the functional style of building functions, without side effects.

You'll learn about the pros and cons of using switch-statements. You'll see how to refactor them into an object-oriented form.

The conclusion for the module where you learned common architectural smells in C#.

The outline of the module where you'll learn about the approaches to errors handling. How to handle exceptions in C# and how to avoid them.

Learn the meaning of the "error" term. What categories of errors exist in C#.

Learn deeply what the problems accompany exceptions in C#.

Look at the common misconceptions concerning exceptions handling in C#.

Learn what strategies of exceptions handling exist in C#.

Learn about the Command-Query Separation principle.

Learns about the interconnection between errors and functional programming.

Learn what is pipelining and how to implement it via methods chaining in C#.

A sub-conclusion about exceptions handling in C#.

Learn about the built-in exception types in C#. Use them properly!

Learn the rules of implementing custom exceptions types in C#.

The conclusion for the module where you learned all nitty-gritty abour errors and exceptions handling C#.

The outline of the module where you'll learn the approaches to dealing with nulls in C#.

You'll learn what the problems accompany null values.

Learn the Null Object pattern in C#.

Learn what is the Maybe monad and how to implement it in C#.

Learn how to automate null checks using the NullGuard.Fody.

Learn how the static analysis can help to struggle with nulls.

Learn about the special case (regarding null values) of returning null values.

The conclusion for the module where you learned the approaches to dealing with null values in C#.