The Visitor design pattern provides flexibility in your designs by enabling you to define a new operation without needing to change the types of the elements on which it would operate
The abundance and easy availability of CPU at the expense of network bandwidth can be a good reason to use content compression in Web API for faster responses and improved performance
Cross-Origin Resource Sharing in ASP.NET Web API allows cross-domain access to your Web API methods.
This pattern represents part-whole hierarchies of objects such that the consumers or the clients can treat the objects and also the compositions of objects in a uniform manner
Create continuations using the Task Parallel Library that can run immediately after the execution of the antecedent is complete or to chain tasks as continuations
xUnit.Net is an open source unit testing tool for the .Net Framework that provides an easy way to work with data driven unit tests
The ConcurrentDictionary and ConcurrentBag classes provide lock-free, thread-safe implementations to work with collections in .Net
The observer design pattern defines one-to-many relationship between objects so that changes to one object can be notified to the other dependent objects
Understand how asynchrony works in .Net and adhere to the recommended practices when writing unit tests to test asynchronous code
The bridge design pattern can be used to decouple an abstraction from its implementation so that both can be changed independent of each other
The prototype design pattern enables you to create new instances by copying existing instances to avoid the overhead involved in creating objects that can consume more resources
Understand the differences between Task.WaitAll and Task.WhenAll methods and when to use which in your application.
Application pools isolate applications even if they are running on the same server for better reliability, security and improved performance
C# 7 focuses on better developer productivity and enhanced performance
Follow the recommended practices when working with asynchronous programming to achieve scalability and performance benefits
NLog can log your app data and create logs regardless of the size and complexity of your application.
Learn what stubs, mocks, and shims are, their differences, and why they are needed and used to write efficient unit tests
Learn how to pass multiple complex objects as parameters to Web API controller methods.
The Law of Demeter principle reduces dependencies and helps build components that are loose coupled for code reuse, easier maintenance, and testability
This article is a continuation of the series of articles on Dapper. In the earlier article on Dapper, we have had a brief introduction on Dapper and to get started using in and perform CRUD operations. In this post, I’ll present a discussion on....
Extension methods can be used to inject new functionality to a type without needing to modify, derive, or recompile the original type
When working with asynchronous code in your applications, follow the recommended best practices to avoid potential pitfalls
Jagged arrays are a special type of arrays that can be used to store rows of data of varying lengths to improve performance when working with multi-dimensional arrays
The yield keyword performs custom and stateful iteration and returns each element of a collection one at a time sans the need of creating temporary collections
Log4net is an easy to use, reliable, fast, popular, extensible, and open source library for logging data to various configured log targets
Take advantage of the NULL Object pattern to avoid writing too much boilerplate code in your application when checking for null values
Learn the potential pitfalls of using the repository pattern, including adding an extra layer of abstraction when it's not needed in your software designs
Unity Application Block, a lightweight dependency injection container, can build loosely coupled applications that are extensible and easier to test and maintain
The ConcurrentStack and ConcurrentQueue classes, lock-free and thread-safe implementations of the Stack and Queue classes, build thread safe collections in .Net
Learn the drawbacks of using the Singleton design pattern, one of the most widely used design patterns, and the alternatives to avoid its potential pitfalls
Microsoft .Net provides support for cloning objects -- an ability to create an exact copy of an object (also known as a clone). Cloning can be of two types: shallow copy and deep copy.
The Repository pattern implements separation of concerns by abstracting the data persistence logic in your applications
Proper synchronization constructs, structured and deterministic code flow will help you avoid Thread.Abort or Thread.Interrupt methods and terminate threads gracefully
The ServiceLocator design pattern builds loosely coupled modules that can be independently developed, tested, and deployed seamlessly
Connection pooling in ADO.Net lets you reuse database connections and improves data access performance
ASP.Net Core is an open-source and cross-platform, lean and modular framework for building high-performance web applications
Refrain from calling the GC.Collect method explicitly to reclaim the memory occupied by the objects in your application unless there is a specific reason do so
Cyclomatic complexity is a quantitative measure of the linearly independent paths in source code that can help you understand the complexity of your program and improve code coverage
Tuples can be used to store a finite sequence of homogeneous or heterogeneous data of fixed sizes and can be used to return multiple values from a method
SpinLock handles "busy wait" in scenarios where you have frequent contention but with reasonably short waiting times by avoiding context switches and improving performance
HTTPHandler is a low level request and response API in ASP.Net for injecting pre-processing logic to the pipeline based on file extensions and verbs
The Managed Extensibility Framework in .Net avoids fragile hard dependencies in your code and builds applications that are loosely coupled, lightweight, and extensible
HTTP modules intercept incoming requests and inject pre-processing logic in the ASP.Net request processing pipeline
The BlockingCollection class in .Net implements thread-safe collections efficiently
WebSockets implement fast, secure, bi-directional, full duplex communication between a client and a server to support real-time, low-latency messaging
Take advantage of Mutex for inter process synchronization and Semaphore to limit concurrent access to a shared resource in your application
Explore ways to handle concurrency conflicts to maintain data integrity and data consistency when working with Entity Framework
Content negotiation in Web API helps determine the best representation of a resource from among the various representations available
You can use covariance and contravariance to provide polymorphic extension to delegates, arrays, and generics in C#. Here’s how.
You can increase the performance and scalability of your client-server applications by using asynchronous sockets. Here’s how.