API in C The Best Practices of Design and Implementation
What you’ll learn
Design and implement a type or an API taking care of it’s users.
Encapsulate types so the other programmers would not hate you.
Code in a good style making the code clearer in its intent.
Refactor the code making it much better to read and understand.
Throw and handle exceptions properly.
Decide whether to comment a particular part of the code is a good idea or not. By the way, which comments are helpful and which are not?
Dealing with Null values
Requirements
You should already be familiar with the basics of C#.
You should already have some practice working with Visual Studio.
Description
Learn how to design and implement types in C# so that the other developers won’t hate you when using one of the types developed by you. It means you are going to learn how to write code of the high quality: readable, understandable and reliable. Improve your knowledge in object-oriented programming in the context of clean coding and building types of high quality.Understand the characteristics of a well-designed typeGrasp the principles of the convenient API developmentWrite clean code, get rid of unpleasant smellsLearn about what exceptions are intended for and how to throw and catch them properlyProtect your types from the incorrect usage making them properly encapsulated.Foundations of building object-oriented infrastructures Despite the fact that C# is a very rich on features language, it’s very common to see poorly designed and implemented types in a real world. In fact, C# is one of the richest on features language among object-oriented languages in the world nowadays. But with great power comes great responsibility. It’s challenging to use all those features in a right way. You probably have already heard the following well-known statement: most code sucks. Well, this course is all about how to produce code which doesn’t suck. Owning skills of producing a well-designed and well-implemented types is the prerequisite for the other developers to treat you as a real professional. Content and Overview This course is aimed at all the C# developers, from beginners to seniors. Topics which are covered in the course are relevant for all kinds of C# developers since all developers design and implement APIs. The topics complexity is very different. There are plenty of very simple topics, and at the same time, there are topics which require from you a solid C# background. There are plenty of code examples throughout this course, so you will learn both theoretical and practical material. Starting with characteristics and principles of a well-designed type you will go further, learning how to give names for different members, how many parameters a method should take, is it a good idea to take a Boolean as a parameter of a method and much more than that. Then you will learn what encapsulation really means. How to encapsulate a type? There are some trade-offs we will deal with encapsulating our types. There are many experienced programmers who don’t know what encapsulation is in essence. Investigating this topic together we will see how to build a consistent and reliable type. After mastering the topic of types encapsulating you will face the great problem of exceptions handling. Yep, it’s a hard nut to crack. We will start from discussing a question of why do we use exceptions as a mechanism of errors handling. And why C# team didn’t invent any other mechanisms? In the end, we will look at how to fight with null values. As you may know, Tony Hoar said that the invention of a null value was his billion-dollar mistake.To sum up, the course covers the following topics:API development principlesHow to give better names for API members and what naming conventions exist in the .NET platform and suited for C#.Common problems encountered by C# developers in the process of designing and implementing APIs: classes vs structures, abstract classes vs interfaces, creational patterns vs constructors, how to implement dispose pattern (are you sure you understand this allegedly simple case?)Common implementation smells such as poor naming, excessively long methods, output parameters and so on.Common Architectural Design Smells such as Primitive Obsession, Hidden Dependencies, Violation of Law of Demeter and other.How to deal with errors. It is surprisingly hard to develop robust software where errors handling is based on exceptions. We will find out why this is so and how to struggle with problems of error handling.How to deal with Nulls. Null Vales have always been a pain the ass. NullReferenceException is a well-known and popular guest in our software. We will look at the possible ways of diminishing the disrupting power of null-values.Teaching ApproachNo fluff, no ranting, no beating the air. I esteem your time. The course material is succinct, yet comprehensive. All important concepts are covered. Particularly important topics are covered in-depth. For absolute beginners I offer my help on Skype absolutely free, if requested. Don’t forget that this course has English subtitles, so if you don’t understand my accent, feel free to turn them on.Take this course and you will be satisfied.————————————————————Keywords related to the course:C# Clean CodeC# Best PracticesAPI in C#Building API in C#Clean Code in C# tutorialRefactoring
Overview
Section 1: Introduction to API
Lecture 1 How to Ask Questions
Lecture 2 Download Source Code
Lecture 3 Join .NET Community of Students
Lecture 4 Outline
Lecture 5 API’s Characteristics
Lecture 6 Public API VS Private API
Lecture 7 API Development Principles
Lecture 8 Conclusion
Section 2: Names
Lecture 9 Outline
Lecture 10 General Principles of Naming
Lecture 11 Naming Conventions in .NET
Lecture 12 Conclusion
Section 3: Designing and Implementing Types and their Members
Lecture 13 Outline
Lecture 14 Class VS Structure
Lecture 15 Abstract Class VS Interface
Lecture 16 Implementing Abstract Classes
Lecture 17 Property VS Method
Lecture 18 Implementing Constructors
Lecture 19 Creational Patterns VS Constructors
Lecture 20 Tester-Doer Pattern
Lecture 21 Conversion VS Casting Operator
Lecture 22 Implementing Parameters
Lecture 23 Implementing “Dispose” Pattern
Lecture 24 Conclusion
Section 4: Implementation Smells
Lecture 25 Outline
Lecture 26 Poor Naming
Lecture 27 Violating Naming Conventions
Lecture 28 Variable Declarations on the Top
Lecture 29 Magic Numbers
Lecture 30 Too Long Method
Lecture 31 Poor Conditional Clauses
Lecture 32 Output Parameters
Lecture 33 Comments
Lecture 34 Prefer Positive if-statements
Lecture 35 Conclusion
Section 5: Common Architectural Smells
Lecture 36 Outline
Lecture 37 Primitives Obsession
Lecture 38 Hidden Dependencies
Lecture 39 Violation of Law of Demeter
Lecture 40 Temporal Coupling
Lecture 41 Temporal Coupling and Immutability
Lecture 42 Switch Statements
Lecture 43 Conclusion
Section 6: Dealing with Errors
Lecture 44 Outline
Lecture 45 What Does an “Error” Mean?
Lecture 46 Problems with Exceptions
Lecture 47 Common Misconceptions
Lecture 48 Exception Handling Strategies
Lecture 49 CQS Principle
Lecture 50 Errors and Functional Programming
Lecture 51 Pipelining by Method Chaining
Lecture 52 Conclusion on Exceptions Handling
Lecture 53 BCL Exceptions Types
Lecture 54 Custom Exception Types
Lecture 55 Conclusion
Section 7: Dealing with Nulls
Lecture 56 Outline
Lecture 57 Problems with Nulls
Lecture 58 Null Object Pattern
Lecture 59 Maybe monad in C#
Lecture 60 Automating Null Checks
Lecture 61 Static Analysis
Lecture 62 Returning IEnumerables
Lecture 63 Conclusion
Lecture 64 BONUS LECTURE
This course is primarily oriented on programmers who have at least basic knowledge of C# and looking for practical guidelines concentrated on the improving of code qualities.
Course Information:
Udemy | English | 3h 24m | 659.51 MB
Created by: Engineer Spock
You Can See More Courses in the Developer >> Greetings from CourseDown.com