Cloud era do We need OO?
This is q good question. We have a lot scripting framework that can be used to develop sophisticated web. We have low level codes that can help build an app within a minute. We have cloud template to deploy solution in minutes. Do we still need Object Oriented (OO)? The answer is it depends.
When you build a game, you might need OO. In example, unity project needs C# scripting with OO.
When you build a website, you might need OO. In example, asp.net need C# with the MVC (Model View Control)
When you build a mobile app, you might need OO. In example, building Xamarin codes.
When you build a desktop app, you might need OO. In example, building Windows Form or WPF codes.
So the most answer is YES.
Learning OO in the cloud era
So we back in the square one. What we need to learn in OO especially in the cloud era.
Setup the tools and basic language of C#. We can start to learn OO by setup the SDK, IDE, and many more.
Configuring Visual Studio
Configuring Visual Studio Codes
Understanding Class, Namespace, and Variables
Understanding Method, Parameter, and Library
Understanding Building Process in Visual Studio
Introducing UML class diagram
Abstraction. We discuss the abstraction implementation.
Abstraction concept
Abstraction C# example
Inheritance. The inheritance pillar that helps to make a class reusable
Inheritance concept
Inheritance C# example
Interface. The interface pillar that helps to make a class consistent
Interface concept
Interface C# example
Polymorphism. The pillar that helps to make a class extendable and less changes
Polymorphism concept
Polymorphism C# example
Object oriented analysis and design (OOAD)
Introduction OOAD
OOAD in example
A Pie. Putting it all together. Creating a full project in Visual Studio consoles project
Case Study project: Class Design
Case study project: relationship Design
Case study project: test design
Design patterns. Providing the information about how to create a software with the best design in mind.
Creational pattern examples
Structural pattern examples
Behavioural pattern examples
Refactoring in Visual Studio
SOLID principles. Providing the information to make OO programming more approachable and consistent
Single responsibility principle
Open/Closed principle
Liskov Substitution Principle
Interface Segregation Principle (ISP)
Dependency Inversion Principle
Object oriented in Database Layer
Database API model: ADO.NET
Database ORM Model: Entity Framework
Project Creating Database Layer
Object-oriented in-Service Layer
Web services, JSON and HTTP REST
Project Creating Service Layer
Object oriented in Desktop App
Introducing WPF, Windows Form, and UWP
Project Creating Desktop App.
Object Oriented in web App
Introducing MVC
Project Creating Web App
Object Oriented in Mobile App
Introducing Xamarin and MAUI
Project creating Mobile App
Starting 1 – 9, you can work with any sample or spike codes that shows the concept. In Chapter 10 – 14 you can build a multi-channel application that build the software from end to end.
//
The SOLID era
There are three things that early programmer knows in the object-oriented programming (OOP) concept.
OOP Pillars: Abstraction, Polymorphism, Inheritance, Encapsulation. It is a basic pillar that programmer should know how to develop software with OO in mind.
SOLID Principle: developer principles when want to build solution with OOP Pillars.
Design Patterns: a ready to use recipe that can be used by the programmer. The recipe includes SOLID principle in adoption.
OOAD (Object Oriented Analysis and Design): a structured method to develop solution based on OO.
What is SOLID?
SOLID is an abbreviation of:
Single Responsibility: Class should only changes because its main responsibility. Therefore, the class should be independent for changes do not depend on the other classes. We can do this principle by applying abstraction pillar.
Open Closed Principles: Class should avoid modification, but it should extend when needed. We can do this principle by applying Inheritance and interface (Encapsulation) pillar.
Liskov Substitution: Children class can replace the parent class when necessary. Therefore, the dependency with specific classes can be avoided and substituted with other classes. This principle can be applied by using Inheritance and Polymorphism.
Interface Segregation: Breakdown the interface into smaller interfaces, never force a class to implement a method. This principle can be applied by using interface (Encapsulation) and abstraction pillar.
Dependency Inversion: (Parent/Abstract) High level classes never depends on (Children/Concrete) low level classes. Program in interface not in implementation. This principle can be applied by using encapsulation and abstraction pillar.
medianet_width = "600";
medianet_height = "250";
medianet_crid = "858385152";
medianet_versionId = "3111299";
The Analysis in SOLID Principle
If you read my statement about what pillar that related with SOLID, we will find some 'secret' behind of the concept. The SOLID principle fulfils low in coupling and high in cohesion. In simple definition 'class should strong enough to break, and relation between classes should be weak enough to be independent'. Please see the illustration below
Want to see and example of SOLID Principle? Just visit the VSID YouTube Channel How do you think? is the SOLID principle still relevant? put your comment
medianet_width = "600";
medianet_height = "250";
medianet_crid = "858385152";
medianet_versionId = "3111299";