Sayedur Rahaman

Minimal APIs start small and fast but rarely stay that way for longer than a day in development. Is your Minimal API component becoming... non-minimal, too? From configuring services over mapping endpoints to grouping routes, this video demonstrates the whole process of separating the Minimal API project into small, manageable portions of code. Enjoy watching! https://lnkd.in/deFKtHmv

৫৫

৬ মন্তব্যসমূহ

Mastering the Unit of Work Pattern in C# for Modern Applications Should we use UOW always? Well.. we should in my project now, but actually, it's not always the best way to go. In this post I've analyzed the pros and cons of using the UOW to get to that conclusion. Interesting approaches that say to remove the UOW especially if using EF and why should we keep it, nevertheless.. like and follow :) #SoftwareDesign #Arhcitecture #BestPractise

৩

Warning: Developer Geek Rant Topic: Configuration in .NET Apps Audience: .NET Developers If you’re not a .NET developer please move on you will not care I assure you. TL;DR; - Stop relying on old school token replacement in build pipelines for *non-secrets* - Do use .NET ConfigurationBuilder in the Microsoft .NET standard way - Understand the beauty of the secrets.json file for local private configuration on your dev workstation and use it! RANT: As a software engineer and architect for close to three decades now, I’ve seen all variations of configuration strategies for applications. The most basic is token replacement, which I discovered and used plenty since the 1990’s Fast-forward to the advent of .NET, and Microsoft came up with a much better way to setup configuration for .NET applications using their ConfigurationBuilder. The benefits are too numerous to explain in this post but here’s why I’m venting. With just about every client I work with, the way configuration is handled is inefficient at best or a total mess at worst and it’s usually the latter. It blows my mind that .NET developers, some of whom have been in their careers for well over a decade, do not understand the .NET standard of configuration, much less why it is so much better than the garbage strategy of token replacement. They continue to use terrible strategies for configuration causing headaches and annoyances that have been solved well before most Gen Z’ers were even born. These outdated configuration strategies cause delays and constitute a hidden source of loss of productivity. If I were to add up all the times some developer had to go and resolve some configuration issue it is probably causing large enterprises hundreds of thousands of dollars a year in hidden costs due to time lost because someone needed to hunt down some config buried in a build pipeline or ask and wait for a developer to copy/paste the config into a Teams chat to share configuration that should have been automatic plug & play through a file directly in the repo, or because of some other of the many ills of dumb config strategies. For all you .NET Devs out there … for the love of all that is pure and holy … please take the time to learn one of the most basic things in .NET app development: The ConfigurationBuilder. For those that do use ConfigurationBuilder most of them do not even know that the User Secrets file is a thing (ie, secrets.json) much less understand why it’s awesome. So learn that too and use it for local config, specific to your environment, that can’t be shared. And don’t get me started on, “but I hate repeating config across files for the other environments.” If you’re repeating config across files then you don’t know what the heck you are doing. No self-respecting .NET developer should go on developing .NET applications without knowing this basic aspect of building .NET apps. And shame on the architects that allow devs to do this. Please do better! 😤 End of rant.

২

#Laravel Tip 💡 If you're logging the exception message, you might also want to provide more context to it. By including details like the error code, line number, and file path, you can quickly pinpoint where the error occurred without having to search through your codebase. 🚀

১৯১

১২ মন্তব্যসমূহ

EN: 🚀 Mastering Dependency Injection in #ASP.NET Core 🚀 Dependency Injection (DI) is the backbone of modern #ASP.NET Core development. 🌐 Whether you're a beginner or looking to level up your skills, understanding DI lifetimes—transient, scoped, and singleton—is essential for building robust, maintainable applications. In my current tutorial, I demystify everything about DI in #ASP.NET Core with practical examples and insights: 👉 Dependency injection lifetimes explained 👉 Registering multiple instances and keyed services 👉 The power of TryAdd for optimistic registration 💡 Timeline Highlights: 🎯 0:00 - what we're going to learn 🎯 0:55 - getting started 🎯 03:20 - AddControllers() and MapControllers() 🎯 05:45 - Dependency injection lifetimes 🎯 09:00 - Transient and Scoped lifetime 🎯 20:16 - Singleton lifetime 🎯 21:50 - Different lifetimes 🎯 26:00 - Registering multiple instances 🎯 28:40 - TryAdd optimistic registration 🎯 30:20 - Registering multiple instances 🎯 32:00 - Keyed services 🎯 21:50 - Comparing lifetimes (transient, scoped, singleton) 🎯 26:00 - Registering multiple instances and keyed services 📽️ This hands-on tutorial is packed with actionable knowledge for both beginners and experienced developers. Whether you're setting up your first ASP.NET Core project or fine-tuning a production application, this is a must-watch! 👉 The link is in the comment section If you’ve ever struggled with understanding or implementing DI in ASP.NET Core, this is your chance to conquer it. 🖥️#ASPNetCore #DependencyInjection #CSharp #CleanCode #SoftwareDevelopment #LearningTogether #turalsuleymanitech #turalsuleymani AZ: Deməli, ana dilimizdə söhbəti qısa kəsəcəyəm. Əgər Dependency İnjection mövzusuna advanced səviyyədə baxmaq istəyirsinizsə, xüsusən bir neçə eyni interfeys realizasiyasını necə registrasiya edim, təzə .NET core bizə nə kimi inkanlar verir, keyed servislər nədir,optimistik Dİ registrasiyası nədir kimi məsələləri öyrənmək istəyirsinizsə bu video tam da sizin üçündür.

৮১

৪ মন্তব্যসমূহ

Frozen Collections: With .NET 8, the 'System.Collections.Frozen' namespace introduces two new read-only collection classes: 1. FrozenDictionary<TKey, TValue> 2.FrozenSet<T>. These collections are designed for scenarios requiring highly optimized read performance, similar to ImmutableDictionary<K, V> and ImmutableHashSet<T>, but without methods for nondestructive mutation (e.g., Add or Remove). You can create a frozen collection from an existing collection or sequence by using the ToFrozenDictionary or ToFrozenSet extension methods. Frozen collections are ideal for lookups that are initialized at the start of a program and used throughout the application’s lifecycle. #Microsoft #Dotnet8 #c

৪

StructuralComparisons The `StructuralComparisons` class in .NET is part of the `System.Collections` namespace and is used to provide comparison services for collections that do not have a specific order, such as arrays. It offers two properties - `StructuralEqualityComparer` and `StructuralComparer` - that can be used to compare arrays and other collections based on their structure rather than their reference. Advantages 1.Structural Comparison: It allows for comparing the contents of two arrays or collections, treating them as equal if their structure and content are equivalent, rather than their references. 2.Ease of Use: The class provides a straightforward way to perform deep comparisons without needing to implement custom comparison logic. 3.Flexibility: It can be used with different data types, including nested collections, making it versatile for a variety of use cases. 4.Standard Implementation: By using StructuralComparisons, developers leverage a standardized implementation which can reduce potential bugs compared to custom comparison logic. 5.Support for Multiple Types: It can handle comparing arrays containing different types of elements, which can be helpful in dynamic programming situations. Disadvantages 1.Performance Overhead: Structural comparison may introduce performance overhead, especially for large collections, since it checks each element recursively. 2.Limitation to Arrays: Designed primarily for comparing arrays and flat collections, it may not be effective for more complex types or needs that require specialized comparison logic. 3.Implicit Dependencies: If the structures being compared contain nested objects that do not implement the appropriate equality members, the comparison might yield misleading results. 4.Use in .NET Core: As it is part of .NET Framework, usage in .NET Core and .NET 5+ may be limited or require a different approach. Users transitioning from .NET Framework to .NET Core should be mindful of this. 5.Lack of Advanced Features: It may not support advanced comparison features like filtering or custom sorting, requiring additional code to extend functionality. In this example, two integer arrays (array1 and array2) that contain the same elements in the same order are compared using StructuralComparisons.StructuralEqualityComparer, resulting in `true`. Conversely, array1 and array3,which contain the same elements but in different orders, are compared and yield `false`. The `StructuralComparisons` class provides functionality for comparing collections based on their structure and contents, making it suitable for scenarios where deep comparisons are necessary. However, developers should be aware of its performance implications, limitations in complex data types, and the potential need to implement custom logic for specific use cases, especially when transitioning to .NET Core. Want to know more? Follow me or connect🥂 Please don't forget to like❤️ and comment💭 and repost♻️, thank you🌹🙏

৯৪

১৫ মন্তব্যসমূহ

How I build sites with F# + HTMX: Start with an MPA: * Request comes in * Code generates HTML * Send HTML to browser HTMX sprinkled in to allow components on the page to re-render themselves. https://lnkd.in/eHNXcXvK

১

8 ways to set the URLs for an ASP.NET Core app https://lnkd.in/eYpvv7FM #csharp #dotnet #dotnetcore #aspnetcore #port

৯

Common patterns with C# and JSON Schema - constraints on a simple data object. #dotnet #csharp #Json #JsonSchema #Serialization #Performance #Openapi https://buff.ly/4am2Jep

৪

Implement ASP.NET Core OpenID Connect OAuth PAR client with Keycloak using .NET Aspire #SharpCoding #DotNET #Aspire

১

Two identical components: client-rendered (1st one), 2nd one is server-rendered. Can you see the difference? #nextjs #server_component #client_component

১১

৪ মন্তব্যসমূহ

Discards "Discards" in .NET (specifically from C# 7.0 and onward) are a feature that allows you to specify that you want to ignore a value that would otherwise be returned or produced by an operation, such as a method call, tuple deconstruction, or pattern matching. The discard symbol is represented by an underscore (`_`). Advantages of Discards 1. Code Clarity: Discards indicate that you explicitly do not care about a value being returned. This can enhance readability, signaling to other developers that certain values are intentionally ignored. 2. Reduction of Unused Variables: When a method returns multiple values (such as in a tuple), using a discard allows you to ignore unwanted variables without the clutter of unused local variables and warnings. 3. Pattern Matching: In pattern matching scenarios, discards can simplify the code by avoiding the need to create unnecessary variables for types you don't care about. 4. Improved Performance: By not creating unused variables, your code could potentially allocate less memory, although the performance difference is usually negligible. 5. Clean Syntax: Discard syntax is straightforward and less verbose compared to declaring variables that you'll not be using. Disadvantages of Discards 1. Loss of Information: By using a discard, you may miss important information that could be useful for debugging or understanding the code. This is especially true if the discarded value might have been useful later. 2. Overuse Leading to Poor Practices: If not used judiciously, reliance on discards might lead to code that is hard to maintain or understand, as developers might ignore important return values too frequently. 3. Lack of Reflexivity: If you use discards in scenarios where one might reasonably expect to use those values later, it could lead to confusion or bugs in your code. 4. IntelliSense Limitations: In some IDEs or editors, you may not receive useful IntelliSense recommendations when using discards since they do not hold any values. 5. Potential for Bugs in Future Refactoring: Changes in method signatures might lead to a situation where previously discarded values are now important, which may not be immediately obvious to someone unfamiliar with the history of the code. Discards provide a useful and expressive way to cleanly handle cases where certain values are not needed. However, like any feature, they should be used thoughtfully to ensure code remains understandable and maintainable. Want to know more? Follow me or connect🥂 Please don't forget to like❤️ and comment💭 and repost♻️, thank you🌹🙏 #backend #fullStack #developer #Csharp #github #EFCore #dotnet #dotnetCore #programmer

৯০

২২ মন্তব্যসমূহ