Coupling Resources

Share

Related resources for Coupling

Implement the Mediator Pattern in a .NET Web API12/17/2024 10:44:03 AM. Learn how to implement the Mediator Pattern in a .NET Web API using the MediatR library. This design pattern reduces tight coupling between components by centralizing communication through a mediator.
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,
Builder Design Pattern in .NET Core C#8/9/2024 5:34:59 AM. The Builder Design Pattern in .NET simplifies constructing complex objects by using a step-by-step approach. It involves components like Abstract Builder, Concrete Builder, Director, and Product to se
Dependency Injection in ASP.NET Core7/16/2024 5:41:43 AM. Dependency Injection (DI) in ASP.NET Core enhances modularity, testability, and maintainability by providing class dependencies externally via the built-in Inversion of Control (IoC) container. Config
Introduction To MediatR Pattern6/5/2024 11:08:55 AM. MediatR pattern promotes loose coupling by facilitating in-process messaging, reducing dependencies between objects. It enables one-way broadcast communication, allowing objects to communicate solely
Creating Azure Service Bus Queues And Sending Messages To Queues4/17/2024 7:45:35 AM. Service buses facilitate decoupling of applications/services via messaging queues. Queues created through Azure Portal or Service Bus Explorer. Settings like Enable Sessions and Dead Lettering enhance
Microsoft.Extensions.DependencyInjection for Dependency Injection4/16/2024 5:51:27 AM. Dependency Injection (DI) is a software development design pattern that aims to achieve loose coupling between components and enhance the maintainability, testability, and scalability of applications.
Attribute Based Routing In ASP.NET MVC 54/1/2024 8:15:42 AM. Explore ASP.NET MVC 5's attribute-based routing, offering debugging ease, decoupling benefits, and flexible route configuration. Learn to optimize routing with RoutePrefix, Route Constraints, and
Learn Everything About REST API3/21/2024 6:31:08 AM. This tutorial covers building a full-fledged application with WPF, REST API, and Entity Framework. It emphasizes the importance and implementation of REST APIs, discussing CRUD operations and their re
Introduction to Structure Map2/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.
Loosely Coupling in Software Design2/28/2024 5:16:40 AM. Let's learn loosely coupling in software design together! We talked about different forms of loosely coupling using C# as an example, but the topic itself is a language agnostic.
Creating Consistent ASP.NET Core Web API Responses with AutoMapper and DTOs11/17/2023 5:40:18 AM. Developing a robust ASP.NET Core Web API hinges on the subtle yet pivotal details of response structuring. Leveraging AutoMapper in tandem with well-designed Data Transfer Objects (DTOs) not only ensu
Mediator Design Pattern in ASP.NET Core Web API with 3-Tier Architecture10/19/2023 5:10:38 AM. The Mediator Design Pattern is a behavioral design pattern that defines an object that centralizes communication between a set of objects. It promotes loose coupling between components by preventing d
Efficient ASP.NET Core Web API Development with Clean Architecture, Flyweight Pattern10/11/2023 6:35:10 AM. the implementation of the CarCompany CRUD operations within an ASP.NET Core Web API, following the Clean Architecture principles, has been successfully structured. The separation of concerns into laye
Measure Depth Of Inheritance And Class Coupling In Visual Studio10/6/2023 5:24:36 AM. Here, we will see how to measure depth of inheritance and class coupling in the Visual Studio environment.
Differences Between CQRS, MediatR, and CRUD9/21/2023 10:35:46 AM. Explore the differences between CQRS, MediatR, and CRUD in this insightful article. Learn when to use each technique, their unique benefits, and find scenarios where they shine in .NET development.
Object Instantiation in C#: Part II - Factory Methods9/18/2023 5:06:14 AM. There are many ways to approach object instantiation. In this article we’ll cover a few of the patterns used to instantiate objects. We'll look at different instantiation patterns used to con
Basics of Dependency Injection1/1/2021 12:17:46 PM. In this article we will learn about Dependency Injection.
Voice Of A Developer: Decoupling Your Application - Part 356/5/2020 9:59:37 AM. In this article, you will learn about decoupling your application in JavaScript.
Dependency Injection - Part Four -Embracing Abstraction2/12/2018 1:27:54 AM. Dependency Injection (DI) is a technique that helps us achieve loose coupling between objects and their collaborators. In this post, we will use constructor based dependency injection, however, we ar
Dependency Injection - Part One -Tightly Coupled Application8/18/2017 4:16:10 AM. It is a best practice to use interfaces instead of concrete classes. These interfaces can then be mocked at the time of unit testing, which will prevent any call to the actual database. Also, it is a
Dependency Injection - Part Two - Five Reasons To Write Loosely Coupled Code8/18/2017 4:15:44 AM. A loosely coupled application has good isolation among its classes, modules and assemblies. Therefore, if we make a change to one part of the application, we only need to update the relevant modules.
Analyzing A Tightly Coupled Application8/18/2017 2:04:23 AM. In this video, we looked at a tightly coupled application and tried to understand the problems associated with the same. You may also visit my article about the same at http://www.c-sharpcorner.com/ar
Overview Of Delegates12/18/2015 12:48:35 AM. In this article you will learn about Delegates and its types.
In Depth Look: Strategy Design Pattern, Dependency Injection (DI), Open/Closed Principle (OCP) and Loose Coupling6/6/2015 11:46:58 PM. This article explains the Strategy Design Pattern, Dependency Injection, Open/Closed principle and Loose Coupling.
Onion Architecture Using MVC and Database First Approach5/5/2015 6:08:09 PM. The main purpose of this article is try to explain the Onion Architecture and provide sample sample code that is loosely coupled and easily maintainable.
Constructor Dependency Injection Pattern Implementation in C#5/25/2014 4:54:02 PM. This article is about the Constructor Dependency Injection Pattern Implementation in C#.
Dynamic WCF Usage in Client6/13/2013 2:00:54 PM. I have decided to show a Channel Factory usage in the client side.The Channel Factory will be created in a generic ServiceFactory according to ServiceContract type. It will provide us full isolated usage WCF service more dynamically than adding a service into the service references. Also I would like to show us proxy and channelFactory usage differences.
Difference Between Loose Coupling and Tight Coupling12/21/2012 7:39:35 AM. The pros and cons Loose Coupling and Tight Coupling.
Implement Concrete Factory Design Pattern using Reflection in VB.NET11/10/2012 12:42:30 AM. Reflection is used to dynamically create an instance of a type, bind the type to an existing object, or get the type from an existing object. In this example, we implement Concrete Factory Pattern using Reflection to fetch records from MS-Access and MS-SQL Database.
A Better Solution for Enterprise Architects - SOA : Part I10/13/2012 4:24:30 AM. I would like to begin to determine what SOA (service-oriented architecture) is technically meaning. We can clearly say SOA is a methodology for designing software architectures to utilize and organize distributed systems using loosely coupled software services.
S.O.L.I.D Design Principles Explained : Part 28/13/2012 3:13:28 PM. Here we will discuss the second letter in the word SOLID i.e., O. O stands for OCP (Open Closed Principle).
S.O.L.I.D Design Principles Explained : Part 18/13/2012 2:45:19 PM. This article will cover the acronyms for SOLID and a brief introduction to Cohesion and Coupling is provided to understand the SOLID principles.
Design pattern -Inversion of control and Dependency injection11/6/2008 4:28:49 AM. In this section we will discuss about how IOC and DI can help us build loosely coupled software architecture.

Topics