Latest Post on Blogers Hub



Redis, an acronym for Remote Dictionary Server, is a versatile in-memory data store that has gained significant popularity for its performance, flexibility, and broad range of use cases. Originally conceived in 2009, Redis has evolved into a multi-model database, supporting data structures such as strings, hashes, lists, sets, and sorted sets. As an in-memory database, it provides exceptional speed, making it an ideal choice for caching, session management, real-time analytics, and high-performance applications.

Redis stands out for its simplicity and efficiency. It operates with an in-memory dataset, ensuring quick read and write access compared to disk-based databases. This makes Redis a popular choice for enhancing the performance of web applications by caching frequently accessed data, thereby reducing the load on relational databases and speeding up response times. Furthermore, Redis supports various forms of persistence, allowing data to be stored on disks without sacrificing its high performance.

In the context of .NET Core, a popular open-source, cross-platform framework from Microsoft, Redis is often used as a distributed cache, session store, or a message broker. The integration of Redis with .NET Core applications is straightforward, thanks to the availability of various .NET client libraries such as StackExchange.Redis.

In addressing the multifaceted aspects of Redis, it's important to recognize that each topic encapsulates a breadth of intricacies and depth of knowledge. Given the expansive nature of these subjects, it is beyond the purview of this article to delve into each facet in its entirety. Therefore, the focus will be on providing a high-level overview, imparting a comprehensive yet concise understanding of each topic. This approach ensures that readers gain a holistic insight into the fundamental elements of Redis, while acknowledging the complex and detailed nature of its individual components.

  1. Redis Data Types with .NET Core

  2. Persistence in Redis

  3. Replication in Redis

  4. Partitioning in Redis

  5. Eviction Policies in Redis

  6. Redis Client-Side Caching in .NET Core

  7. Redis Cluster Creation and Testing in .NET Core

  8. Removing an Instance from a Redis Cluster


The release of Angular 15 marked a significant stride in the framework's journey, building upon the foundations laid by Angular 14. This article delves into the key differences and enhancements introduced in Angular 15, offering insights into how these changes improve the developer experience and application performance.

1. Embracing Stability with Standalone APIs

Angular 14 introduced the concept of Standalone APIs, albeit in an experimental phase. Angular 15 took this innovation to the next level by stabilizing these APIs. This shift significantly reduces the boilerplate code necessary for application development, allowing developers to bootstrap applications with single components. This simplification not only streamlines the development process but also makes the framework more approachable for newcomers.

// Angular 14 required NgModules for structuring applications
@NgModule({
  imports: [BrowserModule, FormsModule],
  declarations: [AppComponent],
  bootstrap: [AppComponent]
})
export class AppModule {}
// Angular 15 allows standalone components, eliminating the need for NgModules
@Component({
  selector: 'app-root',
  standalone: true,
  imports: [BrowserModule, FormsModule],
  template: `...`,
})
export class AppComponent {}

2. Directive Composition API: A Leap in UI Flexibility

...........


In the domain of microservice architecture, numerous challenges are ubiquitous, ranging from accessibility to retrieving configuration details, effective messaging, and service discovery. These challenges find resolution through common solutions, known as patterns. These patterns embody established methodologies and strategies designed to overcome these hurdles, strengthening the microservices architecture.

Representing tried-and-tested blueprints, these patterns offer structured approaches to resolve common obstacles within microservice frameworks. They provide an array of solutions aimed at simplifying accessibility, configuring information retrieval, optimizing messaging frameworks, and improving service discovery. Implementing these patterns empowers architects and developers to build resilient architectures, effectively mitigating the complexities associated with microservices.

The post explores two critical patterns: API Gateway/BFF and External Configuration Store.

The API Gateway pattern serves as a unified access point for client applications to interact with the associated microservices, offering routing, authentication, and load balancing functions. However, as the system expands and client needs diversify, a single API Gateway may face limitations. The Backends for Frontends (BFF) design pattern addresses this challenge by segmenting client applications, employing multiple Gateways catering to specific client types.

Different applications such as web or mobile apps demand varying content. The BFF pattern, when used alongside API Gateways, efficiently manages these differences, optimizing the content provided to different client types. This is crucial for mobile app users with limited data usage.

In the realm of configuration management, the External Configuration Store pattern offers a solution for microservices. It centralizes configuration information in a common repository, ensuring consistency across all instances. Each microservice instance accesses this store through local configuration files, determining when to retrieve the settings based on startup or as-needed, catering to the dynamic nature of certain configurations.

The post delves into essential considerations when employing these patterns, emphasizing maintenance to avoid excessive coupling between Gateways and microservices, ensuring smooth operations. Additionally, the importance of configuring information retrieval and handling dynamic settings is highlighted, as it significantly impacts microservice behavior.


The article delves into the challenges faced by major companies like Twitter, PayPal, and Netflix due to the limitations of their monolithic architecture. Issues such as scaling, quality, and frequent downtimes revealed the pitfalls of 'monolith hell' as these systems grew more complex, leading to delayed feature implementation and increased bugs.

The evolution of applications over time can transform them into burdens, impacting development speed and deployment efficiency. To address these challenges, a pivot towards a microservices architecture becomes crucial. The shift allows development teams to extract functionalities from monolithic applications, enabling more focused feature development and streamlined deployment schedules.

The article extensively explores the benefits of a microservices architecture, covering team autonomy, service autonomy, scalability advantages, fault isolation, and data autonomy. It also outlines the challenges faced during the transition, including the need for a flexible approach, learning curves, quality balance, and the impact on testing and development tasks.

Lastly, it discusses the historical context of microservices, their rise in attention due to cost-effective infrastructure and accessible programming languages and platforms. Despite their cost advantages, creating microservices demands substantial time, skill, and meticulous attention to ensure quality.


The .NET Framework comes to mind when talking about .NET. However, since the release of .NET Core 1.0 in 2016, we need to be more specific and distinguish between the .NET framework (also referred to as the full .NET framework) and the new .NET Core.

To understand the differences between the two, we first need to inspect the two main parts of the .NET framework: Common Language Runtime (CLR) and the Framework Class Library (FCL).

The Common Language Runtime is the virtual machine part of the .NET framework, responsible for running applications. It provides multiple services which make the following possible:


This post aims to describe, how we can access local package feed and download symbols to debug package. This post also explains how we have to step Visual studio to access package feed and symbol server. To see how you can create packages that can be debugged in Visual Studio 2017, please refer my last past "Create Nuget Package with source and symbol to debug in VS 2017

Setting up Visual Studio 2017

1. Open solution for the project in Visual Studio 2017. 

2. Click on Tools Options from top menu items in VS. 

3. Go to NuGet Package Manager Package Source. 

4. Click on the icon on the top right icons. Name it YourFeed (You can give a name as per your convenience) and put source http://yourservername:81/nuget/YourPackage/. Then click on update button. 


In this post, we will see the easiest way to create a package with all the symbols in Visual Studio 2017. So that once we install a symbol server and upload package to this symbol server then we can debug that package in Visual Studio 2017.  I will share steps to debug package in Visual Studio 2017 in "Setup and Debug NuGet packages in Visual Studio 2017". 

The process to Create a new package in Visual Studio 2017:

All process to create package will work as expected after these changes so you can use any of the processes to create new package i.e. msbuild, pack commands. Here I will explain default option to pack package with source and symbol. 


Introduction: In Today's Post I will explain how to do Validation with Jquery for Emailid, Phone number, numbers, Decimal and Required in single generic code. 

Post: Client side validation is the most common process in any web site. Even though we have jQuery form validation plugin also. But the issue we faced with this plugin is that We have to write separate code to validate every form. So I decided to something generic that I can write once and not need to think about client side validation part. Luckily jQuery provide us option to do this easily.

One single code will validate the complete site. In the current post, I will validation only for required, email, phone number, and decimal values. With a little code of jQuery and some CSS, we can do it.


In the Previous post, we learned about Validation with Jquery. In the Current post, we will learn a new feature of C sharp in .net framework 4.5. 

Introduction to Async and Await

Async and await are two new keywords that are introduced with .net framework 4.5 for supporting asynchronous programming. We can use Async feature which makes asynchronous programming straightforward as synchronous programming.

Async modifier specifies that method is an async method and returns a Task or Task. Task or Task return type hold information regarding ongoing work of methods i.e. Task contains information that the caller of the method can use status of Task, its unique ID and method's result.

async Task<int> DoSomeTasksAsync()

Await operator is used with return task in an await expression. This expression suspends execution of the method that contains it until the awaited task is complete. In mean time controls is returned to the caller of the suspended method.

Task<int> taskobject=  DoSomeTasksAsync()
int taskResult = await taskobject;

In the last post of jquery, we learn how to create a generic jquery code to validation complete site. Now will learn how to Delay function or Method execution for some time with SetTimOut Function after Jquery ready method.

Sometimes we have to delay execution of the method for some time or want to execute method continuously after a fix time interval using java script. i.e. want to create clock or do a service call. In any of these situations, we will user java script setTimeOut function.

Latest on posts

Blog Archive

Tags