TECHNOLOGIES
FORUMS
JOBS
BOOKS
EVENTS
INTERVIEWS
Live
MORE
LEARN
Training
CAREER
MEMBERS
VIDEOS
NEWS
BLOGS
Sign Up
Login
No unread comment.
View All Comments
No unread message.
View All Messages
No unread notification.
View All Notifications
C# Corner
Post
An Article
A Blog
A News
A Video
An EBook
An Interview Question
Ask Question
About Principle
Share
facebook
twitter
linkedIn
Reddit
Topics
No topic found
Content Filter
Articles
Videos
Blogs
News
Complexity Level
Beginner
Intermediate
Advanced
Refine by Author
[Clear]
George (6)
Geo J Thachankary (6)
Ajay Kumar (6)
Ashutosh Singh (5)
Vishal Yelve (5)
Pranay Rana (5)
Jitendra Mesavaniya (3)
Nagaraj M (3)
Rasul Huseynov (2)
Ayush Gupta (2)
Vikas Singh (2)
Sandeep Singh Shekhawat (2)
Rijwan Ansari (2)
Munib Butt (2)
Sandip Jadhav (2)
Jitendra Maurya (2)
Harsh Sharma (2)
Vinoth Xavier (2)
Habibur Rony (2)
Thiago Vivas (2)
Usama Hafeez (2)
Hadshana Kamalanathan (1)
Chetan Sanghani (1)
Kautilya Utkarsh (1)
Harshit Pandey (1)
Dwarkesh Vajjala (1)
Sundaram Subramanian (1)
Chethan N (1)
Shrikrishn Bansal (1)
Naveen Kumar (1)
Prasad Raveendran (1)
Md Sarfaraj (1)
Sanjay Kumar (1)
Ankur Mistry (1)
Mark Pelf (1)
Sandeep Thomas (1)
Manikanta Pattigulla (1)
Dhana Lakshmi (1)
Sardar Mudassar Ali Khan (1)
Ratnesh Singh (1)
Jagannath Sethi (1)
Matthew Cochran (1)
Aravind Govindaraj (1)
Arindam Dawn (1)
Anupam Maiti (1)
Sandeep Mishra (1)
Ravi Raghav (1)
Damodara Naidu (1)
Tural Suleymani (1)
Mohomed Shihan (1)
Ojash Shrestha (1)
Rikam Palkar (1)
Rahim Lotfi (1)
Hisham Nawzer (1)
Mukesh Shah (1)
Anant Vernekar (1)
Related resources for Principle
No resource found
Object Oriented Design Balancing with Anti-Single Responsibility
11/5/2024 4:18:47 AM.
This article will change your perspective on working with the Single Responsibility Principle (SRP). The main point is to focus on finding balance when designing object-oriented systems and applying S
Apply Azure Virtual Machines to the Zero Trust Principles
9/25/2024 7:04:48 AM.
This content explores the integration of Azure Virtual Machines with Zero Trust principles, emphasizing the importance of robust security in cloud environments.
Design Principle (2): Inversion of Control (IoC) Principle
9/19/2024 3:44:37 PM.
This series delves into Software Design Principles, with a focus on the Inversion of Control (IoC) Principle in this article. It covers Dependency Inversion, Dependency Injection, IoC Containers, and
Design Principle (1-1): SOLID in Code Demo
9/19/2024 3:43:58 PM.
This article will discuss the SOLID in code demo. This article series covers Software Design Principles, focusing on the SOLID principles. It includes practical code demos and explanations for each pr
Design Principle (1): SOLID in Concept
9/13/2024 12:17:57 PM.
This series explores software design principles, focusing on SOLID principles: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion, and their pract
Design Principle (0): Design Principle vs Design Pattern
9/13/2024 12:17:06 PM.
This series explores software design principles, distinguishing between high-level design principles like SOLID and low-level design patterns, offering practical guidelines and implementation strategi
Understanding Dependency Inversion Principle (DIP) with C#
8/27/2024 9:40:32 AM.
This guide explains how DIP enhances software design by decoupling high-level and low-level modules, promoting flexibility and maintainability. Understand its implementation using Dependency Injection
Understanding the Interface Segregation Principle (ISP) with C#
8/21/2024 4:03:01 AM.
Explore the Interface Segregation Principle (ISP) from SOLID design principles to ensure code flexibility and maintainability. ISP advocates for breaking down large, unwieldy interfaces into smaller,
Understanding the Liskov Substitution Principle (LSP) with C#
8/14/2024 8:15:01 AM.
The Liskov Substitution Principle (LSP) ensures that objects of a base class can be replaced with objects of a derived class without altering program correctness. This principle, part of SOLID design,
Understanding the Open/Closed Principle (OCP) with C#
8/12/2024 8:46:10 AM.
The Open/Closed Principle (OCP) states that software entities should be open for extension but closed for modification. This principle helps in creating flexible and maintainable code by allowing new
Understanding Builder Design Pattern
8/1/2024 6:14:40 AM.
The Builder is a pattern that belongs to the creational design patterns family. What makes it special is its ability to provide abstraction to the client by encapsulating different types of the same o
Design Pattern (3-1), Differences between Singleton & Static Class
7/29/2024 2:24:17 AM.
This article will discuss the Differences between Singleton and Static Class. This series explores Design Patterns, starting with MVC. The article discusses differences between Singleton and Static cl
Design Pattern (5), Dependency Injection
7/29/2024 2:22:29 AM.
This article discusses Dependency Injection. This article series covers Design Patterns, starting with MVC. This specific article focuses on Dependency Injection (DI) in .NET, explaining the Dependenc
FIRST Principles of Unit Testing: A Guide to Quality Code in C#
6/12/2024 5:46:57 AM.
Emphasizing the FIRST principles (Fast, Independent, Repeatable, Self-validating, and Timely), this guide equips developers with the techniques and best practices needed to ensure robust, reliable, an
Introduction to Agile Development: Principles and Practices
6/12/2024 5:31:43 AM.
Agile development is a dynamic approach to software projects, emphasizing iterative progress, collaboration, and flexibility. Grounded in the Agile Manifesto, it values customer satisfaction, adaptabi
Principle Component Analysis
6/5/2024 11:10:34 AM.
Principal Component Analysis is a powerful tool in the arsenal of data scientists and researchers. It simplifies complex datasets, enhances visualization, reduces noise, and improves the efficiency of
What Are The Twelve Codd's Principles In DBMS
6/5/2024 10:50:53 AM.
Edgar F. Codd's twelve rules define relational database management systems (RDBMS), ensuring data integrity and consistency. These guidelines aid in robust database design and management, facilita
Basic Principles of .NET Core for Modern Development
6/3/2024 9:38:36 AM.
.NET Core, developed by Microsoft, is a versatile, cross-platform framework for modern applications. It offers modularity, high performance, and compatibility across operating systems. With strong co
Understanding SOLID Principles in .NET Core
6/2/2024 10:05:10 AM.
SOLID principles are a set of five design principles in object-oriented programming that aim to make software designs more understandable, flexible, and maintainable. In this blog post, we’ll explore
Mastering SOLID Principles in C# with Real-Time Examples
5/29/2024 5:39:49 AM.
Mastering SOLID principles in C# enhances software design by promoting maintainability, scalability, and robustness. These principles include Single Responsibility, Open/Closed, Liskov Substitution, I
Understanding the SOLID Principles in Object-Oriented Design
5/18/2024 6:36:28 AM.
The SOLID principles are five foundational design guidelines proposed by Robert C. Martin to create maintainable, flexible, and understandable object-oriented software, aiding in adaptability and ease
CRUD Operations Using the Generic Repository Pattern and Dependency Inversion Principle With IoC Container and DI in MVC
5/13/2024 11:17:00 AM.
Learn how to implement CRUD operations using the Generic Repository Pattern and Dependency Inversion Principle (DIP) in an MVC application. Explore the integration of an IoC Container for Dependency I
Mastering OOP in C#: A Real-World Project Journey
5/13/2024 4:57:51 AM.
Explore Object-Oriented Programming in C# through a practical journey. Learn key concepts like inheritance, polymorphism, and encapsulation while working on real-world projects. Master C# development
An Overview on Domain Driven Design (DDD)
5/13/2024 3:55:21 AM.
Explore the fundamentals of Domain Driven Design (DDD) in this overview, focusing on principles like domain modeling, ubiquitous language, and bounded contexts.
SOLID Principles in Software Development using C#
5/9/2024 5:21:11 AM.
This article will explore each SOLID principle and demonstrate how they can be applied in C#.
Guiding Principles in Artificial Intelligence
5/8/2024 6:24:19 AM.
In this article, we delve into the key guiding principles of Artificial Intelligence. Each principle plays a pivotal role in shaping the development, deployment, and regulation of AI systems, ultimate
Learn About SOLID Principles
5/7/2024 11:24:48 AM.
SOLID principles are fundamental to object-oriented design, ensuring code is clean, maintainable, and scalable. Learn SRP, OCP, LSP, ISP, and DIP for robust, flexible software architecture.
Understanding the Single Responsibility Principle (SRP) using C#
5/2/2024 5:03:22 AM.
The article delves into the Single Responsibility Principle (SRP) in C#, emphasizing its importance in object-oriented programming. It illustrates SRP violations and provides improved code examples fo
S.O.L.I.D Principles - A Primer
4/29/2024 5:51:10 AM.
Explore the essential S.O.L.I.D principles in software development for robust, maintainable code. Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Invers
Dependency Injection and Service Lifetimes in .NET Core
4/19/2024 5:02:29 AM.
Dependency Injection (DI) simplifies software development by promoting loosely coupled code, aligning with the Dependency Inversion Principle of SOLID. In this guide, we'll explore how to implemen
REST APIs: Principles, Components, and Advantages
4/19/2024 4:48:44 AM.
In today's interconnected digital world, the need for efficient communication between software systems has never been greater. In this article, we'll delve into the world of REST APIs, explori
SOLID Principles In Flutter Development
4/16/2024 5:05:02 AM.
Explore how SOLID principles can enhance your Flutter development process. Learn how to apply these principles to create more understandable, flexible, and maintainable software designs.
SOLID Principles in C# for Employee Management Example Mastering
4/11/2024 4:56:36 AM.
SOLID principles are a set of design principles that help developers create maintainable, scalable, and flexible software. In this article, we'll explore each of the SOLID principles: Single Respo
Mastering SOLID Design Principles in C#
4/11/2024 3:58:49 AM.
SOLID design principles provide guidelines for creating maintainable, flexible, and scalable software. They enhance code readability, reduce duplication, and promote effective testing. Principles like
Learn Principles Of Lean Thinking
4/5/2024 5:44:22 AM.
In this article, we will learn Principles of Lean Thinking" encapsulates the core tenets of Lean Manufacturing, emphasizing continuous improvement and waste reduction.
All-in-One Architecture/Monolithic Architecture in .NET
4/4/2024 4:37:26 AM.
The "All-in-One" architecture, also known as the Monolithic architecture, is a traditional software design approach where all components of an application are tightly integrated into a singl
Dependency Inversion Principle (DIP)
4/2/2024 5:43:52 AM.
The Dependency Inversion Principle (DIP) advocates that high-level modules shouldn't rely on low-level modules. Instead, both should depend on abstractions, reducing coupling and facilitating futu
Learn Open/Closed Principle (OCP)
4/2/2024 5:16:26 AM.
The Open/Closed Principle (OCP) emphasizes that software entities should be open for extension but closed for modification. It enables adding new functionalities without altering existing code structu
Learn Interface Segregation Principle (ISP)
4/2/2024 4:11:52 AM.
Learn about the Interface Segregation Principle (ISP) for cleaner and more maintainable code. Discover how segregating interfaces based on functionality improves system clarity and prevents unnecessar
Learn Liskov Substitution Principle (LSP)
4/1/2024 11:49:58 AM.
Explore the Liskov Substitution Principle (LSP) for robust software design. Learn how to ensure derived classes can seamlessly substitute base classes, avoiding unexpected behaviors and maintaining co
Single Responsibility Principle (SRP)
3/30/2024 8:40:56 AM.
This article explores the Single Responsibility Principle (SRP), emphasizing the importance of class cohesion and minimizing reasons for modification. It provides examples of code violating and adheri
Learn Service Locator Pattern in C#
3/26/2024 11:29:22 AM.
This beginner’s tutorial explores the Service Locator Pattern in C#. Despite its decline in favor of Dependency Injection, it remains relevant for legacy systems. The tutorial covers its implementati
Solid Principle in C# : A Quick Reference with Example
3/24/2024 6:02:50 PM.
These principles guide object-oriented design for more understandable, flexible, and maintainable software. The Single Responsibility Principle suggests a class should have only one reason to change,
Web API Design Principles Or Web API Design Guidelines
3/19/2024 6:10:44 AM.
This article delves into the best practices for implementing and designing web APIs. It emphasizes the importance of considering both the API implementation and consumer perspectives. Key points inclu
What Is DevOps And Its Key Principles
3/15/2024 6:16:52 AM.
DevOps merges development and operations, emphasizing collaboration, automation, and continuous integration. Key principles include infrastructure as code, agile practices, and a feedback loop for mon
Introduction to Structure Map
2/28/2024 6:58:30 AM.
This article provides an introduction to the concepts of the Dependency Injection Principle (DIP) and Inversion of Control (IOC), explaining their significance in software development.
DRY, YAGNI, KISS Engineering Principles
2/19/2024 10:51:37 AM.
In software development and engineering, certain guiding principles serve as beacons of efficiency and effectiveness. Among these principles, DRY, YAGNI, and KISS stand out as fundamental pillars that
SOLID Principles In C# - Liskov Substitution Principle
2/15/2024 7:10:01 AM.
C# is an object-oriented programming language. These days whenever you talk about object-oriented programming you hear the acronym, SOLID. These are five design principles introduced by Michael Feathe
Dependency Inversion Principle
2/15/2024 6:57:31 AM.
In this article, you will learn about the Dependency Inversion Principle. The Dependency Inversion Principle (DIP) in SOLID, outlined by Robert C. Martin, advocates that high-level modules should depe
Open Closed Principle in SOLID
2/15/2024 6:51:23 AM.
In this article, we will learn about the Open Closed Principle. The Open Closed Principle (OCP) in SOLID, coined by Robert C. Martin, asserts that software entities should be open for extension but cl
Interface Segregation Principle
2/15/2024 6:51:21 AM.
In this article, you will learn about the Interface Segregation Principle. The Interface Segregation Principle (ISP) in SOLID, by Robert C. Martin, emphasizes coding according to specific interfaces r
Liskov Substitution Principle
2/15/2024 6:41:43 AM.
This article explains the Liskov Substitution Principle. The Liskov Substitution Principle (LSP), a key SOLID principle by Barbara Liskov, advocates seamless substitution of base class objects with de
What is Single Responsibility Principle
2/15/2024 5:57:43 AM.
In this article, you will learn about the Single Responsibility Principle. The Single Responsibility Principle (SRP) in SOLID, emphasized by Robert C. Martin, asserts that a class or function should h
How to Make REST APIs Idempotent?
1/16/2024 8:41:00 AM.
Some HTTP methods are by default Idempotent and some we need to make them Idempotent to avoid but obvious issues in our REST APIs
The SOLID Principles in C#
1/10/2024 8:27:55 AM.
Explore the SOLID principles in C# programming for maintainable, scalable, and adaptable code. Dive into Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency
Single Responsibility Principle
1/10/2024 6:21:17 AM.
The Single Responsibility Principle emphasizes that a class should have a single reason to change, focusing on one task. This ensures cleaner, smaller classes with well-defined responsibilities and im
Interface Segregation Principle
1/10/2024 6:15:27 AM.
The Interface Segregation Principle advocates breaking down a large interface into smaller, client-specific interfaces. This ensures that no class is compelled to depend on methods it doesn't use,
Dependency Inversion Principle VS Dependency Injection in C#
1/4/2024 8:33:40 AM.
Dependency Inversion Principle (DIP) and Dependency Injection (DI) are pivotal in crafting resilient software. Learn their implementations in C# for modular, adaptable, and maintainable code structure
Why do We Use Dependency Injection?
12/11/2023 7:27:32 AM.
What is a dependency injection and why to embrace it as a better programming practice.
Interface Segregation Principle (ISP) in .NET 6 Core
11/15/2023 10:55:55 AM.
As we navigate the SOLID principles in the realm of .NET 6 Core, the Interface Segregation Principle (ISP) takes center stage. This principle emphasizes creating specialized interfaces for clients rat
Liskov Substitution Principle (LSP) in .NET 6 Core
11/15/2023 9:13:04 AM.
As a burgeoning developer delving into the SOLID principles, understanding the Liskov Substitution Principle (LSP) is pivotal for crafting robust and maintainable code. In this article, we'll demy
Interface Segregation Principle in Object-Oriented Design
11/10/2023 5:36:10 AM.
This article explains about Interface Segregation Principle (ISP), and its application in C# is clear and well-illustrated through the example of a shape drawing application. Breaking down a generic I
SOLID Principles: Practical Examples for Better Software Design
11/7/2023 4:32:08 AM.
There are some essential principles and best practices that are generally recommended to help manage code and projects more easily. These practices make the code easier to maintain, scale, adopt, and
Dependency Inversion Principle in C#
11/2/2023 5:50:24 AM.
This blog effectively explains the Dependency Inversion Principle (DIP) in the context of C# programming, providing a clear understanding of its significance and benefits. The use of real-world exampl
Interface Segregation Principle (ISP)
10/30/2023 9:42:49 AM.
I= Interface Segregation Principle , is one of the five SOLID principles of object-oriented programming.
Liskov Substitution Principle
10/30/2023 7:12:23 AM.
Liskov Principle is part of SOLID Design Principles. The Liskov Substitution Principle (LSP) is a fundamental concept in object-oriented programming that ensures the correct design of inheritance hier
Open-Closed Principle (OCP) in .NET 6 Core
10/30/2023 5:50:49 AM.
As a beginner developer, you're likely on a quest to create clean, maintainable, and scalable code. One of the guiding principles in this journey is the "Open-Closed Principle" from the
Overview Of SOLID Principles In C#
10/30/2023 5:04:17 AM.
This article explains the basic rules which are combined and called the SOLID Principles. SOLID principles are a set of design principles in object-oriented programming (OOP) that help developers crea
Single Responsibility Principle (SRP) in .NET Core
10/23/2023 8:19:29 AM.
As a developer with one year of experience, you've likely come across the SOLID principles, a set of five principles that promote clean, maintainable, and scalable code. Among these principles, th
Coding Principles - SOLID
10/6/2023 9:37:30 AM.
Solid Principles & Design Patterns explained.
Coding Principles - DRY and KISS
10/6/2023 9:34:11 AM.
This article explains DRY (Don't Repeat Yourself), KISS (Keep It Simple, Stupid) principles.
Building Flexible And Future-Proof C# Applications With Examples
9/27/2023 6:11:38 AM.
This article explores the Open Closed Principle (OCP), one of the SOLID principles of object-oriented design, and how it can help developers build flexible and future-proof C# applications. By adherin
SOLID Principle of Object Oriented Programming in C#
9/25/2023 9:02:45 AM.
The SOLID principles along with examples and explanations. These principles are indeed important for designing maintainable and robust software systems. If you have any specific questions or if there&
SOLID Principles In C# - Dependency Inversion Principle
9/17/2023 8:41:47 PM.
C# is an object-oriented programming language. These days whenever you talk about object-oriented programming you hear the acronym, SOLID. These are five design principles introduced by Michael Feathe
Understanding S.O.L.I.D. Principles in C#
9/13/2023 8:53:58 AM.
Learn how to apply the five key principles of Object-Oriented Programming (OOP) - Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion - in C# with
Software Testing - Best Practices And Principles To Write Unit Testing
8/31/2023 10:10:32 AM.
In this article, you will learn best practices and principles to write Unit testing.
Software Testing Approaches And Techniques
8/23/2023 8:34:38 AM.
This article give you a general best practices guidelines for writing software test according to the testing principles.
Writing Better Code -- Keepin' it Cohesive
7/20/2023 7:12:26 AM.
One of the aspects of code quality we can look at is cohesion. If code is highly cohesive it is also much more testable, reusable, readable and maintainable (all the good things in life). Likewise,
Backpressure Pattern- Design Principle
5/31/2023 10:24:27 AM.
The backpressure pattern is a design principle used in software systems to manage and regulate the flow of data between components or services.
Applying SOLID Principles in Angular Development: Building Robust and Maintainable Applications
5/27/2023 2:12:52 PM.
Explore the practical implementation of SOLID principles in Angular development with code examples. Learn how Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Depend
Cloud FinOps - What it is and Why You Need it
4/27/2023 9:41:14 AM.
This article explains Cloud FinOps in detail. What is it? Why do we need it? When to use it?
4C Principle Behind Microsoft Team
4/27/2023 5:34:22 AM.
We will learn about 4C principle behind Microsoft Teams, How to create a project-based team, Channel for sub teams, Add apps and resources in a channel.
SOLID With .Net Core
3/27/2023 5:30:04 AM.
This article will explain the SOLID principles along with a practical sample of how to apply each of them.
Clean Coding Practices In .NET - Unit Tests And SOLID Principles
3/20/2023 8:25:31 AM.
In this article, you will learn about Clean Coding Practices in .NET: Unit Tests and SOLID Principles.
SOLID Principles In C# With Examples
3/13/2023 6:11:46 AM.
In this article, I'm going to explain SOLID principles in C#, including Single Responsibility Principle (SRP), Open Closed Principle (OSP), Liskov Substitution Principle (LSP), Interface Segregati
The Single Responsibility Principle You Don't Know
9/2/2022 5:38:22 AM.
In this article, you will learn about the single responsibility principle you don't know.
SOLID - Single Responsibility Principle With C#
8/23/2022 5:25:26 AM.
In this article for discussion and explanation purpose, I am introducing to you, two fictional characters Mark (a .NET developer) and Bob (a Tech Lead).
Types Of Service Principals Authentication Methods
7/26/2022 9:46:26 PM.
In this article, you will learn the types of service principals authentication methods.
Design Principles For Better Software
7/18/2022 6:23:11 AM.
This article is about design principles and will help in basic understanding of most important principles used in better software development
Solid Principles Simplified (C#, .Net 5)
6/30/2022 1:46:41 PM.
This article is about Solid principles, concepts are described with examples for clear understanding of each principle.
Design Principles In Software Architecture
6/21/2022 11:48:31 AM.
This article discusses about the Design Principles and Standards extensively used in Software Architecture which are time-tested and relevant as of 2021.
Creating An Extension Method To Get Enum Description
3/30/2022 12:55:39 PM.
This article will take you down the rabbit hole to understand the extension methods in C#.
Introduction Of ASP.NET Unique Architecture (AUA)
11/2/2021 9:21:53 AM.
AUA ( Asp.Net Unique Architecture ) Framework, you can easily have better, faster, and more orderly and focused coding. This framework is based on new and up-to-date concepts, structures and architect
How To Create Extensible Software Components
9/13/2021 5:08:24 AM.
As we grow as a software engineers it is important for us to learn the best practices to increase the quality of the code. In this article I would like write on what is extensible software components
Liskov Substitution Principle
8/9/2021 6:36:21 AM.
In this article, you will learn about Liskov Substitution Principle.
Quick Start On Observer Design Pattern
6/7/2021 7:12:52 AM.
Understanding of observer Design Patterns with real-world analogy and technical implementation in c#.
Interface Segregation Principle Using Python
4/1/2021 12:03:41 PM.
In this article we will learn about one of the Solid Principle i.e. Interface segregation principle
S.O.L.I.D Principles with C#
3/30/2021 9:28:12 AM.
In this video, I break down the 5 principles from SOLID alongside their common scenarios and how to apply the right principle to fix them
Interface Segregation Principle Using Java
3/25/2021 7:31:28 PM.
In this article we will learn about one of the Solid Principle i.e. Interface segregation principle
Interface Segregation Principle Using C#
3/24/2021 2:57:26 PM.
In this article, we will learn about one of the Solid Principle i.e. Interface segregation principle