search

When registering dependencies in the ConfigureServices method, you must have seen a pattern like the following code snippet.

Bharat Dwarkani shared on Nov 24, 2019
image
codeburst.io
bookmarks
share
favorite_border0 visibility3
favorite_border0 visibility3 share bookmarks

Sometimes developing usable components of an application that communicate with legacy components or interfaces of other working systems require components which aren't compatible with each other to be integrated. In a real-world scenario take the example of a system which exposes a micro-USB port for communication, and we have another plugin component which needs to communicate with this system but has a USB port for its access.

Bharat Dwarkani shared on Nov 24, 2019
image
referbruv.com
bookmarks
share
favorite_border0 visibility4
favorite_border0 visibility4 share bookmarks

The third principle of the SOLID principles, which are five principles describing few fundamental rules for developing arguably ideal software components which are scalable, extensible, robust and flexible, is the Liskov Substitution Principle. This principle can be termed as one of the basic foundations of the Object Oriented Design languages which talks mainly about substitutions and inheritance.

Bharat Dwarkani shared on Nov 24, 2019
image
referbruv.com
bookmarks
share
favorite_border0 visibility0
favorite_border0 visibility0 share bookmarks

Nulls are one of the most common occurences when developing application logic, or when dealing with entities which can have a possibility of having no referenced value. A Null Object implies to no referenced value or a neutral behaviour. While this is no uncommon, but direct references to null objects can result in "code leakage" or "broken ends", where our application program might have a chance to break. A NullObject Pattern is one of the many design patterns which specifically explains about

Bharat Dwarkani shared on Nov 02, 2019
image
referbruv.com
bookmarks
share
favorite_border0 visibility9
favorite_border0 visibility9 share bookmarks

With the Repository pattern, we create an abstraction layer between the data access and the business logic layer of an application. By using it, we are promoting a more loosely coupled approach to access our data from the database. Also, the code is cleaner and easier to maintain and reuse. Data access logic is in a separate class, or sets of classes called a repository, with the responsibility of persisting the application’s business model.

Bharat Dwarkani shared on Sep 22, 2019
image
code-maze.com
bookmarks
share
favorite_border0 visibility3
favorite_border0 visibility3 share bookmarks

Suppose you are building an ASP.NET Core application that stores data in some data store. You want to support multiple data stores and they should be configurable.

Bharat Dwarkani shared on Aug 26, 2019
image
binaryintellect.net
bookmarks
share
favorite_border0 visibility11
favorite_border0 visibility11 share bookmarks
add