GraphQL Mutations in ASP.NET Core
GraphQL mutations are actions which we use to Add, Update and Delete data from a database. Until now, we have been executing only GraphQL Queries (fetching data) but in this article, we are going to talk more about data mutations in GraphQL. Getting Started with...
Advanced GraphQL Queries, Error Handling, Data Loader
In the previous article, we have learned about the GraphQL integration with the ASP.NET Core application. We have created our first GraphQL query and fetched some data from the server-side application. But we won’t stop on just basic queries. In this article, we are...
Getting Started with GraphQL in ASP.NET Core
In this article, we are going to learn how to set up GraphQL in the ASP.NET Core application. We are going to use different third-party libraries to make this integration easier and will explain in detail how to use GraphQL elements (Type, Query, and Schema) to...
C# Design Patterns – Strategy Design Pattern
The Strategy design pattern is a behavioral design pattern that allows us to define different functionalities, put each functionality in a separate class, and make their objects interchangeable. In other words, we have a main Context object that holds a reference...
C# Design Patterns – Command
The Command pattern is a behavioral design pattern that we can use to turn a request into an object that contains all the information about the request. The Command design pattern is quite popular in C#, especially when we want to delay or queue a request’s execution...
C# Design Patterns – Decorator
In this article, we are going to talk about another structural C# design pattern, the Decorator Design Pattern. We are going to learn, how to implement this pattern in our project and what we can get by doing that. Builder Design Pattern and Fluent Builder Fluent...
Basic Tips and Tricks to Boost Productivity in Visual Studio
Visual Studio is a Microsoft IDE that is used by many developers worldwide every day. It is a great tool that provides a lot of interesting and very useful features to make a developer’s life a lot easier, but often, especially when we are new to the IDE we don’t...
C# Design Patterns – Composite
The Composite design pattern is a structural design pattern that allows us to compose objects into a tree structure and then work with that structure as if it is a single object. That also means using this design pattern makes sense when the part of our app can be...
C# Design Patterns – Adapter
The Adapter design pattern is a structural pattern that allows incompatible interfaces to work together. By doing so, we allow objects from different interfaces to exchange data. In this article, we are going to learn how to implement the Adapter pattern into our...
C# Design Patterns – Singleton
The Singleton is a creational design pattern that allows us to create a single instance of an object and to share that instance with all the users that require it. There is a common opinion that the Singleton pattern is not recommended because it presents a code...
Factory Design Pattern in C#
The Factory method is a creational design pattern that provides an interface for creating objects without specifying their concrete classes. It defines a method that we can use to create an object instead of using its constructor. The important thing is that the...
C# Design Patterns – Faceted Builder
In the previous two articles, we were talking about Builder Design Pattern and Fluent Builder With Recursive Generics. We recommend reading at least the first one for a better understanding of the Builder Design Pattern. The second one is the upgrade to the first...
C# Design Patterns – Fluent Builder Interface With Recursive Generics
In the previous post, we have been talking about Builder and the Fluent Builder design patterns. So, we strongly recommend reading that one before you continue with this post if you are not familiar with the Fluent Builder pattern. In this post, we are going to get a...
C# Design Patterns – Builder Design Pattern and Fluent Builder
The Builder design pattern is a creational design pattern that lets us create an object one step at a time. It is quite common to use this pattern when creating a complex object. By using this pattern, we can create different parts of an object, step by step, and then...
Dynamic Type in C#
The dynamic type has been added to C# since C# 4.0 (.NET 4.5) and its main purpose is to bypass the static type checks and add more flexibility to the language. In this article, we are going to go through the basic concepts of dynamic type, and learn how it works and...
SOLID Principles in C# – Dependency Inversion Principle
The basic idea behind the Dependency Inversion Principle is that we should create the higher-level modules with its complex logic in such a way to be reusable and unaffected by any change from the lower-level modules in our application. To achieve this kind of...
SOLID Principles in C# – Interface Segregation Principle
The Interface Segregation Principle states that no client should be forced to depend on methods it does not use. So, this is the basic definition which we can read in many different articles, but what does this really mean? Let’s imagine that we are starting a new...
Using C# and DalSoft.RestClient to Consume Any REST API
This post is going to take you through using the DalSoft.RestClient C# library to consume a RESTful API. We are going to show you the most common scenarios using live examples from the REST API JSONPlaceholder. We are using JSONPlaceholder because it's a great tool...
SOLID Principles in C# – Liskov Substitution Principle
The Liskov Substitution Principle (LSP) states that child class objects should be able to replace parent class objects without compromising application integrity. What this means essentially, is that we should put an effort to create such derived class objects which...
SOLID Principles in C# – Open Closed Principle
The Open Closed Principle (OCP) is the SOLID principle which states that the software entities (classes or methods) should be open for extension but closed for modification. But what does this really mean? Basically, we should strive to write a code that doesn’t...
SOLID Principles in C# – Single Responsibility Principle
While developing a project, we strive to write maintainable and readable code (besides the working part 😀 ). To accomplish this, each and every class should do its own task and do it well. Yes, it is quite important for a class to have no more than one task. If it...