Gyan Prakash Singh

Master Spring Boot: A Complete Guide to Essential Annotations 1. @SpringBootApplication 2. @EnableAutoConfiguration 3. @SpringBootConfiguration 4. @ComponentScan 5. @RestController, @Controller 6. @RequestMapping, @GetMapping, @PostMapping, @PutMapping, @DeleteMapping, @PatchMapping 7. @ResponseBody 8. @PathVariable, @RequestParam 9. @CrossOrigin 10. @Component, @Service, @Repository 11. @Autowired 12. @Qualifier 13. @Primary 14. @Bean 15. @Value 16. @ConfigurationProperties 17. @PropertySource 18. @Profile 19. @Conditional 20. @Scheduled 21. @SpringBootTest, @DataJpaTest, @WebMvcTest, @JsonTest, @WebFluxTest 👍🏿 Subscribe to our newsletter - https://bit.ly/3x4j5dT #systemdesign #coding #interviewtips

847

17 Comments

Unreliable object states? Inconsistent object initialization? Data integrity issues? 🚀 Propel your code quality with C# Required Properties! 🚀 With required properties, your classes require initialization at compile-time, ensuring valid object states and reducing runtime errors. Say goodbye to half-baked objects and hello to robust, maintainable code! 🗨️ Do you frequently use required properties? Tell us more about it in the comments! #ASPNETCore #SoftwareArchitecture #dotnet #csharp #DesignAndArchitecture #CodeDesign

69

13 Comments

Learn how to implement real-time streaming in .NET Core applications using Kafka in Ajay Kumar's latest article. Read the article now: https://lnkd.in/gdTrepPU #DOTNET #DOTNETCore #ApacheKafka

43

Intro to Integration Tests | Complete Guide on writing integration tests in csharp dotnet | xunit. #csharp #dotnet #codewithparveenyadav https://lnkd.in/gP3srE6q

5

Single endpoint for fetching the data from various Table Being a C# API Developer I planned to Generalize the getting (fetching) data from various table in an endpoint. This will enhance the development on fetching data on masters, list of values and any complicated data from combination of tables. A project will have minimum of 5+ master tables and 10+ transaction tables. On development to fetch data from these tables we need to design 15+ endpoints. If a single endpoint replace these endpoints which acts as these endpoints, then we can save a lot of time in designing, testing and bug fixing on all these endpoints. We need is to test and debug only the generic "GetData" endpoint.

3

ASP.NET Core Dependency Injection advanced interview question: Does IServiceProvider have a Singleton or Scoped lifetime? Answer: Both! We have 2 different IServiceProvider in ASP.NET Core, one is the Singleton which we injected directly into our services and lives for the entire application lifetime and is in the root scope of the DI container. Another one has a Scoped lifetime, usually per request, you may see there is a property in the HttpContext named RequestServices that provides access to the request's service container. Very interesting, no? I borrowed this image from this incredible article: https://lnkd.in/dqgJmHnA A big thanks to Andrew Lock for his invaluable content. #dependencyinjection #aspnetcore #iserviceprovider

380

27 Comments

From DotNet C# Technical Interviews: Explain the Difference Between Parallel.ForEach and Parallel.ForEachAsync What’s the Difference? - Parallel.ForEach: 1) Designed for CPU-bound tasks. 2) Executes iterations in parallel using multiple threads. 3) Blocks the calling thread until all iterations complete. 4) Great for tasks that are synchronous and computationally intensive. - Parallel.ForEachAsync: 1) Built for asynchronous workflows. 2) Leverages async/await, making it non-blocking. 3) Ideal for IO-bound or mixed operations where some tasks involve asynchronous calls. Both methods process collections in parallel, but their use cases and internal mechanics are quite different. Let's understand them better with an example. Console.WriteLine("Using Parallel.ForEach:"); ParallelForEachPrimeCheck(2, 50); Console.WriteLine("\nUsing Parallel.ForEachAsync:"); await ParallelForEachAsyncPrimeCheck(2, 50); static void ParallelForEachPrimeCheck(int start, int end) {   var primes = new ConcurrentBag<int>();   Parallel.ForEach(Enumerable.Range(start, end - start + 1), number =>   {     if (IsPrime(number))       primes.Add(number);   });   Console.WriteLine($"Primes: {string.Join(", ", primes.OrderBy(x => x))}"); } static async Task ParallelForEachAsyncPrimeCheck(int start, int end) {   var primes = new ConcurrentBag<int>();   await Parallel.ForEachAsync(Enumerable.Range(start, end - start + 1), async (number, _) =>   {     await Task.Delay(10); // Simulating async work     if (IsPrime(number))       primes.Add(number);   });   Console.WriteLine($"Primes: {string.Join(", ", primes.OrderBy(x => x))}"); } Parallel.ForEach: - Processes the range of numbers (2 to 50) in parallel using threads. - Each number is checked for primality using IsPrime. - Results are stored in a thread-safe collection (ConcurrentBag<int>). - This method is optimal here because the IsPrime function is CPU-bound and doesn’t require asynchronous operations. Parallel.ForEachAsync: - Does the same task but uses asynchronous processing for each number. - Simulates an asynchronous workload (using Task.Delay) to mimic scenarios like IO-bound operations or API calls. - Again, results are safely stored in a ConcurrentBag<int>. Full code you can see in the attached image #DotNet #CSharp #TechnicalInterviews #ParallelProgramming #Async

129

5 Comments

Null reference errors? Fragile code? Frequent runtime errors? ⚡Strengthen your codebase with Nullable Reference Types!⚡ Nullable reference types—introduced in C# 10—help us handle potential null reference errors more effectively by integrating nullability into the type system. 👍Advantages - Enhances code safety by identifying possible null reference errors at compile time. - Improves code readability and maintainability by explicitly marking nullable reference types. - Assists in preventing runtime null reference exceptions. 👎Disadvantages - Requires updating existing codebases, which can be time-consuming. - May produce numerous warnings in legacy code, making the initial adoption process challenging. - Do not stop null values from flowing at runtime; only do static analysis during the compilation. This reality is important for library authors to consider. ✅When to Use - When starting new projects to ensure null safety from the beginning. - During code refactoring to improve code quality and reduce runtime errors. - In large teams to enforce consistent handling of null references across the codebase. ❌When Not to Use - When working with legacy code that cannot be easily modified to accommodate nullable reference types. 💡Takeaways Nullable reference types provide a robust mechanism to handle null references, making our code more reliable. While the transition might require some effort, the long-term benefits in terms of code safety and maintainability are significant. Nullable reference types rely only on static analyzers, so runtime errors can still occur if external consumers call your code (or vice versa). 💬Comments Have you started using nullable reference types in your projects? Share your experiences and tips below! #ASPNETCore #SoftwareArchitecture #dotnet #csharp #DesignAndArchitecture #CodeDesign #ProgrammingTips #CleanCode

96

20 Comments

Most apps I worked with had strict mode disabled, I am driving a big project at Celonis to migrate our codebase to strict mode, this talk was from learning migrating the big codebase. #angular #strictmode

10

2 Comments

An SDE in a startup doesn’t need a team lead, nor they need a technical architect, nor they need a DBA, or a manager, not even an admin. Because they are all in one, they can so everything for themselves. They don’t even need documentation because they are the documentation 😂 What else you don’t need? Continue in comments #startup #sde #entrepreneur

12

3 Comments

Dynamic registration of FluentValidation in minimal API #dotnet #dotnetcore #csharp #fluentvalidation #api #dependencyinjection https://lnkd.in/gDkaFMDc

10

A simple and good representation of REST vs GraphQL.......

3

Have you heard about Project Bedrock in ASP.NET Core? It has been added to ASP.NET Core as 𝐌𝐢𝐜𝐫𝐨𝐬𝐨𝐟𝐭.𝐀𝐬𝐩𝐍𝐞𝐭𝐂𝐨𝐫𝐞.𝐂𝐨𝐧𝐧𝐞𝐜𝐭𝐢𝐨𝐧𝐬.𝐀𝐛𝐬𝐭𝐫𝐚𝐜𝐭𝐢𝐨𝐧𝐬 package since .NET 3.0 and provide a set of API which abstracting network transport-layer. Many existing building block of ASP.NET Core like Kestrel and SignalR are built on top of it. It help you build custom application protocols (or use existing one) without having to rewriting it for different transport-layer (like TCP, QUIC and WebSocket). References: https://lnkd.in/geFC_Jac https://lnkd.in/gegNNfvu

8

Indeed one of the coolest feature of visual studio that can save huge amount of time in framing the DTOs and models for the JSON data. Moreover those who want to try this. Click on the "Edit" button in the menu and this option will be visible.

2

Day 5: Routing in Minimal APIs Routing is a fundamental concept in ASP.NET Core, and Minimal APIs make it simpler and more efficient. On Day 5, let’s explore how routing works in Minimal APIs, helping you control how incoming requests are mapped to API endpoints. What is Routing? Routing is the process of matching an incoming HTTP request to an endpoint. In ASP.NET Core, routing is flexible and can be customized based on the application’s needs. How Routing Works in Minimal APIs Minimal APIs simplify routing by enabling you to define routes directly in the endpoint definitions. You can control which HTTP methods (GET, POST, etc.) and URL patterns match your routes with minimal code. Here’s how you can define basic routes in Minimal APIs: var app = WebApplication.CreateBuilder().Build(); // GET endpoint app.MapGet("/hello", () => "Hello, World!"); // POST endpoint app.MapPost("/submit", (MyModel model) => { /* Handle the POST request */ }); app.Run(); Defining Route Parameters You can add route parameters directly within the route template. This allows your API to be dynamic and handle a variety of inputs: app.MapGet("/products/{id}", (int id) => $"Product ID: {id}"); In this example, {id} is a route parameter, allowing your API to respond to different product IDs dynamically. Handling Query Parameters Query parameters can be passed along with routes for more granular control. Minimal APIs allow query parameters to be easily retrieved in methods: app.MapGet("/search", (string? q) => $"Search query: {q ?? "No query provided"}"); HTTP Method Matching Minimal APIs support all HTTP methods such as GET, POST, PUT, DELETE, and more. You can specify the method and route pattern directly: app.MapPut("/update", (MyModel model) => { /* Handle PUT request */ }); app.MapDelete("/delete/{id}", (int id) => { /* Handle DELETE request */ }); Advanced Routing Features ASP.NET Core’s routing system supports more advanced features such as: Constraints: Limit acceptable values for route parameters (e.g., integers only). Optional Parameters: Make route parameters optional by using ? after the parameter name. Custom Route Templates: Customize the URL patterns to suit your API’s needs. Example using a constraint: app.MapGet("/users/{id:int}", (int id) => $"User ID: {id}"); Benefits of Routing in Minimal APIs Simplicity: Define routes with minimal code, making the API easier to understand and maintain. Flexibility: Leverage the full power of ASP.NET Core routing in a concise format. Scalability: Easily handle complex routing scenarios, allowing your API to grow with your application’s needs. #Day5Challenge #100DaysOfCode #MinimalAPIs #ASPNETCore #Routing #WebDevelopment #DependencyInjection #APIDevelopment #SoftwareEngineering #CleanCode #DotNetDeveloper #CodingJourney

17

3 Comments

Asked recently on here about MQTT client speeds in .NET, got a lot of responses. Decided to just write my own MQTT client using Akka.NET streams - hitting ~70k msg/s with QoS level 1 enabled. With an 8kb payload I'm able to hit about 35k msg/s (from both my stress tester and my client) before EMQX (running in a Docker container) starts dropping connections. Almost done with auto-reconnect support so I can see if that helps (I suspect the default EMQX Docker image config has a buffer size limit that's being hit somewhere.) Gonna make the client source code available soon, but wanted to provide an update - making a faster .NET client was the less risky option over replacing all of the infrastructure our client had chosen for this project.

48

New Article : Understand OpenAPI document generation in AspNet Core https://lnkd.in/dcAhNkGi #AspNet #AspNetCore #DotNet #CSharp #VisualStudio #WebDevelopment #SoftwareDevelopment #TechBlog #CodingTips #TechNews #LearnToCode #DevCommunity #Blazor

2