Loading
Learn it from developers who built it.
Tutorials, how-tos and deep dives on AI, .NET, C#, cloud and developer tools, written by the community.
To swiftly develop an industry-standard .NET Core CRUD API, utilize ASP.NET Core's MVC framework with Entity Framework Core for data access. Employ dependency injection, repository pattern, and AutoMapper for efficient development.
This is an introduction to Apache Kafka and how to work with Kafka with .NET. This article introduces Apache Kafka, a distributed event streaming platform, and explains how to set it up with .NET. It covers installation, configuration, and integration, providing a comprehensive overview of Kafka.
In .NET Core, understanding service lifetimes is crucial for efficient dependency management. This article explores transient, scoped, and singleton lifetimes with practical examples in ASP.NET Core applications.
ASP.NET Core is a powerful framework for building web APIs, allowing developers to create robust and scalable applications. One of the key features of modern web development is the integration of third-party APIs, which provide access to external services and data.
Explore rate limiting in .NET Core to manage incoming traffic, enhance performance, and defend against malicious activities. Test fixed window, concurrency, token bucket, and sliding window limiters in a Minimal API.
In .NET 9, developers have been granted a powerful tool to enhance data serialization: CamelCase Serialization. This feature facilitates smoother interoperability with systems and frameworks that expect camelCase formatted data
In software development, dealing with mistakes is really important. Whether it's a small problem or a big one, how a program handles mistakes can really affect how well it works for users. In the .NET Core world, there's a cool way to handle errors called global exception handling using custom middleware.
This hands-on article guides you through implementing prompt engineering with .NET Core to build effective conversational AI systems. Learn techniques such as contextual prompts, error handling, and response variation.
OpenTelemetry revolutionizes observability in software development, offering a unified approach to collecting telemetry data across distributed systems. With its standardized APIs and SDKs, developers can effortlessly instrument their .NET Core applications for distributed tracing,
This article introduces the concept of telemetry in web APIs, focusing on its significance in performance monitoring and issue identification.
Global exception handling in .NET Core, utilizing custom middleware, centralizes error management, enhancing resilience and simplifying maintenance. This approach streamlines error handling across the application, promoting consistency and fortifying against unexpected failures.
In Visual Studio, .http files enable direct API testing within the IDE from Visual Studio 2019 onwards. Before this, developers relied on tools like Postman or Swagger, or unit testing. These files streamline API testing by allowing requests.
This content provides an overview of Progressive Web Apps (PWAs) and outlines their key characteristics. It also includes step-by-step instructions on how to create a PWA using ASP.NET Core, along with the necessary prerequisites and installation steps for adding PWA features to a web application.
In this article, you will learn how to install .NET Core and how to create and run a simple console application. .NET Core supports command line interface for developing the applications.
Learn to connect an existing website to a local database using Entity Framework Core. Benefit from faster setup, simplified data access, and reduced code with LINQ. Embrace cross-platform capabilities and continuous improvement.
Learn how to use GC.RefreshMemoryLimit() in .NET 8 to refresh memory limits when container or cloud resource limits change.
These directories are needed because the C# compiler and linker require intermediate files to be generated during the build process to produce the final output file. The "obj" directory contains these intermediate files, which are needed to link and optimize the final executable or library file.
Explore the fundamentals of logging and its benefits in software development using NLog in .NET Core 6. Follow a step-by-step implementation with prerequisites, NLog configuration, and a demo Weather Forecast API.
Learn the fundamentals of dependency injection in .NET Core, including service registration, IServiceProvider, service lifetimes, constructor injection, and practical best practices.
In ASP.NET Core, middleware components are used to handle requests and responses as they flow through the application's pipeline. These middleware components can be chained together to process requests and responses in a specific order. Transferring data between middleware components can be achieved using various techniques.
In this article, we explore efficient HTTP request handling in .NET Core using HttpClient and harness the power of HttpClientFactory. Learn best practices for scalability, dependency injection, and optimal configuration.
Explore the world of performance metrics and benchmarking in .NET with this comprehensive guide. Uncover essential insights into measuring and optimizing the performance of your .NET applications, gaining a deep understanding of benchmarking techniques and strategies.
In ASP.NET Core, routing to controller actions is facilitated through attributes that define route templates, mapping incoming HTTP requests to specific actions. Multiple conventional routes can be established in the Startup.cs file using the MapControllerRoute method.
In ASP.NET Core MVC, you can pass temporary data from one controller to another using TempData. TempData is a dictionary that can be used to share data between controllers during the current request and the subsequent redirect. Here's how you can achieve this:
In this article, I'm going to implement the basic CRUD Operations using .Net Core Web API & the Dockerized MSSQL Server. This article guides you through implementing CRUD operations in ASP.NET Core Web API using .NET Core 8 and saving data in a Dockerized MS SQL Server. Follow the steps for setup and coding.
Checking the health of a .NET Core application is an important aspect of monitoring and maintaining the application's reliability. One way to achieve this is by implementing a health check endpoint. Health checks provide a quick way to assess the state of your application, such as checking database connections, external dependencies, or other critical components.
This article explains the concept of minimal APIs, their advantages, and steps to implement CRUD operations. Explore the flexibility and simplicity of minimal APIs for building efficient HTTP APIs. The article covers database setup, model creation, repository implementation, and dynamic registration of APIs during runtime.
ASP.NET Core 7 Web API. Lazy loading is a technique where related data is only loaded from the database when it is explicitly requested. In Entity Framework Core, lazy loading can be achieved by marking navigation properties as virtual.
In ASP.NET Core, eager loading is a technique used to load related data along with the main entity in a single database query. This helps to optimize performance by reducing the number of database calls. Let's implement an example of eager loading in an ASP.NET Core Web API using Entity Framework Core.
Synchronous Programming: In synchronous programming, tasks are executed one after the other, in a sequential manner. When a request is made to a synchronous API, the server processes the request and waits for it to be completed before moving on to the next task. This means that if one operation takes a long time to finish, it can block the execution of subsequent operations, potentially leading to slower response times for clients. Asynchronous Programming: On the other hand, asynchronous programming allows tasks to be executed concurrently. When a request is made to an asynchronous API, the server can initiate tasks and continue processing other requests without waiting for the previous tasks to be completed. This can lead to better scalability and responsiveness, especially in scenarios where certain operations, such as I/O operations, may take some time. ASP.NET Core Web API: In ASP.NET Core Web API, you have the flexibility to choose between synchronous and asynchronous programming models. The framework supports both approaches. Asynchronous programming is particularly useful when dealing with I/O-bound operations, such as accessing a database or making external API calls, where the application can continue processing other tasks while waiting for the I/O operation to complete. To implement asynchronous programming in ASP.NET Core Web API, you can use the `async` and `await` keywords in your controller methods, allowing you to write non-blocking code. This helps improve the overall performance and responsiveness of your API, especially in scenarios with high concurrency.
Everything on .NET Core, not only its articles: the .NET Core page →
Write an article and earn +1,000 SHARP when it is approved.
Write an article
