Article(s)
About 60 min
Article(s) 관련
freeCodeCamp Programming Tutorials: Python, JavaScript, Git & More
Browse thousands of programming tutorials written by experts. Learn Web Development, Data Science, DevOps, Security, and get developer career advice.
Milan Jovanović | Helping You Become a Better .NET Engineer
The .NET Weekly is a newsletter that delivers 1 practical tip on .NET & sofwtare architecture that you can easily implement.
johnnyreilly | johnnyreilly
The blog of John Reilly ❤️🌻
Code Maze - C#, .NET and Web Development Tutorials
Welcome to Code Maze. Here, you can find C#, .NET and Web Development tutorials. Join millions of readers from all over the world.
freecodeCamp
freecodecamp.org
How to Use Object-Oriented Programming in C# – Explained With Examples
Welcome to this comprehensive guide on object-oriented programming (OOP) using C#. This article will delve into the four fundamental pillars of OOP: * Inheritance * Encapsulation * Polymorphism * Abstraction Whether you're a seasoned programmer or a beginner stepping into the world of C#, this article...
How to Build CRUD Operations with .NET Core – A Todo API Handbook
Welcome to this comprehensive guide on building CRUD operations with .NET Core. We'll use a Todo API as our practical example so you can get hands-on experience as you learn. Throughout this tutorial, you'll learn how to create, read, update, and delete Todo items, and how to leverage Entity Framework...
How To Use LINQ in C# – With Code Examples
.Net (pronounced as 'dot net') has many internal libraries and tools, but one that wields great power is LINQ (Language Integrated Query). It can be used in two ways: the language-level query syntax, or the LINQ API. In this article, we'll explore: * What LINQ is. * How...
Using Entity Framework Core with MongoDB
Entity Framework Core is a popular ORM (Object-Relational Mapper) for .NET applications, allowing developers to work with databases using .NET objects. It can be used with many types of databases, including MongoDB. In this article, you will learn ho...
Learn C# for Unity in Spanish
Unity is a very popular and powerful game engine that relies on C# as its primary scripting language. Learn how to bring your games to life with Unity and C#. We just published a course on the freeCodeCamp.org Spanish YouTube channel that will guide ...
Master Object-Oriented Programming and Design Patterns in C#
Understanding design patterns are important for efficient software development. They offer proven solutions to common coding challenges, promote code reusability, and enhance maintainability. By mastering these patterns, developers can create more ro...
Milan Jovanović | Helping You Become a Better .NET Engineer
milanjovanovic.tech
Why I Write My LINQ Queries Tall, Not Wide
In this newsletter, I'll show you how you can write tall LINQ queries to improve readability and make your code easier to maintain. We are going to start from a wide LINQ query, and see how we can refactor it into a tall LINQ query.
Records, Anonymous Types, and Non-Destructive Mutation
Today, I'm going to share some fascinating things you can do with records and anonymous types. I will introduce you to the concept of non-destructive mutation. And I will talk about when and why we might want to use this C# language feature.
How To Improve Performance With EF Core Query Splitting
I recently ran into an issue with Entity Framework Core. The query I was running was constantly timing out. So I used a new EF Core feature called Query Splitting to significantly improve my performance.
3 Ways To Create Middleware In ASP.NET Core
In this newsletter, we'll be covering three ways to create middleware in ASP.NET Core applications. Middleware allows us to introduce additional logic before or after executing an HTTP request. You are already using many of the built-in middleware available in the framework. I'm going to show you three approaches to how you can define custom middleware: With Request Delegates, By Convention, and Factory-Based.
Decorator Pattern In ASP.NET Core
Let's imagine we have an existing Repository implementation, and we want to introduce caching to reduce the load on the database. How can we achieve this without changing anything about the Repository implementation? Decorator pattern is a structural design pattern that allows you to introduce new behavior to an existing class, without modifying the original class in any way. I'll show you how you can implement this with the ASP.NET Core DI container.
How I Optimized an API Endpoint to Make It 15x Faster
Performance optimizations are my favorite thing about software engineering. Over the last 5 years, I've encountered various performance problems that taught me different ways to overcome them.
Introduction To Locking And Concurrency Control in .NET 6
In this week's newsletter, we'll see how we can work with locking in .NET 6. We won't talk about how the lock is actually implemented at the operating system level. We will focus on application-level locking mechanisms instead. Locking allows us to control how many threads can access some piece of code. Why would you want to do this?
How To Use Global Query Filters in EF Core
In this week's newsletter, I'll show you how you can remove repetitive conditions in EF Core database queries. An example would be when you implement soft-delete, and have to check if a record was soft-deleted or not in every query. Also, it is practical if you're working in a multi-tenant system and need to specify a tenantId on every query. EF Core has a powerful feature called Query Filters that can help you remove repetitive conditions from your code.
5 Ways To Check For Duplicates In Collections, With Benchmarks
In this week's newsletter, we will take a look at five different ways to check if a collection contains duplicates. I'm going to explain the idea behind each algorithm, discuss the algorithm complexity (Big O Notation), and at the end, we'll look at some benchmark results.
What's New In .NET 7?
In this week's newsletter I want to highlight a few interesting things that are now available with the release of C# 11 and .NET 7. In case you missed it, .NET 7 was released November 8th.
How To Use The Options Pattern In ASP.NET Core 7
In this week's newsletter I want to show you how you can use the powerful Options pattern in ASP.NET Core 7. The options pattern uses classes to provide strongly typed settings in your application at runtime. The values for the options instance can come from multiple sources. The typical use case is to provide the settings from application configuration.
How To Use The New Bulk Update Feature In EF Core 7
In this week's newsletter, we're going to explore the new ExecuteUpdate and ExecuteDelete methods that were released with EF7. ExecuteUpdate allows us to write a query and run a bulk update operation on the entities matching that query. Similarly, ExecuteDelete allows us to write a query and delete the entities matching that query. We can significantly improve performance using the new methods in some scenarios, and I'm going to show you what those scenarios are.
Running Background Tasks In ASP.NET Core
In this week's newsletter we will talk about running background tasks in ASP .NET Core. After reading this newsletter, you will be able to set up a background task and have it up and running within minutes. Background tasks are used to offload some work in your application to the background, outside of the normal application flow. A typical example can be asynchronously processing messages from a queue. I will show you how to create a simple background task that runs once and completes. And you will also see how to configure a continuous background task, that repeats after a specific period.
How To Structure Minimal APIs
Minimal APIs were introduced to remove some of the ceremony of creating traditional APIs with controllers. To define an endpoint, you can use the new extension methods the were introduced such as MapGet to define a GET endpoint. I see one big issue with Minimal APIs, and that is the lack of clear guidance around how to structure applications built with Minimal APIs. In this newsletter, I want to offer a few solutions for that problem.
Fast Document Database In .NET With Marten
Did you know you can turn PostgreSQL into a fully-fledged Document database? Marten is a .NET library that allows developers to use the PostgreSQL database as both a document database and a fully-featured event store. You don't need to install anything else to be able to use PostgreSQL as a document database, outside of the Nuget pacakge. Marten relies on the JSONB support available since PostgreSQL 9.4. In this week's newsletter, I want to introduce you to the basics of working with Marten and show you how easy it is to get started.
Clean Architecture And The Benefits Of Structured Software Design
In the world of software development, there are countless approaches and methodologies to choose from. It's easy to get swayed with the latest trends, and loose sight of architectural principles that really matter. One of the more popular ones is Clean Architecture, a design approach that prioritizes maintainability, scalability, flexibility, and productivity. In this week's newsletter, we will explore the key benefits of using Clean Architecture and how it can help your team build better software.
Adding Validation To The Options Pattern In ASP.NET Core
In this week's newsletter I will show you how to easily add validation the strongly-typed configuration objects injected with IOptions. The Options pattern allows us to use classes to provide strongly-typed configuration values in our application at runtime. But you have no guarantee that the configuration values injected with IOptions will be correctly read from the application settings. Let's see how we can introduce validation for our IOptions and make sure the application settings are correct.
Unleash EF Core Performance With Compiled Queries
In this week's newsletter I want to introduce you to an interesting feature in EF Core called Compiled Queries. If you have queries that you execute frequently in your application with a different set of parameters, it can be helpful to explicitly compile the query and reuse it throughout the lifetime of your application. Compiled Queries are more performant than standard EF queries, because they can take advantage of some additional optimizations. Let me show you how to use Compiled Queries, and how much performance improvement to expect.
C# Yield Return Statement
In this week's newsletter I want to talk about the yield keyword in C#. I think it's a powerful C# feature and I wanted to highlight the benefits. The yield keyword tells the compiler that the method in which it appears is an iterator block. An iterator block, or method, returns an IEnumerable as the result. And the yield keyword is used to return the values for the IEnumerable. An interesting thing aboug IEnumerable is that it is lazily evaluted. Calling a method with an iterator block doesn't run any code. It's only when the IEnumerable is iterated over, or enumerated, that we get the actual values. I'll talk about this more later.
How To Implement API Key Authentication In ASP.NET Core
In this week's newsletter I want to show you how to implement API Key authentication in ASP.NET Core. This authentication approach uses an API Key to authenticate the client of an API. You can pass the API Key to the API in a few ways, such as through the query string or a request header. I will show you how to implement API Key authentication where the API key is passed in a request header. But the implementation would be similar if we were to use any other approach. When would you want to use API Key authentication? This kind of authentication mechanism is common in Server-to-Server (S2S) communication. When your API serves request for other server-side applications to consume and integrate with. It's less common in client-server communication scenarios.
Working With Transactions In EF Core
Every software engineer working with SQL databases needs to know about transactions. And since most of the time the SQL database will be abstracted by an ORM like EF Core, it's important to understand how you can work with transactions using the available abstractions.
Messaging Made Easy With Azure Service Bus
If you're working in a distributed system, you need to be able to communicate between multiple services. There are a few ways that you can implement this. Depending on your chosen approach, you can either introduce tight coupling between your services or stay loosely coupled. Loose coupling is an important quality in a distributed system. It will allow you to evolve your services independently. So how do you implement loosely coupled communication between services?
Structured Logging In ASP.NET Core With Serilog
Structured logging is a practice where you apply the same message format to all of your application logs. The end result is that all your logs will have a similar structure, allowing them to be easily searched and analyzed. Serilog is a popular logging library in .NET, packed with many features. It provides logging to files, logging to the console, and elsewhere. However, why Serilog is unique is because it comes with support for structured logging out of the box.
Outbox Pattern For Reliable Microservices Messaging
Working with Microservices, or any distributed system for that matter, is difficult. In a distributed system many things can go wrong, and there are even research papers about this. If you want to explore this topic futher, I suggest that you read about the fallacies of distributed computing. Reducing the surface area for things to go wrong should be one of your goals, as an engineer. In this week's newsletter, we'll try to achieve exactly that using the Outbox pattern. How can you implement reliable communication between components in a distributed system? The Outbox pattern is an elegant solution to this problem, allowing you to achieve transactional guarantees in a single service and at-least-once message delivery to external systems.
How To Apply Functional Programming In C#
Although C# is an object-oriented programming language, it received many new functional features in recent versions. To mention just a few of these features: - Pattern matching - Switch expressions - Records You're probably already doing functional programming without even knowing it. Do you use LINQ? If you do, then you're doing functional programming. Because LINQ is a functional .NET library.
Using Multiple EF Core DbContexts In a Single Application
Entity Framework Core (EF Core) is a popular ORM in .NET that allows you to work with SQL databases. EF Core uses a DbContext, which represents a session with the database and is responsible for tracking changes, performing database operations, and managing database connections. It's common to have only one DbContext for the entire application. But what if you need to have multiple DbContexts?
Creating Data-Driven Tests With xUnit
Data-driven testing is a testing method where test data is provided through some external source. Hence it's also known as parameterized testing. A popular testing library in .NET that supports parameterized testing is xUnit. It uses attributes to define test methods. The Fact attribute defines a simple test, and the Theory attribute defines a parameterized test.
How To Publish MediatR Notifications In Parallel
MediatR is a popular library with a simple mediator pattern implementation in .NET. Here's a definiton taken from MediatR's GitHub: 'In-process messaging with no dependencies.' With the rise in popularity of the CQRS pattern, MediatR became the go-to library to implement commands and queries. However, MediatR also has support for the publish-subscribe pattern using notifications. You can publish an INotification instance and have multiple subscribers handle the published message. Until recently, the handlers subscribing to an INotification message could only execute serially, one by one.
Implementing The Saga Pattern With Rebus And RabbitMQ
Designing long-lived processes in a distributed environment is an interesting engineering challenge. And a well known pattern for solving this problem is a Saga. A Saga is a sequence of local transactions, where each local transaction updates the Saga state and publishes a message triggering the next step in the Saga. Sagas come in two forms: Orchestrated Choreographed With an orchestrated Saga, there's a central component responsible for orchestrating the individual steps. In a choreographed Saga, processes work independently but coordinate with each other using events.
How To Use Rate Limiting In ASP.NET Core
Rate limiting is a technique to limit the number of requests to a server or an API. A limit is introduced within a given time period to prevent server overload and protect against abuse. In ASP.NET Core 7 we have a built-in rate limiter middleware, that's easy to integrate into your API.
EF Core Raw SQL Queries
EF Core is getting many new and exciting features in the upcoming version. EF7 introduced support for returning scalar types using SQL queries. And now we're getting support for querying unmapped types with raw SQL queries in EF8. This is exactly what Dapper offers out of the box, and it's good to see EF Core catching up.
Idempotent Consumer - Handling Duplicate Messages
What happens when a message is retried in an event-driven system? It happens more often than you think. The worst case scenario is that the message is processed twice, and the side effects can also be applied more than once. Do you want your bank account to be double charged? I'll assume the answer is no, of course. You can use the Idempotent Consumer pattern to solve this problem.
Health Checks In ASP.NET Core For Monitoring Your Applications
We all want to build robust and reliable applications that can scale indefinitely and handle any number of requests. But with distributed systems and microservices architectures growing in complexity, it's becoming increasingly harder to monitor the health of our applications. It's vital that you have a system in place to receive quick feedback of your application health. That's where health checks come in. Health checks provide a way to monitor and verify the health of various components of an application including: - Databases - APIs - Caches - External services
Enforcing Software Architecture With Architecture Tests
Software architecture is a blueprint for how you should structure your system. You can follow this blueprint strictly, or you can give yourself varying levels of freedom. But when deadlines are tight, and you start cutting corners, that beautiful software architecture you built crumbles like a house of cards. How can you enforce your software architecture? By writing architecture tests. Architecture tests are automated tests that verify the structure and design of your code. You can use them to enforce your software architecture and the direction of dependencies of your projects.
Multi-Tenant Applications With EF Core
Most software applications today are built around the concept of multi-tenancy. One application serves multiple customers, while keeping their data isolated. You can approach multi-tenancy in two ways: - Single database & logical isolation of tenants - Multiple databases & physical isolation of tenants Which option you decide to use will depend mostly on your requirements. Some industries like healthcare require a high degree of data isolation, and using a database per tenant is a must. So how are we going to implement multi-tenancy support with EF Core? We can use Query Filters to apply a tenant filter to all database queries.
Scheduling Background Jobs With Quartz.NET
If you're building a scalable application, it's a common requirement to offload some work in your application to a background job. A few examples of that are: - Publishing email notifications - Generating reports - Updating a cache - Image processing How can you create a recurring background job in .NET? Quartz.NET is a full-featured, open source job scheduling system that can be used from smallest apps to large scale enterprise systems.
The Right Way To Use HttpClient In .NET
If you're building a .NET application, chances are high that you'll need to call an external API over HTTP. The easy way to make HTTP requests in .NET is to use the HttpClient to send those requests. And it's a great abstraction to work with, especially with the methods supporting JSON payloads and responses. Unfortunately, it's easy to misuse the HttpClient. Port exhaustion and DNS behavior are some of the most common problems.
Refactoring From an Anemic Domain Model To a Rich Domain Model
Today's modern applications must deliver the latest information without Is the Anemic domain model an antipattern? It's a domain model without any behavior and only data properties. Anemic domain models work great in simple applications, but they are difficult to maintain and evolve if you have rich business logic. The important parts of your business logic and rules end up being scattered all over the application. It reduces cohesiveness and reusability, and makes adding new features more difficult. Rich domain model attempts to solve this by encapsulating as much of the business logic as possible. This is a never-ending process of moving business logic into the domain and refining your domain model.
Adding Real-Time Functionality To .NET Applications With SignalR
Today's modern applications must deliver the latest information without refreshing the user interface. If you need to introduce real-time functionality to your application in .NET, there's one library you will most likely reach for - SignalR. SignalR allows you to push content from your server-side code to any connected clients as changes happen in real-time.
Response Compression In ASP.NET Core
Reducing the size of your API responses can noticeably improve the performance of your application. And since network bandwidth is a limited resource, you should at least consider the benefits of response compression.
Implementing an API Gateway For Microservices With YARP
Large Microservice-based systems can consist of tens or even hunders of individual services. A client application needs to have all of this information to be able to make requests to the relevant microservice directly. However, this has numerous issues such as security concerns, complexity, and coupling. We can solve this by introducing an API gateway that acts as a reverse proxy to accept API calls from the client application, forwarding this traffic to the appropriate service. The API gateway also enforces security and ensures scalability and high availability. In this week's newsletter, I'll show you how to implement an API gateway using the YARP reverse proxy.
8 Tips To Write Clean Code
Clean code is code that's easy to read, maintain, and understand. I consider writing clean code a skill. And it's a skill that you can learn and improve with deliberate practice. My favorite approach to practice clean coding is doing refactoring exercises. So I prepared one for you today, and we're going to improve one step at a time by applying clean code principles.
How To Use Domain Events To Build Loosely Coupled Systems
In software engineering, coupling means how much different parts of a software system depend on each other. If they are tightly coupled, changes to one part can affect many others. But if they are loosely coupled, changes to one part won't cause big problems in the rest of the system. Domain events are a Domain-Driven Design (DDD) tactical pattern that we can use to build loosely coupled systems. You can raise a domain event from the domain, which represents a fact that has occurred. And other components in the system can subscribe subscribe to this event, and handle it accordingly.
Mastering Dapper Relationship Mappings
Dapper is a lightweight object-relational mapper in .NET. It's popular because it's easy to use and fast at the same time. Dapper extends the IDbConnection interface with methods for sending SQL queries to the database. But, because of the nature of SQL, mapping the result into an object model can be tricky.
Advanced Rate Limiting Use Cases In .NET
Rate limiting is about restricting the number of requests to your application. It's usually applied within a specific time window or based on some other criteria. Rate limiting is practical for a few reasons: - Improves security - Guards against DDoS attacks - Prevents overloading of application servers - Reduces costs by preventing unnecessary resource consumption But you need to know how to implement it correctly, or you could grind your system to a halt.
Testcontainers - Integration Testing Using Docker In .NET
Modern software applications rarely work in isolation. On the contrary, a typical application will talk to several external systems like databases, messaging systems, cache providers, and many 3rd party services. And it's up to you to ensure everything functions correctly. Hopefully, I don't have to convince you about the value of writing tests. You should be writing tests. Period. However, I do want to discuss the value of integration testing. Unit tests are helpful to test business logic in isolation, without any external services. They are easy to write and provide almost instant feedback. But you can't be fully confident in your application without integration tests.
Solving Race Conditions With EF Core Optimistic Locking
How often do you think about concurrency conflicts when writing code? You write the code for a new feature, confirm that it works, and call it a day. But one week later, you find out you introduced a nasty bug because you didn't think about concurrency. The most common issue is race conditions with two competing threads executing the same function. If you don't consider this during development, you introduce the risk of leaving the system in a corrupted state.
Feature Flags in .NET and How I Use Them for A/B Testing
The ability to conditionally turn features on or off in your application without redeploying the code is a powerful tool. It lets you quickly iterate on new features and frequently integrate your changes with the main branch. You can use feature flags to achieve this. Feature flags are a software development technique that allows you to wrap application features in a conditional statement. You can then toggle the feature on or off in runtime to control which features are enabled.
Monolith to Microservices: How a Modular Monolith Helps
You start building a beautiful monolith system. Maybe a modular monolith. The system grows, and requirements are ever-changing. Slowly, cracks begin to appear in the system. This could be for organizational reasons and distributing the work across a team. Or it could be because of scaling issues and performance bottlenecks. You begin the process of evaluating the benefits and tradeoffs of possible solutions. At last, you come to a decision. It's time to migrate parts of the system to individual services. So, how do we approach this migration from monolith to microservices?
CQRS Validation with MediatR Pipeline and FluentValidation
Validation is an essential cross-cutting concern that you need to solve in your application. You want to ensure the request is valid before you consider processing it. Another important question you need to answer is how you approach different types of validation. For example, I consider input and business validation differently, and each deserves a specific solution. I want to show you an elegant solution for validation using MediatR and FluentValidation. If you aren't using CQRS with MediatR, don't worry. Everything I explain about validation can easily be adapted to other paradigms.
Getting Started With NServiceBus in .NET
NServiceBus is a feature-rich messaging framework supporting many different message transports. It's developed and maintained by Particular Software. And it simplifies the process of building complex distributed systems across various cloud-based queueing technologies. The basic building blocks of NServiceBus are messages and endpoints. A message contains the required information to execute a business operation. Endpoints are logical entities that send and receive messages.
Improving ASP.NET Core Dependency Injection With Scrutor
Dependency injection (DI) is one of the most exciting features of ASP.NET Core. It helps us build more testable and maintainable applications. However, ASP.NET Core's built-in DI system sometimes needs a little help to achieve more advanced scenarios. So I want to introduce you to a powerful library for enhancing your ASP.NET Core DI - Scrutor.
CQRS Pattern With MediatR
Today I want to show you how to use the CQRS pattern to build fast and scalable applications. The CQRS pattern separates the writes and reads in the application. This separation can be logical or physical and has many benefits. I'm also going to show you how to implement CQRS in your application using MediatR.
Functional Error Handling in .NET With the Result Pattern
How should you handle errors in your code? This has been a topic of many discussions, and I want to share my opinion. One school of thought suggests using exceptions for flow control. This is not a good approach because it makes the code harder to reason about. The caller must know the implementation details and which exceptions to handle. Exceptions are for exceptional situations. Today, I want to show you how to implement error handling using the Result pattern. It's a functional approach to error handling, making your code more expressive.
Vertical Slice Architecture
Layered architectures are the foundation of many software systems. However, layered architectures organize the system around technical layers. And the cohesion between layers is low. What if you wanted to organize the system around features instead? This is where Vertical Slice Architecture comes in.
How To Easily Create PDF Documents in ASP.NET Core
Reporting is essential for business applications like e-commerce, shipping, fintech, etc. One of the most popular document formats for reporting purposes is PDF. Today I want to show you a few interesting ways to generate PDF files in .NET.
How To Use EF Core Interceptors
EF Core is my favorite ORM for .NET applications. Yet, its many fantastic features sometimes go unnoticed. For example, query splitting, query filters, and interceptors. EF interceptors are interesting because you can do powerful things with them. For example, you can hook into materialization, handle optimistic concurrency errors, or add query hints. The most practical use case is adding behavior when saving changes to the database.
How to Build a URL Shortener With .NET
A URL shortener is a simple yet powerful tool that converts long URLs into more manageable, shorter versions. Today, I'll guide you through the design, implementation, and considerations for creating your URL shortener in .NET
How I Made My EF Core Query 3.42x Faster With Batching
EF Core is a fantastic ORM if you're building .NET applications. Today, I'll show you a simple idea I used to get an almost 4x performance improvement.
Getting the Current User in Clean Architecture
The applications you build serve your users (customers), to help them solve some problems. It's a common requirement that you will need to know who the current application user is.
Using Scoped Services From Singletons in ASP.NET Core
Did you ever need to inject a scoped service into a singleton service? I'll explain how you can solve this problem and safely use scoped services from within singletons in ASP.NET Core.
Automatically Register Minimal APIs in ASP.NET Core
In ASP.NET Core applications using Minimal APIs, registering each API endpoint with app.MapGet, app.MapPost, etc. can introduce repetitive code. Today, I'll show you how to automatically register your Minimal APIs with a simple abstraction.
Lightweight In-Memory Message Bus Using .NET Channels
Suppose you're building a modular monolith, a type of software architecture where different components are organized into loosely coupled modules. Or you might need to process data asynchronously. You'll need a tool or service that allows you to implement this.
Implementing Soft Delete With EF Core
A soft delete is a data persistence strategy that prevents the permanent deletion of records from your database. Today, we'll dive into the details of how to implement soft deletes using EF Core.
Fast SQL Bulk Inserts With C# and EF Core
Explore various methods for fast bulk inserts in SQL with C# and EF Core, highlighting techniques like Dapper, EF Core optimizations, EF Core Bulk Extensions, and SQL Bulk Copy.
Horizontally Scaling ASP.NET Core APIs With YARP Load Balancing
When a single server reaches its limits, performance degrades, leading to slow response times, errors, or complete downtime. We'll dive into load balancing, why it matters, and how YARP simplifies the process for .NET applications.
Master Claims Transformation for Flexible ASP.NET Core Authorization
Claims-based authorization mechanisms are central to modern authorization in ASP.NET Core. However, the access tokens issued by your Identity Provider (IDP) might not always perfectly align with your application's internal authorization needs. The solution? Claims transformation.
A Clever Way To Implement Pessimistic Locking in EF Core
Sometimes, especially in high-traffic scenarios, you absolutely need to ensure that only one process can modify a piece of data at a time. Entity Framework Core is a fantastic tool, but it doesn't have a direct mechanism for pessimistic locking. In this article, I'll show you how we can solve that problem with raw SQL queries.
Introduction to Distributed Tracing With OpenTelemetry in .NET
Sometimes, especially in high-traffic scenarios, you absolutely need to ensure that only one process can modify a piece of data at a time. Entity Framework Core is a fantastic tool, but it doesn't have a direct mechanism for pessimistic locking. In this article, I'll show you how we can solve that problem with raw SQL queries.
Request-Response Messaging Pattern With MassTransit
When building distributed systems with .NET, direct calls between services can create tight coupling. The request-response messaging pattern can allow distributed services to communicate in a loosely coupled way.
Implementing API Gateway Authentication With YARP
In this newsletter, we'll explore how you can implement API gateway authentication using YARP (Yet Another Reverse Proxy), a powerful and flexible reverse proxy library for .NET applications.
Building Resilient Cloud Applications With .NET
By designing your applications with resilience in mind, you can create robust and reliable systems, even when the going gets tough. In this newsletter, we'll explore the tools and techniques we have in .NET to build resilient systems.
EF Core Migrations: A Detailed Guide
In this newsletter, we'll break down the essentials of EF Migrations. We'll explore creating migrations, SQL scripts, applying migrations, migration tooling, and more.
Shift Left With Architecture Testing in .NET
In this newsletter, we'll explore how architecture testing can safeguard our project's architecture. Architecture tests can help us shift left and detect architectural issues faster.
Vertical Slice Architecture: Structuring Vertical Slices
Are you tired of organizing your project across layers? Vertical Slice Architecture is a compelling alternative to traditional layered architectures.
Caching in ASP.NET Core: Improving Application Performance
Caching is one of the simplest techniques to significantly improve your application's performance. In this newsletter, we will explore how to implement caching in ASP.NET Core applications.
From Transaction Scripts to Domain Models: A Refactoring Journey
Transaction Scripts organizes business logic by procedures where each procedure handles a single request from the presentation. We will explore when you should consider introducing a Domain Model.
What You Need To Know About EF Core Bulk Updates
EF Core 7 introduced two powerful new methods, ExecuteUpdate and ExecuteDelete. However, there's an important caveat: these bulk operations bypass the EF Core Change Tracker.
Service Discovery in Microservices With .NET and Consul
Service discovery is a pattern that allows developers to use logical names to refer to external services, instead of physical IP addresses and ports. In this week's issue, we'll see how to implement service discovery in your .NET microservices with Consul.
Building Your First Use Case With Clean Architecture
This is a question I often hear: how do I design my use case with Clean Architecture? In this article, we'll explore a practical example of how to apply Clean Architecture principles by building a user registration feature.
Testing Modular Monoliths: System Integration Testing
System integration testing is the perfect testing approach for modular monoliths. It's an approach to testing the interactions between various modules within a single system.
Simple Messaging in .NET With Redis Pub/Sub
Redis is a popular choice for caching data, but its capabilities go far beyond that. One of its lesser-known features is Pub/Sub support. Redis channels offer an interesting approach for implementing real-time messaging in your .NET applications.
Improving Code Quality in C# With Static Code Analysis
Static code analysis helps you build secure, maintainable, and high-quality C# code. In this week's newsletter, we'll explore how to integrate it into your .NET projects.
5 EF Core Features You Need To Know
EF Core is powerful, and knowing a few key features can save you lots of time and frustration. I've cherry-picked five essential features that you really need to know.
5 Awesome C# Refactoring Tips
Refactoring is a technique for restructuring existing code without changing its behavior. You can think of refactoring as a series of small code transformations. One change (refactoring) does little. But a sequence of refactors produces a significant transformation. There's no better way to learn refactoring than practicing. So I prepared a refactoring exercise for you.
Global Error Handling in ASP.NET Core 8
Exceptions are for exceptional situations. But they will inevitably happen in your applications, and you need to handle them. You can implement a global exception handling mechanism or handle only specific exceptions. ASP.NET Core gives you a few options on how to implement this. So which one should you choose? Today, I want to show you an old and new way to handle exceptions in ASP.NET Core 8.
Modular Monolith Data Isolation
Modular monoliths are an architectural approach that's becoming very popular. They combine the benefits of modularity and monolithic design. Data isolation ensures that modules are independent and loosely coupled. Today, I will show you four data isolation approaches for modular monoliths
5 Serilog Best Practices For Better Structured Logging
Serilog is a structured logging library for .NET. It's also my preferred logging library in the projects I'm developing. I want to share 5 practical tips for better structured logging with Serilog.
Value Objects in .NET (DDD Fundamentals)
Value Objects are one of the building blocks of Domain-Driven Design. Today, I'll show you some best practices for implementing Value Objects.
API Versioning in ASP.NET Core
API versioning allows your API to evolve independently from the clients using it. I'll show you how to implement API versioning in ASP.NET Core.
Using MassTransit with RabbitMQ and Azure Service Bus
MassTransit is an open-source distributed application framework for .NET. It provides a messaging abstraction on top of the supported message transports. In this week's issue, I'll show you how to use MassTransit.
Extending HttpClient With Delegating Handlers in ASP.NET Core
Delegating handlers are like ASP.NET Core middleware. Except they work with the HttpClient. I'll show you how to work with delegating handlers
Balancing Cross-Cutting Concerns in Clean Architecture
Cross-cutting concerns are software aspects that affect the entire application. These are your common application-level functionalities that span several layers and tiers. Cross-cutting concerns should be centralized in one location. This prevents code duplication and tight coupling between components. In today's newsletter, I'll show you how to integrate cross-cutting concerns in Clean Architecture.
John Reilly
johnnyreilly.com
Using Kernel Memory to Chunk Documents into Azure AI Search | johnnyreilly
To build RAG (Retrieval Augmented Generation) experiences, where LLMs can query documents, you need a strategy to chunk those documents. Kernel Memory supports this.
Code Maze - C#, .NET and Web Development Tutorials
code-maze.com
What Is Continuous Integration and Why Do You Need It?
While not every project is destined to be a great success, Continuous Integration can drastically improve the success rate of any project.
Top 8 Continuous Integration Tools
Discover what the top 8 most used and well established continuous integration tools and find out how they can improve your software development process.
A Few Great Ways to Consume RESTful API in C#
RESTful APIs are an integral part of our lives. Because of that is important to know how to consume a RESTful API and which tools are at your disposal.
HTTP – Overview of the Basic Concepts
In the world driven by the Internet, messages are being sent between clients and servers countless times per day via HTTP.
The HTTP Reference
This HTTP reference is a compilation of all the HTTP Status Codes, Request Methods, Headers and MIME types in one place.
HTTP Architectural Aspects
HTTP cannot function by itself as an application protocol. It needs infrastructure that makes communication over the World Wide Web possible and efficient.
HTTP – Client Identification
Let's answer the question of why the client identification is so important and how can Web servers identify you (your Web client).
HTTP Authentication Mechanisms
HTTP has its own authentication mechanisms that allow the servers to issue challenges and get the proof they need to identify the users.
HTTP – Security, TLS, and Certificates
Do you really need HTTPS? In this article we're going to explore some HTTPS security basics and learn about its strengths and weaknesses.
ASP.NET Core Web API – Creating MySQL Database
Find out how to use Workbench with MySQL to create a database, create and populate tables and place relations between them, with the backup process.
ASP.NET Core Web API – .NET Service Configuration
Find out how to use Workbench with MySQL to create a database, create and populate tables and place relations between them, with the backup process.
ASP.NET Core Web API – Logging With NLog
Why is logging so important in a development and how to use NLog to create custom logging service in .NET Core application? Find out in his post.
Top REST API Best Practices
In this post, we will learn what REST really is and how to design your API using some of the REST API best practices compiled in one place.
ASP.NET Core Web API – Repository Pattern
Let's learn how to create a Repository pattern in ASP.NET Core Web API application and how to create a Repository layer to fetch the data from the database.
ASP.NET Core Web API – How to Handle Get Request
Learn how to handle Get Request in .NET Core by using previously created repository pattern for business logic and how to write great controller code.
Content Negotiation in Web API
Content negotiation is the process of selecting the best resource for a response when multiple resource representations are available.
ASP.NET Core Web API – Post, Put, Delete
Learn how to handle Get Request in .NET Core by using previously created repository pattern for business logic and how to write great controller code.
Angular Components and Project Preparation
This part is focused on the Angular project preparation and Angular components as well as installing and registering the third party libraries.
Angular Navigation and Routing
Find out how to create a navigation menu by using Bootstrap classes and how to use the Angular routing inside the project.
Angular HttpClient, Services and Environment Files
Find out how to create a repository with the Angular HttpClient, and how to use environment variables, by using services.
Angular Lazy Loading
Find out how to use angular modules, why are they important in our application and how to configure Angular Lazy Loading feature.
Angular Error Handling
This post is focused on Angular Error Handling while sending HTTP requests, by centralizing the error handling logic inside a service.
Angular Input and Output Decorators and Directives
Find out how to use Angular Input Output decorators in a combination with EventEmitter to provide the possibility to interact between components.
Angular Form Validation and POST Request
Find out how to prepare Angular Form Validation (Reactive approach) to validate our forms while combining the HTML template and Component.
Handling PUT Requests with Angular and ASP.NET Core Web API
This is focused on Angular PUT Actions by sending the PUT request. We are going to modify our entities and to use all the validations as well.
Working with Delete Requests in Angular
This post is focused on Angular Delete Actions by using the DELETE request. We are going to delete entities and to finish the coding part of the series.
ASP.NET Core Web API – IIS Deployment
In this post: IIS Deployment, we are going to deploy our .NET Core and Angular application to the IIS server. We will go through all the needed steps.
How to Prepare an ASP.NET Core Application for Dockerization
In this part of the series, we are preparing our ASP.NET Core application for the process of dockerization that we will perform later in the series.
ASP.NET Core Web API – Linux Deployment
This post is focused on .NET Core Linux Deployment. We will create a mysql database, install .net core, deploy the application and install nginx.
Adding MySQL to ASP.NET Core App With Docker Compose
In this post, we are going to add a MySQL database as another container and connect it with our application utilizing Docker Compose.
ASP.NET Core Web API Best Practices
Find out what we consider to be the Best Practices in .NET Core Web API. All the stated is our recommendation based on a development experience.
Continuous Integration with TeamCity and Docker
In this article, we are going to learn a bit about more advanced features of TeamCity, how to build Docker images and run integration tests.
How to Easily Create a PDF Document in ASP.NET Core Web API
Find out how to easily create a PDF document in ASP.NET Core Web API. Play with configuration, save, download or show PDF document in a web browser.
JWT Authentication in ASP.NET Core Web API
In this article, we are going to learn how to provide a JWT authentication to secure our ASP.NET Core Web API app.
Global Error Handling in ASP.NET Core Web API
Find out how to replace try-catch blocks in your code with the Global Error Handling by using the custom or built-in middleware in ASP.NET Core.
Conditions in C# with If-Else, and Switch-Case Statements
Learn about Conditions in C#, differences between if, if-else, if-else if, and switch-case conditional statements, and how to use them.
C# Methods
Let's learn about Methods in C#, how to create a valid method signature, how to work with parameters and arguments and optional params.
C# Back to Basics – Arrays
Learn about Arrays in C#. How to declare them, initialize them and manipulate them. Also, learn how to use multi-dimensional arrays.
Angular JWT Authentication with ASP.NET Core Web API
Angular JWT as a frontend part of the ASP.NET Core JWT Authentication and Authorization example project implemented using the Angular framework.
C# Basics – Development Environment Setup
Find out the basics about Visual Studio 2017 environment. How we can use it in our complete tutorial and how it can help us with our examples.
Operators in C#
In this article, we are going to learn more about Operators in C# - Arithmetic, Relational and Logical operators, and their differences
Linear Structures in C# with Inputs and Printing Output Results
Find out more about Input and Output in C#, how to work with it by accepting inputs from a user, processing them, and print the output.
While, For, Do-While Loops in C#
Learn more about Loops in C#. How to use them and when to use them and what are the differences. Learn all of that through the examples.
Difference Between Ref and Out keywords in C#
Learn more about Ref and Out Keywords in C#. What are the differences between them and how we can use them in our projects.
C# Back to Basics – Files, StreamWriter and StreamReader
Find out how to work with files by using StreamWriter and StreamReader classes. Furthermore, learn about initialization and their methods as well.
Unit Testing in ASP.NET Core Web API
Find out what Unit testing is and how to write unit tests in ASP.NET Core Web API Project to test Controllers and Repo logic.
Data Types, Declarations and Variable Definitions in C#
Find out more about C# Data Types, what kind of data types exists in C#, how to use declarations and how to use variables as well.
Type Conversion in C#
Learn about C# Type Conversions, how to use implicite and explicite conversion. Practice through examples in this article.
Working With Strings in C# – String Methods
FInd out how to work with strings in C# project, what type of String Methods in C# exists, and how to use them through examples.
C# Access Modifiers
Learn about Access Modifiers in C#, how to use them, what are the differences between them and what are constraints of each of them.
C# Back to Basics – Recursion and Recursive Methods
Learn how to use Recursion and Recursive Methods in C#. And, what is the difference between regular methods and recursive ones.
C# Back to Basics – File and Directory Classes
Find out how to work with files by using File and Directory classes. Furthermore, learn about their methods and how to use them as well.
C# Intermediate – Properties
Find out how to work with files by using File and Directory classes. Furthermore, learn about their methods and how to use them as well.
C# Intermediate – Static Members, Constants and Extension Methods
In this article, you are going to learn about Static Memebers in C# (Classes and Methods). Furthermore, we will explain how to create extension methods.
C# Intermediate – Anonymous and Nullable Types
In this article, you will learn about Anonymous and Nullable types in C#. We are going to show how to use anonymous classes and nullable type properteis.
Implementing Action Filters in ASP.NET Core
Find out how to use action filters to write cleaner actions and create a reusable code to validate your actions in .NET Core Web API.
C# Intermediate – Structures
We are going to learn about Structures in C#, how to use them, what are the constraints, and when to use structs instead of a classes.
C# Intermediate – Enumerations
In this article you are going to learn about Enumerations in C#, what they are, how to use them in C# and how to use their assigned values.
Enabling CORS in ASP.NET Core
Let's learn about enabling CORS in ASP.NET Core, what is the Same Origin Policy and how CORS works with different policies.
C# Intermediate – Inheritance
You will learn about C# Inheritance, how to use base keyword, more about polimorphism with the new, virtual and override keywords and what rules to follow.
C# Intermediate – Interfaces
In this article you are going to learn about Interfaces in C#, how to define them, implement them, work with multiple interfaces and more...
ASP.NET Core Web API with EF Core Code-First Approach
Describes how to create a .NET Core Web API application with EF Core Code-First approach. We create the models first and then generate DB using migrations.
C# Intermediate – Abstract Classes
In this article you are going to laearn about Abstract Classes in C#, how to create them and what is Seald class as well.
C# Intermediate – Generics
In this article you will learn more about Generics in C#. We will talk about Generic Types, whata are the constraints and generic methods.
Getting Started With Angular Material
In this article, you will learn how to deal with angular material installation and how to prepare project with all the required packages.
C# Intermediate – Queue, Stack, and Hashtable
Let's learn about Queue, Stack, And Hashtable Collections in C#. We'll also show the usage of different methods they provide.
C# Intermediate – Generic List and Dictionary
In this article, you will learn about Generic List and Dictionary in C#. You will learn how lists work, how we can use tham and how to use key value pairs.
Angular Material Navigation Menu – Complete Responsive Navigation
In this article, we are going to learn about Angular Material Navigation, how to create it and make it fully responsive with side bar and main nav menu.
C# Intermediate – Delegates
In this article, you will learn about Delegates in C#. Differences between Action and Func delegates and how to write better code with delegates.
Angular Material Table, Filtering, Sorting, Paging
In this article we are going to learn about Angular Material Table and its functionalities related to Filtering, Sorting and Paging.
Angular Material – Error and Details Pages With Material Components
In this article we create different pages by using Angular Material Progress Bar, Spinner, Check Box, Card, Select and Expansion Panel Components.
Angular Material Form Validation, Input, Datepicker and Modal
In this article, you will learn how to implement Angular Material Form Validation by using input and datepicker components. We will talk about modals too.
ASP.NET Core Web API with EF Core DB-First Approach
In this article, we’ll take a look at the EF Core Database-First approach. In this approach, we create our database first and then model our entities.
.NET Core with SignalR and Angular – Real-Time Charts
In this article, we are going to learn how to use SignalR with .NET Core and Angular by creating real-time chart application.
Consuming GitHub API (REST) With Flurl
In this article, we are going to learn how to consume a RESTful API (GitHub) in C# using Flurl library. We will add unit testing as well.
Uploading Files With .NET Core Web API and Angular
In this article, we are going to learn how to upload files with .Net Core Web API and Angular. We are going to use those files as well in our app.
SOLID Principles in C# – Single Responsibility Principle
In this article you will learn how to implement Single Responsibility Principle (SRP) in your code thus making it better, readable and maintainable as well.
SOLID Principles in C# – Open Closed Principle
In this article you will learn about Open Closed Principle, how to implement it step by step and why it is important while developing a project.
SOLID Principles in C# – Liskov Substitution Principle
In this article you will learn more about Liskov Substitution Principle, how to achieve it in your code and why should we use it.
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 any RESTful API.
SOLID Principles in C# – Interface Segregation Principle
In this article you are going to learn about Interface Segregation Principle, how to implement it and what are the benefits of its implementation.
SOLID Principles in C# – Dependency Inversion Principle
In this article you are going to learn about Dependency Inversion Principle, how to implement this principle and what are the benefits of implementation.
Dynamic Type in C#
Dynamic type in C# is a useful type that extends the language with dynamic features. We're going to learn what it is and how to use it.
C# Design Patterns – Builder Design Pattern and Fluent Builder
In this article, you are going to learn what is Builder Design Pattern and how to implement it into your code to create more complex objects.
C# Design Patterns – Fluent Builder Interface With Recursive Generics
In this article you will learn about Fluent Builder with Recursive Generics and how to use this pattern to allow inheritance between Fluent Builders.
C# Design Patterns – Faceted Builder
You will learn how to create Faceted Builder design pattern and how to create complex objects which need more than one builder class.
C# Design Patterns – Factory Method
We are going to learn about Factory method design pattern, how to implement it into the application and how to use Factory Method refactoring technique.
C# Design Patterns – Singleton
In this article, you are going to learn what is Singleton design pattern, how to implement it into your project and how to create a thread safe singleton.
C# Design Patterns – Adapter
In this article we are going to learn about Adapter design pattern, how to implement it in the project and when shoud we use it.
C# Design Patterns – Composite
We are going to learn how to implement the Composite design pattern, what are it's elements and how to put them all together.
C# Design Patterns – Decorator
In this article, we are going to learn what is Decorator design pattern, when should we use it and how to implement it in practice.
C# Design Patterns – Command
We are going to learn how to impelement Command design pattern in C#, how to use it to keep track of our actions and undo them as well.
C# Design Patterns – Strategy Design Pattern
In this article, we are going to learn what is Strategy design pattern, how to use it in our code and when to use it as well.
Getting Started with GraphQL in ASP.NET Core
In this article we are going to learn about GraphQL in ASP.NET Core integration, how to start with the project and how to create a first GraphQL query.
Advanced GraphQL Queries, Error Handling, Data Loader
In this article we are going to learn how to write advanced GraphQL Queries, how to handle erros and optimize queries by using data loader.
GraphQL Mutations in ASP.NET Core
In this article, we are going to learn about GraphQL Mutations. We will learn how to create POST, PUT and DELETE mutations.
Consuming a GraphQL API with ASP.NET Core
In this article, we are going to learn how to Consume GraphQL API with the ASP.NET Core application by using the GraphQL.Client library.
Getting Started with ASP.NET Core MVC
Here we are going to look at the basics of building an ASP.NET Core MVC web app. We are going to create controllers, views and models.
Working with Data in ASP.NET Core MVC
In this article we are goning to learn how to connect ASP.NET Core MVC application with the database by using Entity Framework Core, Code-First approach.
Views, Partial Views, and Layouts in ASP.NET Core MVC
In the ASP.Net Core MVC, Views handle the application's data presentation and user interaction.VIews separate UI from other parts of the application.
State Management in ASP.NET Core MVC
In this article, we are going to learn about the State Management with Session State, Query Strings, etc. in ASP.NET Core MVC Applications.
Routing in ASP.NET Core MVC
In this article, we’re going to discuss the conventional and attribute routing capabilities and the support for file upload in ASP.NET Core MVC.
File Upload in ASP.NET Core MVC
In this article we are going to learn how to upload a file or multiple files in ASP.NET Core MVC application.
Dependency Injection in ASP.NET Core MVC
In this article, we are going to discuss an important concept of ASP.NET Core MVC – Dependency Injection, and how to use DI in our Controllers and Views.
Unit Testing in ASP.NET Core MVC
In this article we are going to cover Unit Testing or rather why we need unit tests and how to implement them in our ASP.NET Core applications.
Filters in ASP.NET Core MVC
Filters in ASP.NET Core MVC allows us to run certain actions before or after specific stages in the request processing pipeline
Entity Framework Core – Getting Started
Let's learn how to integrate Entity Framework Core in an ASP.NET Core application. We will talk about Entities and DbContext class in detail.
Configuring Nonrelational Properties in EF Core
In this article, we are going to talk about EF Core Configuration of Nonrelational properties and different approaches to do that.
Migrations and Seed Data With Entity Framework Core
We are going to learn about Migrations and Seed data in Entity Framework Core and how to optimize EF Core migrations.
Entity Framework Core Relationships – Convention, Data Annotations and Fluent API
In this article, we are going to learn about EF Core Relationships and different ways to accomplish relationship creation.
Database Queries in Entity Framework Core
In this article we are going to learn about Queries in Entity Framework Core and different ways to use them to fetch out data from the database.
Modifying Data with Entity Famework Core
In this article, we are going to talk about modifying data with EF Core by using differnet approaches and different actions.
How to Configure PostgreSQL in Entity Framework Core
In this article, we are going to learn how to configure PostgreSQL, a popular and reliable open-source relational database in our .NET Core application.
Unit Testing with xUnit in ASP.NET Core
In this article, we will explain Unit Testing with xUnit in the ASP.NET Core application, using different features that xUnit provides.
Data Shaping in ASP.NET Core Web API
In this article, we are going to talk about a neat concept called data shaping and how to implement it in ASP.NET Core Web API.
How to Implement Sorting in ASP.NET Core Web API
In this article, we're going to talk about sorting in ASP.NET Core Web API. Sorting is a commonly used mechanism, that every API should implement.
Searching in ASP.NET Core Web API
In this article, we're going to tackle the topic of searching in ASP.NET Core Web API and combine it with the paging and filtering
Filtering in ASP.NET Core Web API
In this article, we will cover filtering in ASP.NET Core Web API. We'll learn what filtering is, how it's different from searching, and how to implement it.
Protecting Data with IDataProtector in ASP.NET Core
In this article, we are going to learn how to use IDataProtector to protect the sensitive data in the ASP.NET Core application.
Paging in ASP.NET Core Web API
In this article, we're going to learn how to implement paging in ASP.NET Core Web API project with detailed examples and improvements.
System Testing a REST API using C# and DalSoft Rest Client
In this post, we're going to cover the recent extensions to the DalSoft RestClient library which allows you to easily test a REST API using C#
Configuring and Using Swagger UI in ASP.NET Core Web API
We are going to learn how to integrate the Swagger UI/OpenAPI in an ASP.NET Core Web API, extend the documentation, and customize UI.
Getting Started with AutoMapper in ASP.NET Core
we are going to learn how to use the AutoMapper in a .NET Core application. We will look into what the AutoMapper is and what problem it solves.
Differences Between .NET Framework, .NET Core, and .NET Standard
The .NET Framework and .NET Core are implementions of .NET whereas .NET Standard is not an implmention rather it's a specification.
Automated UI Tests with Selenium and ASP.NET Core
In this article, we are going to learn how to write automated UI tests for the ASP.NET Core application with the Selenium library.
How to Include AntiForgeryToken for MVC Integration Testing
In this post, we are going to learn how to include AntiForgeryToken for Integration Testing and how to register it in the IServiceCollection.
Integration Testing in ASP.NET Core
We are going to learn about Integration testing in ASP.NET Core, and how to use WebApplicationFactory class that helps in the process.
Testing Controllers with Unit Tests and Moq in ASP.NET Core
In this article, we are going to talk about unit testing controllers by using the Moq library, which enables us to isolate dependencies.
How to Send an Email in ASP.NET Core
In this article, we are going to learn how to send email from the ASP.NET Core project in sync, async way with attachments as well.
Introducing Identity to the ASP.NET Core Project
In this article, we are going to learn how to integrate the ASP.NET Core Identity library in our existing project and add additional tables and columns.
User Registration with ASP.NET Core Identity
In this article, we are going to learn about the User registration process with ASP.NET Core Identity and how to modify the default Identity configuration.
OWASP Top 10 – Injection
In this article, we are going to look at the injection attack, which is the most critical web application security threat as per OWASP Top 10 list.
Authentication With ASP.NET Core Identity
In this article, we are going to learn about the Authentication process with ASP.NET Core Identity, Logout process and adding additional Claims.
Password Reset with ASP.NET Core Identity
In this article, we are going to learn about the Password Reset functionality with ASP.NET Core Identity with detailed examples
Email Confirmation with ASP.NET Core Identity
In this article, we are going to learn how to enable email confirmation during the registration process with ASP.NET Core Identity
User Lockout with ASP.NET Core Identity
In this article, we are going to learn about User Lockout functionality with ASP.NET Core. Additionally, we'll implement a custom password validation.
Two-Step Verification with ASP.NET Core Identity
In this article, we are going to learn about the Two-Step Verification process with the ASP.NET Core Identity, for more secure login process.
External Identity Provider with ASP.NET Core Identity
In this article, we are going to learn how to configure an External Identity Provider with ASP.NET Core Identity and how to implement it in our solution.
OWASP Top 10 – Broken Authentication
Broken Authentication, the second most critical vulnerability as per OWASP Top10 list allows attackers to gain control over user accounts in a system.
C# Design Patterns – Facade
In this article we are going the describe the Facade Pattern and what difference does it make in our code, as well as its implementation.
Getting Started with ASP.NET Core and MongoDB
In this article, we’re going to cover how to set up and configure an ASP.NET Core Web API with MongoDB as our database.
Multiple Environments in ASP.NET Core
In this article, we’re going to cover how to set up and manage multiple environments in ASP.NET Core through different examples.
OWASP Top 10 – Sensitive Data Exposure
Sensitive data exposure occurs when an application accidentally exposes sensitive data and it usually occurs when we fail to protect our application data.
How to Migrate the IdentityServer4 Configuration to the Database with EntityFramework Core
In this article we are going to learn how to Migrate the IdentityServer4 Configuration to the MS SQL database in a few easy steps.
Securing Web API with the Hybrid Flow
In this article, we are going to learn about Securing Web API by using the Hybrid Flow. Additionally, we are going to use Policies to secure our app.
IdentityServer4 Authorization and Working with Claims
We are going to learn how to add new claims and modify existing ones. Additionally, we are going to learn about the IdentityServer4 Authorization process.
The Hybrid Flow – Securing ASP.NET Core Web Application
In this article, we are going to learn how to protect our Web Application by using the Hybrid Flow. Also, we'll learn to retrieve additional user data.
How to Easily Deploy ASP.NET Core Web API to Kubernetes Cluster on Azure
In this article, let's learn about one simple way to deploy an ASP.NET Core Web API app to Kubernetes Cluster on Azure with Codefresh.
IdentityServer4 UI and Web API Basic Security
In this article, we are going to learn how to add IdentityServer4 UI in the project and how to setup the basic Web API protection using IS4
IdentityServer4 Integration with ASP.NET Core
In this article, we are going to learn about the IdentityServer4 Integration with ASP.NET Core project. We will learn about the flows and integration setup.
How to Publish Angular with ASP.NET Core
In this article, we are going to cover how to publish Angular SPA production files by configuring ASP.NET Core's project file.
Implementing OAuth2 Refresh Token with Angular and IdentityServer4
Let's learn how to implement the OAuth2 refresh token with the angular application and IdentityServer4 as our authorization server app.
Role-Based Access Control and Claims with Angular and IdentityServer4
In this article, we are going to learn about role-based access control with Angular and IdentityServer4 and how to improve it with Guards
Securing Requests from Angular to Web API With Access Tokens
Let's learn how to extract Access Token from the user object and use it inside the Angular request to access prtected API resources.
CQRS and MediatR in ASP.NET Core
How to use the MediatR NuGet library in ASP.NET Core, and working with the CQRS and Mediator architectural patterns.
ASP.NET Core Configuration – Azure Key Vault
In this article, we're going to talk about how to protect our sensitive configuration data in the production environment with Azure Key Vault
Securing Sensitive Data Locally in ASP.NET Core
We've come to the most important part of this series - securing sensitive data when working with the configuration in ASP.NET Core
Creating Custom Configuration Provider in ASP.NET Core
In this article, we are going to create a custom configuration provider that reads our configuration from the database.
How to Send Client-Specific Messages Using SignalR
In this article, we are going to learn how we can send real time client-specific messages using SignalR and Angular as a client-side application.
How to Implement SignalR Automatic Reconnect with Angular
In this article, we are going to look at the SignalR Automatic Reconnect feature and how to implement automatic reconnect in our SignalR app.
IncludeMembers and Custom Projections with AutoMapper in ASP.NET Core
In this article, get ready to dive into custom projections with AutoMapper, using IncludeMembers and Value and Type Converters.
Introduction to gRPC in ASP.NET Core With MongoDB
In this article, we’re going to cover how to set up an ASP.NET Core gRPC service with MongoDB as our database.
FluentValidation in ASP.NET Core
Learn how to make use of FluentValidation in an ASP.NET Core application, to validate user input and make our applications easier to maintain and test.
Deep Dive Into Different Validators with FluentValidation
In this article we are going to learn more about different Validators with FluentValidation, that we can use to protect our app from bad inputs.
Dependency Injection in ASP.NET Core
In this article, we're going to talk about dependency injection, one of the most frequently used design patterns out there.
ASP.NET Core Configuration – Basic Concepts
In this introductory article, we are going to learn how ASP.NET Core configuration works and cover the basic configuration concepts.
ASP.NET Core Configuration – Options Pattern
In this article, we're going to cover another, better way of reading configuration data in .NET Core - the options pattern.
ASP.NET Core Configuration – Options Validation
In this article, we're going to learn the importance of options validation and a few ways to implement it in our ASP.NET Core applications.
ASP.NET Core Configuration – Configuration Providers
In this article, we're going to talk about different configuration providers in ASP.NET Core applications.
Deploying ASP.NET Core Web API to Azure API Apps
We can use Azure API Apps to create and deploy RESTful APIs in Azure with Cross-Origin Resource Sharing (CORS) support.
Elasticsearch in ASP.NET Core
How to use Elasticsearch in ASP.NET Core, including using queries and aggregations to build a search system.
Using Azure WebJobs in .NET Applications
Azure WebJobs along with Azure WebJobs SDK enables us to create run background jobs which can be based on schedules and triggers.
How to Send an SMS with ASP.NET Core
In this article, we are going to cover how to send an SMS with ASP.NET Core by integrating a Twilio service to help us in a process.
User Registration with Angular and ASP.NET Core Identity
Let's learn how to create User Registration with Angular and ASP.NET Core Identity. We are going to use the Web API for the server app.
Custom Validators and Handling Errors with Angular and ASP.NET Core Identity
Let's learn how to improve the registration functionality by implementing the Custom Validators for the Confirm Password and handle errors.
Using Property Mappings in AutoMapper To Define Mapping Rules
AutoMapper allows us to map two objects. Let's take a look at how to get the property mappings that have been defined using AutoMapper.
Event-Driven by Oskar Dudycz
event-driven.io
Filtering EventStoreDB subscriptions by event types - Event-Driven.io
Filtering EventStoreDB subscriptions by event types
