In the world of ASP.NET Core development, the Program.cs file is like the control center of your application. It's where you configure everything that your web app needs to run smoothly. Let's take a closer look at what Program.cs is and how you can use it to set up your ASP.NET Core application.
Think of Program.cs as the starting point of your ASP.NET Core application. It's where you define how your app should be built and configured before it starts serving requests from users. Inside Program.cs, you'll find code that sets up things like services, database connections, API versioning, authentication, and more.
One of the most important tasks in Program.cs is configuring the services that your app needs. These services could be anything from database access to logging utilities. Here's a simple example of how you can configure a service:
// Configuring Services\nbuilder.Services.AddScoped<IAuthService, AuthService>();Health checks are like routine check-ups for your application. They help you monitor the health of your app's components and dependencies. Here's how you can set up health checks in Program.cs:
// Health Checks\nbuilder.Services.AddHealthChecks()\n .AddSqlServer(builder.Configuration.GetConnectionString(\"DefaultConnection\"), tags: new[] { \"database\" });CORS (Cross-Origin Resource Sharing) policies control which external domains can access your API. You can configure CORS policies in Program.cs like this:
// CORS Policies\nvar myCorsPolicy = \"MyCorsPolicy\";\nbuilder.Services.AddCors(options =>\n{\n options.AddPolicy(myCorsPolicy, builder =>\n {\n builder.AllowAnyOrigin().WithExposedHeaders(\"x-my-custom-header\");\n });\n});Connecting your ASP.NET Core app to a database is essential for storing and retrieving data. Here's how you can set up database connections in Program.cs:
// Database Connections\nbuilder.Services.AddDbContext<MyDbContext>(options =>\n options.UseSqlServer(builder.Configuration.GetConnectionString(\"DefaultConnection\")));\nbuilder.Services.AddDbContext<AppDbContext>(options =>\n{\n options.UseNpgsql(builder.Configuration.GetConnectionString(\"DefaultConnectionPS\"));\n});API versioning allows you to manage changes to your API over time. You can configure API versioning in Program.cs like this:
// API Versioning\nbuilder.Services.AddApiVersioning(o =>\n{\n o.AssumeDefaultVersionWhenUnspecified = true;\n o.DefaultApiVersion = new ApiVersion(2, 0);\n o.ReportApiVersions = true;\n});Swagger generates interactive API documentation for your ASP.NET Core app. Here's how you can set up Swagger in Program.cs:
// Swagger for API Documentation\nbuilder.Services.AddSwaggerGen();MassTransit is a powerful messaging library for .NET applications. You can configure MassTransit in Program.cs like this:
// MassTransit Setup\nbuilder.Services.AddMassTransit(x =>\n{\n x.UsingRabbitMq();\n});\nbuilder.Services.AddMassTransitHostedService();Authentication and authorization control access to your app's resources. Here's how you can set up authentication and authorization in Program.cs:
// Authentication and Authorization\nbuilder.Services.AddJwtAuthentication();\nbuilder.AddAppAuthentication();\nbuilder.Services.AddAuthorization();Logging helps you keep track of what's happening in your application. Configure logging in Program.cs like this:
// Configuring Logging\nbuilder.Host.ConfigureLogging(logging =>\n{\n logging.ClearProviders();\n logging.AddConsole();\n});\nvar logger = new LoggerConfiguration()\n .ReadFrom.Configuration(builder.Configuration)\n .Enrich.FromLogContext()\n .CreateLogger();\nbuilder.Logging.ClearProviders();\nbuilder.Logging.AddSerilog(logger);Hosted services allow you to run background tasks in your ASP.NET Core app. You can enlist hosted services in Program.cs like this:
// Enlisting Hosted Services for Background Tasks\nbuilder.Services.AddHostedService<MyBackgroundService>();\nbuilder.Services.AddHostedService<CartCleanupService>();API key validation helps you control access to your API endpoints. You can set up API key validation in Program.cs like this:
// API Key Validation\napp.UseMiddleware<ApiKeyMiddleware>();AutoMapper simplifies object-to-object mapping in your ASP.NET Core app. Configure AutoMapper in Program.cs like this:
// AutoMapper Configuration\nIMapper mapper = MappingConfig.RegisterMaps().CreateMapper();\nbuilder.Services.AddSingleton(mapper);\n\npublic static MapperConfiguration RegisterMaps()\n{\n\tvar mappingConfig = new MapperConfiguration(config =>\n\t{\n\t\tconfig.CreateMap<LocationDto, Location>().ReverseMap();\n\t});\n\treturn mappingConfig;\n}Ocelot is a library for building API gateways on ASP.NET Core. You can configure Ocelot in Program.cs like this:
// Ocelot Configuration\nbuilder.Configuration.AddOcelotWithSwaggerSupport(options =>\n{\n options.Folder = \"OcelotConfiguration\";\n});\nbuilder.Services.AddOcelot(builder.Configuration).AddAppConfiguration();\nbuilder.Services.AddSwaggerForOcelot(builder.Configuration);Rate limiting helps you control the rate of requests to your API endpoints. You can set up rate limiting in Program.cs like this:
// Rate Limiting\n\nbuilder.Services.AddRateLimiter(options =>\n{\n options.RejectionStatusCode = StatusCodes.Status429TooManyRequests;\n options.addfixedwindowlimiter(\"fixed\", options =>\n {\n options.permitlimit = 100;\n options.window = timespan.fromseconds(60);\n options.queueprocessingorder = queueprocessingorder.oldestfirst;\n options.queuelimit = 5;\n });\n options.AddTokenBucketLimiter(\"token\", options =>\n {\n options.TokenLimit = 100;\n options.QueueProcessingOrder = QueueProcessingOrder.OldestFirst;\n options.QueueLimit = 5;\n options.ReplenishmentPeriod = TimeSpan.FromSeconds(60);\n options.TokensPerPeriod = 20;\n options.AutoReplenishment = true;\n });\n options.AddPolicy(\"fixed-by-ip\", httpContext =>\n RateLimitPartition.GetFixedWindowLimiter(\n httpContext.Request.Headers[\"X-Forwarded-For\"].ToString(),\n factory: _ => new FixedWindowRateLimiterOptions\n {\n PermitLimit = 10,\n Window = TimeSpan.FromMinutes(1)\n }\n )\n );\n options.AddConcurrencyLimiter(\"concurrency\", options =>\n {\n options.PermitLimit = 10;\n options.QueueProcessingOrder = QueueProcessingOrder.OldestFirst;\n options.QueueLimit = 5;\n });\n});The Program.cs file in ASP.NET Core 8 is the heart of your application’s configuration. From setting up databases to API versioning, authentication, messaging, and more, this file defines how your app behaves and scales. With real-world examples, you can see how each of these features applies to building a robust application, like an e-commerce site. Mastering the configurations in Program.cs will help you build more efficient, scalable, and secure applications in ASP.NET Core.
Minimal APIs were introduced in ASP.NET Core 6 and have been further enhanced in ASP.NET Core 8. Unlike traditional MVC-based APIs, Minimal APIs provide a lightweight and simplified approach for building HTTP services. They aim to reduce boilerplate code, allowing developers to create RESTful services using a more functional programming style.
\nIn a Minimal API, you directly define routes and handle requests within the Program.cs file, without the need for controllers, attributes, or extensive configuration. This approach is ideal for microservices, serverless functions, and small services where you need quick, straightforward implementations.
Let's walk through a complete example of how to set up a Minimal API from scratch in ASP.NET Core 8.
\nStart by creating a new ASP.NET Core 8 project using the command line.
\ndotnet new web -n MinimalApiExample\ncd MinimalApiExampleThis template generates a basic web project, which you can modify to implement a minimal API.
\nProgram.csIn ASP.NET Core 8, you define endpoints directly in the Program.cs file. Here's an example:
var builder = WebApplication.CreateBuilder(args);\nvar app = builder.Build();\n\n// A simple GET request\napp.MapGet(\"/\", () => \"Welcome to Minimal API in ASP.NET Core 8\");\n\n// Start the application\napp.Run();In this basic setup:
\n/ is hit, it returns the message \"Welcome to Minimal API in ASP.NET Core 8\".You can add routes for different HTTP methods and include parameters in the routes to handle more complex operations.
\nvar builder = WebApplication.CreateBuilder(args);\nvar app = builder.Build();\n\n// GET method to fetch all users\napp.MapGet(\"/users\", () =>\n{\n return new[] { \"Alice\", \"Bob\", \"Charlie\" };\n});\n\n// GET method with a parameter to fetch a user by ID\napp.MapGet(\"/users/{id}\", (int id) =>\n{\n return $\"User ID: {id}\";\n});\n\n// POST method to create a new user\napp.MapPost(\"/users\", (User newUser) =>\n{\n return Results.Created($\"/users/{newUser.Id}\", newUser);\n});\n\n// Start the application\napp.Run();\n\n// Define the User model\npublic record User(int Id, string Name, string Email);id and returns the corresponding user ID.User object (model binding) and returns a \"Created\" response with a link to the newly created user.You can still use all the ASP.NET Core features, such as Dependency Injection, with minimal APIs.
\nvar builder = WebApplication.CreateBuilder(args);\n\n// Add services to DI container\nbuilder.Services.AddSingleton<IUserService, UserService>();\n\nvar app = builder.Build();\n\n// GET method with DI\napp.MapGet(\"/users\", (IUserService userService) =>\n{\n return userService.GetAllUsers();\n});\n\n// Start the application\napp.Run();\n\n// Service and Interface\npublic interface IUserService\n{\n IEnumerable<string> GetAllUsers();\n}\n\npublic class UserService : IUserService\n{\n public IEnumerable<string> GetAllUsers()\n {\n return new[] { \"Alice\", \"Bob\", \"Charlie\" };\n }\n}Even in Minimal APIs, you can easily integrate Swagger to generate API documentation.
\nAdd the Swashbuckle.AspNetCore NuGet package for Swagger.
dotnet add package Swashbuckle.AspNetCoreNext, configure Swagger in Program.cs:
var builder = WebApplication.CreateBuilder(args);\n\n// Add Swagger services\nbuilder.Services.AddEndpointsApiExplorer();\nbuilder.Services.AddSwaggerGen();\n\nvar app = builder.Build();\n\n// Enable Swagger\napp.UseSwagger();\napp.UseSwaggerUI();\n\n// Define minimal API routes\napp.MapGet(\"/\", () => \"Hello, World!\");\n\n// Start the app\napp.Run();Now, when you run the application, Swagger documentation will be available at /swagger in the browser.
Minimal APIs also support authentication and authorization. Here’s a basic example using JWT authentication.
\nvar builder = WebApplication.CreateBuilder(args);\n\n// Add JWT authentication\nbuilder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)\n .AddJwtBearer(options =>\n {\n options.Authority = \"https://your-auth-server\";\n options.Audience = \"your-api-audience\";\n });\n\nbuilder.Services.AddAuthorization();\n\nvar app = builder.Build();\n\napp.UseAuthentication();\napp.UseAuthorization();\n\n// A protected API route\napp.MapGet(\"/secure\", () => \"This is a protected resource\")\n .RequireAuthorization();\n\napp.Run();In this example:
\nAddJwtBearer./secure route is protected by RequireAuthorization, ensuring that only authenticated users can access it.Endpoint filters in ASP.NET Core 8 allow you to define reusable logic that can be applied to multiple endpoints. This could include validation, logging, or modifying the request/response.
\nvar builder = WebApplication.CreateBuilder(args);\n\nvar app = builder.Build();\n\n// Define an endpoint filter\napp.MapPost(\"/users\", (User newUser) =>\n{\n return Results.Created($\"/users/{newUser.Id}\", newUser);\n}).AddEndpointFilter(async (context, next) =>\n{\n var user = context.GetArgument<User>(0);\n \n if (string.IsNullOrEmpty(user.Name))\n {\n return Results.BadRequest(\"Name is required\");\n }\n\n return await next(context);\n});\n\napp.Run();\n\n// User model\npublic record User(int Id, string Name, string Email);In this example:
\nMinimal APIs in ASP.NET Core 8 provide a streamlined and efficient way to build small-scale web services. They reduce the overhead of traditional MVC patterns while still retaining the full power of ASP.NET Core's middleware, dependency injection, and other features. Whether you're building microservices, serverless functions, or just want a lightweight API for quick tasks, Minimal APIs offer a flexible and easy-to-use solution.
"}},{"node":{"frontmatter":{"title":"Secure Your API By IP Whitelisting Using ASP.NET Core 8 Web API","date":"Sep 29, 2024","readtime":"8 min read","cover":{"childImageSharp":{"gatsbyImageData":{"layout":"constrained","placeholder":{"fallback":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAALCAIAAADwazoUAAAACXBIWXMAAAPoAAAD6AG1e1JrAAACiUlEQVQozwXBb08ScQAA4PsmrV60ZZNaaqDCcXccB3cHd9yPA47jOE7+c3J6BwgODDkQVExTZJnOaDld2exFY2ttrjWXq1VvW5+n54Ew2ySNPY1w3hBHxuJRJhxh5RTIG7xanvMHZz0+nGG5EHDjTpJwEE4r4Xjisk3Aj+85LHcgArEyNCbLQrVeXTXbIF3gFqvR1kHx8CzXG1R2BqJeY5OqVn9m9jo+ng+EeD+J+gmYRK2Qx4NExEggGpWXy9FSI9ToZ46umpfX51+/v7v5aeyflnr9Qr0Z1lbSK/VATgd5nYvLDEsT8DTk9rjCCSWcLUjVlrjWF3rH6mg8+vZ788MX480n/fhSqHXW+31jY5tUa8Fyi8npzELOA4Io5oA4QRAXS/6UGqu1hcZ2cO3F0vahZm4yRsu8GJvvP2vdXUaUqq0WV9sMtYdCc5dRK76k6hNECKdpTkmT8XRAq3Flk610lzt9RV2UNf3X33/jH3/Orz4SDFNpNkVzX9g751tDslinM0uspEBeH1XvdPZOTrdejXonb3unF93hkWYUYwn5+vZ2fHP7cjTy0N7i6mq8fSD0R77GnidX9ufLnJKBCC8ek2ONjtk9GKRKNb6gy0tlo7KUTYlcgBJjYZrCM+nYxmAIaybYORM2hmyhTEYk3I1ABGrzU1hCkZRsJiRJQJLoIE9xXCopCjwdBlQuGU5nFdFoVAev440tsbIOEmkfACQBQ+jMA0A5I0E6BGiO9QKOBsAPowhOkiAEMvlMbCGR1HRGWmjvPFdyWRdNuXEYh2ew2UnI/ugubnvonrNgtknXnIVwThOoDYOtKGqHnfMwCqM4StKk3W7DkHnMaUPmp5BZCzIz4Zy6/x8KUgCPiOusTwAAAABJRU5ErkJggg=="},"images":{"fallback":{"src":"/static/773623bdb434960fc399f5295e06e5f2/dcd92/SecureAPI.webp","srcSet":"/static/773623bdb434960fc399f5295e06e5f2/745fa/SecureAPI.webp 175w,\n/static/773623bdb434960fc399f5295e06e5f2/b0f73/SecureAPI.webp 350w,\n/static/773623bdb434960fc399f5295e06e5f2/dcd92/SecureAPI.webp 700w,\n/static/773623bdb434960fc399f5295e06e5f2/c98e3/SecureAPI.webp 1400w","sizes":"(min-width: 700px) 700px, 100vw"},"sources":[{"srcSet":"/static/773623bdb434960fc399f5295e06e5f2/1934d/SecureAPI.avif 175w,\n/static/773623bdb434960fc399f5295e06e5f2/8f8aa/SecureAPI.avif 350w,\n/static/773623bdb434960fc399f5295e06e5f2/a273d/SecureAPI.avif 700w,\n/static/773623bdb434960fc399f5295e06e5f2/49b21/SecureAPI.avif 1400w","type":"image/avif","sizes":"(min-width: 700px) 700px, 100vw"}]},"width":700,"height":400}}},"tech":["ASP.NET Core",".Net 8 Core","Microservice","Secure API"],"github":null,"external":"/blogs/secure-your-api-by-ip-whitelisting-using-asp-net-core-8-web-api","cta":"/blogs/secure-your-api-by-ip-whitelisting-using-asp-net-core-8-web-api"},"html":"In today’s digital landscape, securing APIs is a top priority, especially when exposing services over the internet. One way to increase security is through IP whitelisting — a technique that restricts access to only a specified set of IP addresses, effectively blocking traffic from unauthorized sources. This can be a crucial component in applications where access must be tightly controlled, like in financial services, internal APIs, or administrative dashboards.
\nIn this blog, we’ll dive deep into how to implement IP whitelisting in an ASP.NET Core 8 Web API using a custom middleware.
\nIP Whitelisting is the process of allowing access to a web service only from pre-approved IP addresses. This ensures that even if someone has the correct credentials, they cannot access the API unless they’re using an approved IP address.
\nIn an ASP.NET Core Web API, this functionality can be implemented via middleware that intercepts incoming requests, checks the origin’s IP, and determines whether to grant or deny access based on the whitelist.
\nMiddleware is perfect for this task since it can inspect each HTTP request as it arrives. The following code shows how to create a custom IPWhitelistMiddleware that checks the client’s IP address against a predefined whitelist in the configuration:
using System.Net;\n\nnamespace BEArgentina.Services.AuthAPI.Middlewares\n{\n public class IPWhitelistMiddleware\n {\n private readonly RequestDelegate _next;\n private readonly IConfiguration _configuration;\n\n public IPWhitelistMiddleware(RequestDelegate next, IConfiguration configuration)\n {\n _next = next;\n _configuration = configuration;\n }\n\n public async Task InvokeAsync(HttpContext context)\n {\n // Get the remote IP address of the client\n var remoteIp = context.Connection.RemoteIpAddress;\n\n // Fetch the allowed IPs from configuration\n var allowedIPs = _configuration.GetSection(\"AllowedIPs\").Get<string[]>();\n\n // Check if the remote IP is in the allowed IP list\n if (!IPAddress.IsLoopback(remoteIp) && !allowedIPs.Contains(remoteIp?.ToString()))\n {\n // If the IP is not allowed, return a forbidden response\n context.Response.StatusCode = (int)HttpStatusCode.Forbidden;\n await context.Response.WriteAsync($\"Access denied from IP: {remoteIp}\");\n return;\n }\n\n // Proceed to the next middleware in the pipeline if the IP is allowed\n await _next(context);\n }\n }\n}Program.csNow that the middleware is created, we need to register it in the request pipeline. Open your Program.cs file and add the IPWhitelistMiddleware to the pipeline using app.UseMiddleware.
Here’s how to do that:
\nvar builder = WebApplication.CreateBuilder(args);\n\n// Add services to the container.\nbuilder.Services.AddControllers();\n\n// Configure IP whitelist middleware\nvar app = builder.Build();\n\n// Adding IP Whitelisting Middleware\napp.UseMiddleware<BEArgentina.Services.AuthAPI.Middlewares.IPWhitelistMiddleware>();\n\n// Configure the HTTP request pipeline.\napp.MapControllers();\n\napp.Run();appsettings.jsonWe’ll store the list of allowed IP addresses in the appsettings.json file. This makes it easy to configure and update the whitelist without touching the application’s codebase.
Add the following section to your appsettings.json:
{\n \"AllowedIPs\": [\n \"192.168.1.100\",\n \"203.0.113.42\",\n \"203.0.113.50\"\n ]\n}In this example, the application will only allow requests originating from the IP addresses 192.168.1.100, 203.0.113.42, and 203.0.113.50.
Now that you’ve set up the middleware and configured the allowed IPs, you can test the functionality by sending requests from an unauthorized IP. The middleware should respond with:
\nAccess denied from IP: {client IP}If the IP address is allowed, the request will proceed as usual.
\nYou can enhance the basic implementation of IP whitelisting in several ways, such as:
\nEnvironment-Specific IP Whitelists: You may want different whitelists for different environments (development, staging, production). This can be handled by creating environment-specific configuration files (appsettings.Development.json, appsettings.Production.json).
CIDR Support: Instead of only allowing individual IP addresses, you could allow entire IP ranges using CIDR notation. This would require checking if the client’s IP falls within the allowed range.
\nDynamic IP Whitelisting: You could build a more dynamic system by fetching the allowed IPs from a database or a remote API, allowing administrators to update the whitelist without restarting the application.
\nIP whitelisting can be useful in various scenarios:
\nInternal APIs: APIs that are only intended for internal use, such as those used by company applications or within corporate networks.
\nAdministrative Panels: Admin panels or dashboards that should only be accessible from within the office network or through a VPN.
\nCompliance Requirements: Some industries, such as finance or healthcare, have strict compliance requirements that mandate restricting access based on IP address.
\nExternal Service Access: APIs that allow access to external services but want to limit access to specific trusted partners or clients.
\nImplementing IP whitelisting in an ASP.NET Core 8 Web API adds an additional layer of security to your application. By controlling which IP addresses can access your API, you mitigate the risk of unauthorized access, especially to sensitive or administrative endpoints.
\nThis simple yet effective technique can be easily set up using middleware in ASP.NET Core. You can also customize and enhance the whitelist logic as needed to fit more complex scenarios or requirements.
\nBy implementing this security measure, your APIs are much more robust and ready to handle real-world security challenges.
"}},{"node":{"frontmatter":{"title":"Stripe Payment using .NET 8 Core Microservice and React JS","date":"Sep 27, 2024","readtime":"10 min read","cover":{"childImageSharp":{"gatsbyImageData":{"layout":"constrained","placeholder":{"fallback":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAALCAIAAADwazoUAAAACXBIWXMAAAPoAAAD6AG1e1JrAAACiklEQVQozwXBWU/aAAAA4P6VJcviJgleTEAFPGq5ESg3lkLpRRHKYZFytrYrt4hMxE2cR1yWPRgfdmS/YMme97Zkj/sb+z7gxfLmIripcQRUG5Z5PajaMKtNdrXJpt5yLGw5F3ecYAQDo5jRG4EiqD2Ow1QqmM6QlXJREYC51ztaJ6gLEwug55UO3A2iTEPSW31aKxxksql6xUHn8qOJBSUcZMbLZPzpA6RYpOvVvCICL1dBU8BmPCirQa/e5tlLUO4EaUuiZjKHST1a7pA8T9eFzOQqLirBPBdk8yjHUY1aTjkGXukgKOYFj4QFyOdEcDua3jwqk2+ztc9fhNkHplSB3EEQSZLdHqu0WEWJFksIV6KaDbYlA/NrVhsG7/H8qhvx0ZlwoeqeXtUeL3PDCX73SW33PVNpLCjJdFuJukhJSpyvRjieEES23QJUBsd22G8ncQtGBEp17mzSvnkojM7hepf49fe5LRTyR6maEOTquZMxN5lGilys2iQlhe13AfWWawWCV6z+QCqHNOXieHx2PZMfPm4HYtFijWtJjrZsrogOPI01Ffy4E6sKiaZEKe1svw8sgV4wTBgD2FaIMBJs4+Lyx9frw9nAmcg+fX/6/e9P4/4Ovbrxib3C+Q3VHiBNCTtW6E4vOxwBS7uwOZaGEEbjiMwZnUjmEC+L6wUOllteXm7M7h9/fmvdTiNCPzl4h7wZxKU2rvTp3kl2NAaWQFhjDWhd0XUY1XlihkRxg5UNyUM/L/mEPja8hcp0uNsIKVNYPg1Kw4TSxzsnmfGUnbwHli1+rWtf74mtwXFDmDTup0xYDmR4KC/usE1bue2qDfdqA7/QC4ndfakXVwbJ3ilzNmUvZv8B150SuKogXmgAAAAASUVORK5CYII="},"images":{"fallback":{"src":"/static/2d5dcc2b30dca75b0bab3a133db10e0a/dcd92/SecureAPI.webp","srcSet":"/static/2d5dcc2b30dca75b0bab3a133db10e0a/745fa/SecureAPI.webp 175w,\n/static/2d5dcc2b30dca75b0bab3a133db10e0a/b0f73/SecureAPI.webp 350w,\n/static/2d5dcc2b30dca75b0bab3a133db10e0a/dcd92/SecureAPI.webp 700w,\n/static/2d5dcc2b30dca75b0bab3a133db10e0a/c98e3/SecureAPI.webp 1400w","sizes":"(min-width: 700px) 700px, 100vw"},"sources":[{"srcSet":"/static/2d5dcc2b30dca75b0bab3a133db10e0a/1934d/SecureAPI.avif 175w,\n/static/2d5dcc2b30dca75b0bab3a133db10e0a/8f8aa/SecureAPI.avif 350w,\n/static/2d5dcc2b30dca75b0bab3a133db10e0a/a273d/SecureAPI.avif 700w,\n/static/2d5dcc2b30dca75b0bab3a133db10e0a/49b21/SecureAPI.avif 1400w","type":"image/avif","sizes":"(min-width: 700px) 700px, 100vw"}]},"width":700,"height":400}}},"tech":["Stripe","ASP.NET Core",".Net 8 Core","Microservice","React.js","React Hooks"],"github":null,"external":"https://www.prafulchauhan.com/blogs/stripe-payment-using-net-8-core-microservice-and-react-js","cta":"https://www.prafulchauhan.com/blogs/stripe-payment-using-net-8-core-microservice-and-react-js"},"html":"In this blog, we will walk through the process of integrating Stripe payments into a .NET 8 Core Microservice architecture with a React JS front-end. This will cover both the backend API for processing payments and the React component for capturing customer details and initiating payments.
\ndotnet new webapi -n StripePaymentService\ncd StripePaymentServiceAdd the Stripe NuGet package to your project:
\ndotnet add package Stripe.net --version 42.0.0appsettings.jsonIn the appsettings.json file, add your Stripe secret key.
{\n \"Stripe\": {\n \"SecretKey\": \"your-stripe-secret-key\",\n \"PublishableKey\": \"your-stripe-publishable-key\"\n }\n}In the Program.cs file, configure Stripe services:
var builder = WebApplication.CreateBuilder(args);\n\n// Add services to the container.\nbuilder.Services.Configure<StripeSettings>(builder.Configuration.GetSection(\"Stripe\"));\n\nbuilder.Services.AddSingleton<IStripeClient, StripeClient>(sp =>\n{\n var config = sp.GetRequiredService<IOptions<StripeSettings>>().Value;\n return new StripeClient(config.SecretKey);\n});\n\nbuilder.Services.AddControllers();\n\nvar app = builder.Build();\n\napp.UseHttpsRedirection();\napp.UseAuthorization();\napp.MapControllers();\napp.Run();Create a new controller named PaymentController.cs to handle the payment request.
[ApiController]\n[Route(\"api/[controller]\")]\npublic class PaymentController : ControllerBase\n{\n private readonly IStripeClient _stripeClient;\n\n public PaymentController(IStripeClient stripeClient)\n {\n _stripeClient = stripeClient;\n }\n\n [HttpPost(\"create-payment-intent\")]\n public async Task<IActionResult> CreatePaymentIntent([FromBody] PaymentIntentRequest request)\n {\n var options = new PaymentIntentCreateOptions\n {\n Amount = request.Amount,\n Currency = request.Currency,\n PaymentMethodTypes = new List<string> { \"card\" }\n };\n\n var service = new PaymentIntentService(_stripeClient);\n var paymentIntent = await service.CreateAsync(options);\n\n return Ok(new { clientSecret = paymentIntent.ClientSecret });\n }\n}\n\npublic class PaymentIntentRequest\n{\n public long Amount { get; set; }\n public string Currency { get; set; }\n}You can test the API using Postman or another API testing tool. Send a POST request to https://localhost:5001/api/payment/create-payment-intent with the following JSON payload:
{\n \"amount\": 2000,\n \"currency\": \"usd\"\n}If successful, it will return a clientSecret which you will use in the front-end to complete the payment.
In your React project, install the necessary Stripe packages:
\nnpm install @stripe/react-stripe-js @stripe/stripe-jsSet up the StripeProvider and Elements in your App.js:
import React from 'react';\nimport { Elements } from '@stripe/react-stripe-js';\nimport { loadStripe } from '@stripe/stripe-js';\nimport PaymentForm from './PaymentForm';\n\nconst stripePromise = loadStripe('your-publishable-key');\n\nfunction App() {\n return (\n <Elements stripe={stripePromise}>\n <PaymentForm />\n </Elements>\n );\n}\n\nexport default App;Create a new component PaymentForm.js that will handle the payment process:
import React, { useState } from 'react';\nimport { CardElement, useStripe, useElements } from '@stripe/react-stripe-js';\n\nconst PaymentForm = () => {\n const [amount, setAmount] = useState(2000); // Amount in cents\n const stripe = useStripe();\n const elements = useElements();\n\n const handleSubmit = async (event) => {\n event.preventDefault();\n const { error, paymentIntent } = await createPaymentIntent(amount);\n\n if (!error && stripe && elements) {\n const { error: stripeError } = await stripe.confirmCardPayment(paymentIntent.clientSecret, {\n payment_method: {\n card: elements.getElement(CardElement)\n }\n });\n\n if (stripeError) {\n console.error('Payment failed', stripeError);\n } else {\n console.log('Payment successful');\n }\n }\n };\n\n const createPaymentIntent = async (amount) => {\n const response = await fetch('https://localhost:5001/api/payment/create-payment-intent', {\n method: 'POST',\n headers: { 'Content-Type': 'application/json' },\n body: JSON.stringify({ amount, currency: 'usd' })\n });\n return await response.json();\n };\n\n return (\n <form onSubmit={handleSubmit}>\n <CardElement />\n <button type=\"submit\" disabled={!stripe}>Pay</button>\n </form>\n );\n};\n\nexport default PaymentForm;Run your React application and test the payment flow by entering card details such as:
\n4242 4242 4242 4242If everything is configured correctly, you should see a successful payment response in your browser.
\nIntegrating Stripe payments with a .NET 8 Core Microservice and React JS is a powerful way to handle secure transactions. The combination of .NET for backend processing and React for handling frontend interactions ensures a smooth and efficient payment experience.
\nThis blog demonstrated setting up a microservice, processing payments with Stripe, and building a frontend interface for users. Happy coding!
"}},{"node":{"frontmatter":{"title":"Mastering NuGet Package Creation in .NET 8 Core: A Complete Guide to Building, Packaging, and Publishing","date":"Oct 18, 2024","readtime":"12 min read","cover":{"childImageSharp":{"gatsbyImageData":{"layout":"constrained","placeholder":{"fallback":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAALCAIAAADwazoUAAAACXBIWXMAAAPoAAAD6AG1e1JrAAACpElEQVQozwXBWU/TAAAA4P4KHowPGiMajeIgEoLcuiEbMgaFwYBxFQTG2BjsYN1R2o4dXdt1PUbp1q0dsAyUBRCEGA94IvGID8Q3H0188T/4fYC4lS7ILMtEZInKiqQkUkVV2C3lDyo770/3Dyo7YpZN0Ri27sZj69kcJysSyaY2ZbGwnQdIKiqJ5CaLp5JhLh3NSXROog/2lb1yDo2j3ebBu7V1PvuwQjgVAf95dfT7+lM+n0lnWFnJAkkS3y2wb1Qmx+GqRO6rLMsT0IqjE+x/0NRevYi0cmXQpMVWJ6DBF1lknA9PM0mElzLZ/CagZOm3hdSXiljOIN9OBCG+oukx3XrW0vK89dGQrSr//T5R1OnbnQvDBl39QMdD0jNaUjhhSxC2OGBHTh3J2C7rzUTm0zYtMqNr1HU80eru1T/VGIx1xkEEg/PKVsA5mkBXAmFvPjr3cSfC8SQjMMDwWL8bMijRWTk8MtVTL9ARyL18p62tWdeGoF5Z4TEKp3laLalJOprLpZdsY/DqdIpJ0CwJVN2+caf6JrmgK6LWDDbrd0ITE6APXmZ5Yhl2jdshNL5+9fXy778/oUgoADs2NoIobCPjwWQqAdQ01NY0aJqaHvNBawDqGjW/jKCeUMgdI3H/uu/krPL54vzw3QGZim2XCijiphJBIh5EMBiL44Ae7NV2azWNtT2GlmTY5ltbKtPuYsyulNTrXz9Oz48Ynjo83sOICCcyFEt51xxrYb83DIdwBOjqfwVaQOuUBbSAE9b+Hn2z2dKrFkWnZ8kT9JX31YvLs9MPxzgRMU+O2QKBeY/b4V11+b2+MAzojAbjYG+vuc9kGTCB3UajtkPf0d7Z0jc6ZBoZSkubOBEdm5m0zkxB9oUp2+s55+Kcy2H3rLj8nv+KmD/qs3SqrgAAAABJRU5ErkJggg=="},"images":{"fallback":{"src":"/static/04a8104dc44cede314613fc0faf50be2/dcd92/SecureAPI.webp","srcSet":"/static/04a8104dc44cede314613fc0faf50be2/745fa/SecureAPI.webp 175w,\n/static/04a8104dc44cede314613fc0faf50be2/b0f73/SecureAPI.webp 350w,\n/static/04a8104dc44cede314613fc0faf50be2/dcd92/SecureAPI.webp 700w,\n/static/04a8104dc44cede314613fc0faf50be2/c98e3/SecureAPI.webp 1400w","sizes":"(min-width: 700px) 700px, 100vw"},"sources":[{"srcSet":"/static/04a8104dc44cede314613fc0faf50be2/1934d/SecureAPI.avif 175w,\n/static/04a8104dc44cede314613fc0faf50be2/8f8aa/SecureAPI.avif 350w,\n/static/04a8104dc44cede314613fc0faf50be2/a273d/SecureAPI.avif 700w,\n/static/04a8104dc44cede314613fc0faf50be2/49b21/SecureAPI.avif 1400w","type":"image/avif","sizes":"(min-width: 700px) 700px, 100vw"}]},"width":700,"height":400}}},"tech":[".NET 8 Core","NuGet","IP Whitelisting","Web API"],"github":null,"external":"/blogs/mastering-nu-get-package-creation-in-net-8-core-a-complete-guide-to-building-packaging-and-publishing","cta":"/blogs/mastering-nu-get-package-creation-in-net-8-core-a-complete-guide-to-building-packaging-and-publishing"},"html":"Creating a custom NuGet package is an excellent way to distribute reusable code across projects and share it with the .NET community. In this blog, we'll walk through the entire process of building and publishing a NuGet package in .NET 8 Core, using a practical example: an IP whitelisting middleware.
\nThis step-by-step guide will help you understand how to package your .NET code and publish it on the official NuGet registry for others to use.
\nA NuGet package is essentially a compiled library that can be shared and reused across different projects. It contains assemblies, files, and metadata that describe the contents and dependencies. With NuGet, you can easily share reusable code or libraries with other developers.
\nBefore starting, make sure you have the following:
\nThe first step is to create a new project in .NET 8 Core.
\ndotnet new classlib -n IPWhitelist\ncd IPWhitelistThis creates a new class library project named IPWhitelist.
We'll now write the actual middleware that will whitelist certain IP addresses and block others.
\nIPWhitelist.cs:using Microsoft.AspNetCore.Http;\nusing Microsoft.Extensions.Configuration;\nusing System.Net;\n\nnamespace IPWhitelist\n{\n public class IPWhitelist\n {\n private readonly RequestDelegate _next;\n private readonly IConfiguration _configuration;\n\n public IPWhitelist(RequestDelegate next, IConfiguration configuration)\n {\n _next = next;\n _configuration = configuration;\n }\n\n public async Task InvokeAsync(HttpContext context)\n {\n var remoteIp = context.Connection.RemoteIpAddress;\n var allowedIPs = _configuration.GetSection(\"AllowedIPs\").Get<string[]>();\n\n if (!IPAddress.IsLoopback(remoteIp) && !allowedIPs.Contains(remoteIp?.ToString()))\n {\n context.Response.StatusCode = (int)HttpStatusCode.Forbidden;\n await context.Response.WriteAsync(\"Access denied for IP: \" + remoteIp);\n return;\n }\n\n await _next(context);\n }\n }\n}This reads a list of allowed IP addresses from the configuration and blocks any requests coming from an IP not in the list.
\nNow we need to prepare the project for packaging. This involves updating the project file (.csproj) with important metadata like package name, version, description, and authors.
.csproj file and modify it as follows:<Project Sdk=\"Microsoft.NET.Sdk\">\n\n <PropertyGroup>\n <TargetFramework>net8.0</TargetFramework>\n <PackageId>IPWhitelist</PackageId>\n <Version>1.0.0</Version>\n <Authors>Praful Chauhan</Authors>\n <Description>IP whitelisting in ASP.NET Core</Description>\n <PackageLicenseFile>LICENSE.txt</PackageLicenseFile>\n <PackageProjectUrl>https://github.com/cprafulm-gmail/IPWhitelist</PackageProjectUrl>\n <RepositoryUrl>https://github.com/cprafulm-gmail/IPWhitelist</RepositoryUrl>\n </PropertyGroup>\n\n <ItemGroup>\n <PackageReference Include=\"Microsoft.AspNetCore.Http\" Version=\"8.0.0\" />\n <PackageReference Include=\"Microsoft.Extensions.Configuration\" Version=\"8.0.0\" />\n <PackageReference Include=\"Microsoft.Extensions.Configuration.Binder\" Version=\"8.0.0\" />\n </ItemGroup>\n\n</Project>Here’s what each property means:
\nTo include a license with your package, create a file called LICENSE.txt in the root of your project directory. Here’s an example of an MIT license:
MIT License\n\nCopyright (c) 2024 Your Name\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n...Make sure you add the path to this file in your .csproj file as demonstrated above.
With the code and metadata ready, it’s time to create the actual NuGet package.
\ndotnet pack --configuration ReleaseThis will generate a .nupkg file in the bin/Release folder. The package is now ready to be published.
Before publishing your package to NuGet.org, it's a good idea to test it locally.
\ndotnet nuget add source \"path/to/your/package/directory\" -n LocalPackages\ndotnet add package IPWhitelist --source LocalPackagesThis allows you to verify the functionality of your package in a new project.
\nOnce you're satisfied with the package, you can publish it to NuGet.org.
\ndotnet nuget push bin/Release/IPWhitelist.1.0.0.nupkg -k <your-api-key> -s https://api.nuget.org/v3/index.jsonReplace <your-api-key> with the API key you generated on NuGet.org.
In this blog, we walked through the process of creating, packaging, and publishing a NuGet package in .NET 8 Core. By following these steps, you can create your own reusable middleware or library, and share it with the world through NuGet.
\nCreating and publishing NuGet packages empowers developers to build reusable, modular code that others can benefit from. Whether it’s for internal use or for the community, the process is straightforward and allows you to contribute to the broader .NET ecosystem.
\nHappy coding!
"}},{"node":{"frontmatter":{"title":"Create and Publish a Custom React Hook as an NPM Package","date":"Oct 16, 2024","readtime":"10 min read","cover":{"childImageSharp":{"gatsbyImageData":{"layout":"constrained","placeholder":{"fallback":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAALCAIAAADwazoUAAAACXBIWXMAAAPoAAAD6AG1e1JrAAACqklEQVQozwGfAmD9AIJfQINdO1I5H4ZvW6R4Vq19WayYiKyZiqajori1tqysr7O0t7m5u8nDw6uhm1RVS5aMhcG0tLSloo99cQCQdmKfhG+pjXqxlYKvl4SBeG2HhX99d22Fgn6LiYSUkYqOi4SlnZfTwbqRhnCAfGq0p6GQh4SnmpebhHUAqpuRrZ6ToZaNx7ixrp+UMmJ+RYq1HzY7PkhHSFdZRFNTRFNTgXx32cO48drO6NHCyLeytKWghnx0g3RlAK6bjpqIeId+criqn7uqnUpmc1GDn0BQUz9HSkZGRzhHRjRGSHx5c9fCt6OccaiidMSzrr2qo4d6cHZoVwCXgnCpk4KxnY++qJrBrJ9gYVxQV1VLU1A4SUw7QUU3SEcrP0JeYV7Sv7JmZzWIiUnLurSsmpJ3al2QemUAo5CDqpWFtpyKin5wiWpTZVxSREpGTFBNTVRUPUdER09UR1JVTFdVsJ6SqYxw0buqs56ThnVkemZSkHJWAJ+Dapd5XqeOe6WRgZqKfYB5clxdV0VNS1dVVjlJRzVDSD1IS0JRT49tUr6Tb+rKq5yBZXNgSoNxXdu5nAB/aE1zWT2CXkCghnGdi352Z1k/RkE/Rj9PTUhUUUdTT0ZdVEpqW02tkHriw6TAo4uyn5G5noTfu5/uyaoAd2RPn4Bixpx3dFs/va+lnoNpREE3Ozw1T0g+YlpSbmVfiXx4qZaSuKGVxKqX1LWar492tqSY6cmx58OoAJRnQaZ7VZVzU4JfP9m5nvbPq41uVEdKRGdgV5aGgKiYlrajnbmkmMGkjsOiiNOxmcSgh6WLeLmXgJ96XgCUakawhWCUcVBrWkSLeWvBo4nJoHpuXUaegGW1j2++lXC7kWy8kWy5kHC3j3OdeFyHY0hyUTZVQSw/NSR2JUuWZaJ9tQAAAABJRU5ErkJggg=="},"images":{"fallback":{"src":"/static/b1b3c134b9e43e809e89780141cd7c41/dcd92/SecureAPI.webp","srcSet":"/static/b1b3c134b9e43e809e89780141cd7c41/745fa/SecureAPI.webp 175w,\n/static/b1b3c134b9e43e809e89780141cd7c41/b0f73/SecureAPI.webp 350w,\n/static/b1b3c134b9e43e809e89780141cd7c41/dcd92/SecureAPI.webp 700w,\n/static/b1b3c134b9e43e809e89780141cd7c41/c98e3/SecureAPI.webp 1400w","sizes":"(min-width: 700px) 700px, 100vw"},"sources":[{"srcSet":"/static/b1b3c134b9e43e809e89780141cd7c41/1934d/SecureAPI.avif 175w,\n/static/b1b3c134b9e43e809e89780141cd7c41/8f8aa/SecureAPI.avif 350w,\n/static/b1b3c134b9e43e809e89780141cd7c41/a273d/SecureAPI.avif 700w,\n/static/b1b3c134b9e43e809e89780141cd7c41/49b21/SecureAPI.avif 1400w","type":"image/avif","sizes":"(min-width: 700px) 700px, 100vw"}]},"width":700,"height":400}}},"tech":["NPM","ReactJS","Package","Frontend"],"github":null,"external":"/blogs/create-and-publish-a-custom-react-hook-as-an-npm-package","cta":"/blogs/create-and-publish-a-custom-react-hook-as-an-npm-package"},"html":"As React developers, we often come across scenarios where we want to reuse specific logic across multiple components. React hooks make this easy, but what if you want to share your hooks with the wider community? Publishing your custom hooks as NPM packages allows you to contribute to the open-source community while making your work reusable across different projects.
\nIn this blog, I’ll guide you through the process of creating a custom hook and publishing it as an NPM package step-by-step. We will cover:
\nBy the end of this tutorial, you will have your own React hook published on NPM, ready for the world to use.
\nIt looked something like this:
\nFirst, let's create a simple React hook that tracks the browser window size. This can be useful for responsive layouts.
\nuseWindowSizeimport { useState, useEffect } from 'react';\n\nexport function useWindowSize() {\n const [windowSize, setWindowSize] = useState({\n width: window.innerWidth,\n height: window.innerHeight\n });\n\n useEffect(() => {\n function handleResize() {\n setWindowSize({\n width: window.innerWidth,\n height: window.innerHeight\n });\n }\n\n window.addEventListener('resize', handleResize);\n handleResize();\n\n return () => window.removeEventListener('resize', handleResize);\n }, []);\n\n return windowSize;\n}This hook listens to the resize event and updates the width and height whenever the window size changes.
To publish our hook as an NPM package, we need to set up a project and configure it to build our code. We will use Babel for transpiling our code into a format that can be consumed by projects using different versions of React.
\nRun the following command to create a new NPM project:
\nnpm initFill in the details like name, version, and description. Here’s an example of a package.json:
{\n \"name\": \"usepcscustomhook\",\n \"version\": \"1.0.0\",\n \"description\": \"A custom hook for window size tracking\",\n \"main\": \"dist/useCustomHook.js\",\n \"scripts\": {\n \"build\": \"babel src --out-dir dist\",\n \"test\": \"echo \\\"Error: no test specified\\\" && exit 1\"\n },\n \"keywords\": [\"npm\", \"custom\", \"hook\"],\n \"author\": \"Praful Chauhan\",\n \"license\": \"MIT\",\n \"devDependencies\": {\n \"@babel/cli\": \"^7.25.7\",\n \"@babel/core\": \"^7.25.8\",\n \"@babel/preset-env\": \"^7.25.8\",\n \"@babel/preset-react\": \"^7.25.7\"\n },\n \"peerDependencies\": {\n \"react\": \"^18.0.0\",\n \"react-dom\": \"^18.0.0\"\n }\n}Now, install the necessary development dependencies:
\nnpm install --save-dev @babel/cli @babel/core @babel/preset-env @babel/preset-reactAdd a .babelrc configuration file to the root of your project to tell Babel how to transpile your code:
{\n \"presets\": [\"@babel/preset-env\", \"@babel/preset-react\"]\n}In the root of your project, create the following structure:
\n/src\n - useWindowSize.js\n/dist (This will be generated after the build)\n/index.jsThe index.js should look like this:
export { useWindowSize } from './src/useWindowSize';To compile your hook using Babel, run:
\nnpm run buildThis command will transpile the source files in src/ to the dist/ folder, making them ready for publication.
Now that your hook is ready, you can publish it to NPM.
\nMake sure you have an NPM account. If you don’t have one, create an account on NPM.
\nThen, log in via the command line:
\nnpm loginYou will be prompted for your username, password, and email.
\nMake sure your package.json version is set appropriately (e.g., 1.0.0). Every time you publish a new version, you need to increment the version number.
Run the following command to publish your package:
\nnpm publish --access publicYour hook will now be available on NPM, and you can install it in any project by running:
\nnpm install usepcscustomhookIt’s important to provide clear instructions for using your hook. Here’s an example README.md for our useWindowSize hook:
# usepcscustomhook\n\nA custom React hook for tracking window size.\n\n## Installation\n\n```bash\nnpm install usepcscustomhookimport React from 'react';\nimport { useWindowSize } from 'usepcscustomhook';\n\nconst MyComponent = () => {\n const { width, height } = useWindowSize();\n\n return (\n <div>\n <h1>Window Size</h1>\n <p>Width: {width}px</p>\n <p>Height: {height}px</p>\n </div>\n );\n};\n\nexport default MyComponent;MITIn this blog, we walked through the process of creating and publishing a custom React hook as an NPM package. This is a great way to make your reusable code available to the broader developer community.
\nNow, go ahead and create your own custom hooks, and don't hesitate to share them with the world via NPM!
"}},{"node":{"frontmatter":{"title":"Deep Dive into JavaScript ES6 Features","date":"Oct 02, 2024","readtime":"11 min read","cover":{"childImageSharp":{"gatsbyImageData":{"layout":"constrained","placeholder":{"fallback":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAALCAYAAAB/Ca1DAAAACXBIWXMAAAsTAAALEwEAmpwYAAACuklEQVQozz2TzYsbdRjHn5lJJruTl5lMZjKTyds0CdlJNtl0ts1uu1a725doKh528aUIKl56E/HYgxfBP8CDF6Fv1BdE9FRoq9IWqVDwUESlPVhaoZdS/wJL/cgMWw8/Hn6Xz/N5eL6PjEYjoiii1+vRbrep1+t4nkelUqFUKmEYBrquo6gqmYyGYeiUiga2XaJatQmCKmG7QcLZ2txChsPh/8AwDGk0Gvi+j+M4WJZFoVBgYWEhhWlaDjVbYTEfUDRblJ0Orr+EV4vo9yPW19eRbrebmjWbTYIgwHXdFPTMLpvNoqqCiMLeZZNLn9lcPuNw5azL1XMeP1zwuXLWY/PQgKWlEbK2ts50usaz0Sd7Y8bjMa1WkzBsp7Ve9xHR2X7Jg4cC93ffvd36l3ByZ0I7jJAT82O8/to28/mM2WzG7PgmR4++SLw6ZbwSc3DjeTY2nkPLlHjluA93Mvzzq/D0d4E/hX//EJ78pnFyJybsRMixQzbbsyIntkxGkc2B2ODwms78hSzTscbBibDSl13DAO5oqdmjm8KnHwofvy88+FHl7TdWCTsDJGy79Pa4tJoVXKdM1TVp1Qu06ov4ro5T1nDtLCIGO/MG3NV4/LNw7bzCB+8onD4l/PKNxrtv7mNPdxmxrArFokWhaFIoFFlczJPJLqCoOiIqIloaG1HyvPpyA/4Wbn8rfPSecOsr4ZPTwu3vhFNv7aPTHSG1Wg3TNMnn8+lWk4joehZN09Ko5HI6hbyBniuyMfX5/lyFn750ufFFleufe1y76HPza5/ZkQmDwRgZDAbYtk0ul0tNMpkMqqqmwOSfNEiyaJkmluVQKoc4Xh8/GFJvjQm7Me3OKsPhiMlkgkz3709DnAAURUlhCTRpkFgneSyXy+nlVKsuQa1Ks1FLr6PXDVnqdxktR6ysjInjmP8ASjBXYnM8mZ8AAAAASUVORK5CYII="},"images":{"fallback":{"src":"/static/57a30047df84a430a466f3b928e6fa94/40bd6/SecureAPI.png","srcSet":"/static/57a30047df84a430a466f3b928e6fa94/9051f/SecureAPI.png 175w,\n/static/57a30047df84a430a466f3b928e6fa94/15da0/SecureAPI.png 350w,\n/static/57a30047df84a430a466f3b928e6fa94/40bd6/SecureAPI.png 700w,\n/static/57a30047df84a430a466f3b928e6fa94/3ad04/SecureAPI.png 1400w","sizes":"(min-width: 700px) 700px, 100vw"},"sources":[{"srcSet":"/static/57a30047df84a430a466f3b928e6fa94/2f9bd/SecureAPI.avif 175w,\n/static/57a30047df84a430a466f3b928e6fa94/8024a/SecureAPI.avif 350w,\n/static/57a30047df84a430a466f3b928e6fa94/c141d/SecureAPI.avif 700w,\n/static/57a30047df84a430a466f3b928e6fa94/ea4a7/SecureAPI.avif 1400w","type":"image/avif","sizes":"(min-width: 700px) 700px, 100vw"},{"srcSet":"/static/57a30047df84a430a466f3b928e6fa94/9b040/SecureAPI.webp 175w,\n/static/57a30047df84a430a466f3b928e6fa94/3d0d8/SecureAPI.webp 350w,\n/static/57a30047df84a430a466f3b928e6fa94/e7e5b/SecureAPI.webp 700w,\n/static/57a30047df84a430a466f3b928e6fa94/accb3/SecureAPI.webp 1400w","type":"image/webp","sizes":"(min-width: 700px) 700px, 100vw"}]},"width":700,"height":371}}},"tech":["JavaScript","ES6","Web Development","ReactJS"],"github":null,"external":"/blogs/deep-dive-into-java-script-es-6-features","cta":"/blogs/deep-dive-into-java-script-es-6-features"},"html":"JavaScript ES6 (ECMAScript 2015) brought groundbreaking features that transformed the way we write and maintain code. These features not only made code more concise but also enhanced readability, scalability, and maintainability. Let's take a detailed dive into some of the most impactful ES6 features and understand their practical applications.
\nArrow functions provide a more compact syntax for writing functions. They are particularly useful for short, anonymous functions, especially as callbacks. The key distinction is that arrow functions do not bind their own this context but inherit it from the surrounding scope, unlike traditional functions.
=> to separate the parameters from the function body.this Binding: Arrow functions do not have their own this. They capture this from the lexical context.// Traditional function\nfunction multiply(a, b) {\n return a * b;\n}\n\n// Arrow function equivalent\nconst multiply = (a, b) => a * b;\n\nconsole.log(multiply(5, 3)); // Output: 15\n\n// Arrow functions in callbacks\nconst numbers = [1, 2, 3];\nconst squares = numbers.map(num => num * num);\nconsole.log(squares); // Output: [1, 4, 9]this is critical (such as event handlers or promises).Template literals introduce a new way to work with strings, making it easier to construct complex strings with embedded expressions. They utilize backticks (`) instead of single/double quotes, enabling multi-line strings and expression interpolation.
${}.const name = \"John\";\nconst age = 28;\nconst greeting = `Hello, my name is ${name} and I am ${age} years old.`;\n\nconsole.log(greeting);\n// Output: Hello, my name is John and I am 28 years old.Destructuring assignment allows you to unpack values from arrays or properties from objects into distinct variables. This feature simplifies the extraction of values and properties, especially when dealing with nested objects or large datasets.
\n// Array Destructuring\nconst coordinates = [10, 20];\nconst [x, y] = coordinates;\nconsole.log(x, y); // Output: 10 20\n\n// Object Destructuring\nconst person = { name: 'Alice', age: 32 };\nconst { name, age } = person;\nconsole.log(name, age); // Output: Alice 32\n\n// Destructuring with renaming\nconst { name: personName, age: personAge } = person;\nconsole.log(personName, personAge); // Output: Alice 32...)The spread operator (...) allows iterable elements (like arrays or objects) to be expanded into individual elements. This is useful when creating copies of arrays/objects, combining arrays/objects, or passing arguments to functions.
// Merging arrays\nconst arr1 = [1, 2, 3];\nconst arr2 = [4, 5, 6];\nconst combined = [...arr1, ...arr2];\nconsole.log(combined); // Output: [1, 2, 3, 4, 5, 6]\n\n// Copying objects\nconst obj1 = { a: 1, b: 2 };\nconst obj2 = { ...obj1, c: 3 };\nconsole.log(obj2); // Output: { a: 1, b: 2, c: 3 }concat() or Object.assign().The rest parameter syntax (...args) allows functions to accept an indefinite number of arguments as an array. It’s a more flexible way to work with multiple arguments without explicitly listing each one.
function sum(...numbers) {\n return numbers.reduce((total, number) => total + number, 0);\n}\n\nconsole.log(sum(1, 2, 3)); // Output: 6\nconsole.log(sum(10, 20, 30, 40)); // Output: 100async/await is a new way to work with asynchronous code in JavaScript, making it more readable and easier to follow than traditional promise chaining. By using async functions, you can pause code execution using await until a promise is resolved or rejected.
async to enable await inside it.await keyword pauses execution until the promise resolves.async function fetchData() {\n try {\n const response = await fetch('https://api.example.com/data');\n const data = await response.json();\n console.log(data);\n } catch (error) {\n console.error('Error fetching data:', error);\n }\n}\n\nfetchData();try/catch blocks.ES6 introduces two new data structures: Map and Set. A Map is an ordered collection of key-value pairs, and a Set is a collection of unique values.
// Map Example\nconst map = new Map();\nmap.set('key1', 'value1');\nmap.set('key2', 'value2');\nconsole.log(map.get('key1')); // Output: value1\n\n// Set Example\nconst set = new Set([1, 2, 2, 3]);\nconsole.log(set); // Output: Set { 1, 2, 3 }Map provides better handling for non-string keys, and Set ensures data uniqueness, simplifying operations like finding duplicates.Default parameters allow you to set default values for function parameters if no argument is passed, reducing the need for checks like if or ||.
undefined is passed, the default value is used.function greet(name = 'Guest') {\n return `Hello, ${name}!`;\n}\n\nconsole.log(greet()); // Output: Hello, Guest!\nconsole.log(greet('Alice')); // Output: Hello, Alice!ES6 modules provide a structured way to organize and share code across files, promoting better separation of concerns and reusability. By using import and export, you can share functions, objects, and variables across files.
// utils.js\nexport function add(a, b) {\n return a + b;\n}\n\n// main.js\nimport { add } from './utils.js';\nconsole.log(add(2, 3)); // Output: 5The map() method creates a new array by applying a function to each element of an existing array. It is commonly used to transform arrays.
const numbers = [1, 2, 3, 4];\nconst squares = numbers.map(num => num * num);\nconsole.log(squares); // Output: [1, 4, 9, 16]map() method provides an elegantway to transform data, making operations on arrays both concise and expressive.
\nThe filter() method creates a new array with elements that pass a test defined by a function. It’s useful for filtering out unwanted data from arrays.
const numbers = [1, 2, 3, 4, 5];\nconst evenNumbers = numbers.filter(num => num % 2 === 0);\nconsole.log(evenNumbers); // Output: [2, 4]filter() method provides a simple way to extract only the relevant elements from arrays, improving code readability.The reduce() method reduces an array to a single value by applying a function to each element and accumulating the result. It’s useful for summing up values or combining them in some way.
const numbers = [1, 2, 3, 4];\nconst sum = numbers.reduce((total, num) => total + num, 0);\nconsole.log(sum); // Output: 10reduce() method provides an elegant way to condense arrays into a single value, making it ideal for aggregations and transformations.ES6 revolutionized JavaScript, making it more modern, functional, and developer-friendly. Features like arrow functions, destructuring, template literals, and async/await have reshaped how developers write JavaScript, promoting cleaner, more maintainable code. By mastering these features, you can harness the full power of JavaScript to create efficient, readable, and scalable applications.
"}},{"node":{"frontmatter":{"title":"ASP.NET Core 8 microservices in a single solution using Docker","date":"Oct 02, 2024","readtime":"8 min read","cover":{"childImageSharp":{"gatsbyImageData":{"layout":"constrained","placeholder":{"fallback":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAALCAYAAAB/Ca1DAAAACXBIWXMAAAsTAAALEwEAmpwYAAAC4klEQVQoz0XRS1caBwCGYX5Ol111213PSdUaEaMkRhCDUuQ2wAADw3C/FVQYQfAGAlGHQgQ1JrE2Pcc26SKLtifJwtRFfsrbYzb9B+/3PbqxQI6ZSJEHQpw5X5wHQhRHpowzV2FR+YlpXwKznGclVcYcKzHlCmMUEyzJecZXRCZtIhNWP2MWge8WnOgmnDIGXxKjL8HjYBpHZoOnz68oH41wFus0nl2Q6z7DrR7gWNtlNVvh75tbXvz+JzMeGb0jxLQ9yOSyn7FFN7ofrH6M7gjmUAqTlEEoblFoD/Budkh1h+wML4mqLWqjS9LdIfZiHfV4yPVf71nr/MyYTcTgCnPfJjK+JKDTO8I8DiSwyHmexIo4iw181TZSc0Csf4lY3iPaOeWPD7cktzViBwPEaotQtclKcp0Zr8KcV8HgkL5U6gwuGVMojTVewlGoIW0fEdwfkNYuuP74Lw3tjMDpWx51XvP1lJO6dkah94LArsZyusySUmQ+kGTWE+W+LYBuxq2wKOexZVTEWpfyyRWl0WvU0RWpapPB9Tt+ffceS6nLVwY/3z+RCO30SByf49ts4y83MUfyGH1x9PYQujtdS7SAPacilPcJ7mgURr+R3OuzmlaZKPX4xhTl2wUJT6nJcmQN/9YRsaNz/LUutqyKWS7w0J9gelVCNyvEWYzk+bHQQKg08TcOUV+9JdbQ8KRV2pdvEIp7ZCq7lPuvMIfXOTi7Irzfx1vt4C7WMYVz/xcaXFEWgmmsyQ2cpW2izR6p9gnaL9dcf/zEzefP9E5f4lJKVLQLak9PCOaqhNUWyvYh9kyFhVCWWUFh0hZEN2WXeOiLf/nxDiXTPSHYHuHZOuaet8hW/yX/3NzS7D8nkK2iF9LMr3eRqy1WspuYInkeiSnulk7YJHTjy0HuYOZDWayJDXzVLu7dAU61w5y8gaOuEW4NmZPWMGUbKIfnONQ2llQFS2wdo5jG4FLQOxXuWUP8B7cuMauUG1TUAAAAAElFTkSuQmCC"},"images":{"fallback":{"src":"/static/8153a81bf484311c1bfeb52fdf433f40/4e258/SecureAPI.png","srcSet":"/static/8153a81bf484311c1bfeb52fdf433f40/68202/SecureAPI.png 175w,\n/static/8153a81bf484311c1bfeb52fdf433f40/fe25d/SecureAPI.png 350w,\n/static/8153a81bf484311c1bfeb52fdf433f40/4e258/SecureAPI.png 700w,\n/static/8153a81bf484311c1bfeb52fdf433f40/a22cc/SecureAPI.png 1400w","sizes":"(min-width: 700px) 700px, 100vw"},"sources":[{"srcSet":"/static/8153a81bf484311c1bfeb52fdf433f40/1934d/SecureAPI.avif 175w,\n/static/8153a81bf484311c1bfeb52fdf433f40/8f8aa/SecureAPI.avif 350w,\n/static/8153a81bf484311c1bfeb52fdf433f40/a273d/SecureAPI.avif 700w,\n/static/8153a81bf484311c1bfeb52fdf433f40/49b21/SecureAPI.avif 1400w","type":"image/avif","sizes":"(min-width: 700px) 700px, 100vw"},{"srcSet":"/static/8153a81bf484311c1bfeb52fdf433f40/745fa/SecureAPI.webp 175w,\n/static/8153a81bf484311c1bfeb52fdf433f40/b0f73/SecureAPI.webp 350w,\n/static/8153a81bf484311c1bfeb52fdf433f40/dcd92/SecureAPI.webp 700w,\n/static/8153a81bf484311c1bfeb52fdf433f40/c98e3/SecureAPI.webp 1400w","type":"image/webp","sizes":"(min-width: 700px) 700px, 100vw"}]},"width":700,"height":400}}},"tech":["ASP.NET Core",".Net 8 Core","Microservice","Docker"],"github":null,"external":"/blogs/asp-net-core-8-microservices-in-a-single-solution-using-docker","cta":"/blogs/asp-net-core-8-microservices-in-a-single-solution-using-docker"},"html":"To work with multiple ASP.NET Core 8 microservices in a single solution using Docker, you can create individual Dockerfiles for each service and orchestrate them using Docker Compose. Docker Compose allows you to define and manage multiple containers (microservices) in a single configuration file (docker-compose.yml), making it easier to run, scale, and manage multi-container applications.
Here’s a detailed step-by-step guide to containerizing multiple ASP.NET Core 8 microservices in a single solution.
\nLet’s assume you have two microservices in your solution:
\nEach microservice will be built and run as its own container, but Docker Compose will orchestrate them.
\ndotnet new sln -n MicroservicesSolution\ncd MicroservicesSolutiondotnet new webapi -n HotelServicedotnet new webapi -n FlightServicedotnet sln add HotelService/HotelService.csproj\ndotnet sln add FlightService/FlightService.csprojFor each microservice, you’ll add a Dockerfile and .dockerignore file.
Navigate to the HotelService folder and create a Dockerfile:
# Stage 1: Build the HotelService application\nFROM mcr.microsoft.com/dotnet/sdk:8.0 AS build-env\nWORKDIR /app\n\n# Copy csproj and restore as distinct layers\nCOPY *.csproj ./\nRUN dotnet restore\n\n# Copy the rest of the application code\nCOPY . ./\nRUN dotnet publish -c Release -o out\n\n# Stage 2: Build the runtime image\nFROM mcr.microsoft.com/dotnet/aspnet:8.0\nWORKDIR /app\nCOPY --from=build-env /app/out .\n\nEXPOSE 80\nENTRYPOINT [\"dotnet\", \"HotelService.dll\"]Create a .dockerignore file in the HotelService folder:
bin/\nobj/Navigate to the FlightService folder and create a Dockerfile:
# Stage 1: Build the FlightService application\nFROM mcr.microsoft.com/dotnet/sdk:8.0 AS build-env\nWORKDIR /app\n\n# Copy csproj and restore as distinct layers\nCOPY *.csproj ./\nRUN dotnet restore\n\n# Copy the rest of the application code\nCOPY . ./\nRUN dotnet publish -c Release -o out\n\n# Stage 2: Build the runtime image\nFROM mcr.microsoft.com/dotnet/aspnet:8.0\nWORKDIR /app\nCOPY --from=build-env /app/out .\n\nEXPOSE 80\nENTRYPOINT [\"dotnet\", \"FlightService.dll\"]Create a .dockerignore file in the FlightService folder:
bin/\nobj/At the root of your solution (where the .sln file is located), create a docker-compose.yml file. This file will define and configure both microservices.
version: '3.8'\n\nservices:\n hotelservice:\n build:\n context: ./HotelService\n dockerfile: Dockerfile\n ports:\n - \"5001:80\"\n networks:\n - microservices-network\n depends_on:\n - flightservice\n\n flightservice:\n build:\n context: ./FlightService\n dockerfile: Dockerfile\n ports:\n - \"5002:80\"\n networks:\n - microservices-network\n\nnetworks:\n microservices-network:\n driver: bridgehotelservice, 5002 for flightservice).microservices-network) to allow the services to communicate with each other.hotelservice waits for flightservice to be ready.Navigate to the root directory of your solution (where the docker-compose.yml is located).
Build the Docker images for both services:
\ndocker-compose builddocker-compose upThe docker-compose up command will start both microservices in separate containers, map the ports, and handle communication between them.
Once the services are up, you can test them by visiting the following URLs:
\nBoth microservices should be running and accessible through their respective ports.
\nThe two services are on the same Docker network (microservices-network). Therefore, you can communicate between services internally using their service names (hotelservice, flightservice).
For example, if HotelService needs to make a request to FlightService, it would use http://flightservice:80 internally, and similarly, FlightService can reach HotelService via http://hotelservice:80.
docker-compose downThis will stop and remove the containers for both microservices.
\ndocker image pruneThis will remove unused Docker images and free up disk space.
\nIf you want to share or deploy the microservices using Docker Hub, follow these steps:
\ndocker logindocker tag hotelservice your_dockerhub_username/hotelservice:latest\ndocker tag flightservice your_dockerhub_username/flightservice:latestdocker push your_dockerhub_username/hotelservice:latest\ndocker push your_dockerhub_username/flightservice:latestYou can deploy the Docker images to cloud platforms like Azure App Service for Containers, AWS ECS, or Google Cloud Run. For example, to deploy to Azure:
\nBy following these steps, you can containerize multiple ASP.NET Core 8 microservices in a single solution and use Docker Compose to manage them. Docker Compose simplifies the orchestration of multiple microservices, allowing you to run them simultaneously, set up networking between them, and manage dependencies.
\nThis setup is highly scalable and can be extended to include databases, caching layers, message queues, etc., in the same docker-compose.yml file.
In the realm of software development, ensuring the reliability, correctness, and maintainability of code is paramount. Automated testing plays a pivotal role in achieving these objectives, and among the plethora of testing frameworks available, xUnit stands out as a powerful and versatile tool. In this in-depth guide, we’ll embark on a journey to...
\n"}},{"node":{"frontmatter":{"title":"Secure Web API by Key Authentication in ASP.NET Core","date":"Jun 29, 2024","readtime":"12 min read","cover":{"childImageSharp":{"gatsbyImageData":{"layout":"constrained","placeholder":{"fallback":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAANCAYAAACpUE5eAAAACXBIWXMAAAsTAAALEwEAmpwYAAACcklEQVQ4y12TW08TURSF+xv0RWrodKadll6HoS3Tlt5bFJpSAmkplUupKASIF0xU8BYIkcREYqKJkYQHeVNefDCGmBATf9lnzpQptQ8r57b3OuvstY9NlmWcTifWaEGsBSTJgT8QpFVvsjmZYS5t0G5tYMRTOJ0SiqJ0ciWJ64M3sVmJvST9EGftxRV2l+9w8GKf2nwb+8ANPB6PeS5ITWJFwdavzuVy4Xa7u0EiyW4fYGFplc9fTjn5ekY6WzCVq6rajbNg61VnbQpCAYvcNzTERHmao08n7Lw+xOMdwu12mYQixoLgsPWTibkVINbpdJZKZZZaY4mDdx+Zml1AkqSuOofD0RVgElp18nq9jI2NMaJH0HWdWMwgGo3Sat1lbXObZ7v7nJx+ozrTwIgliEZjhMNhisUigUDgSmHnyTKaptFsNrk1XqZWb7C6eo9SqcTR+w+c/77g4s9ffvw8pza3yHyjSbU6RaVS4fj4GMMwTNXdGgqIJ8RiMTQtQjw6SilXJKRprK9v8PjJDiv3H/B0d49EKosvGDLVh0IhstksPp+va6itt11EHRyyTCGi8/3Vc1KGQXhYZ6JcpV5vksuXGA2HKWcyXdNEvlX7jimXLotN0zVVJexVeTmV59fhHm8fbpEcGebR9CRGKMBaMcXZ9hrt8TyyaZ7yXx/b5J6fYTktguJ+D8vZBG+WGkzHdZoJnRljmK2SwWJKJ6C6cfZ1x5XCnsYWF0hOJ16Xi1G/l4hHIR30UtB85DU/OT1oPleSr4g6Ii5dvjZoNwnkS+JuPRUX6WSC8VyW2/kchUyKZDJBJBpDVT3mxeKr9f59Mf4DN3ukMStSBU4AAAAASUVORK5CYII="},"images":{"fallback":{"src":"/static/ff193eeaa61c663d9660b1b3053537b5/3e1ab/SecureAPI.png","srcSet":"/static/ff193eeaa61c663d9660b1b3053537b5/57a76/SecureAPI.png 175w,\n/static/ff193eeaa61c663d9660b1b3053537b5/f00e6/SecureAPI.png 350w,\n/static/ff193eeaa61c663d9660b1b3053537b5/3e1ab/SecureAPI.png 700w,\n/static/ff193eeaa61c663d9660b1b3053537b5/9f3f1/SecureAPI.png 1400w","sizes":"(min-width: 700px) 700px, 100vw"},"sources":[{"srcSet":"/static/ff193eeaa61c663d9660b1b3053537b5/50167/SecureAPI.avif 175w,\n/static/ff193eeaa61c663d9660b1b3053537b5/5a8a9/SecureAPI.avif 350w,\n/static/ff193eeaa61c663d9660b1b3053537b5/bc4f6/SecureAPI.avif 700w,\n/static/ff193eeaa61c663d9660b1b3053537b5/5be71/SecureAPI.avif 1400w","type":"image/avif","sizes":"(min-width: 700px) 700px, 100vw"},{"srcSet":"/static/ff193eeaa61c663d9660b1b3053537b5/81b0f/SecureAPI.webp 175w,\n/static/ff193eeaa61c663d9660b1b3053537b5/bfc62/SecureAPI.webp 350w,\n/static/ff193eeaa61c663d9660b1b3053537b5/74bac/SecureAPI.webp 700w,\n/static/ff193eeaa61c663d9660b1b3053537b5/b7a7f/SecureAPI.webp 1400w","type":"image/webp","sizes":"(min-width: 700px) 700px, 100vw"}]},"width":700,"height":467}}},"tech":["Api Development","Asp.net","Web Api Development","Security Services","Authentication"],"github":null,"external":"https://www.prafulchauhan.com/blogs/secure-web-api-by-key-authentication-in-asp-net-core","cta":"https://www.prafulchauhan.com/blogs/secure-web-api-by-key-authentication-in-asp-net-core"},"html":"When you’re dealing with Web APIs or REST APIs, it’s important to keep the endpoints secure. One common way to do this is by using something called API Keys. API Keys are special codes that serve as a kind of password for accessing these endpoints. They’re usually stored in files like appsettings.json or other storage places. In this article, we’ll...
"}},{"node":{"frontmatter":{"title":"Razorpay Payment Gateway Integration using ASP.NET Core Clean Architecture and React JS","date":"Jun 29, 2023","readtime":"12 min read","cover":{"childImageSharp":{"gatsbyImageData":{"layout":"constrained","placeholder":{"fallback":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAKCAYAAAC0VX7mAAAACXBIWXMAAAsTAAALEwEAmpwYAAACnUlEQVQoz2WLW0uTAQCGv58Q9CPqJuoiqAjNA3iKNE0syzSdRZZ0pxEREtG0xLIIzTQyh4ZOy6ZN89CcrjbNWWtirs2Vm9vcPpsz3drY4QmMyOiF5+KF5xES75nYStJ9E4n1JhLvzhNX/4WD982bP6F+nqQHCyQ3fCWh/q+fcPczyY129lx6wvY9BxBSmxbYSspDC2nNVo42m7lZp+HMg1nSmyxkPP5Gwq0pdhc3k9YwT+ojKylNlk0/vcVGvFTFLokUIUtm4w+ZMjv5L5bJbF1kR62F4xVyauoUxHWKHJS+ZX92FfmlNcTVTpPWtsTh9kWy2+1ktdk42rHMse41hDy5k+NyJ7mdTk4/d9CnMCC5oWFbiZqdN8fZ3mWjeEjkUPUEyUllVLeMUPPGQaHCQ26Pi5M9y5t9XpeDvE47QmG/SJFSJF/hoaTjK42t05x8aibn9nv21hioUrlotvjJaJil+PoAshkvlydclA3ZqB53Ujbo4tSrFc4oRQpfiQilI14ko17ODn8npdfNEU2AkgEPJe0LXJBbqVS7ufzxBwW9LvZd1ZFRO0lln5lBmx/ZmAmj1UX1tJeCYS/nVF6Eixof5RM+zo/5ODG0wh2dm5xuJ0WDbiRKF1c0IkP2IOXjq+yWfiDr4Rx1c34KP/3k2qQLggEWfQFUdj8mbxDhqhUq5+CcPkjrtyBGsxuJYok7c35ufFyn0bjKOzHEgC1Av3GFD0s/UFrXUYsR/Pw/IUvaSMXoZ2SOGK+dP5kQQ+jdARwbYdZCEYLhKJFI9J+o22TnWe9LDFOTaHU6tFodY+px3B4PQnzKIbr6lQSB1fUgvo0wXn8YcT2MuPGb7/4I0ViMSDRGKBpjcknE8MmIwWBgZmYGvV6PVqvF5/PxCxikZamTHT7KAAAAAElFTkSuQmCC"},"images":{"fallback":{"src":"/static/8dca34942874ea546bcd08259d84178e/18b2e/tourwiz1.png","srcSet":"/static/8dca34942874ea546bcd08259d84178e/a4d46/tourwiz1.png 175w,\n/static/8dca34942874ea546bcd08259d84178e/d8f52/tourwiz1.png 350w,\n/static/8dca34942874ea546bcd08259d84178e/18b2e/tourwiz1.png 700w","sizes":"(min-width: 700px) 700px, 100vw"},"sources":[{"srcSet":"/static/8dca34942874ea546bcd08259d84178e/19d98/tourwiz1.avif 175w,\n/static/8dca34942874ea546bcd08259d84178e/46c45/tourwiz1.avif 350w,\n/static/8dca34942874ea546bcd08259d84178e/12925/tourwiz1.avif 700w","type":"image/avif","sizes":"(min-width: 700px) 700px, 100vw"},{"srcSet":"/static/8dca34942874ea546bcd08259d84178e/eac4f/tourwiz1.webp 175w,\n/static/8dca34942874ea546bcd08259d84178e/a4795/tourwiz1.webp 350w,\n/static/8dca34942874ea546bcd08259d84178e/377b6/tourwiz1.webp 700w","type":"image/webp","sizes":"(min-width: 700px) 700px, 100vw"}]},"width":700,"height":350}}},"tech":["Razorpay","ASP.NET Core","Clean Architecture","React.js","React Hooks"],"github":"","external":"https://www.prafulchauhan.com/blogs/razorpay-payment-gateway-integration-using-asp-net-core-clean-architecture-and-react-js","cta":null},"html":"In the digital age, online payment processing has become a vital component for businesses of all sizes. Integrating a reliable and secure payment gateway is crucial to provide a seamless experience for customers. One such popular payment gateway is Razorpay, known for its simplicity, robustness, and extensive features. In this blog, we will explore...
\n"}},{"node":{"frontmatter":{"title":"Microservices Communication with Ocelot in ASP.NET Core Web API","date":"Jun 29, 2022","readtime":"12 min read","cover":{"childImageSharp":{"gatsbyImageData":{"layout":"constrained","placeholder":{"fallback":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAALCAYAAAB/Ca1DAAAACXBIWXMAAAsTAAALEwEAmpwYAAAC4ElEQVQozzWS3U9TBxjG33NOT08/bOnphz0tpayUArbKENCsVpRsrYhzm3wEO0XUjYKdc8qAtq4alw0GQtJliQHdmHNGL7YRr7frbXe72/6f31KIN2/yvsn7y/PkecQdszC8HlQRFNFRlQO4jAR+X47I4RLRmW0yj/6iZ+V3WscaxHrL+H2ncBlJNNVEREcRG6qoaKIgumFgs+0fNcXEZe8iaJ4mkf6YSP4+sdor+n75l56f/iF+Zxdr+B7tXVcIB97B48igKwdRxYXa/G8Cm8pU0VDFjVPvJOQdJmAVufLpY+rfbBEbXSRbfcHAwo+88d59Lt94wNKD54Tj00QDBTx6L7oSRhEHmqhIczQXmxzE5xwgbk0Sz9wmN1rl6bNdavUGS7UGi9VNbn++xs7OSyamvyae+YzO9iLBA6dxqyk08e4Jk33vXlxqNyHPMLHWIt0Dy4SCb1OvPeTPv/9js7HDk51f2f3tD7Yf/UxbtED6aIVkYoaoeQ6f3o9dLFTRm0ANXQL47MdpazlPMj7L4GCdeKjAhxPzTJW/ZGX9Mc+fveLc9buU5yt0hPMM9lU4lJgnGbqIZZzEJW1oYrwGegkqvWQCUwyll/ng1AYnOmc5ni6wur5F4+EPfLfxPRvfPiWfGyfbMcP7Q2sU+u5y1LpKTM/hlig2se9btokTU9pJe0YZ6bhJKbvK1OEq/YECV8dLrK9usvLVGrMXb/BW5F3G0wvMndxkPLNAnzlJWD2CIS1oYmuGouxF7pAW2vQ3OWGOcbnzFuWee8ylKlyKfsTWzW1e1l9wPVGmlFyk1P0F11IL5K0iSecQLUormthRRF4D1b2DRwmTsPWS9eQ575/kmjXHregdlqxlauFlKrEqs9FPmAhNk/OMcMg4RkBrxy4udMOJI2Du97BZnSZUFwduxYdfIhzx9zOSOsuF1AWm00Vm0peY7BrjTOIMxyJZQkoMrxLAEPdeXXSXE0fQ5H+8dWS6Gkx1EwAAAABJRU5ErkJggg=="},"images":{"fallback":{"src":"/static/619162723a389cef3493919b1e29d447/bc3b9/wms.png","srcSet":"/static/619162723a389cef3493919b1e29d447/9a130/wms.png 175w,\n/static/619162723a389cef3493919b1e29d447/a3fa1/wms.png 350w,\n/static/619162723a389cef3493919b1e29d447/bc3b9/wms.png 700w","sizes":"(min-width: 700px) 700px, 100vw"},"sources":[{"srcSet":"/static/619162723a389cef3493919b1e29d447/dae43/wms.avif 175w,\n/static/619162723a389cef3493919b1e29d447/d7667/wms.avif 350w,\n/static/619162723a389cef3493919b1e29d447/7ec1a/wms.avif 700w","type":"image/avif","sizes":"(min-width: 700px) 700px, 100vw"},{"srcSet":"/static/619162723a389cef3493919b1e29d447/5d873/wms.webp 175w,\n/static/619162723a389cef3493919b1e29d447/26a00/wms.webp 350w,\n/static/619162723a389cef3493919b1e29d447/f23f0/wms.webp 700w","type":"image/webp","sizes":"(min-width: 700px) 700px, 100vw"}]},"width":700,"height":394}}},"tech":["Microservices","Ocelots","Aspnet Core Web Api","Api Gateway","Routing"],"github":null,"external":"https://www.prafulchauhan.com/blogs/microservices-communication-with-ocelot-in-asp-net-core-web-api","cta":"https://www.prafulchauhan.com/blogs/microservices-communication-with-ocelot-in-asp-net-core-web-api"},"html":"In a microservices architecture, managing communication between services can become complex. Each service may have its own endpoints and protocols, leading to challenges in routing and maintaining consistency. This is where Ocelot comes in — a middleware framework for ASP.NET Core that simplifies the process of building and maintaining APIs...
"}}]}}}