Resources   No resource found

• Understanding SOLID Principles with simple Console App in .NET Jun 28, 2025. This article breaks down each principle — Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion — with simple console app.
• Understanding the Dependency Inversion Principle (DIP) in SOLID DesignApr 08, 2025. The Dependency Inversion Principle (DIP) promotes decoupling by ensuring high-level modules depend on abstractions, not concrete implementations, enhancing flexibility, testability, and maintainability in code.
• Mastering SOLID Principles in Software DesignApr 06, 2025. The SOLID principles are five key object-oriented design guidelines—Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion—aimed at writing clean, maintainable, and scalable software systems.
• Understanding SOLID PrinciplesJan 30, 2025. Hello all, I am trying to explain about SOLID principles the main and important principles of any programming language. Please after reading this content if you have any questions or any suggestions please le me know in the comment box. Thank you!.
• The SOLID Principles in C# 13Jan 25, 2025. Ziggy Rafiq's detailed examples provide an overview of the SOLID principles of object-oriented design in C# 13. You'll learn how to adhere to SRP, OCP, LSP, ISP, and DIP to write maintainable, scalable, and extensible code.
• Design Principle (1-1): SOLID in Code DemoJun 28, 2024. 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 principle: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion.
• Design Principle (1): SOLID in ConceptJun 26, 2024. This series explores software design principles, focusing on SOLID principles: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion, and their practical application in software development.
• Understanding SOLID Principles in .NET CoreJun 02, 2024. 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 each SOLID principle in detail with examples implemented in .NET Core.
• Mastering SOLID Principles in C# with Real-Time ExamplesMay 29, 2024. Mastering SOLID principles in C# enhances software design by promoting maintainability, scalability, and robustness. These principles include Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion.
• Understanding the SOLID Principles in Object-Oriented DesignMay 18, 2024. 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 of extension.
• Mastering SOLID Design Principles in C#Feb 14, 2024. SOLID design principles provide guidelines for creating maintainable, flexible, and scalable software. They enhance code readability, reduce duplication, and promote effective testing. Principles like SRP, OCP, LSP, ISP, and DIP ensure clear responsibilities, extensibility, and decoupling.
• The SOLID Principles in C# Jan 10, 2024. 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 Inversion with practical examples.
• Applying SOLID Principles in Angular Development: Building Robust and Maintainable ApplicationsMay 27, 2023. Explore the practical implementation of SOLID principles in Angular development with code examples. Learn how Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion principles enhance the architecture and maintainability of your Angular applications. Build robust and scalable codebases with these proven principles.
• Clean Coding Practices In .NET - Unit Tests And SOLID PrinciplesMar 20, 2023. In this article, you will learn about Clean Coding Practices in .NET: Unit Tests and SOLID Principles.
• Introduction To SOLID PrinciplesSep 24, 2020. In this article, you will learn about SOLID Principles.
• D In SOLID - Dependency Inversion Principle (DIP)Oct 29, 2019. In this article, you will learn about Dependency Inversion Principle.
• I In SOLID - Interface Segregation Principle (ISP)Oct 16, 2019. In this article, you will learn about I in SOLID - Interface Segregation Principle (ISP).
• L In SOLID - Liskov Substitution PrincipleSep 24, 2019. In SOLID, L stands for Liskov's Substitution Principle. LSP states that the object of the derived class should be able to replace an object of the base class without any issue in the application or changing the behavior of the base class.
• O In The SOLID - Open Closed Principle (OCP)Sep 21, 2019. In this article, you will learn about O, i.e., the Open-Closed Principle (OCP) in SOLID.
• S In The SOLID - Single Responsibility Principle (SRP)Sep 16, 2019. In this article, you will learn about S in the SOLID - Single Responsibility Principle (SRP).
• What Is SOLID And Why SOLID In C#Sep 16, 2019. In this article, we are discussing SOLID Principles and why software developers and architects highly recommend using these principles.
• Deep Dive Into SOLID PrinciplesJul 28, 2019. In this article, you will learn about SOLID principles with real time examples.
• Learn About SOLID PrinciplesApr 01, 2019. 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.
• An Overview Of SOLID PrinciplesApr 20, 2017. An overview of SOLID Principles. SOLID. abbreviation means S for Single Responsibility, O for Open Close principle, L for Liskov Substitution principle, I for Interface segregation principle, D for Dependency inversion principle.
• Overview of SOLID PrincipleJul 13, 2015. In this article you will learn about SOLID principles.
• Overview Of SOLID Principles In C#Apr 06, 2015. 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 create more maintainable, flexible, and robust software. These principles were introduced by Robert C. Martin and are represented by the acronym SOLID, where each letter stands for a different principle.
• C# Corner Chandigarh Chapter Webinar 14th September 2014 Official Recap - SOLID Design PrinciplesSep 29, 2014. The C# Corner Chandigarh Chapter held its event on the 14th of September 2014. It was a house full of attendees who came across to attend this event. Thanks to all who joined us.
• WPF 3D Solid Wireframe TransformJan 24, 2011. In the very beginning, I decided to build an application in WPF that renders 3D objects, wireframe objects, and do basic 3D operations. This article is the result of the process.
• Solid Introduction to Expression Trees in C#Sep 26, 2024. This article provides a comprehensive introduction to Expression Trees in C#. You'll learn about their structure, how they represent code as data, and their applications in LINQ queries.
• SOLID Principles in Software Development using C#May 09, 2024. This article will explore each SOLID principle and demonstrate how they can be applied in C#.
• SOLID Principles In Flutter DevelopmentApr 16, 2024. 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 MasteringApr 11, 2024. 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 Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion.
• Solid Principle in C# : A Quick Reference with ExampleMar 24, 2024. 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, such as a User class handling user properties but not user persistence.
• SOLID Principles: Practical Examples for Better Software DesignNov 07, 2023. 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 read. One of the most well-regarded principles is known as the SOLID principle, and it’s something every developer, no matter what programming language or framework they use, should consider.
• Coding Principles - SOLIDOct 04, 2023. Solid Principles & Design Patterns explained.
• SOLID Principle of Object Oriented Programming in C#Sep 21, 2023. 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's anything else you'd like to know or discuss related to software development or any other topics.
• Solid Principles Simplified (C#, .Net 5)Jun 30, 2022. This article is about Solid principles, concepts are described with examples for clear understanding of each principle.
• SOLID With .Net CoreApr 16, 2021. This article will explain the SOLID principles along with a practical sample of how to apply each of them.
• SOLID Principles In C# - Dependency Inversion PrincipleMay 29, 2020. 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 Feathers to make our object-oriented applications easy to understand, maintain and expand as future requirements change. Today, we will look at the fifth and final principle with an example. I covered the first four principles in my previous articles.
• SOLID Principles In C# - Interface Segregation PrincipleMay 29, 2020. 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 Feathers to make our object-oriented applications easy to understand, maintain, and expand as future requirements change. Today, we will look at the fourth principle with an example. I covered the first three principles in my previous articles.
• SOLID Principles In C# - Liskov Substitution PrincipleMay 27, 2020. 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 Feathers to make our object-oriented applications easy to understand and maintain.
• SOLID Principles In C# - Single Responsibility PrincipleMay 26, 2020. 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 Feathers to make our object-oriented applications easy to understand, maintain and expand as future requirements change. Today, we will look at the first principle with an example and in the following articles we will cover the remaining principles with examples of each.
• SOLID Principles In C# - Open Closed PrincipleMay 26, 2020. 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 Feathers to make our object-oriented applications easy to understand, maintain and expand as future requirements change. Today, we will look at the second principle with an example. I covered the first principle in my previous article.
• 😇SOLID Design Principles Simplified With UMLMay 11, 2020. Frequently asked interview question. & good programming practice.
• SOLID With a Simple ExampleMay 05, 2020. In this article, you will learn about SOLID with a simple example.
• SOLID - Single Responsibility Principle With C#Aug 01, 2018. 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).
• SOLID Architectural Pattern With Real World ExampleMar 09, 2017. This article explains SOLID Architectural Pattern with Real World examples.
• Open Closed Principle in SOLIDApr 27, 2015. 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 closed for modification, fostering adaptability without altering existing logic.
• SOLID Principles In C# With ExamplesOct 09, 2014. 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 Segregation Principle (ISP), and Dependency Inversion Principle (DIP)
• Demystify SOLID: D For “Dependency Inversion Principal”May 10, 2014. In this article we will discuss the last principal called “Dependency Inversion Principal”. This is one of the important principals to develop de-coupled architecture.
• Demystify SOLID: I For "Interface Segregation Principal"Apr 28, 2014. In this article we will understand the interface segregation principal.
• Demystify SOLID: L For “Liskov Substitution Principal”Apr 26, 2014. In this series we are talking about a SOLID principal of software development.
• Demystify SOLID: "O" For Open Close PrincipalApr 24, 2014. As per the title, this article exlains the concept of “Open close principal in this article”.
• Demystify SOLID: "S" For Single Responsibility PrincipalApr 23, 2014. In this article we will discuss the meaning of S in the SOLID principal.
• SOLID (Object Oriented Design) PrinciplesMar 24, 2014. This article attempts to describe the best technique for writing code that requires a minimum of changes to add/modify requirements that are easily scale-able and most importantly, reusable. This is where the S.O.L.I.D. principles and Design patterns are useful.
• The Open Closed Principle of SOLIDMay 22, 2013. SOLID principles are like the backbone of OOP, I've gone through with this and obtained a good understanding of this and I thought to share it so that anyone can understand this principle at MAX.
• SolidColorBrush in SilverlightApr 16, 2009. This article demonstrates how to use a solid brush in Silverlight using XAML and C#.
• Mastering the Factory Pattern in C# 13: Best Practices with Real-World ExamplesJun 08, 2025. With this best practices guide by Ziggy Rafiq, you will learn Factory Pattern in C# 13 with clean architecture, DI, and testable design.
• Building a Clean ASP.NET Core API with C# 13, EF Core, and DDDJun 02, 2025. The guide is written by Ziggy Rafiq and follows real-world architecture and testing best practices to provide a clean, scalable REST API using ASP.NET Core, C# 13, EF Core, and MS SQL.
• Clean Code and Best Practices with C# 13Jun 01, 2025. Ziggy Rafiq teaches you how to create clean, maintainable, and testable C# 13 code using modern features, architecture patterns, and clean code principles.
• Open/Closed Principle (OCP)Apr 08, 2025. The Open/Closed Principle encourages extending software functionality without modifying existing code. It enhances flexibility, reduces bugs, and promotes maintainability by using interfaces and polymorphism for scalable, change-resilient design.
• Interface Segregation Principle (ISP)Apr 08, 2025. The Interface Segregation Principle (ISP) is one of the SOLID principles of object-oriented design. It promotes creating small, specific interfaces so that implementing classes don’t need to depend on methods they don’t use, leading to cleaner, modular code.
• Liskov Substitution Principle (LSP)Apr 07, 2025. Understand the Liskov Substitution Principle (LSP), a key SOLID principle that ensures subclasses can replace base classes without errors, promoting reliable inheritance, clean abstraction, and maintainable object-oriented design.
• Simple Best Practices for Code Quality and Performance in .NETApr 07, 2025. Let's break down some best practices for writing good and fast code in .NET, using simple examples and including important principles that anyone can understand.
• Understanding the Single Responsibility Principle (SRP)Apr 06, 2025. This code demonstrates the Single Responsibility Principle by separating concerns: salary calculation, report generation, and data persistence are handled by dedicated classes, keeping the Employee class clean.
• Understanding IT Solution ArchitectureMar 12, 2025. Solution architecture is focused mainly on the understanding of the business requirements and based on that need to design the project. Solutions should be designed in a way that it will be easy for maintenance and updates.
• Object Oriented Design Balancing with Anti-Single ResponsibilityNov 05, 2024. 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 SRP.
• Understanding Dependency Inversion Principle (DIP) with C#Aug 27, 2024. 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 and best practices in C#.
• Design Principle (0): Design Principle vs Design PatternJun 24, 2024. This series explores software design principles, distinguishing between high-level design principles like SOLID and low-level design patterns, offering practical guidelines and implementation strategies for creating better software applications.
• Mastering OOP in C#: A Real-World Project JourneyMay 13, 2024. 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 with hands-on examples, SOLID principles, and design patterns in Visual Studio and .NET framework.
• Understanding the Single Responsibility Principle (SRP) using C#May 02, 2024. 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 for clarity.
• S.O.L.I.D Principles - A PrimerApr 29, 2024. 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 Inversion.
• Dependency Injection and Service Lifetimes in .NET CoreApr 19, 2024. 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 implement Dependency Injection and delve into the significance of different service lifetimes in .NET Core applications.
• Single Responsibility PrincipleJan 10, 2024. 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 improved maintainability.
• Interface Segregation PrincipleJan 10, 2024. 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, promoting cleaner design.
• Interface Segregation Principle (ISP) in .NET 6 CoreNov 15, 2023. 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 rather than imposing broad, one-size-fits-all contracts.
• Liskov Substitution Principle (LSP) in .NET 6 CoreNov 15, 2023. 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 demystify LSP and illustrate its application in .NET 6 Core through a familiar context—a chain of classes. We'll employ a comparable example to the ones used in our previous discussions on the Single Responsibility Principle (SRP) and the Open-Closed Principle (OCP)
• Interface Segregation Principle (ISP)Oct 30, 2023. I= Interface Segregation Principle , is one of the five SOLID principles of object-oriented programming.
• Liskov Substitution PrincipleOct 30, 2023. 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 hierarchies. It was introduced by Barbara Liskov, an American computer scientist, in 1987. The principle emphasizes that objects of a superclass should be replaceable with objects of its subclasses without affecting the functionality of the program. It essentially deals with the behavior of objects when they are used in place of their parent objects.
• Single Responsibility Principle (SRP) in .NET CoreOct 23, 2023. 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, the Single Responsibility Principle (SRP) is fundamental and worth mastering. In this article, we'll explain SRP in a beginner-friendly manner and provide a straightforward .NET Core example to illustrate its significance.
• Coding Principles - DRY and KISSOct 06, 2023. This article explains DRY (Don't Repeat Yourself), KISS (Keep It Simple, Stupid) principles.
• Understanding S.O.L.I.D. Principles in C#Sep 13, 2023. 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 real-world examples for cleaner and more maintainable code.
• The Single Responsibility Principle You Don't KnowSep 02, 2022. In this article, you will learn about the single responsibility principle you don't know.
• Design Principles For Better SoftwareJul 18, 2022. This article is about design principles and will help in basic understanding of most important principles used in better software development
• Creating An Extension Method To Get Enum DescriptionMar 30, 2022. This article will take you down the rabbit hole to understand the extension methods in C#.
• Multiple Interface Implementations In ASP.NET CoreFeb 21, 2022. ASP.NET Core has built-in support for dependency injection. However, multiple implementations of an interface in ASP.NET Core is tricky. In this article, I’m going to explain two approaches through which how we can dynamically select a service from such an implementation in ASP.NET Core
• Introduction Of ASP.NET Unique Architecture (AUA)Nov 02, 2021. 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 architectures, including: Clean Architecture, Clean Code, Domain-driven design (DDD), Lmax Architecture , SOLID Principle, Code Refactoring, GRASP (object-oriented design principle)AUA is a simple, lightweight framework for producing projects of any size (small and large).
• How To Create Extensible Software ComponentsSep 13, 2021. 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 and how we can implement in our codebase by applying concepts such as abstraction, Dependency Injection.
• Liskov Substitution PrincipleAug 08, 2021. In this article, you will learn about Liskov Substitution Principle.
• Quick Start On Design Pattern In C#Jun 21, 2021. In this article, you will learn about Design Patterns and it's benefits.
• Interface Segregation Principle Using PythonMar 25, 2021. In this article we will learn about one of the Solid Principle i.e. Interface segregation principle
• Interface Segregation Principle Using JavaMar 25, 2021. In this article we will learn about one of the Solid Principle i.e. Interface segregation principle
• Interface Segregation Principle Using C#Mar 24, 2021. In this article, we will learn about one of the Solid Principle i.e. Interface segregation principle
• Single Responsibility Principle (SRP)Feb 05, 2021. In this article, you will learn about the Single Responsibility Principle.
• How to Write Testable Code in .NETDec 16, 2019. Learn the art of writing testable code in .NET for robust software. Discover techniques like dependency injection and unit testing for improved code quality and easier maintenance. Master the principles of test-driven development (TDD) for resilient applications.
• Dependency Inversion PrincipleJul 07, 2015. 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 depend on abstractions rather than low-level details. This promotes flexibility and reduces tight coupling in software components.
• Interface Segregation PrincipleJul 07, 2015. 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 rather than broad ones, preventing unnecessary method implementations and enhancing code flexibility.
• Things Every Good Developer Should KnowMay 18, 2015. This article describes most of the things that every good developer should know.
• What is Single Responsibility PrincipleApr 20, 2015. 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 have only one reason to change, promoting simplicity and maintainability.
• Liskov Substitution Principle in C#Jul 27, 2014. Here you will learn about Liskov's Substitution Principle (LSP).