From de3a180c4e4bc4296f4f3f018bf398763c898bbf Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 9 Sep 2026 13:12:51 +0200 Subject: [PATCH] chore: sync content to repo (#10293) Co-authored-by: nilbuild <4921183+nilbuild@users.noreply.github.com> --- .../content/activemq@sNYYEBMHV_NO_NToP51VY.md | 4 +--- ...and-communication@GLkDH0X0uy8_1DIdCzbUD.md | 8 ++------ ...tings-and-configs@EJxliq-HPVp00CVsFc6kf.md | 6 +----- .../content/autofac@gbpSbjF12dBE1Tb3PX8Bz.md | 6 ++---- .../automapper@GPmlueMnuLCUW_t4jvGhc.md | 4 +--- .../azure-pipelines@_-GQNpsb7KZw76hNNOq3h.md | 4 +--- .../content/blazor@4iD_hDtgJ15IlJGxiO-E8.md | 7 +------ .../content/bogus@QERTjawqCCCkHfR44Ca0s.md | 2 +- .../cassandra@U_-Gt5csu_hihl7ybFY-B.md | 4 +--- ...hange-tracker-api@wfEOvAkGXkTZGdGX341D4.md | 4 +--- .../content/ci--cd@KIFmahcNiSo2NGoLtAyRR.md | 6 ++---- .../circle-ci@KyGjXgG6JFo42qOV0wqfB.md | 4 +--- .../content/cloud@LrjmJs6_rXUkc2A7fEq24.md | 6 ++---- ...first--migrations@ZPeebwJ3OBuywEgLLgQTG.md | 6 ++---- .../constraints@1-XdtrGPbUoxpu9ZcQlBA.md | 2 +- .../content/coravel@p3bZnKIyRgLmB764Kkhju.md | 4 +--- .../cosmos-db@KrkV1w9b_Nwm6pe9diDRS.md | 4 +++- .../content/couchdb@vHcwt6ARi5YR3v-eDDjfl.md | 4 +--- .../content/dapper@UkWc41r0bZ1lptjse3As6.md | 4 +--- ...es-and-algorithms@RAX2xN37taw9cqA3pnORh.md | 4 ++-- ...base-fundamentals@tnKUdsgp6bnFtQTexEmfy.md | 13 +++--------- .../databases@Ujzn_dILCA7xoupnz398l.md | 10 +--------- ...endency-injection@IejHMMVKwA0sIInla4FjX.md | 4 +--- .../di-containers@iM760f8Ys66-VSkMiZfIX.md | 4 +--- .../distributed-lock@T2FsSndxzSuKTFdjoyPi-.md | 2 +- .../content/docker@rmRESzLiZNWdBFXLrwQFJ.md | 8 +++----- .../dynamo-db@1Om9aQDZmnj_DN10ogwDL.md | 4 +--- .../content/easynetq@X6iSHoHnFFMaGb6YPQFhl.md | 4 +--- .../elastic-search@mK9OAwjReZoQZr1WSLRKJ.md | 4 ++-- ...k-2nd-level-cache@FV4GsPjUyAc99DnIwkkCC.md | 6 ++---- .../fakeiteasy@diRJ_F6kx42Ucs0fxidtZ.md | 4 ++-- .../content/fluid@ZaOhWWDgVxrn0hbesJ7xT.md | 2 +- .../framework-basics@eGVaAz3VhGu3cXBNxTAWd.md | 6 ++---- .../frameworks@1YL7aXluINOO15W3waaiD.md | 2 +- ...evelopment-skills@NEnna_8DstfYH4T9qrP3-.md | 18 ++--------------- ...--version-control@OtdCmkj0SvrGwCUSfm96C.md | 4 ++-- .../github-actions@0-PLMXGlRyRzTk-EjXMs2.md | 4 +--- .../gitlab-cicd@8Y73Ae32eo6_ye7dw5QRQ.md | 2 +- .../content/graphql@BdTQ5ZMNDNZvkAUoCfL5H.md | 8 +++----- .../content/grpc@x3SJlLc19DNJ-PyDOOj_G.md | 4 +--- .../content/hangfire@QiQsx1udyKcPJ-lZjRQVy.md | 4 +--- .../hotchocolate@XMrQx9JH0eSQJpMzhvy0F.md | 6 ++---- ...p--https-protocol@YI3cAezupWNntFw4B6elY.md | 20 ++++--------------- .../content/kafka@L8RkeMYm0WGNeLLcHKF1R.md | 6 ++---- .../kubernetes@02rtFStTeIm8prNskxaUN.md | 10 +++------- ...-explicit-loading@9AMotSwdEbB8uOg80SykE.md | 12 ++--------- ...n-the-basics-of-c@NvODRFR0DLINB0RlPSsvt.md | 8 ++------ .../life-cycles@Tjaczp2E-cCn0qSv89xgo.md | 10 ++-------- .../light-bdd@aWRv5sU9dksgcpE9RGJb1.md | 2 +- .../content/litedb@3gcXaOnHL4v5OoStrTWNV.md | 4 +--- .../log-frameworks@fQ3w8REYWzQfeJ0nPyq6W.md | 10 +--------- .../manual-mapping@oMMBzRrHkUymxAR4oqr75.md | 4 +--- .../content/mapperly@x0OopRTwIvoWgT8qi0CE9.md | 2 +- .../content/mariadb@Gs8XcsTo11MeCsiSGpjkU.md | 4 +--- .../content/marten@ipb6proIZKG-_vCOMAiBu.md | 2 +- .../mass-transit@SQKIUa_UsJ4cls-Vs9yHU.md | 4 +--- .../microservices@37c2eCvRdebztkbc5AjYp.md | 4 +--- ...crosoftextensions@J9XdYLo7qJiBoL8p3c68P.md | 6 ++---- .../middlewares@dG--AAcZZdltYCeg6zCz2.md | 4 +--- .../minimal-apis@ipABerBcM9zCte9pYaIse.md | 4 +--- .../content/mongodb@-wYRa8qSuKVKo_yOTKV67.md | 8 +++----- .../content/moq@eyOXWb1kL80Wqiwc2WHd_.md | 2 +- .../content/mvc@D3aQw0-pk3ycO-n10HBaA.md | 6 +----- .../content/mysql@WsGwg4qdlu_vBsFEpmBvU.md | 4 +--- ...ackground-service@uP1nqbmFmZL_wA2DoqP8C.md | 4 +--- .../net-aspire@HqhqqiA5X00Xl1RnZgrNJ.md | 2 +- .../net-aspire@Ohc0xzI6qX4hOFVNfRj1F.md | 2 +- .../content/net-maui@olqSPUU3RoxhQ6exfMzeN.md | 2 +- .../content/netmq@8d4f7_3VO03vy7YDWwPI9.md | 4 +--- .../nhibernate@z24IJndpQYTl1PhiUI2mx.md | 4 +--- .../content/nlog@ykF2bB_68AhCOzeQ_QSW1.md | 4 +--- .../content/nosql@WUis4K9vduriYdVkKvM9r.md | 10 ++++------ .../nservicebus@vf8W1FLhcb3awx4JBaY5r.md | 4 +--- .../nsubstitute@iZCxinqlVefBk5-ICqt4v.md | 2 +- .../content/nuke@EsC1JwFOMOlQVelpmxISh.md | 6 ++---- .../content/nunit@qHYBlBCvCGUZGh6gyEI63.md | 2 +- .../object-mapping@9ECykIIvXlDblbFbRVcJS.md | 4 +--- .../content/ocelot@2k-rGuhYTTAR9XN3aDAnW.md | 4 +--- .../content/odata@YojZ5fpzw-5WgoqqkO6wl.md | 4 +--- .../content/orleans@XKsLqDDco5OXKURCcWAmv.md | 4 +--- .../content/polly@gQhiEpvx__70N1WbEHGYJ.md | 2 +- .../postgresql@An9TLvo-I6NtC8wFU3bh4.md | 8 +++----- .../content/quartz@zOWlPXIl4XPs_0pA8-yi5.md | 4 +--- .../content/rabbitmq@KqvBn2_wvYhFdv0dBZMC9.md | 4 +--- .../razor-components@vePinRjDfSGULKw0LE9K-.md | 4 +--- .../razor-pages@qpVxwuyA2oE06MZLtEdP1.md | 4 +--- .../content/razor@nUE2-egUMNFQoPVrVRFPl.md | 2 +- ...ime-communication@9Vv3OxafB6BlHhi1ZkeVO.md | 6 ++---- .../content/redis@Ts0gJ4DdwFp48LGr4YSvM.md | 10 ++++------ .../relational@FnRxRY3uDZdTve1w-nBfc.md | 6 ++---- .../content/repodb@tYDVcnG0oUF3R8DwASvAh.md | 4 +--- .../content/respawn@TCswZHviRiu6SIOwUisu8.md | 2 +- .../content/rest@KJCtxH3mYsZq3hfBZ6cJF.md | 4 +--- .../content/scalar@Zb4Gugxf7d6MoeEcfngrV.md | 2 +- .../content/scoped@M3BW_63MFQyD8NE68dazD.md | 6 ++---- .../content/scriban@dWB5OCvWVYkD30Op_dMwy.md | 2 +- .../content/scrutor@f212ztDU_kb7gO71Nn76L.md | 4 +--- .../search-engines@6p5atMYw3b3bXkQuXZsDV.md | 4 +--- .../content/shouldly@zhn-VLGPfV6FZT2OMl6zf.md | 2 +- .../signalr-core@8dvd4M0TKNyQR8dEolGNT.md | 2 +- .../singleton@y9bDrCjkDbxSIrEEtu_Mi.md | 4 +--- .../content/solr@2sY_p_8cOOBmZtDHO2Cmy.md | 4 +--- .../content/specflow@9WZmjiFowydYrkHQ2xeNm.md | 2 +- .../content/sphinx@Ye9WHfwZa-Fc2YDaTCmU1.md | 4 +--- .../sql-basics@aOJMVrTcA_I2y_QHzj7aM.md | 12 ++++------- ...stored-procedures@ZiK-c9zNbi5RZkKUi44wP.md | 2 +- .../task-scheduling@s57tKy1rajlJbKFDVXLqs.md | 4 +--- .../test-containers@8eW5BaOjJbnQ7uk4zMOiU.md | 2 +- .../content/testing@XofWWhlU_vWCG5oXVMZze.md | 2 +- .../transient@-N0XM0-VtCZ6QMo2YyMD-.md | 4 +--- .../content/triggers@2f_CJMnXwPxjMEwm5P_QJ.md | 6 +----- .../web-sockets@tBl8neu3tJd5GPwGfJbjZ.md | 7 +++---- ...pplicationfactory@Xx5G09n4WWnnydCgxnL0A.md | 2 +- .../content/xunit@R8C6s53RYjkRVma0nCJpy.md | 2 +- 114 files changed, 164 insertions(+), 389 deletions(-) diff --git a/roadmaps/aspnet-core/content/activemq@sNYYEBMHV_NO_NToP51VY.md b/roadmaps/aspnet-core/content/activemq@sNYYEBMHV_NO_NToP51VY.md index f15d95882..8e54a14e7 100644 --- a/roadmaps/aspnet-core/content/activemq@sNYYEBMHV_NO_NToP51VY.md +++ b/roadmaps/aspnet-core/content/activemq@sNYYEBMHV_NO_NToP51VY.md @@ -1,8 +1,6 @@ # ActiveMQ -ActiveMQ is an open-source message broker written in Java that implements the Java Message Service (JMS) API. It can be used to send and receive messages between different applications in a loosely coupled, asynchronous manner. ActiveMQ supports a variety of messaging protocols, including JMS, AMQP, STOMP, MQTT, and OpenWire. - -In the context of an [ASP.NET](http://ASP.NET) application, ActiveMQ can be used to send and receive messages to and from other systems. For example, it can be used to send messages from a web application to a background service, or to send messages between different microservices. +ActiveMQ is an open-source, multi-protocol message broker that facilitates communication between distributed services by acting as a middleman for data exchange. It enables applications to send and receive messages asynchronously, ensuring that services remain decoupled and resilient even when one system is temporarily unavailable. By supporting industry-standard protocols like AMQP and STOMP, it allows different components of a microservices architecture to share information reliably across various environments. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/api-clients-and-communication@GLkDH0X0uy8_1DIdCzbUD.md b/roadmaps/aspnet-core/content/api-clients-and-communication@GLkDH0X0uy8_1DIdCzbUD.md index 57f813133..67128214a 100644 --- a/roadmaps/aspnet-core/content/api-clients-and-communication@GLkDH0X0uy8_1DIdCzbUD.md +++ b/roadmaps/aspnet-core/content/api-clients-and-communication@GLkDH0X0uy8_1DIdCzbUD.md @@ -1,10 +1,6 @@ -# API Clients +# API Clients and Communication -API clients in [ASP.NET](http://ASP.NET) are software libraries that allow applications to interact with external APIs. They provide a set of methods and classes that make it easy to send requests to an API and process the responses. - -API clients can be used to access a wide variety of services, such as web services, cloud services, and social media platforms. They can be used to perform tasks such as fetching data, posting updates, and deleting resources. - -API clients in [ASP.NET](http://ASP.NET) are typically built using the HttpClient class, which is part of the System.Net.Http namespace. This class provides a set of methods for sending HTTP requests and receiving HTTP responses. +API clients in ASP.NET Core are components used to send HTTP requests to external web services and receive responses. The framework provides the `IHttpClientFactory` to manage the lifetime and configuration of `HttpClient` instances, which helps prevent socket exhaustion and DNS issues. Developers use these tools to consume RESTful endpoints, handle serialization of JSON data, and manage cross-service communication within a distributed application architecture. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/app-settings-and-configs@EJxliq-HPVp00CVsFc6kf.md b/roadmaps/aspnet-core/content/app-settings-and-configs@EJxliq-HPVp00CVsFc6kf.md index 7272022fd..b5a30eb58 100644 --- a/roadmaps/aspnet-core/content/app-settings-and-configs@EJxliq-HPVp00CVsFc6kf.md +++ b/roadmaps/aspnet-core/content/app-settings-and-configs@EJxliq-HPVp00CVsFc6kf.md @@ -1,10 +1,6 @@ # App Settings and Configurations -In the [ASP.NET](http://ASP.NET) Core framework, app settings and configurations refer to the process of storing and managing application-specific settings and configuration data. - -* **App Settings** refers to the key-value pairs of data that an application uses to configure its behavior, such as database connection strings, api keys, or other settings. These settings are typically stored in configuration files, such as `appsettings.json`, `appsettings.development.json`, or `appsettings.production.json`, and can be accessed using the IConfiguration interface. - -* **Configurations** refer to the process of loading and managing the app settings, including specifying the source of the settings and the format of the configuration files. In [ASP.NET](http://ASP.NET) Core, the `Startup` class is responsible for configuring the application's settings, and typically loads configuration data from various sources, such as JSON files, environment variables, or command-line arguments. +App settings and configurations provide a way to manage environment-specific variables and application parameters outside of the compiled code. ASP.NET Core uses a centralized configuration system that aggregates data from multiple sources such as JSON files, environment variables, command-line arguments, and user secrets. This approach allows developers to easily switch settings between development, staging, and production environments without modifying the source code. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/autofac@gbpSbjF12dBE1Tb3PX8Bz.md b/roadmaps/aspnet-core/content/autofac@gbpSbjF12dBE1Tb3PX8Bz.md index c711bac07..1c33f0d8d 100644 --- a/roadmaps/aspnet-core/content/autofac@gbpSbjF12dBE1Tb3PX8Bz.md +++ b/roadmaps/aspnet-core/content/autofac@gbpSbjF12dBE1Tb3PX8Bz.md @@ -1,8 +1,6 @@ -# Autofac +# AutoFac -Autofac is an open-source dependency injection framework for .NET. It is designed to make it easier to manage the dependencies of an application by automatically resolving and managing the lifetime of objects and their dependencies. - -Autofac uses a technique called "component registration" to define the objects and dependencies of an application. This is done by creating instances of the `ContainerBuilder` class and using its methods to register types, instances and factories. Then, the `Build()` method is called to create an instance of the `IContainer` interface, which can be used to resolve dependencies throughout the application. +AutoFac is an inversion of control container for .NET applications that manages the dependencies between classes. It facilitates the loose coupling of components by automatically resolving and injecting required services into constructors or properties. Developers use AutoFac to configure complex object lifetimes, scan assemblies for registrations, and manage modular application structures more efficiently than the built-in ASP.NET Core container. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/automapper@GPmlueMnuLCUW_t4jvGhc.md b/roadmaps/aspnet-core/content/automapper@GPmlueMnuLCUW_t4jvGhc.md index f1c63c905..f1e2406dd 100644 --- a/roadmaps/aspnet-core/content/automapper@GPmlueMnuLCUW_t4jvGhc.md +++ b/roadmaps/aspnet-core/content/automapper@GPmlueMnuLCUW_t4jvGhc.md @@ -1,8 +1,6 @@ # AutoMapper -AutoMapper is a library for .NET that allows you to easily map between objects of different types. It is particularly useful when working with domain models and data transfer objects (DTOs) in a layered architecture. It can also be used to map between different versions of an object, or to map between objects in different formats, such as JSON and XML. - -AutoMapper uses a convention-based approach to mapping, which means that it automatically maps properties with the same name and type from one object to another. It also provides a fluent API for configuring more complex mappings, such as ignoring certain properties, using custom logic to map properties, or mapping properties based on a value in another property. +AutoMapper is an object-to-object mapping library that eliminates the need for manual code when transforming one type of object into another. It works by using a convention-based approach to match properties between a source object and a destination object, which simplifies the process of flattening complex models into simpler Data Transfer Objects (DTOs). By automating the mapping logic, it reduces repetitive code and keeps the separation between domain models and external-facing representations clean. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/azure-pipelines@_-GQNpsb7KZw76hNNOq3h.md b/roadmaps/aspnet-core/content/azure-pipelines@_-GQNpsb7KZw76hNNOq3h.md index 55b9f0efd..c1933382c 100644 --- a/roadmaps/aspnet-core/content/azure-pipelines@_-GQNpsb7KZw76hNNOq3h.md +++ b/roadmaps/aspnet-core/content/azure-pipelines@_-GQNpsb7KZw76hNNOq3h.md @@ -1,8 +1,6 @@ # Azure Pipelines -Azure Pipelines is a continuous integration and continuous delivery (CI/CD) platform that allows developers to automate the process of building, testing, and deploying code. It is a part of the Azure DevOps suite of tools and can be used to automate the software development process for various languages and platforms, including [ASP.NET](http://ASP.NET). - -In [ASP.NET](http://ASP.NET), Azure Pipelines can be used to automate various tasks related to the development, testing, and deployment of [ASP.NET](http://ASP.NET) applications. For example, you can use Azure Pipelines to automatically build, test, and deploy an [ASP.NET](http://ASP.NET) application to a hosting provider, such as Azure or AWS, every time you push code to your source control repository. +Azure Pipelines is a cloud-based service that allows you to automatically build, test, and deploy your ASP.NET Core applications to any platform or cloud provider. It uses YAML configuration files to define continuous integration and continuous deployment workflows, which trigger automatically whenever you push code to your repository. This process automates the steps of compiling your code, running unit tests, and packaging your application into artifacts ready for deployment. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/blazor@4iD_hDtgJ15IlJGxiO-E8.md b/roadmaps/aspnet-core/content/blazor@4iD_hDtgJ15IlJGxiO-E8.md index a9b736b50..6212151c2 100644 --- a/roadmaps/aspnet-core/content/blazor@4iD_hDtgJ15IlJGxiO-E8.md +++ b/roadmaps/aspnet-core/content/blazor@4iD_hDtgJ15IlJGxiO-E8.md @@ -1,11 +1,6 @@ # Blazor -Blazor is a framework for building web applications using C# and .NET that runs in the browser via WebAssembly. It allows developers to write C# code that runs directly in the browser, eliminating the need for JavaScript. - -Blazor comes in two flavors: - -* Blazor WebAssembly, a client-side solution that allows you to run C# code directly in the browser using WebAssembly. The app is executed on the client-side and can work offline, it can also interact with JavaScript and access the browser's DOM. -* Blazor Server, a server-side solution that allows you to run C# code on the server and update the UI in real-time. The app is executed on the server-side and requires an active connection to the server to function. +Blazor is a web framework that allows developers to build interactive web user interfaces using C# instead of JavaScript. It runs .NET code directly in the browser via WebAssembly or handles UI updates on the server through a real-time connection. Because it shares the same language and libraries across both the client and server, developers can reuse their existing .NET code and business logic throughout the entire application. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/bogus@QERTjawqCCCkHfR44Ca0s.md b/roadmaps/aspnet-core/content/bogus@QERTjawqCCCkHfR44Ca0s.md index 1832ad5fc..038f25d37 100644 --- a/roadmaps/aspnet-core/content/bogus@QERTjawqCCCkHfR44Ca0s.md +++ b/roadmaps/aspnet-core/content/bogus@QERTjawqCCCkHfR44Ca0s.md @@ -1,3 +1,3 @@ # Bogus -Bogus is a simple, C#-friendly fake data generator. It lets you create realistic mock objects, lists, and data sets with a fluent API, making it easy to seed tests and demo applications with believable data. +Bogus is a simple, C#-friendly fake data generator. It lets you create realistic mock objects, lists, and data sets with a fluent API, making it easy to seed tests and demo applications with believable data. \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/cassandra@U_-Gt5csu_hihl7ybFY-B.md b/roadmaps/aspnet-core/content/cassandra@U_-Gt5csu_hihl7ybFY-B.md index 14687c0b1..4ed568005 100644 --- a/roadmaps/aspnet-core/content/cassandra@U_-Gt5csu_hihl7ybFY-B.md +++ b/roadmaps/aspnet-core/content/cassandra@U_-Gt5csu_hihl7ybFY-B.md @@ -1,8 +1,6 @@ # Cassandra -Apache Cassandra is a free and open-source, NoSQL, distributed, wide-column store, and high-performance database management system designed to handle large amounts of data across many commodity servers, providing high availability with no single point of failure. It is designed to handle large amounts of data across many commodity servers, providing high availability with no single point of failure. - -Cassandra is a column-family store and it stores data in a structured format, using tables and columns. It is based on a data model that is similar to that of Google's Bigtable, and it provides a query language that is similar to SQL. +Apache Cassandra is a distributed NoSQL database designed to handle large amounts of data across many commodity servers while providing high availability with no single point of failure. In an ASP.NET Core environment, it is typically accessed using the DataStax C# Driver, which allows developers to execute CQL (Cassandra Query Language) statements to read and write data. This database structure is particularly effective for managing massive datasets that require fast write speeds and horizontal scalability across multiple data centers. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/change-tracker-api@wfEOvAkGXkTZGdGX341D4.md b/roadmaps/aspnet-core/content/change-tracker-api@wfEOvAkGXkTZGdGX341D4.md index de2e9360d..35989630b 100644 --- a/roadmaps/aspnet-core/content/change-tracker-api@wfEOvAkGXkTZGdGX341D4.md +++ b/roadmaps/aspnet-core/content/change-tracker-api@wfEOvAkGXkTZGdGX341D4.md @@ -1,8 +1,6 @@ # Change Tracker API -The Change Tracker API is a feature of ORM (Object-Relational Mapping) frameworks, such as Entity Framework Core, that allows developers to track changes to entities and automatically persist them to the database. - -The Change Tracker API is typically exposed through the context class, which is the main class that manages the connection to the database and provides access to the entities. +The Change Tracker API is a feature within Entity Framework Core that monitors the state of entities loaded into the application's memory. It automatically detects modifications, additions, and deletions made to objects, keeping track of their current values compared to their original state. This mechanism allows the framework to determine which specific updates need to be synchronized with the database when the SaveChanges method is invoked. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/ci--cd@KIFmahcNiSo2NGoLtAyRR.md b/roadmaps/aspnet-core/content/ci--cd@KIFmahcNiSo2NGoLtAyRR.md index 88fa2c4e4..078b6ed76 100644 --- a/roadmaps/aspnet-core/content/ci--cd@KIFmahcNiSo2NGoLtAyRR.md +++ b/roadmaps/aspnet-core/content/ci--cd@KIFmahcNiSo2NGoLtAyRR.md @@ -1,8 +1,6 @@ -# CI CD +# CI/CD -CI/CD (Continuous Integration/Continuous Deployment) is a software development practice that involves automating the process of building, testing, and deploying code changes. It is a popular practice among software development teams, as it helps to ensure that code changes are integrated, tested, and deployed quickly and reliably. - -In the context of [ASP.NET](http://ASP.NET), CI/CD can be used to automate various tasks related to the development, testing, and deployment of [ASP.NET](http://ASP.NET) applications. For example, you can use CI/CD to automatically build, test, and deploy an [ASP.NET](http://ASP.NET) application to a hosting provider, such as Azure or AWS, every time you push code to your source control repository. +CI/CD stands for Continuous Integration and Continuous Deployment, representing a set of practices that automate the process of building, testing, and delivering software. Continuous Integration involves developers frequently merging their code changes into a central repository where automated builds and tests are executed to detect errors early. Continuous Deployment automates the release of these validated changes directly to production environments, allowing teams to deliver new features and bug fixes to users rapidly and reliably. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/circle-ci@KyGjXgG6JFo42qOV0wqfB.md b/roadmaps/aspnet-core/content/circle-ci@KyGjXgG6JFo42qOV0wqfB.md index 77a4b82d5..d62386013 100644 --- a/roadmaps/aspnet-core/content/circle-ci@KyGjXgG6JFo42qOV0wqfB.md +++ b/roadmaps/aspnet-core/content/circle-ci@KyGjXgG6JFo42qOV0wqfB.md @@ -1,8 +1,6 @@ # CircleCI -CircleCI is a cloud-based continuous integration and continuous delivery (CI/CD) platform that allows developers to automate the process of building, testing, and deploying code. It is a popular platform that supports a wide range of languages and frameworks, including [ASP.NET](http://ASP.NET). - -In [ASP.NET](http://ASP.NET), CircleCI can be used to automate various tasks related to the development, testing, and deployment of [ASP.NET](http://ASP.NET) applications. For example, you can use CircleCI to automatically build, test, and deploy an [ASP.NET](http://ASP.NET) application to a hosting provider, such as Azure or AWS, every time you push code to your source control repository. +CircleCI is a cloud-based continuous integration and continuous delivery platform that automates the building, testing, and deployment processes for software applications. It utilizes configuration files defined in YAML to manage workflows, allowing developers to execute automated tests and push builds to various environments whenever code changes are committed to a repository. The platform integrates directly with version control systems like GitHub or GitLab to provide feedback loops and streamline the delivery pipeline for ASP.NET Core projects. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/cloud@LrjmJs6_rXUkc2A7fEq24.md b/roadmaps/aspnet-core/content/cloud@LrjmJs6_rXUkc2A7fEq24.md index 3a3c8bdb7..5e382609e 100644 --- a/roadmaps/aspnet-core/content/cloud@LrjmJs6_rXUkc2A7fEq24.md +++ b/roadmaps/aspnet-core/content/cloud@LrjmJs6_rXUkc2A7fEq24.md @@ -1,8 +1,6 @@ -# Cloud +# Cloud Databases in ASP.NET Core -Cloud in the context of [ASP.NET](http://ASP.NET) refers to the use of cloud computing services to host and run [ASP.NET](http://ASP.NET) web applications. Cloud computing is a model of delivering computing resources (such as servers, storage, and applications) over the internet on a pay-per-use basis. - -In the case of [ASP.NET](http://ASP.NET), cloud providers such as Microsoft Azure, Amazon Web Services (AWS), and Google Cloud Platform (GCP) offer services specifically tailored to host and run [ASP.NET](http://ASP.NET) web applications. These services include virtual machines, web roles, and serverless computing, which can be used to deploy and run [ASP.NET](http://ASP.NET) web applications in the cloud. +Cloud databases are managed database services hosted on platforms like Azure, AWS, or Google Cloud that allow ASP.NET Core applications to store, retrieve, and manage data without maintaining on-premises physical servers. These services provide features such as automated backups, high availability, and horizontal scaling to handle varying workloads. Developers integrate these databases into their applications using connection strings and Entity Framework Core, which acts as an abstraction layer to communicate with cloud-based providers like Azure SQL Database, Cosmos DB, or PostgreSQL. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/code-first--migrations@ZPeebwJ3OBuywEgLLgQTG.md b/roadmaps/aspnet-core/content/code-first--migrations@ZPeebwJ3OBuywEgLLgQTG.md index 59b16a03b..7fcdd06ae 100644 --- a/roadmaps/aspnet-core/content/code-first--migrations@ZPeebwJ3OBuywEgLLgQTG.md +++ b/roadmaps/aspnet-core/content/code-first--migrations@ZPeebwJ3OBuywEgLLgQTG.md @@ -1,8 +1,6 @@ -# Code First Migrations +# Code First and Migrations in Entity Framework Core -Code First Migrations is a feature of Entity Framework that enables you to change the model classes in your application and then propagate those changes to the database. When you use Code First Migrations, Entity Framework generates the necessary SQL commands to update the database schema to match the model classes. - -To use Code First Migrations, you need to enable it in your Entity Framework application. This can be done by adding a reference to the Entity Framework Migrations NuGet package, and then enabling Migrations in your application. +Code First is a development approach where you define your application's data models as C# classes, and Entity Framework Core generates the corresponding database schema from those classes. Migrations serve as a version control system for your database, tracking changes made to your C# models over time. When you modify your classes, you create a migration file that captures the difference between the current state of your code and the previous database structure. These migration files are then applied to the database to ensure the schema remains synchronized with the application code. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/constraints@1-XdtrGPbUoxpu9ZcQlBA.md b/roadmaps/aspnet-core/content/constraints@1-XdtrGPbUoxpu9ZcQlBA.md index 0dbb43f79..a7df4af13 100644 --- a/roadmaps/aspnet-core/content/constraints@1-XdtrGPbUoxpu9ZcQlBA.md +++ b/roadmaps/aspnet-core/content/constraints@1-XdtrGPbUoxpu9ZcQlBA.md @@ -1,6 +1,6 @@ # Constraints -Database constraints are rules that are used to limit the data that can be stored in a database table. These constraints can be used to ensure the integrity and accuracy of the data in the table, and they can be used to enforce business rules or other requirements. For example, a constraint might be used to ensure that a column only contains positive numbers, or to ensure that a column always has a unique value. Constraints can be specified at the time a table is created, or they can be added to an existing table. Some common types of constraints include primary keys, foreign keys, and NOT NULL constraints. +Constraints are rules applied to columns in a database table to limit the type of data that can be inserted, ensuring accuracy and reliability. Common examples include Primary Keys, which uniquely identify each record, Foreign Keys, which maintain relationships between tables, and Unique constraints, which prevent duplicate values in a column. Additionally, Not Null constraints ensure that a field must contain a value, while Check constraints enforce specific logical conditions on the data. These rules are managed within the database schema to maintain the integrity of the information stored in the application. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/coravel@p3bZnKIyRgLmB764Kkhju.md b/roadmaps/aspnet-core/content/coravel@p3bZnKIyRgLmB764Kkhju.md index c3c7a56f7..64dc23f66 100644 --- a/roadmaps/aspnet-core/content/coravel@p3bZnKIyRgLmB764Kkhju.md +++ b/roadmaps/aspnet-core/content/coravel@p3bZnKIyRgLmB764Kkhju.md @@ -1,8 +1,6 @@ # Coravel -Coravel is an open-source, lightweight library for .NET that allows you to easily perform background processing and scheduling in your [ASP.NET](http://ASP.NET) Core application. It provides a simple and elegant way to schedule tasks, run background jobs, and manage queues in your application. - -Coravel is inspired by Laravel's task scheduler and it's built on top of the .NET Core built-in Dependency Injection. It uses a fluent API to schedule tasks, allowing you to easily specify the frequency, start time, and end time of the task. It also provides a simple way to queue and process background jobs, allowing you to easily process large amounts of data or perform long-running tasks. +Coravel is a library that provides a fluent and easy-to-use syntax for handling common application tasks within ASP.NET Core, such as task scheduling, queuing, and background processing. It acts as a lightweight wrapper around native .NET features, allowing developers to manage complex background operations without needing to configure external dependencies or complex infrastructure. By using its built-in service provider, you can define recurring tasks and event-driven processes directly within your application code. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/cosmos-db@KrkV1w9b_Nwm6pe9diDRS.md b/roadmaps/aspnet-core/content/cosmos-db@KrkV1w9b_Nwm6pe9diDRS.md index c34fd8688..1defb3a6b 100644 --- a/roadmaps/aspnet-core/content/cosmos-db@KrkV1w9b_Nwm6pe9diDRS.md +++ b/roadmaps/aspnet-core/content/cosmos-db@KrkV1w9b_Nwm6pe9diDRS.md @@ -1,4 +1,6 @@ -# CosmosDB +# Cosmos DB + +Azure Cosmos DB is a fully managed, NoSQL database service designed for high availability and low-latency access to data at any scale. It supports multiple data models, including document, key-value, graph, and column-family, allowing developers to choose the structure that best fits their application needs. Within ASP.NET Core, it integrates seamlessly through the Azure Cosmos DB .NET SDK, enabling efficient storage, retrieval, and querying of JSON documents in a globally distributed environment. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/couchdb@vHcwt6ARi5YR3v-eDDjfl.md b/roadmaps/aspnet-core/content/couchdb@vHcwt6ARi5YR3v-eDDjfl.md index 6761ebb48..7e5042714 100644 --- a/roadmaps/aspnet-core/content/couchdb@vHcwt6ARi5YR3v-eDDjfl.md +++ b/roadmaps/aspnet-core/content/couchdb@vHcwt6ARi5YR3v-eDDjfl.md @@ -1,8 +1,6 @@ # CouchDB -CouchDB is an open-source, NoSQL document database designed for the web. It uses a document-oriented data model, which means that it stores data in semi-structured JSON format, and it is designed to be simple and easy to use. CouchDB provides a built-in web interface, called Futon, which can be used to interact with the database, and it also provides an HTTP API that can be used to interact with the database from an [ASP.NET](http://ASP.NET) application. - -In an [ASP.NET](http://ASP.NET) application, CouchDB can be used as a data store to persist and retrieve application data. There are several libraries available for integrating CouchDB with an [ASP.NET](http://ASP.NET) application, such as Couchbase, which provides a .NET client for CouchDB that can be used to interact with the CouchDB server from within an [ASP.NET](http://ASP.NET) application. +CouchDB is an open-source, document-oriented NoSQL database that stores data in JSON format. It is designed to be highly available and handles data synchronization across multiple servers or devices using a master-master replication model. Interactions with the database occur through a RESTful HTTP API, allowing developers to perform CRUD operations using standard web requests. Because it is schema-free, it provides the flexibility to store complex, hierarchical data structures that can evolve over time without requiring extensive database migrations. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/dapper@UkWc41r0bZ1lptjse3As6.md b/roadmaps/aspnet-core/content/dapper@UkWc41r0bZ1lptjse3As6.md index 4981c3bb9..4032769c5 100644 --- a/roadmaps/aspnet-core/content/dapper@UkWc41r0bZ1lptjse3As6.md +++ b/roadmaps/aspnet-core/content/dapper@UkWc41r0bZ1lptjse3As6.md @@ -1,8 +1,6 @@ # Dapper -Dapper is a lightweight object-relational mapper (ORM) for the .NET framework. It is designed to provide fast and simple access to data stored in a database, by mapping the data to objects in the application. - -Dapper helps you to write efficient and concise code for interacting with databases, without the need for a full-featured ORM like Entity Framework. It provides a set of extension methods for the IDbConnection interface, which you can use to execute SQL queries and map the results to strongly-typed objects. +Dapper is a lightweight, open-source object-relational mapper for .NET that acts as a thin wrapper over the ADO.NET `IDbConnection` interface. It maps database query results directly to plain old CLR objects by executing raw SQL statements provided by the developer. This tool focuses on high performance and minimal overhead by avoiding the complex abstraction layers found in full-featured ORMs. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/data-structures-and-algorithms@RAX2xN37taw9cqA3pnORh.md b/roadmaps/aspnet-core/content/data-structures-and-algorithms@RAX2xN37taw9cqA3pnORh.md index ddb8a2c26..37bbc2240 100644 --- a/roadmaps/aspnet-core/content/data-structures-and-algorithms@RAX2xN37taw9cqA3pnORh.md +++ b/roadmaps/aspnet-core/content/data-structures-and-algorithms@RAX2xN37taw9cqA3pnORh.md @@ -4,7 +4,7 @@ As the name indicates, a **Data Structure** is a way of organizing the data in t Visit the following resources to learn more: +- [@roadmap@Visit the Dedicated DSA Roadmap](https://roadmap.sh/datastructures-and-algorithms) - [@article@C# resources](https://dev.to/adavidoaiei/fundamental-data-structures-and-algorithms-in-c-4ocf) - [@article@Interview Questions about Data Structures](https://www.csharpstar.com/csharp-algorithms/) -- [@video@Data Structures Illustrated](https://www.youtube.com/watch?v=9rhT3P1MDHk&list=PLkZYeFmDuaN2-KUIv-mvbjfKszIGJ4FaY) -- [@feed@Explore top posts about Algorithms](https://app.daily.dev/tags/algorithms?ref=roadmapsh) \ No newline at end of file +- [@video@Data Structures Illustrated](https://www.youtube.com/watch?v=9rhT3P1MDHk&list=PLkZYeFmDuaN2-KUIv-mvbjfKszIGJ4FaY) \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/database-fundamentals@tnKUdsgp6bnFtQTexEmfy.md b/roadmaps/aspnet-core/content/database-fundamentals@tnKUdsgp6bnFtQTexEmfy.md index 3d8206a4c..f766d41a5 100644 --- a/roadmaps/aspnet-core/content/database-fundamentals@tnKUdsgp6bnFtQTexEmfy.md +++ b/roadmaps/aspnet-core/content/database-fundamentals@tnKUdsgp6bnFtQTexEmfy.md @@ -1,17 +1,10 @@ -# Database fundamentals +# Database Fundamentals -A database is a collection of useful data of one or more related organizations structured in a way to make data an asset to the organization. A database management system is a software designed to assist in maintaining and extracting large collections of data in a timely fashion. - -A **Relational database** is a type of database that stores and provides access to data points that are related to one another. Relational databases store data in a series of tables. - -**NoSQL databases** offer data storage and retrieval that is modelled differently to "traditional" relational databases. NoSQL databases typically focus more on horizontal scaling, eventual consistency, speed and flexibility and is used commonly for big data and real-time streaming applications. +Database fundamentals involve the core concepts of storing, organizing, and retrieving data within software applications. This includes understanding relational databases, which store data in structured tables, and non-relational databases, which handle unstructured or semi-structured data. Developers interact with these systems using tools like SQL to perform operations such as creating, reading, updating, and deleting records. Mastering these basics ensures data integrity, efficient query performance, and reliable application state management. Visit the following resources to learn more: - [@article@Oracle: What is a Database?](https://www.oracle.com/database/what-is-database/) - [@article@Prisma.io: What are Databases?](https://www.prisma.io/dataguide/intro/what-are-databases) - [@article@Intro To Relational Databases](https://www.udacity.com/course/intro-to-relational-databases--ud197) -- [@article@NoSQL Explained](https://www.mongodb.com/nosql-explained) -- [@video@What is Relational Database](https://youtu.be/OqjJjpjDRLc) -- [@video@How do NoSQL Databases work](https://www.youtube.com/watch?v=0buKQHokLK8) -- [@feed@Explore top posts about Database](https://app.daily.dev/tags/database?ref=roadmapsh) \ No newline at end of file +- [@article@NoSQL Explained](https://www.mongodb.com/nosql-explained) \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/databases@Ujzn_dILCA7xoupnz398l.md b/roadmaps/aspnet-core/content/databases@Ujzn_dILCA7xoupnz398l.md index 79b6404fd..21cc01e80 100644 --- a/roadmaps/aspnet-core/content/databases@Ujzn_dILCA7xoupnz398l.md +++ b/roadmaps/aspnet-core/content/databases@Ujzn_dILCA7xoupnz398l.md @@ -1,14 +1,6 @@ # Databases -In an [ASP.NET](http://ASP.NET) application, there are several types of databases that can be used to store and retrieve data. Some of the most commonly used databases include: - -* Relational databases -* NoSQL databases -* In-memory databases -* Embedded databases -* Cloud-based databases - -Each database type has its own set of features and use cases, and the choice of which database to use will depend on the specific requirements of the application. +Databases in ASP.NET Core serve as persistent storage systems that allow applications to save, retrieve, and manage structured data. Developers typically interact with these systems using Entity Framework Core, an object-relational mapper that bridges the gap between database tables and C# objects. This setup enables applications to perform complex queries and transactions while maintaining a clear separation between the data access layer and the business logic of the application. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/dependency-injection@IejHMMVKwA0sIInla4FjX.md b/roadmaps/aspnet-core/content/dependency-injection@IejHMMVKwA0sIInla4FjX.md index 92a4b567d..2f1107906 100644 --- a/roadmaps/aspnet-core/content/dependency-injection@IejHMMVKwA0sIInla4FjX.md +++ b/roadmaps/aspnet-core/content/dependency-injection@IejHMMVKwA0sIInla4FjX.md @@ -1,8 +1,6 @@ # Dependency Injection -Dependency injection (DI) is a software design pattern that is used to manage the dependencies of an application. It is a technique that allows developers to write loosely-coupled code, by separating the responsibility of creating and managing objects from the objects themselves. - -In a typical implementation, a DI container is used to manage the dependencies of the application. The container is responsible for creating and managing instances of objects and their dependencies, and providing them to other objects as needed. +Dependency Injection is a software design pattern that allows a class to receive its dependencies from an external source rather than creating them internally. In ASP.NET Core, this pattern is built directly into the framework to manage the lifetime and instantiation of services throughout an application. By using this approach, components remain decoupled, making the codebase easier to test, maintain, and scale. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/di-containers@iM760f8Ys66-VSkMiZfIX.md b/roadmaps/aspnet-core/content/di-containers@iM760f8Ys66-VSkMiZfIX.md index 6d254ef93..b28b9078d 100644 --- a/roadmaps/aspnet-core/content/di-containers@iM760f8Ys66-VSkMiZfIX.md +++ b/roadmaps/aspnet-core/content/di-containers@iM760f8Ys66-VSkMiZfIX.md @@ -1,8 +1,6 @@ # DI Containers -A dependency injection (DI) container is a software component that is responsible for managing the dependencies of an application. It is used to create and manage instances of objects and their dependencies, and is particularly useful for implementing the Dependency Inversion Principle in software development. - -A DI container typically consists of two main parts: a configuration API, which is used to register the types and their dependencies, and a resolution API, which is used to retrieve instances of the registered types. The DI container automatically resolves the dependencies of the objects it creates, and manages the lifetime of the objects and their dependencies. +A DI container is a framework component that manages the instantiation and lifetime of objects in an application. It acts as a central registry where you define which implementations should be provided for specific interfaces or base classes. When an application requests a service, the container automatically resolves the dependencies, injects them into the class, and manages their disposal according to the defined service lifetime. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/distributed-lock@T2FsSndxzSuKTFdjoyPi-.md b/roadmaps/aspnet-core/content/distributed-lock@T2FsSndxzSuKTFdjoyPi-.md index 4c7a907e7..d9fcabd2b 100644 --- a/roadmaps/aspnet-core/content/distributed-lock@T2FsSndxzSuKTFdjoyPi-.md +++ b/roadmaps/aspnet-core/content/distributed-lock@T2FsSndxzSuKTFdjoyPi-.md @@ -1,3 +1,3 @@ # Distributed Lock -A distributed lock coordinates access to a shared resource across multiple processes or services. It prevents concurrent modifications and race conditions by ensuring only one client holds the lock at a time, typically backed by a store such as Redis, ZooKeeper, or a database. +A distributed lock coordinates access to a shared resource across multiple processes or services. It prevents concurrent modifications and race conditions by ensuring only one client holds the lock at a time, typically backed by a store such as Redis, ZooKeeper, or a database. \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/docker@rmRESzLiZNWdBFXLrwQFJ.md b/roadmaps/aspnet-core/content/docker@rmRESzLiZNWdBFXLrwQFJ.md index af4d1dca9..32b8af025 100644 --- a/roadmaps/aspnet-core/content/docker@rmRESzLiZNWdBFXLrwQFJ.md +++ b/roadmaps/aspnet-core/content/docker@rmRESzLiZNWdBFXLrwQFJ.md @@ -1,12 +1,10 @@ # Docker -Docker is a platform for developing, shipping, and running applications in containers. A container is a lightweight, standalone, and executable package of software that includes everything needed to run a piece of software, including the code, a runtime, system tools, libraries, and settings. - -Docker allows developers to package their applications and dependencies into a container, which can then be easily deployed and run on any host machine with Docker installed. This makes it easy to run the same software on different environments, such as development, staging, and production, without worrying about compatibility issues.s +Docker is an open-source platform that automates the deployment of applications inside lightweight, portable containers. It packages an ASP.NET Core application along with its dependencies, libraries, and runtime environment into a single unit to ensure consistent behavior across different computing environments. Developers use Docker to isolate services from one another, making it easier to build, test, and deploy microservices within a distributed architecture. Visit the following resources to learn more: +- [@roadmap@Visit the Dedicated Docker Roadmap](https://roadmap.sh/docker) - [@article@ASP.NET and Docker](https://www.tatvasoft.com/blog/asp-net-core-and-docker/) - [@article@Introduction to .NET and Docker](https://learn.microsoft.com/en-us/dotnet/core/docker/introduction) -- [@video@What is Docker, Why use it?](https://www.youtube.com/watch?v=vmnvOITMoIg) -- [@feed@Explore top posts about Docker](https://app.daily.dev/tags/docker?ref=roadmapsh) \ No newline at end of file +- [@video@What is Docker, Why use it?](https://www.youtube.com/watch?v=vmnvOITMoIg) \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/dynamo-db@1Om9aQDZmnj_DN10ogwDL.md b/roadmaps/aspnet-core/content/dynamo-db@1Om9aQDZmnj_DN10ogwDL.md index 4338e02ae..0b7156ae4 100644 --- a/roadmaps/aspnet-core/content/dynamo-db@1Om9aQDZmnj_DN10ogwDL.md +++ b/roadmaps/aspnet-core/content/dynamo-db@1Om9aQDZmnj_DN10ogwDL.md @@ -1,8 +1,6 @@ # DynamoDB -Amazon DynamoDB is a fully-managed, NoSQL database service provided by Amazon Web Services (AWS) that can be used to store and retrieve large amounts of data. It is a highly-scalable, fast, and flexible NoSQL database service that supports both document and key-value data models. - -DynamoDB is designed to handle extremely high levels of read and write throughput, and it automatically scales to accommodate the traffic of an application. It also provides built-in support for data replication, allowing data to be automatically spread across multiple availability zones for increased durability and availability. +DynamoDB is a fully managed, serverless NoSQL database service provided by Amazon Web Services that supports key-value and document data structures. In ASP.NET Core applications, it is used to store and retrieve data with consistent single-digit millisecond latency at any scale. Developers typically interact with this service using the AWS SDK for .NET, which provides a high-level Object Persistence Model or a lower-level document model to perform CRUD operations on tables. Because it is schema-less, it allows for flexible data modeling and automatic scaling of throughput capacity to meet the demands of high-traffic web applications. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/easynetq@X6iSHoHnFFMaGb6YPQFhl.md b/roadmaps/aspnet-core/content/easynetq@X6iSHoHnFFMaGb6YPQFhl.md index 2955ad172..bf820a1c7 100644 --- a/roadmaps/aspnet-core/content/easynetq@X6iSHoHnFFMaGb6YPQFhl.md +++ b/roadmaps/aspnet-core/content/easynetq@X6iSHoHnFFMaGb6YPQFhl.md @@ -1,8 +1,6 @@ # EasyNetQ -EasyNetQ is a simple and easy-to-use .NET client for RabbitMQ, a popular open-source message broker. It provides a simple and fluent API for connecting to RabbitMQ, publishing and consuming messages, and managing message queues. - -EasyNetQ supports a wide range of messaging patterns, such as publish-subscribe, request-response, and message-based sagas, and makes it easy to work with RabbitMQ's advanced features, such as message routing, message persistence, and message acknowledgements. +EasyNetQ is a thin, open-source .NET client library for RabbitMQ that simplifies the process of sending and receiving messages. It provides a high-level API that handles complex tasks like connection management, serialization, and exchange or queue declarations automatically. Developers use it to facilitate asynchronous communication between microservices by abstracting the lower-level details of the RabbitMQ C# driver. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/elastic-search@mK9OAwjReZoQZr1WSLRKJ.md b/roadmaps/aspnet-core/content/elastic-search@mK9OAwjReZoQZr1WSLRKJ.md index 6aa978031..0ab7cfa3e 100644 --- a/roadmaps/aspnet-core/content/elastic-search@mK9OAwjReZoQZr1WSLRKJ.md +++ b/roadmaps/aspnet-core/content/elastic-search@mK9OAwjReZoQZr1WSLRKJ.md @@ -4,7 +4,7 @@ Elasticsearch is a distributed, open-source search and analytics engine that can Visit the following resources to learn more: +- [@roadmap@Visit the Dedicated Elasticsearch Roadmap](https://roadmap.sh/elasticsearch) - [@article@Elasticsearch in ASP.NET Core](https://code-maze.com/elasticsearch-aspnet-core/) - [@article@An Elasticsearch Tutorial for .NET Developers](https://www.toptal.com/dot-net/elasticsearch-dot-net-developers) -- [@article@How to integrate ElasticSearch in ASP.NET?](https://blexin.com/en/blog-en/how-to-integrate-elasticsearch-in-asp-net-core/) -- [@feed@Explore top posts about ELK](https://app.daily.dev/tags/elk?ref=roadmapsh) \ No newline at end of file +- [@article@How to integrate ElasticSearch in ASP.NET?](https://blexin.com/en/blog-en/how-to-integrate-elasticsearch-in-asp-net-core/) \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/entity-framework-2nd-level-cache@FV4GsPjUyAc99DnIwkkCC.md b/roadmaps/aspnet-core/content/entity-framework-2nd-level-cache@FV4GsPjUyAc99DnIwkkCC.md index 1098f0f60..f7f2487ee 100644 --- a/roadmaps/aspnet-core/content/entity-framework-2nd-level-cache@FV4GsPjUyAc99DnIwkkCC.md +++ b/roadmaps/aspnet-core/content/entity-framework-2nd-level-cache@FV4GsPjUyAc99DnIwkkCC.md @@ -1,8 +1,6 @@ -# Entity Framework Cache +# Entity Framework 2nd Level Cache -Entity Framework Core(EF Core) is a cross-platform version of the popular Entity Framework data access technology that is lightweight, extendable, and open source. It can be used as an object-relational mapper (O/RM), which can Allow .NET developers to use .NET objects to interact with a database and Removes the requirement for most of the data-access code that is generally required. - -However, during peak loads, high-transaction .NET Core apps using EF Core have performance and scalability problems in the database tier. This is because, although you can scale the application layer by adding more application servers, you can't scale the database tier by adding more database servers. +Entity Framework 2nd Level Cache is a caching mechanism that stores the results of database queries in memory to reduce the number of redundant trips to the database. When an application requests data, the system first checks the cache; if the data is already stored there, it retrieves it directly, bypassing the database execution. This process significantly improves application performance and minimizes database load for frequently accessed, read-heavy data. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/fakeiteasy@diRJ_F6kx42Ucs0fxidtZ.md b/roadmaps/aspnet-core/content/fakeiteasy@diRJ_F6kx42Ucs0fxidtZ.md index 50e9f3a92..4a5145a48 100644 --- a/roadmaps/aspnet-core/content/fakeiteasy@diRJ_F6kx42Ucs0fxidtZ.md +++ b/roadmaps/aspnet-core/content/fakeiteasy@diRJ_F6kx42Ucs0fxidtZ.md @@ -1,6 +1,6 @@ -# FakeitEasy +# FakeItEasy -FakeItEasy is an open-source library for .NET that allows developers to create fake objects for use in unit testing, it is a powerful and easy-to-use mocking framework that provides a simple and intuitive syntax for creating fake objects and setting up fake behavior. In the context of [ASP.NET](http://ASP.NET), FakeItEasy can be used to create fake objects for testing web applications built using the [ASP.NET](http://ASP.NET) framework, it provides a simple and expressive syntax for creating fake objects and setting up fake behavior. FakeItEasy supports a wide range of testing frameworks, including MSTest, NUnit, and xUnit. FakeItEasy is lightweight and easy to use, making it a good choice for developers who are new to mocking and unit testing, it also provides a rich set of features, such as support for setting up fake behavior, making assertions on calls made to the fake objects, and more. It also has a wide range of extension points for customizing the fakes to suit different needs. +FakeItEasy is a popular mocking library for .NET that allows developers to create fake objects for unit tests with a simple and readable syntax. It simplifies the process of stubbing methods, properties, and events, enabling you to isolate the code being tested from its dependencies. By providing a fluent API, it helps in defining the behavior of objects that are not yet implemented or are difficult to instantiate in a test environment. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/fluid@ZaOhWWDgVxrn0hbesJ7xT.md b/roadmaps/aspnet-core/content/fluid@ZaOhWWDgVxrn0hbesJ7xT.md index 1946c8a8f..04f6365c3 100644 --- a/roadmaps/aspnet-core/content/fluid@ZaOhWWDgVxrn0hbesJ7xT.md +++ b/roadmaps/aspnet-core/content/fluid@ZaOhWWDgVxrn0hbesJ7xT.md @@ -1,6 +1,6 @@ # Fluid -Fluid is a template engine for .NET that is based on the Fluid template language, it is similar to Liquid, but it's written in C#. It provides a simple and easy-to-use API for parsing and rendering templates, and supports a wide range of features such as variables, loops, conditionals, and functions. It also provides a wide range of built-in functions for working with strings, numbers, dates, and other types of data. It also supports advanced features such as scripting and metaprogramming. It is often used in web applications to separate the logic of the application from the presentation of the data, making it easy to change the appearance of the application without having to change the underlying code. +Fluid is an open-source template engine for .NET that serves as a .NET implementation of the Liquid template language. It allows developers to create and render text-based templates that are secure, portable, and independent of the underlying application logic. By parsing templates into an abstract syntax tree, it enables efficient execution and provides a sandboxed environment to prevent unauthorized access to sensitive system data during the rendering process. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/framework-basics@eGVaAz3VhGu3cXBNxTAWd.md b/roadmaps/aspnet-core/content/framework-basics@eGVaAz3VhGu3cXBNxTAWd.md index 6be1a7176..31e50c4a6 100644 --- a/roadmaps/aspnet-core/content/framework-basics@eGVaAz3VhGu3cXBNxTAWd.md +++ b/roadmaps/aspnet-core/content/framework-basics@eGVaAz3VhGu3cXBNxTAWd.md @@ -1,8 +1,6 @@ -# Framework Basics +# Entity Framework Core Framework Basics -An ORM (Object-Relational Mapping) framework is a tool that maps the objects in an application to the database tables, allowing developers to work with the database using familiar, object-oriented concepts. - -ORM frameworks are tools that map the objects in an application to the database tables, allowing developers to work with the database using familiar, object-oriented concepts such as Entities, Mapping, Context, Queries, Lazy Loading, Change Tracking, and Caching. +Entity Framework Core is a lightweight, extensible, and cross-platform version of the popular Entity Framework data access technology. It acts as an object-database mapper that enables .NET developers to work with a database using .NET objects. This framework eliminates the need for most of the data-access code that developers usually need to write, allowing them to perform database operations through strongly-typed LINQ queries. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/frameworks@1YL7aXluINOO15W3waaiD.md b/roadmaps/aspnet-core/content/frameworks@1YL7aXluINOO15W3waaiD.md index 188d34a8d..53f3a23ce 100644 --- a/roadmaps/aspnet-core/content/frameworks@1YL7aXluINOO15W3waaiD.md +++ b/roadmaps/aspnet-core/content/frameworks@1YL7aXluINOO15W3waaiD.md @@ -1,3 +1,3 @@ # Frameworks -.NET offers a range of frameworks built on the base runtime, each addressing a specific domain: ASP.NET Core for web applications and APIs, EF Core for data access, and .NET MAUI for cross-platform client apps. Choosing the right framework for the job is one of the first decisions when starting a new .NET project. +.NET offers a range of frameworks built on the base runtime, each addressing a specific domain: [ASP.NET](http://ASP.NET) Core for web applications and APIs, EF Core for data access, and .NET MAUI for cross-platform client apps. Choosing the right framework for the job is one of the first decisions when starting a new .NET project. \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/general-development-skills@NEnna_8DstfYH4T9qrP3-.md b/roadmaps/aspnet-core/content/general-development-skills@NEnna_8DstfYH4T9qrP3-.md index 942235f4d..c988415b6 100644 --- a/roadmaps/aspnet-core/content/general-development-skills@NEnna_8DstfYH4T9qrP3-.md +++ b/roadmaps/aspnet-core/content/general-development-skills@NEnna_8DstfYH4T9qrP3-.md @@ -1,20 +1,6 @@ -# General development skills +# General Development Skills -There are several skills that are generally considered to be important for working with .NET and C#: - -* Object-oriented programming: Understanding the concepts of classes, objects, inheritance, and polymorphism is essential for working with C# and the .NET Framework. - -* C# language: A strong understanding of the C# language, including its syntax, keywords, and built-in classes and types, is necessary for writing efficient and maintainable code. - -* .NET Framework: Familiarity with the .NET Framework, including the Common Language Runtime (CLR) and the Base Class Library (BCL), is important for understanding how C# code is executed and for utilizing the framework's many built-in features. - -* Web & Software development: Knowledge of web development technologies such as HTML, CSS, JavaScript, and [ASP.NET](http://ASP.NET) is important for creating web applications using C# and the .NET Framework and knowledge of software development methodologies such as Agile, Scrum, or Waterfall is also useful. - -* Database: Familiarity with database concepts and technologies, such as SQL and [ADO.NET](http://ADO.NET), is important for working with data in C# applications. - -* Cloud computing: Familiarity with cloud computing concepts and technologies, such as Azure, is becoming increasingly important for deploying and scaling C# applications. - -* DevOps: Understanding of DevOps concepts and practices, such as continuous integration and continuous deployment, is necessary for automating and streamlining the software development process. +General development skills represent the foundational knowledge and practices that enable a programmer to write, maintain, and troubleshoot software effectively. These skills include proficiency in version control systems like Git, a solid understanding of data structures and algorithms, and the ability to apply clean coding principles such as SOLID and DRY. Mastery of these fundamentals allows developers to work efficiently within team environments, manage complex codebases, and bridge the gap between architectural concepts and functional code. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/git---version-control@OtdCmkj0SvrGwCUSfm96C.md b/roadmaps/aspnet-core/content/git---version-control@OtdCmkj0SvrGwCUSfm96C.md index 47bc38770..7930f5169 100644 --- a/roadmaps/aspnet-core/content/git---version-control@OtdCmkj0SvrGwCUSfm96C.md +++ b/roadmaps/aspnet-core/content/git---version-control@OtdCmkj0SvrGwCUSfm96C.md @@ -4,7 +4,7 @@ Visit the following resources to learn more: +- [@roadmap@Visit the Dedicated Git & GitHub Roadmap](https://roadmap.sh/git-github) - [@article@Learn Git with Tutorials, News and Tips - Atlassian](https://www.atlassian.com/git) - [@article@Git Cheat Sheet](https://cs.fyi/guide/git-cheatsheet) -- [@video@Git & GitHub Crash Course For Beginners](https://www.youtube.com/watch?v=SWYqp7iY_Tc) -- [@feed@Explore top posts about Git](https://app.daily.dev/tags/git?ref=roadmapsh) \ No newline at end of file +- [@video@Git & GitHub Crash Course For Beginners](https://www.youtube.com/watch?v=SWYqp7iY_Tc) \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/github-actions@0-PLMXGlRyRzTk-EjXMs2.md b/roadmaps/aspnet-core/content/github-actions@0-PLMXGlRyRzTk-EjXMs2.md index 29311b835..4ea88086b 100644 --- a/roadmaps/aspnet-core/content/github-actions@0-PLMXGlRyRzTk-EjXMs2.md +++ b/roadmaps/aspnet-core/content/github-actions@0-PLMXGlRyRzTk-EjXMs2.md @@ -1,8 +1,6 @@ # GitHub Actions -GitHub Actions is a powerful and flexible automation platform that enables developers to create custom workflows for their software development lifecycle (SDLC) directly in their GitHub repository. It allows developers to automate various tasks, such as building, testing, and deploying code, directly from their GitHub repository. - -In [ASP.NET](http://ASP.NET), GitHub Actions can be used to automate various tasks related to the development, testing, and deployment of [ASP.NET](http://ASP.NET) applications. For example, you can use GitHub Actions to automatically build, test, and deploy an [ASP.NET](http://ASP.NET) application to a hosting provider, such as Azure or AWS, every time you push code to your GitHub repository. +GitHub Actions is a continuous integration and continuous deployment platform that allows developers to automate their software workflows directly within a GitHub repository. It enables the creation of automated pipelines that build, test, and deploy ASP.NET Core applications whenever code changes are pushed. These workflows are defined using YAML files, which trigger specific tasks such as compiling the source code, running unit tests, and publishing artifacts to cloud environments like Azure or AWS. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/gitlab-cicd@8Y73Ae32eo6_ye7dw5QRQ.md b/roadmaps/aspnet-core/content/gitlab-cicd@8Y73Ae32eo6_ye7dw5QRQ.md index 3f7ae7a14..6e6525e5b 100644 --- a/roadmaps/aspnet-core/content/gitlab-cicd@8Y73Ae32eo6_ye7dw5QRQ.md +++ b/roadmaps/aspnet-core/content/gitlab-cicd@8Y73Ae32eo6_ye7dw5QRQ.md @@ -1,3 +1,3 @@ # GitLab CI/CD -GitLab CI/CD is the continuous integration and delivery tooling built into GitLab. Pipelines are defined in a `.gitlab-ci.yml` file, where jobs run on GitLab runners to build, test, and deploy your application automatically on every change. +GitLab CI/CD is the continuous integration and delivery tooling built into GitLab. Pipelines are defined in a `.gitlab-ci.yml` file, where jobs run on GitLab runners to build, test, and deploy your application automatically on every change. \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/graphql@BdTQ5ZMNDNZvkAUoCfL5H.md b/roadmaps/aspnet-core/content/graphql@BdTQ5ZMNDNZvkAUoCfL5H.md index 7b4a339be..1f4cf6cdf 100644 --- a/roadmaps/aspnet-core/content/graphql@BdTQ5ZMNDNZvkAUoCfL5H.md +++ b/roadmaps/aspnet-core/content/graphql@BdTQ5ZMNDNZvkAUoCfL5H.md @@ -1,12 +1,10 @@ # GraphQL -GraphQL is a query language for your API that allows clients to define the structure of the data they need, and the server will return only the requested data. It is an alternative to RESTful web services, and it is gaining popularity because of its flexibility and efficiency. - -In [ASP.NET](http://ASP.NET), GraphQL can be used to create web services that expose data in a more flexible and efficient way. There are several libraries available to implement GraphQL in an [ASP.NET](http://ASP.NET) application, such as [GraphQL.NET](http://GraphQL.NET), Hot Chocolate, and others. These libraries provide a set of classes and methods that make it easy to create a GraphQL schema, handle requests, and generate responses. +GraphQL is a query language for APIs that allows clients to request exactly the data they need from a server. It provides a structured approach to data fetching by using a single endpoint and a strongly-typed schema to define the available capabilities. This technology enables developers to combine multiple data sources into a unified interface, which prevents the problems of over-fetching or under-fetching information. Visit the following resources to learn more: +- [@roadmap@Visit the Dedicated GraphQL Roadmap](https://roadmap.sh/graphql) - [@article@How to implement GraphQL in ASP.Net](https://blog.christian-schou.dk/how-to-implement-graphql-in-asp-net-core/) - [@article@Intro to GraphQL](https://graphql-dotnet.github.io/docs/getting-started/introduction/) -- [@article@Developing API In .NET Core With GraphQL](https://www.c-sharpcorner.com/article/building-api-in-net-core-with-graphql2/) -- [@feed@Explore top posts about GraphQL](https://app.daily.dev/tags/graphql?ref=roadmapsh) \ No newline at end of file +- [@article@Developing API In .NET Core With GraphQL](https://www.c-sharpcorner.com/article/building-api-in-net-core-with-graphql2/) \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/grpc@x3SJlLc19DNJ-PyDOOj_G.md b/roadmaps/aspnet-core/content/grpc@x3SJlLc19DNJ-PyDOOj_G.md index f7afeed31..138a0ab6c 100644 --- a/roadmaps/aspnet-core/content/grpc@x3SJlLc19DNJ-PyDOOj_G.md +++ b/roadmaps/aspnet-core/content/grpc@x3SJlLc19DNJ-PyDOOj_G.md @@ -1,8 +1,6 @@ # gRPC -gRPC is a high-performance, open-source framework for building remote procedure call (RPC) APIs. It uses the Protocol Buffers data serialization format and the HTTP/2 protocol to create highly efficient and scalable APIs. gRPC supports a variety of programming languages, including C# and [ASP.NET](http://ASP.NET). - -In [ASP.NET](http://ASP.NET), gRPC can be used to create high-performance, low-latency APIs for a variety of use cases. gRPC allows for bi-directional streaming of data, which can be useful for real-time applications such as gaming, financial trading, and more. +gRPC is a high-performance, open-source framework that uses HTTP/2 for transport and Protocol Buffers as a message format to enable communication between services. It allows a client application to directly call a method on a server application located on a different machine as if it were a local object. This technology is designed for low-latency, high-throughput communication, making it suitable for internal microservices and real-time streaming data. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/hangfire@QiQsx1udyKcPJ-lZjRQVy.md b/roadmaps/aspnet-core/content/hangfire@QiQsx1udyKcPJ-lZjRQVy.md index 6218cfb21..fb5cd42fa 100644 --- a/roadmaps/aspnet-core/content/hangfire@QiQsx1udyKcPJ-lZjRQVy.md +++ b/roadmaps/aspnet-core/content/hangfire@QiQsx1udyKcPJ-lZjRQVy.md @@ -1,8 +1,6 @@ # Hangfire -Hangfire is an open-source, lightweight library for .NET that allows you to easily perform background processing in your [ASP.NET](http://ASP.NET) application. It provides a simple and elegant way to run background jobs, schedule future tasks, and monitor the progress of your background jobs. - -Hangfire uses a storage backend, such as SQL Server or Redis, to persist the state of your background jobs. This allows you to easily scale your background processing and to monitor and manage your background jobs, even if your application restarts or crashes. +Hangfire is an open-source library that allows developers to create, process, and manage background jobs in .NET applications. It provides a persistent storage mechanism that ensures tasks are executed reliably even if the application restarts. The library features a built-in dashboard for monitoring job progress, retrying failed tasks, and scheduling recurring operations without requiring a separate Windows Service or external task scheduler. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/hotchocolate@XMrQx9JH0eSQJpMzhvy0F.md b/roadmaps/aspnet-core/content/hotchocolate@XMrQx9JH0eSQJpMzhvy0F.md index 214df5cd3..3bc0f2577 100644 --- a/roadmaps/aspnet-core/content/hotchocolate@XMrQx9JH0eSQJpMzhvy0F.md +++ b/roadmaps/aspnet-core/content/hotchocolate@XMrQx9JH0eSQJpMzhvy0F.md @@ -1,8 +1,6 @@ -# Hot Chocolate +# HotChocolate -Hot Chocolate is a GraphQL server implementation for .NET and .NET Core. It is an open-source library that provides a simple and flexible way to build GraphQL APIs in [ASP.NET](http://ASP.NET). - -Hot Chocolate provides a set of classes and methods that make it easy to create a GraphQL schema, handle requests, and generate responses. It also provides a number of features to help with things such as validation, authorization, caching, and more. +HotChocolate is a feature-rich, open-source GraphQL server framework for .NET that enables developers to build flexible APIs. It provides tools to define schemas, resolve data, and execute queries by sitting between your client applications and your underlying data sources. The framework integrates seamlessly with the ASP.NET Core ecosystem, allowing you to expose existing business logic as a strongly typed graph while supporting advanced capabilities like subscriptions, data loaders, and schema stitching. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/http--https-protocol@YI3cAezupWNntFw4B6elY.md b/roadmaps/aspnet-core/content/http--https-protocol@YI3cAezupWNntFw4B6elY.md index 8cb932b0f..87b44433c 100644 --- a/roadmaps/aspnet-core/content/http--https-protocol@YI3cAezupWNntFw4B6elY.md +++ b/roadmaps/aspnet-core/content/http--https-protocol@YI3cAezupWNntFw4B6elY.md @@ -1,22 +1,10 @@ -# HTTP +# HTTP / HTTPS Protocol -HTTP is the `TCP/IP` based application layer communication protocol which standardizes how the client and server communicate with each other. It defines how the content is requested and transmitted across the internet. - -HTTPS -===== - -HTTPS (**H**ypertext **T**ransfer **P**rotocol **S**ecure) is the secure version of HTTP, which is the primary protocol used to send data between a web browser and a website. - -`HTTPS = HTTP + SSL/TLS` +HTTP (Hypertext Transfer Protocol) is the foundational set of rules used for transmitting data across the internet, enabling communication between web browsers and servers. It functions as a request-response protocol where a client sends a request to a server, and the server returns a response containing the requested resource or status information. HTTPS (Hypertext Transfer Protocol Secure) is the encrypted version of this protocol, which incorporates TLS (Transport Layer Security) to protect data integrity and privacy by ensuring that information exchanged between the client and server remains secure from unauthorized interception. Visit the following resources to learn more: -- [@article@Everything you need to know about HTTP](https://cs.fyi/guide/http-in-depth) +- [@roadmap@Visit the Dedicated Network Engineer Roadmap](https://roadmap.sh/network-engineer) - [@article@What is HTTP?](https://www.cloudflare.com/en-gb/learning/ddos/glossary/hypertext-transfer-protocol-http/) - [@article@An overview of HTTP](https://developer.mozilla.org/en-US/docs/Web/HTTP/Overview) -- [@article@HTTP/3 From A To Z: Core Concepts](https://www.smashingmagazine.com/2021/08/http3-core-concepts-part1/) -- [@article@What is HTTPS?](https://www.cloudflare.com/en-gb/learning/ssl/what-is-https/) -- [@article@Why HTTPS Matters](https://developers.google.com/web/fundamentals/security/encrypt-in-transit/why-https) -- [@article@Enabling HTTPS on Your Servers](https://web.dev/enable-https/) -- [@article@How HTTPS works (comic)](https://howhttps.works/) -- [@video@HTTP Crash Course & Exploration](https://www.youtube.com/watch?v=iYM2zFP3Zn0) \ No newline at end of file +- [@article@HTTP/3 From A To Z: Core Concepts](https://www.smashingmagazine.com/2021/08/http3-core-concepts-part1/) \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/kafka@L8RkeMYm0WGNeLLcHKF1R.md b/roadmaps/aspnet-core/content/kafka@L8RkeMYm0WGNeLLcHKF1R.md index e683ea267..c2eba37f6 100644 --- a/roadmaps/aspnet-core/content/kafka@L8RkeMYm0WGNeLLcHKF1R.md +++ b/roadmaps/aspnet-core/content/kafka@L8RkeMYm0WGNeLLcHKF1R.md @@ -1,8 +1,6 @@ -# Apache Kafka +# Kafka -Apache Kafka is an open-source, distributed event streaming platform that is used for building real-time data pipelines and streaming applications. It is designed to handle high volumes of data and to support real-time data processing. - -Kafka is based on a publish-subscribe model, where producers write data to topics, and consumers read data from those topics. Data is stored in topics in a log-based format, which allows for efficient storage and retrieval of data. +Kafka is a distributed event streaming platform used to handle high-throughput data feeds and enable communication between decoupled services. It functions as a publish-subscribe messaging system where producers send records to topics and consumers read those records asynchronously. In an ASP.NET Core environment, it serves as a robust backbone for event-driven architectures, allowing different microservices to exchange messages reliably without being directly connected to one another. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/kubernetes@02rtFStTeIm8prNskxaUN.md b/roadmaps/aspnet-core/content/kubernetes@02rtFStTeIm8prNskxaUN.md index 270aa76d0..94660a9b9 100644 --- a/roadmaps/aspnet-core/content/kubernetes@02rtFStTeIm8prNskxaUN.md +++ b/roadmaps/aspnet-core/content/kubernetes@02rtFStTeIm8prNskxaUN.md @@ -1,14 +1,10 @@ # Kubernetes -Kubernetes is an [open source](https://github.com/kubernetes/kubernetes) container management platform, and the dominant product in this space. Using Kubernetes, teams can deploy images across multiple underlying hosts, defining their desired availability, deployment logic, and scaling logic in YAML. Kubernetes evolved from Borg, an internal Google platform used to provision and allocate compute resources (similar to the Autopilot and Aquaman systems of Microsoft Azure). - -The popularity of Kubernetes has made it an increasingly important skill for the DevOps Engineer and has triggered the creation of Platform teams across the industry. These Platform engineering teams often exist with the sole purpose of making Kubernetes approachable and usable for their product development colleagues. +Kubernetes is an open-source container orchestration platform that automates the deployment, scaling, and management of containerized applications. It organizes containers into logical units called pods and ensures they are running across a cluster of machines according to desired configurations. The system handles tasks such as load balancing, service discovery, and self-healing to maintain the availability and performance of applications. By managing these infrastructure requirements, it allows developers to focus on the continuous delivery and scaling of microservices within a distributed environment. Visit the following resources to learn more: -- [@official@Kubernetes Website](https://kubernetes.io/) +- [@official@Visit the Dedicated Kubernetes Roadmap](https://roadmap.sh/kubernetes) - [@official@Kubernetes Documentation](https://kubernetes.io/docs/home/) - [@article@Primer: How Kubernetes Came to Be, What It Is, and Why You Should Care](https://thenewstack.io/primer-how-kubernetes-came-to-be-what-it-is-and-why-you-should-care/) -- [@article@Kubernetes: An Overview](https://thenewstack.io/kubernetes-an-overview/) -- [@video@Kubernetes Crash Course for Absolute Beginners](https://www.youtube.com/watch?v=s_o8dwzRlu4) -- [@feed@Explore top posts about Kubernetes](https://app.daily.dev/tags/kubernetes?ref=roadmapsh) \ No newline at end of file +- [@article@Kubernetes: An Overview](https://thenewstack.io/kubernetes-an-overview/) \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/lazy-eager-explicit-loading@9AMotSwdEbB8uOg80SykE.md b/roadmaps/aspnet-core/content/lazy-eager-explicit-loading@9AMotSwdEbB8uOg80SykE.md index 621160225..45560ca83 100644 --- a/roadmaps/aspnet-core/content/lazy-eager-explicit-loading@9AMotSwdEbB8uOg80SykE.md +++ b/roadmaps/aspnet-core/content/lazy-eager-explicit-loading@9AMotSwdEbB8uOg80SykE.md @@ -1,14 +1,6 @@ -# Lazy Eager Explicit Loading +# Lazy, Eager, and Explicit Loading -Eager Loading -------------- - -Eager Loading helps you to load all your needed entities at once; i.e., all your child entities will be loaded at single database call. This can be achieved, using the Include method, which returns the related entities as a part of the query and a large amount of data is loaded at once. - -Lazy Loading ------------- - -It is the default behavior of an Entity Framework, where a child entity is loaded only when it is accessed for the first time. It simply delays the loading of the related data, until you ask for it. +Loading patterns in Entity Framework Core determine how and when related data is retrieved from the database when querying a primary entity. Eager loading fetches related data immediately as part of the initial query using the `Include` method. Lazy loading automatically retrieves related data from the database only at the moment a navigation property is accessed in the code. Explicit loading allows developers to manually trigger the retrieval of related data for an entity that has already been loaded, typically using the `Entry` API. Each approach offers a different trade-off between database round-trips and the amount of data transferred, allowing developers to optimize application performance based on specific data access requirements. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/learn-the-basics-of-c@NvODRFR0DLINB0RlPSsvt.md b/roadmaps/aspnet-core/content/learn-the-basics-of-c@NvODRFR0DLINB0RlPSsvt.md index e3933fbcd..b4118650f 100644 --- a/roadmaps/aspnet-core/content/learn-the-basics-of-c@NvODRFR0DLINB0RlPSsvt.md +++ b/roadmaps/aspnet-core/content/learn-the-basics-of-c@NvODRFR0DLINB0RlPSsvt.md @@ -1,10 +1,6 @@ -# C# +# C# Basics -C# (pronounced "C-sharp") is a general-purpose, object-oriented programming language developed by Microsoft. It is part of the .NET family of languages and is used to build a wide range of applications, from web and mobile applications to games and cloud services. - -C# is a statically-typed language, which means that the type of a variable must be specified when it is declared, and that the type of a value cannot be changed after it has been assigned. C# also supports object-oriented programming, which means that it provides features such as encapsulation, inheritance, and polymorphism. - -C# is a popular language for building .NET applications, and it is used by many large companies and organizations, including Microsoft, Dell, and IBM. It is a versatile language that can be used for a wide range of purposes, and it is well-suited for building scalable and maintainable software systems. +C# is a modern, object-oriented programming language developed by Microsoft that serves as the primary language for building applications on the .NET platform. It provides a comprehensive set of features, including strong typing, type safety, and robust memory management, which allow developers to write efficient and maintainable code. Learning C# involves understanding core concepts such as variables, data types, control structures, classes, and namespaces. Mastery of these fundamentals is necessary to effectively structure logic and interact with the various libraries provided by the ASP.NET Core framework. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/life-cycles@Tjaczp2E-cCn0qSv89xgo.md b/roadmaps/aspnet-core/content/life-cycles@Tjaczp2E-cCn0qSv89xgo.md index 214773695..dbe3b7bad 100644 --- a/roadmaps/aspnet-core/content/life-cycles@Tjaczp2E-cCn0qSv89xgo.md +++ b/roadmaps/aspnet-core/content/life-cycles@Tjaczp2E-cCn0qSv89xgo.md @@ -1,12 +1,6 @@ -# Life Cycles +# Dependency Injection Life Cycles -In [ASP.NET](http://ASP.NET), dependency injection (DI) lifecycles determine the lifetime of objects that are resolved through the DI container. There are several predefined lifecycle options in the `Microsoft.Extensions.DependencyInjection` library, including: - -* **Transient:** A new instance of the object is created every time it is requested. -* **Scoped:** A new instance of the object is created for each request within the same scope. -* **Singleton:** A single instance of the object is created and shared across the entire application. - -Additionally, you can also create a custom lifecycle by implementing the `Microsoft.Extensions.DependencyInjection.IServiceScopeFactory` interface +Dependency Injection life cycles define how and when the container creates and disposes of service instances within an application. There are three primary lifetimes: Transient, which creates a new instance every time a service is requested; Scoped, which creates a single instance for the duration of a single client request; and Singleton, which creates a single shared instance the first time it is requested and uses that same instance for every subsequent request throughout the application's lifetime. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/light-bdd@aWRv5sU9dksgcpE9RGJb1.md b/roadmaps/aspnet-core/content/light-bdd@aWRv5sU9dksgcpE9RGJb1.md index f2c17a595..9c8db6a07 100644 --- a/roadmaps/aspnet-core/content/light-bdd@aWRv5sU9dksgcpE9RGJb1.md +++ b/roadmaps/aspnet-core/content/light-bdd@aWRv5sU9dksgcpE9RGJb1.md @@ -1,6 +1,6 @@ # LightBDD -LightBDD is an open-source, lightweight, and easy-to-use BDD (Behavior-Driven Development) framework for .NET, which allows developers to write automated acceptance tests in a simple and readable format. LightBDD is commonly used in the context of [ASP.NET](http://ASP.NET) and other .NET technologies, to write acceptance tests for web applications. LightBDD is designed to provide a simple, yet powerful, way to write BDD tests. It allows developers to write tests using a fluent API, which allows them to describe the behavior of their application in a natural language format. The framework also provides a set of extension methods, which can be used to add additional functionality, such as validating the output of a test, logging test results, or integrating with other testing tools. LightBDD also comes with a built-in test runner, which makes it easy to execute tests and view the results. The framework supports a variety of test runners, such as NUnit, xUnit, and MSTest, and can be integrated with other BDD frameworks, such as SpecFlow and Cucumber. +LightBDD is a framework designed to support Behavior-Driven Development in .NET applications by providing a way to write human-readable test scenarios. It allows developers to define requirements and expectations using structured, descriptive steps that can be mapped directly to automated code execution. By integrating into the testing workflow, it produces detailed reports that bridge the communication gap between technical stakeholders and non-technical team members. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/litedb@3gcXaOnHL4v5OoStrTWNV.md b/roadmaps/aspnet-core/content/litedb@3gcXaOnHL4v5OoStrTWNV.md index 0256a1b2f..ff273c10f 100644 --- a/roadmaps/aspnet-core/content/litedb@3gcXaOnHL4v5OoStrTWNV.md +++ b/roadmaps/aspnet-core/content/litedb@3gcXaOnHL4v5OoStrTWNV.md @@ -1,8 +1,6 @@ # LiteDB -LiteDB is a lightweight, open-source, NoSQL embedded document-oriented database engine for .NET and .NET Core. It uses a file-based storage system, meaning that the entire database is stored in a single file on disk. It uses a similar syntax to MongoDB, but it is designed to be simple and easy to use, and it does not require a separate server or installation. - -LiteDB supports data types like string, int, decimal, DateTime, and also supports binary data and serialized objects. It also supports LINQ, transactions, indexes and collections. +LiteDB is a serverless, single-file NoSQL database engine written in .NET C#. It stores data in a BSON format, making it easy to manage document-based collections directly within an application without needing to install or configure an external database server. It provides a lightweight solution for small-scale projects, desktop applications, or mobile apps that require local data persistence with a simple API. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/log-frameworks@fQ3w8REYWzQfeJ0nPyq6W.md b/roadmaps/aspnet-core/content/log-frameworks@fQ3w8REYWzQfeJ0nPyq6W.md index f29738ad1..25a0402e5 100644 --- a/roadmaps/aspnet-core/content/log-frameworks@fQ3w8REYWzQfeJ0nPyq6W.md +++ b/roadmaps/aspnet-core/content/log-frameworks@fQ3w8REYWzQfeJ0nPyq6W.md @@ -1,14 +1,6 @@ # Log Frameworks -In [ASP.NET](http://ASP.NET), log frameworks are libraries that provide a way to log and analyze data in an application. Some popular log frameworks for [ASP.NET](http://ASP.NET) include: - -* Serilog -* NLog -* Log4Net -* ELMAH -* Microsoft.Extensions.Logging - -These are some of the most popular log frameworks in [ASP.NET](http://ASP.NET), each of them has its own set of features and use cases, and the choice of which log framework to use will depend on the specific requirements of the application. +Log frameworks in ASP.NET Core provide a structured way to record application events, errors, and diagnostic information to various destinations such as the console, files, or cloud-based monitoring services. They integrate with the built-in `ILogger` abstraction, allowing developers to capture runtime data and filter messages based on severity levels like Information, Warning, or Error. These tools help maintain application health by ensuring developers can track execution flows and troubleshoot issues efficiently in production environments. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/manual-mapping@oMMBzRrHkUymxAR4oqr75.md b/roadmaps/aspnet-core/content/manual-mapping@oMMBzRrHkUymxAR4oqr75.md index df5592c9d..7ee6a2017 100644 --- a/roadmaps/aspnet-core/content/manual-mapping@oMMBzRrHkUymxAR4oqr75.md +++ b/roadmaps/aspnet-core/content/manual-mapping@oMMBzRrHkUymxAR4oqr75.md @@ -1,8 +1,6 @@ # Manual Mapping -Manual object mapping in [ASP.NET](http://ASP.NET) Core means explicitly assigning values from one object to another without using third-party libraries like AutoMapper. This approach gives you full control over how properties are mapped and allows for custom transformations if needed. - -For instance, if an **Employee** entity has properties such as Id, Name, Email, and Department, and we need to convert it into an **EmployeeDTO** without exposing sensitive data like Id, a manual mapping method can selectively map only the necessary fields. However, it comes with trade-offs, such as increased boilerplate code and the need for manual updates whenever the data model changes. In a real-world [ASP.NET](http://ASP.NET) Core application, manual mapping can be implemented using static helper methods or extension methods that take an entity as input and return a DTO, ensuring that the mapping logic remains centralized and reusable across different parts of the application. +Manual mapping is the process of explicitly transferring data from one object to another by assigning properties individually within your code. Developers achieve this by creating a new instance of a destination object and setting its fields using the corresponding values from a source object. This approach offers full control over the transformation logic, allowing for specific adjustments, conditional logic, or data formatting during the copy process. Because it relies on standard code without external dependencies, it remains highly performant and easy to debug for simple data structures. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/mapperly@x0OopRTwIvoWgT8qi0CE9.md b/roadmaps/aspnet-core/content/mapperly@x0OopRTwIvoWgT8qi0CE9.md index 4492cf507..066bcc9c3 100644 --- a/roadmaps/aspnet-core/content/mapperly@x0OopRTwIvoWgT8qi0CE9.md +++ b/roadmaps/aspnet-core/content/mapperly@x0OopRTwIvoWgT8qi0CE9.md @@ -1,3 +1,3 @@ # Mapperly -Mapperly is a source generator for .NET that maps objects without runtime reflection. It generates the mapping code at compile time, making it fast and keeping mappings in sync with your models — just declare a mapper class and it takes care of the rest. +Mapperly is a source generator for .NET that maps objects without runtime reflection. It generates the mapping code at compile time, making it fast and keeping mappings in sync with your models — just declare a mapper class and it takes care of the rest. \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/mariadb@Gs8XcsTo11MeCsiSGpjkU.md b/roadmaps/aspnet-core/content/mariadb@Gs8XcsTo11MeCsiSGpjkU.md index 98e52d0ef..77787a1a5 100644 --- a/roadmaps/aspnet-core/content/mariadb@Gs8XcsTo11MeCsiSGpjkU.md +++ b/roadmaps/aspnet-core/content/mariadb@Gs8XcsTo11MeCsiSGpjkU.md @@ -1,8 +1,6 @@ # MariaDB -MariaDB is an open-source relational database management system (RDBMS) that is a fork of the MySQL database. It is fully compatible with MySQL, but it also includes additional features and improvements. MariaDB is developed and maintained by the MariaDB Corporation and the MariaDB community, and it is widely used as a replacement for MySQL in many web and enterprise applications. - -In an [ASP.NET](http://ASP.NET) application, MariaDB can be used as the underlying database for storing and retrieving data. There are several libraries available for integrating MariaDB with an [ASP.NET](http://ASP.NET) application, such as MariaDB.Data, MySql.Data, and Dapper. These libraries provide a .NET client for MariaDB, which can be used to interact with the MariaDB database from within an [ASP.NET](http://ASP.NET) application. +MariaDB is a community-developed, open-source relational database management system that serves as a binary-compatible drop-in replacement for MySQL. It uses structured query language to store, manage, and retrieve data within tables, maintaining a high level of performance and reliability. ASP.NET Core applications interact with MariaDB using connectors or Object-Relational Mappers like Entity Framework Core to execute database operations and manage data persistence. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/marten@ipb6proIZKG-_vCOMAiBu.md b/roadmaps/aspnet-core/content/marten@ipb6proIZKG-_vCOMAiBu.md index b10e287f4..ee58f5253 100644 --- a/roadmaps/aspnet-core/content/marten@ipb6proIZKG-_vCOMAiBu.md +++ b/roadmaps/aspnet-core/content/marten@ipb6proIZKG-_vCOMAiBu.md @@ -1,3 +1,3 @@ # Marten -Marten is a .NET document database library built on PostgreSQL. It turns PostgreSQL into a document store, letting you persist and query .NET objects as JSON documents while still leveraging SQL features such as indexes, transactions, and native Postgres tooling. +Marten is a .NET document database library built on PostgreSQL. It turns PostgreSQL into a document store, letting you persist and query .NET objects as JSON documents while still leveraging SQL features such as indexes, transactions, and native Postgres tooling. \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/mass-transit@SQKIUa_UsJ4cls-Vs9yHU.md b/roadmaps/aspnet-core/content/mass-transit@SQKIUa_UsJ4cls-Vs9yHU.md index 3ffeac04c..d1cc64abd 100644 --- a/roadmaps/aspnet-core/content/mass-transit@SQKIUa_UsJ4cls-Vs9yHU.md +++ b/roadmaps/aspnet-core/content/mass-transit@SQKIUa_UsJ4cls-Vs9yHU.md @@ -1,8 +1,6 @@ # MassTransit -MassTransit is an open-source, highly configurable service bus framework for building distributed systems using the .NET framework. It allows developers to easily create message-based, loosely-coupled applications by providing a simple and fluent API for defining message contracts, handling messages, and managing message routing. - -It supports multiple messaging transports such as RabbitMQ, Azure Service Bus, Amazon SQS and others, automatic serialization and deserialization of messages, automatic retries and exception handling for failed message deliveries, and support for advanced messaging patterns like publish-subscribe, request-response, and event-driven architectures. +MassTransit is a free, open-source distributed application framework for .NET that simplifies the process of creating message-based applications. It acts as an abstraction layer over various message brokers, such as RabbitMQ or Azure Service Bus, allowing developers to focus on application logic rather than the underlying infrastructure. By providing built-in patterns for messaging, such as publish/subscribe, request/response, and routing, it helps manage complex communication between services in a distributed system. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/microservices@37c2eCvRdebztkbc5AjYp.md b/roadmaps/aspnet-core/content/microservices@37c2eCvRdebztkbc5AjYp.md index 6e62bdcd6..87f87cb6d 100644 --- a/roadmaps/aspnet-core/content/microservices@37c2eCvRdebztkbc5AjYp.md +++ b/roadmaps/aspnet-core/content/microservices@37c2eCvRdebztkbc5AjYp.md @@ -1,8 +1,6 @@ # Microservices -Microservices are a software architectural style in which a large application is built as a set of small, independent services that communicate with each other through APIs. These services are typically built using different technologies and run in their own processes, and can be deployed, scaled, and updated independently. - -In [ASP.NET](http://ASP.NET), microservices can be built using the .NET Core framework, which is a cross-platform, open-source version of the .NET framework that can run on Windows, Linux, and macOS. Each microservice can be built as a self-contained, small web application that handles a specific set of functionality, such as user management, product catalog, or order processing. +Microservices is an architectural style that structures an application as a collection of small, autonomous services modeled around specific business domains. In ASP.NET Core, each service runs as an independent process and communicates through lightweight protocols like HTTP/REST, gRPC, or message brokers. This approach allows developers to build, deploy, and scale individual components of an application separately, which increases overall system flexibility and development velocity. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/microsoftextensions@J9XdYLo7qJiBoL8p3c68P.md b/roadmaps/aspnet-core/content/microsoftextensions@J9XdYLo7qJiBoL8p3c68P.md index fe81255a3..438893f9e 100644 --- a/roadmaps/aspnet-core/content/microsoftextensions@J9XdYLo7qJiBoL8p3c68P.md +++ b/roadmaps/aspnet-core/content/microsoftextensions@J9XdYLo7qJiBoL8p3c68P.md @@ -1,8 +1,6 @@ -# Microsoft Extensions Dependency Injection +# Microsoft.Extensions.DependencyInjection -Microsoft.Extensions.DependencyInjection is a dependency injection framework that is part of the Microsoft.Extensions.DependencyInjection NuGet package. It is used to create and manage instances of objects and their dependencies, and is particularly useful for implementing the Dependency Inversion Principle in .NET applications. - -The package provides a simple and consistent API for registering services and resolving dependencies, which can be used to configure and manage the lifetime of objects in an application. It also provides built-in support for various types of service lifetime, such as transient, singleton and scoped. +Microsoft.Extensions.DependencyInjection is the built-in library provided by .NET that implements the dependency injection pattern. It acts as a lightweight container that manages the creation and lifetime of objects within an application. This tool allows developers to register services in a central location, which are then automatically injected into classes as needed through their constructors. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/middlewares@dG--AAcZZdltYCeg6zCz2.md b/roadmaps/aspnet-core/content/middlewares@dG--AAcZZdltYCeg6zCz2.md index 40232e2d7..379ece622 100644 --- a/roadmaps/aspnet-core/content/middlewares@dG--AAcZZdltYCeg6zCz2.md +++ b/roadmaps/aspnet-core/content/middlewares@dG--AAcZZdltYCeg6zCz2.md @@ -1,8 +1,6 @@ # Middlewares -Middleware is software that sits between an operating system and application software, and facilitates communication and data exchange between them. In the context of web development, middleware refers to software components that handle requests and responses in a web application. These components are typically executed in a pipeline, with each component performing a specific task, such as authentication, logging, or routing. - -In the [ASP.NET](http://ASP.NET) Core framework, middleware is a key concept that is used to build web applications. Middleware components are added to the application pipeline using the `IApplicationBuilder` interface, and are executed in the order in which they are added. For example, an application might have middleware components for handling authentication, logging, and routing, in that order. +Middleware is a component that is assembled into an application pipeline to handle HTTP requests and responses. Each component in the pipeline decides whether to pass the request to the next component or perform actions before and after the next component is invoked. These components are executed in the order they are added to the pipeline, allowing developers to manage tasks such as authentication, logging, and routing efficiently. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/minimal-apis@ipABerBcM9zCte9pYaIse.md b/roadmaps/aspnet-core/content/minimal-apis@ipABerBcM9zCte9pYaIse.md index 3bce69970..9c1d54f7e 100644 --- a/roadmaps/aspnet-core/content/minimal-apis@ipABerBcM9zCte9pYaIse.md +++ b/roadmaps/aspnet-core/content/minimal-apis@ipABerBcM9zCte9pYaIse.md @@ -1,8 +1,6 @@ # Minimal APIs -Minimal APIs is a lightweight approach to building HTTP APIs in .NET with minimal ceremony. It is designed for simplicity and performance, making it ideal for microservices, serverless applications, and small web services. Minimal APIs provide a streamlined way to define routes, handle requests, and return responses without requiring controllers or extensive configuration. They leverage top-level statements, reducing boilerplate code while maintaining flexibility and scalability. - -Minimal APIs support dependency injection, middleware, model binding, and validation. They also integrate seamlessly with OpenAPI (Swagger) for API documentation. Their simplicity makes them an excellent choice for building fast and efficient web applications with .NET. +Minimal APIs are a lightweight architectural approach for building HTTP APIs in ASP.NET Core with minimal files, dependencies, and configuration. Instead of requiring complex controller classes, this design allows developers to define endpoints directly within the application's configuration file using simple lambda expressions or method groups. This pattern reduces boilerplate code, making it an efficient choice for creating small, high-performance microservices and cloud-native applications. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/mongodb@-wYRa8qSuKVKo_yOTKV67.md b/roadmaps/aspnet-core/content/mongodb@-wYRa8qSuKVKo_yOTKV67.md index 7a4fd596d..5c9067b8d 100644 --- a/roadmaps/aspnet-core/content/mongodb@-wYRa8qSuKVKo_yOTKV67.md +++ b/roadmaps/aspnet-core/content/mongodb@-wYRa8qSuKVKo_yOTKV67.md @@ -1,11 +1,9 @@ # MongoDB -MongoDB is a cross-platform, open-source, NoSQL document-oriented database that can be used to store and retrieve large amounts of data. It uses a flexible, JSON-like data structure called BSON (binary JSON) and it is designed to handle large amounts of unstructured data. - -In an [ASP.NET](http://ASP.NET) application, MongoDB can be used as a data store to persist and retrieve application data. There are several libraries available for integrating MongoDB with an [ASP.NET](http://ASP.NET) application, such as MongoDB.Driver and C# MongoDB Driver. These libraries provide a .NET client for MongoDB, which can be used to interact with the MongoDB server from within an [ASP.NET](http://ASP.NET) application. +MongoDB is a document-oriented NoSQL database that stores data in flexible, JSON-like documents rather than traditional tables and rows. In an ASP.NET Core environment, developers interact with MongoDB using the official C# driver, which allows for storing complex data structures that can evolve over time without requiring rigid schema migrations. This database provides high scalability and performance, making it a suitable choice for applications that handle large volumes of unstructured or semi-structured data. Visit the following resources to learn more: +- [@roadmap@Visit the Dedicated MongoDB Roadmap](https://roadmap.sh/mongodb) - [@article@Use MongoDB in Your C# ASP.NET Apps](https://developer.okta.com/blog/2020/01/02/mongodb-csharp-aspnet-datastore) -- [@article@MongoDB With ASP.NET Core Web API](https://www.c-sharpcorner.com/article/using-mongodb-with-asp-net-core-web-api/) -- [@feed@Explore top posts about MongoDB](https://app.daily.dev/tags/mongodb?ref=roadmapsh) \ No newline at end of file +- [@article@MongoDB With ASP.NET Core Web API](https://www.c-sharpcorner.com/article/using-mongodb-with-asp-net-core-web-api/) \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/moq@eyOXWb1kL80Wqiwc2WHd_.md b/roadmaps/aspnet-core/content/moq@eyOXWb1kL80Wqiwc2WHd_.md index 25fae817b..81b24bef7 100644 --- a/roadmaps/aspnet-core/content/moq@eyOXWb1kL80Wqiwc2WHd_.md +++ b/roadmaps/aspnet-core/content/moq@eyOXWb1kL80Wqiwc2WHd_.md @@ -1,6 +1,6 @@ # Moq -Moq is an open-source library for .NET that allows developers to create mock objects for use in unit testing, it is a popular mocking framework that provides a simple and intuitive syntax for creating mock objects and setting up mock behavior. In the context of [ASP.NET](http://ASP.NET), Moq can be used to create mock objects for testing web applications built using the [ASP.NET](http://ASP.NET) framework, it provides a simple and expressive syntax for creating mock objects and setting up mock behavior. Moq supports a wide range of testing frameworks, including MSTest, NUnit, and xUnit and it also supports various platforms including .NET Framework, .NET Core and Xamarin. Moq is lightweight and easy to use, making it a good choice for developers who are new to mocking and unit testing, it also provides a rich set of features, such as support for setting up mock behavior, making assertions on calls made to the mock objects, and more. +Moq is a popular mocking library for .NET that allows developers to simulate the behavior of complex objects and interfaces during unit testing. It provides a simple API to create "mock" versions of dependencies, enabling you to define specific return values for methods or verify that certain interactions occurred within your code. By isolating the component under test from its external dependencies, Moq ensures that tests focus solely on the logic being verified. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/mvc@D3aQw0-pk3ycO-n10HBaA.md b/roadmaps/aspnet-core/content/mvc@D3aQw0-pk3ycO-n10HBaA.md index c0ec02f94..676b95400 100644 --- a/roadmaps/aspnet-core/content/mvc@D3aQw0-pk3ycO-n10HBaA.md +++ b/roadmaps/aspnet-core/content/mvc@D3aQw0-pk3ycO-n10HBaA.md @@ -1,10 +1,6 @@ # MVC -MVC is an architectural design pattern used for developing applications, specifically web applications. This pattern separates an application into three main logical components **Model View Controller**. Each architectural component is built to handle specific development aspects of an application. - -* **Model** - Handles all data-related logic. Interacts with Database. -* **View** - Handles UI part of the applications (data presentation). -* **Controller** - Handles request flow, and acts as an intermediary between view and model. +MVC is an architectural pattern that separates an application into three main components: Models, Views, and Controllers. The Model manages the data and business logic of the application, the View handles the visual representation and user interface, and the Controller processes incoming requests, interacts with the Model, and selects the appropriate View to display to the user. This separation of concerns allows developers to build more organized, maintainable, and testable web applications. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/mysql@WsGwg4qdlu_vBsFEpmBvU.md b/roadmaps/aspnet-core/content/mysql@WsGwg4qdlu_vBsFEpmBvU.md index 6f4173e16..16af0c1e5 100644 --- a/roadmaps/aspnet-core/content/mysql@WsGwg4qdlu_vBsFEpmBvU.md +++ b/roadmaps/aspnet-core/content/mysql@WsGwg4qdlu_vBsFEpmBvU.md @@ -1,8 +1,6 @@ # MySQL -MySQL is an open-source relational database management system (RDBMS) that is widely used in web and enterprise applications. It is developed, distributed, and supported by Oracle Corporation. MySQL provides a rich set of features to handle high-performance, high-availability, and high-scalability requirements of modern web applications. - -In an [ASP.NET](http://ASP.NET) application, MySQL can be used as the underlying database for storing and retrieving data. There are several libraries available for integrating MySQL with an [ASP.NET](http://ASP.NET) application, such as MySql.Data, Dapper and EF Core. These libraries provide a .NET client for MySQL, which can be used to interact with the MySQL database from within an [ASP.NET](http://ASP.NET) application. +MySQL is an open-source relational database management system that organizes data into tables with predefined relationships. In an ASP.NET Core environment, it serves as a robust backend storage solution accessed through Entity Framework Core or direct database drivers. It uses Structured Query Language to manage, retrieve, and manipulate data efficiently while ensuring consistency and reliability for web applications. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/native-background-service@uP1nqbmFmZL_wA2DoqP8C.md b/roadmaps/aspnet-core/content/native-background-service@uP1nqbmFmZL_wA2DoqP8C.md index 324cf819c..09132b146 100644 --- a/roadmaps/aspnet-core/content/native-background-service@uP1nqbmFmZL_wA2DoqP8C.md +++ b/roadmaps/aspnet-core/content/native-background-service@uP1nqbmFmZL_wA2DoqP8C.md @@ -1,8 +1,6 @@ # Native Background Service -A Native Background Service in [ASP.NET](http://ASP.NET) is a type of service that can run in the background on a device, without the need for an active user session. These services are typically used for tasks that need to run continuously, such as sending notifications, polling for updates, or processing data. - -In [ASP.NET](http://ASP.NET), a Native Background Service can be implemented using the IHostedService interface, which is part of the Microsoft.Extensions.Hosting namespace. This interface allows you to create a background service that can run continuously, even when the main application is not running. +A Native Background Service is a class in ASP.NET Core that implements the `IHostedService` interface or inherits from the `BackgroundService` base class to execute long-running tasks in the background. These services run independently of the request-response cycle, allowing the application to perform periodic operations like data cleanup, message queue processing, or scheduled report generation. The framework manages the lifecycle of these services, ensuring they start when the application host begins and shut down gracefully when the host stops. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/net-aspire@HqhqqiA5X00Xl1RnZgrNJ.md b/roadmaps/aspnet-core/content/net-aspire@HqhqqiA5X00Xl1RnZgrNJ.md index d23cc8d91..0967e628d 100644 --- a/roadmaps/aspnet-core/content/net-aspire@HqhqqiA5X00Xl1RnZgrNJ.md +++ b/roadmaps/aspnet-core/content/net-aspire@HqhqqiA5X00Xl1RnZgrNJ.md @@ -1,3 +1,3 @@ # .NET Aspire -.NET Aspire is an opinionated stack for building observable, production-ready cloud-native .NET applications. It provides curated packages for common cloud dependencies, service discovery, orchestration for local development, and built-in telemetry to make distributed applications easier to build and debug. +.NET Aspire is an opinionated stack for building observable, production-ready cloud-native .NET applications. It provides curated packages for common cloud dependencies, service discovery, orchestration for local development, and built-in telemetry to make distributed applications easier to build and debug. \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/net-aspire@Ohc0xzI6qX4hOFVNfRj1F.md b/roadmaps/aspnet-core/content/net-aspire@Ohc0xzI6qX4hOFVNfRj1F.md index d23cc8d91..0967e628d 100644 --- a/roadmaps/aspnet-core/content/net-aspire@Ohc0xzI6qX4hOFVNfRj1F.md +++ b/roadmaps/aspnet-core/content/net-aspire@Ohc0xzI6qX4hOFVNfRj1F.md @@ -1,3 +1,3 @@ # .NET Aspire -.NET Aspire is an opinionated stack for building observable, production-ready cloud-native .NET applications. It provides curated packages for common cloud dependencies, service discovery, orchestration for local development, and built-in telemetry to make distributed applications easier to build and debug. +.NET Aspire is an opinionated stack for building observable, production-ready cloud-native .NET applications. It provides curated packages for common cloud dependencies, service discovery, orchestration for local development, and built-in telemetry to make distributed applications easier to build and debug. \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/net-maui@olqSPUU3RoxhQ6exfMzeN.md b/roadmaps/aspnet-core/content/net-maui@olqSPUU3RoxhQ6exfMzeN.md index 4ac65a120..45a63c5d2 100644 --- a/roadmaps/aspnet-core/content/net-maui@olqSPUU3RoxhQ6exfMzeN.md +++ b/roadmaps/aspnet-core/content/net-maui@olqSPUU3RoxhQ6exfMzeN.md @@ -1,3 +1,3 @@ # .NET MAUI -.NET MAUI (Multi-platform App UI) is the cross-platform UI framework for .NET. It lets you build native Android, iOS, macOS, and Windows applications from a single C# and XAML codebase, sharing business logic while still allowing per-platform customizations when needed. +.NET MAUI (Multi-platform App UI) is the cross-platform UI framework for .NET. It lets you build native Android, iOS, macOS, and Windows applications from a single C# and XAML codebase, sharing business logic while still allowing per-platform customizations when needed. \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/netmq@8d4f7_3VO03vy7YDWwPI9.md b/roadmaps/aspnet-core/content/netmq@8d4f7_3VO03vy7YDWwPI9.md index 5849e23de..af7781bbb 100644 --- a/roadmaps/aspnet-core/content/netmq@8d4f7_3VO03vy7YDWwPI9.md +++ b/roadmaps/aspnet-core/content/netmq@8d4f7_3VO03vy7YDWwPI9.md @@ -1,8 +1,6 @@ # NetMQ -NetMQ is a lightweight, open-source messaging library for building distributed systems and real-time applications in .NET. It provides an API for sending and receiving messages using a variety of messaging patterns and protocols, including request-response, publish-subscribe, and push-pull. - -NetMQ is built on top of ZeroMQ, a high-performance, asynchronous messaging library that provides a minimalistic socket-based API for building distributed systems. NetMQ is designed to be easy to use and to abstract away the complexities of ZeroMQ, making it a good choice for developers who want to add messaging capabilities to their [ASP.NET](http://ASP.NET) applications without having to learn a complex API. +NetMQ is a lightweight, high-performance messaging library that serves as a native C# port of the ZeroMQ library. It enables developers to implement various messaging patterns, such as request-reply, pub-sub, and push-pull, for communication between distributed services. By utilizing asynchronous message queues, it allows microservices to exchange data efficiently across different processes or network nodes without relying on a dedicated message broker server. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/nhibernate@z24IJndpQYTl1PhiUI2mx.md b/roadmaps/aspnet-core/content/nhibernate@z24IJndpQYTl1PhiUI2mx.md index 8588a13ff..cab2056fa 100644 --- a/roadmaps/aspnet-core/content/nhibernate@z24IJndpQYTl1PhiUI2mx.md +++ b/roadmaps/aspnet-core/content/nhibernate@z24IJndpQYTl1PhiUI2mx.md @@ -1,8 +1,6 @@ # NHibernate -NHibernate is an open-source Object-Relational Mapping (ORM) framework for .NET. It is a powerful and flexible framework that can greatly simplify working with relational data in .NET. NHibernate is similar to other ORM frameworks such as Entity Framework and RepoDb in that it provides a higher-level abstraction on top of the underlying data access technology ([ADO.NET](http://ADO.NET) in this case) and allows developers to work with data using domain-specific objects, eliminating the need to write raw SQL statements. - -NHibernate uses the concept of "mapping files" which are XML files that define how the classes in the application map to the tables and columns in the database. These mapping files are used to create a conceptual model of the data in the form of classes, and then NHibernate uses this model to generate the SQL statements necessary to interact with the database. +NHibernate is an object-relational mapping (ORM) framework for .NET that facilitates the interaction between a relational database and object-oriented code. It enables developers to map .NET classes to database tables and map properties to table columns, allowing data to be queried and manipulated using object-oriented principles. By automating the generation of SQL commands, it minimizes the need for manual data access code and simplifies complex database operations within an application. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/nlog@ykF2bB_68AhCOzeQ_QSW1.md b/roadmaps/aspnet-core/content/nlog@ykF2bB_68AhCOzeQ_QSW1.md index 1cad40343..4cab1ce3c 100644 --- a/roadmaps/aspnet-core/content/nlog@ykF2bB_68AhCOzeQ_QSW1.md +++ b/roadmaps/aspnet-core/content/nlog@ykF2bB_68AhCOzeQ_QSW1.md @@ -1,8 +1,6 @@ # NLog -NLog is an open-source logging library for .NET applications, including [ASP.NET](http://ASP.NET). It is designed to be easy to use, highly configurable, and extensible, and it provides a number of features that help developers to log and analyze data in their applications. - -NLog is a powerful, flexible, and easy-to-use logging library that can be used in [ASP.NET](http://ASP.NET) applications to provide detailed log data. It allows developers to easily configure their logging pipeline, and to write log data to a variety of destinations, making it easier to analyze and troubleshoot issues in the application. +NLog is a flexible and free logging platform for various .NET platforms, including ASP.NET Core. It allows developers to route log messages to multiple destinations, such as files, databases, or cloud services, based on configurable rules. By using a centralized configuration file, it enables fine-grained control over log levels and output formats without requiring changes to the application code. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/nosql@WUis4K9vduriYdVkKvM9r.md b/roadmaps/aspnet-core/content/nosql@WUis4K9vduriYdVkKvM9r.md index d99206e93..7c68e799c 100644 --- a/roadmaps/aspnet-core/content/nosql@WUis4K9vduriYdVkKvM9r.md +++ b/roadmaps/aspnet-core/content/nosql@WUis4K9vduriYdVkKvM9r.md @@ -1,12 +1,10 @@ -# Nosql +# NoSQL Databases -NoSQL (Not Only SQL) is a type of database that does not use the traditional table-based relational model. It is designed to handle large amounts of unstructured or semi-structured data, and it is often used in big data and real-time web applications. NoSQL databases are highly scalable and can handle high-performance needs and large data sets. - -There are several types of NoSQL databases, such as document databases, key-value databases, graph databases, and column-family databases, each with their own unique features and use cases. Some examples of NoSQL databases include MongoDB, Cassandra, RavenDB, CouchDB, and Redis. +NoSQL databases are non-relational data management systems that store information in flexible formats such as documents, key-value pairs, graphs, or wide-column stores rather than traditional tables. These databases provide a schema-less approach to data storage, allowing developers to handle unstructured or rapidly evolving datasets with high horizontal scalability. In ASP.NET Core applications, these databases are often utilized to manage high-velocity data or complex hierarchical objects that do not fit well into a rigid relational structure. Visit the following resources to learn more: - [@article@NoSQL in .NET Applications](https://www.slideshare.net/shijucv/nosql-database-in-net-apps) +- [@article@Types of NoSQL Databases: How to Choose the Right One](https://roadmap.sh/backend/types-of-nosql-databases) - [@article@Open Source NoSQL Database for .NET](https://www.alachisoft.com/nosdb/) -- [@article@Use NoSQL databases in ASP.NET](https://learn.microsoft.com/en-us/dotnet/architecture/microservices/microservice-ddd-cqrs-patterns/nosql-database-persistence-infrastructure) -- [@feed@Explore top posts about NoSQL](https://app.daily.dev/tags/nosql?ref=roadmapsh) \ No newline at end of file +- [@article@Use NoSQL databases in ASP.NET](https://learn.microsoft.com/en-us/dotnet/architecture/microservices/microservice-ddd-cqrs-patterns/nosql-database-persistence-infrastructure) \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/nservicebus@vf8W1FLhcb3awx4JBaY5r.md b/roadmaps/aspnet-core/content/nservicebus@vf8W1FLhcb3awx4JBaY5r.md index afa0c2cec..011d52a40 100644 --- a/roadmaps/aspnet-core/content/nservicebus@vf8W1FLhcb3awx4JBaY5r.md +++ b/roadmaps/aspnet-core/content/nservicebus@vf8W1FLhcb3awx4JBaY5r.md @@ -1,8 +1,6 @@ # NServiceBus -NServiceBus (NSB) is a service bus framework for building distributed systems using the .NET framework. It provides a set of features for building message-based, loosely-coupled applications, including support for message routing, message handling, and message persistence. - -NSB supports multiple messaging transports, including MSMQ, RabbitMQ, and Azure Service Bus, and provides support for advanced messaging patterns such as publish-subscribe, request-response, and message-based sagas. +NServiceBus is a service bus framework for .NET that simplifies the process of building distributed systems by managing messaging between decoupled services. It provides a reliable abstraction over messaging transports like RabbitMQ, Azure Service Bus, or Amazon SQS, handling complex tasks such as message retries, transactional consistency, and out-of-the-box support for the Saga pattern. Developers use NServiceBus to ensure that messages are processed reliably even if individual components experience temporary failures or network interruptions. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/nsubstitute@iZCxinqlVefBk5-ICqt4v.md b/roadmaps/aspnet-core/content/nsubstitute@iZCxinqlVefBk5-ICqt4v.md index 92217738e..65dd4dfd8 100644 --- a/roadmaps/aspnet-core/content/nsubstitute@iZCxinqlVefBk5-ICqt4v.md +++ b/roadmaps/aspnet-core/content/nsubstitute@iZCxinqlVefBk5-ICqt4v.md @@ -1,6 +1,6 @@ # NSubstitute -NSubstitute is a popular open-source .NET library that allows developers to create mock objects for use in unit testing, it is a powerful and flexible substitute for traditional mocking frameworks such as Moq and Rhino Mocks. In the context of [ASP.NET](http://ASP.NET), NSubstitute can be used to create mock objects for testing web applications built using the [ASP.NET](http://ASP.NET) framework, it provides a simple and intuitive syntax for creating mock objects, setting up mock behavior, and making assertions on calls made to the mock objects. NSubstitute supports a wide range of testing frameworks and test runners, including MSTest, NUnit, and xUnit and it also supports various platforms including .NET Framework, .NET Core, Xamarin and Unity. +NSubstitute is a friendly library for .NET used to create and work with mock objects in unit tests. It provides a simple, concise syntax that allows developers to substitute dependencies, define return values for methods, and verify that specific actions were performed during a test execution. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/nuke@EsC1JwFOMOlQVelpmxISh.md b/roadmaps/aspnet-core/content/nuke@EsC1JwFOMOlQVelpmxISh.md index fa281b325..ee31b031c 100644 --- a/roadmaps/aspnet-core/content/nuke@EsC1JwFOMOlQVelpmxISh.md +++ b/roadmaps/aspnet-core/content/nuke@EsC1JwFOMOlQVelpmxISh.md @@ -1,8 +1,6 @@ -# NUKE +# Nuke -NUKE (Build Automation for .NET) is an open-source build automation tool for .NET projects. It is designed to be simple, flexible, and extensible, making it easy to automate the build, test, and deployment process of your .NET projects. - -NUKE allows you to define your build process using a simple, declarative syntax, making it easy to understand and maintain. It provides a set of built-in tasks for common build actions, such as compiling, testing, and publishing, as well as a powerful extensibility model that allows you to add custom tasks and scripts. +Nuke is a cross-platform build automation system that allows you to define your build processes using C#. It leverages the power of the .NET ecosystem to provide strongly typed build scripts, enabling you to manage complex tasks like compilation, testing, and deployment directly within your IDE. By treating your build configuration as code, it offers full IntelliSense support, easy debugging, and simple integration with various CI/CD pipelines. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/nunit@qHYBlBCvCGUZGh6gyEI63.md b/roadmaps/aspnet-core/content/nunit@qHYBlBCvCGUZGh6gyEI63.md index ba172c5f9..dfb6fbd03 100644 --- a/roadmaps/aspnet-core/content/nunit@qHYBlBCvCGUZGh6gyEI63.md +++ b/roadmaps/aspnet-core/content/nunit@qHYBlBCvCGUZGh6gyEI63.md @@ -1,6 +1,6 @@ # NUnit -NUnit is a unit testing framework for the .NET framework, it's an open-source testing framework that provides a set of attributes and classes that can be used to create unit tests. In the context of [ASP.NET](http://ASP.NET), NUnit can be used to write unit tests for web applications built using the [ASP.NET](http://ASP.NET) framework. NUnit provides features such as support for data-driven tests, support for parallel test execution, and support for test discovery and execution, it also provides support for test isolation which allows developers to run tests in isolation from each other. NUnit is a popular alternative to other testing frameworks like MSTest and xUnit and it has a similar syntax as JUnit and it's considered as one of the oldest testing frameworks for .NET. +NUnit is an open-source unit testing framework for the .NET ecosystem that allows developers to write and execute tests to ensure individual sections of code function as intended. It provides a rich set of assertions and attributes that help structure test suites, manage setup and teardown processes, and handle various test scenarios. By integrating seamlessly with the .NET CLI and Visual Studio, it enables automated verification of application logic during the development lifecycle. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/object-mapping@9ECykIIvXlDblbFbRVcJS.md b/roadmaps/aspnet-core/content/object-mapping@9ECykIIvXlDblbFbRVcJS.md index 800927669..fc9bb848e 100644 --- a/roadmaps/aspnet-core/content/object-mapping@9ECykIIvXlDblbFbRVcJS.md +++ b/roadmaps/aspnet-core/content/object-mapping@9ECykIIvXlDblbFbRVcJS.md @@ -1,8 +1,6 @@ # Object Mapping -Object mapping in [ASP.NET](http://ASP.NET) refers to the process of converting an object of one type to an object of another type. This can be useful in a number of scenarios, such as when working with domain models and data transfer objects (DTOs) in a layered architecture, or when mapping between different versions of an object or different formats such as JSON and XML. - -There are several libraries available for object mapping in [ASP.NET](http://ASP.NET), such as AutoMapper, ExpressMapper, AgileMapper, AgileMapster and Mapster. These libraries provide a convenient and flexible way to map between objects, using a convention-based approach or a fluent API to configure more complex mappings. They also support for a wide range of mapping scenarios, including nested and circular object graphs, collections, and different types of inheritance. +Object mapping is the process of automatically converting data from one object type to another, typically between domain models and data transfer objects (DTOs). It streamlines the development process by eliminating the need to write repetitive manual assignment code when moving data between different layers of an application. Libraries like AutoMapper are frequently integrated into ASP.NET Core projects to handle these transformations efficiently, ensuring that complex object structures remain synchronized across various parts of the system. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/ocelot@2k-rGuhYTTAR9XN3aDAnW.md b/roadmaps/aspnet-core/content/ocelot@2k-rGuhYTTAR9XN3aDAnW.md index d8e99de7e..450aeb191 100644 --- a/roadmaps/aspnet-core/content/ocelot@2k-rGuhYTTAR9XN3aDAnW.md +++ b/roadmaps/aspnet-core/content/ocelot@2k-rGuhYTTAR9XN3aDAnW.md @@ -1,8 +1,6 @@ # Ocelot -Ocelot is an open-source API gateway for [ASP.NET](http://ASP.NET) Core. It is designed to work as a reverse proxy, routing incoming requests to the appropriate service and aggregating the responses to return to the client. Ocelot allows you to define routing rules, handle requests and responses, and perform other common API gateway tasks such as rate limiting, caching, and authentication. - -One of the key features of Ocelot is its flexibility, it can route incoming requests to multiple services, aggregate the responses, and return them as a single response to the client. It also allows you to define dynamic routes, based on the request's content, perform request and response transformations, and handle errors. +Ocelot is an open-source API gateway designed for ASP.NET Core applications that acts as a single entry point for a microservices architecture. It functions as a reverse proxy that receives incoming HTTP requests and routes them to the appropriate downstream services based on predefined configuration. This tool handles essential cross-cutting concerns such as request aggregation, authentication, authorization, rate limiting, and caching, allowing developers to centralize service management rather than implementing these features in every individual Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/odata@YojZ5fpzw-5WgoqqkO6wl.md b/roadmaps/aspnet-core/content/odata@YojZ5fpzw-5WgoqqkO6wl.md index 03a1b19c4..890f2c765 100644 --- a/roadmaps/aspnet-core/content/odata@YojZ5fpzw-5WgoqqkO6wl.md +++ b/roadmaps/aspnet-core/content/odata@YojZ5fpzw-5WgoqqkO6wl.md @@ -1,8 +1,6 @@ # OData -OData (Open Data Protocol) is a web protocol for querying and updating data. It is an open standard for creating and consuming RESTful web services. OData is built on top of the HTTP protocol, and it uses the conventions of REST to expose data through a standard interface. - -In [ASP.NET](http://ASP.NET), OData can be used to create RESTful web services that expose data in a standardized way. OData provides a set of conventions for defining the structure of the data, and it also provides a set of conventions for querying and updating the data. +OData is an open protocol that allows for the creation and consumption of queryable and interoperable RESTful APIs. It provides a standardized way to define the data model and the query syntax, enabling clients to request specific data using URL parameters for filtering, sorting, pagination, and selecting properties. By integrating with ASP.NET Core, it simplifies the development of data-driven services that support complex querying capabilities without requiring custom code for every filtering scenario. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/orleans@XKsLqDDco5OXKURCcWAmv.md b/roadmaps/aspnet-core/content/orleans@XKsLqDDco5OXKURCcWAmv.md index f33058938..1c8fa8b5c 100644 --- a/roadmaps/aspnet-core/content/orleans@XKsLqDDco5OXKURCcWAmv.md +++ b/roadmaps/aspnet-core/content/orleans@XKsLqDDco5OXKURCcWAmv.md @@ -1,8 +1,6 @@ # Orleans -Orleans is an open-source virtual actor model framework for building distributed, high-scale, and low-latency applications in .NET. It is designed to make it easy to build and operate large-scale, distributed systems, such as cloud services, IoT applications, and gaming servers. - -One of the key features of Orleans is its use of the virtual actor model, which is a programming model that allows developers to write concurrent and parallel code in a way that is similar to writing single-threaded code. Orleans provides a set of abstractions for building stateful actors, which are similar to objects in object-oriented programming, that can be distributed across multiple machines. These actors can communicate with each other using message passing, and can be accessed remotely using a transparent proxy +Orleans is a cross-platform framework for building robust, scalable distributed applications in .NET. It simplifies the development process by using a virtual actor model that allows developers to create stateful, distributed objects without needing to manage complex concurrency, persistence, or messaging concerns manually. The runtime automatically handles the lifecycle, placement, and activation of these objects across a cluster of servers, making it well-suited for high-throughput systems like gaming backends, real-time analytics, and chat applications. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/polly@gQhiEpvx__70N1WbEHGYJ.md b/roadmaps/aspnet-core/content/polly@gQhiEpvx__70N1WbEHGYJ.md index 14b6a51ec..ca2154ed8 100644 --- a/roadmaps/aspnet-core/content/polly@gQhiEpvx__70N1WbEHGYJ.md +++ b/roadmaps/aspnet-core/content/polly@gQhiEpvx__70N1WbEHGYJ.md @@ -1,6 +1,6 @@ # Polly -Polly is an open-source library for .NET that provides a simple and flexible API for handling transient faults and other types of errors that occur during the execution of a service. It allows developers to define a set of policies, such as retry, circuit breaker, and timeout, that can be used to handle specific types of errors and improve the resiliency of the service. It provides a fluent API that makes it easy to define and configure policies, supports advanced features such as async and sync execution, fallback policies, and policy wrapping. Additionally, it allows to specify the exception type that is thrown and it would trigger the policy. +Polly is a .NET resilience and transient-fault-handling library that allows developers to express policies such as Retry, Circuit Breaker, Timeout, Bulkhead Isolation, and Fallback in a fluent and thread-safe manner. It helps manage instability in external services by defining how an application should react when a network request fails or a system resource becomes unresponsive. By integrating these policies, applications can maintain stability and gracefully handle failures during remote service communication. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/postgresql@An9TLvo-I6NtC8wFU3bh4.md b/roadmaps/aspnet-core/content/postgresql@An9TLvo-I6NtC8wFU3bh4.md index a66f846ba..5d2c7cfce 100644 --- a/roadmaps/aspnet-core/content/postgresql@An9TLvo-I6NtC8wFU3bh4.md +++ b/roadmaps/aspnet-core/content/postgresql@An9TLvo-I6NtC8wFU3bh4.md @@ -1,12 +1,10 @@ # PostgreSQL -PostgreSQL, often simply "Postgres", is an open-source relational database management system (RDBMS) emphasizing extensibility and SQL compliance. It was originally developed at the University of California, Berkeley in the 1980s and is now maintained by the PostgreSQL Global Development Group. - -Postgres is known for its robustness and reliability, as well as its support for advanced features such as concurrency control, full-text search, and geospatial data. It is also highly extensible, allowing developers to create custom functions and operators in a variety of programming languages, including C, Python, and JavaScript. +PostgreSQL is an open-source, object-relational database management system known for its reliability, feature robustness, and performance. Within the ASP.NET Core ecosystem, it serves as a powerful storage backend that integrates seamlessly with Entity Framework Core to handle complex data relationships and transactions. Developers often utilize the Npgsql provider to establish a direct connection between their applications and the database, allowing for efficient data querying, schema management, and persistent storage of structured information. Visit the following resources to learn more: +- [@roadmap@Visit the Dedicated PostgreSQL DBA Roadmap](https://roadmap.sh/postgresql-dba) - [@official@Postgresql - Open Source Relational Database](https://www.postgresql.org/) - [@article@What is Postgresql?](https://postgresqltutorial.com/postgresql-getting-started/what-is-postgresql/) -- [@article@Introduction, Advantages & Disadvantages of PostgreSQL](https://www.guru99.com/introduction-postgresql.html) -- [@feed@Explore top posts about PostgreSQL](https://app.daily.dev/tags/postgresql?ref=roadmapsh) \ No newline at end of file +- [@article@Introduction, Advantages & Disadvantages of PostgreSQL](https://www.guru99.com/introduction-postgresql.html) \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/quartz@zOWlPXIl4XPs_0pA8-yi5.md b/roadmaps/aspnet-core/content/quartz@zOWlPXIl4XPs_0pA8-yi5.md index f5f953227..fe8007123 100644 --- a/roadmaps/aspnet-core/content/quartz@zOWlPXIl4XPs_0pA8-yi5.md +++ b/roadmaps/aspnet-core/content/quartz@zOWlPXIl4XPs_0pA8-yi5.md @@ -1,8 +1,6 @@ # Quartz -Quartz is an open-source, job scheduling library for .NET that can be used in [ASP.NET](http://ASP.NET) applications. It is based on the popular Quartz scheduler for Java, and provides a similar feature set for scheduling and executing background jobs in .NET applications. - -With Quartz, you can schedule jobs to run at specific times or intervals, and you can also set up triggers to start a job based on certain events. Quartz also provides a rich set of options for configuring and managing your jobs, such as pausing, resuming, and canceling jobs, as well as job chaining and priorities. +Quartz is an open-source job scheduling library that allows developers to integrate sophisticated task scheduling into their applications. It enables the execution of background jobs based on complex triggers, such as specific times, recurring intervals, or cron Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/rabbitmq@KqvBn2_wvYhFdv0dBZMC9.md b/roadmaps/aspnet-core/content/rabbitmq@KqvBn2_wvYhFdv0dBZMC9.md index 4fed2a646..d271fdcdc 100644 --- a/roadmaps/aspnet-core/content/rabbitmq@KqvBn2_wvYhFdv0dBZMC9.md +++ b/roadmaps/aspnet-core/content/rabbitmq@KqvBn2_wvYhFdv0dBZMC9.md @@ -1,8 +1,6 @@ # RabbitMQ -RabbitMQ is an open-source message broker software that implements the Advanced Message Queuing Protocol (AMQP). It is written in Erlang and can be used to send and receive messages between different applications in a loosely coupled, asynchronous manner. RabbitMQ supports a variety of messaging patterns, including point-to-point, publish-subscribe, and request-response. - -In the context of an [ASP.NET](http://ASP.NET) application, RabbitMQ can be used to send and receive messages to and from other systems. For example, it can be used to send messages from a web application to a background service, or to send messages between different microservices. +RabbitMQ is an open-source message broker that acts as a middleware for services to communicate asynchronously by sending and receiving messages. In an ASP.NET Core microservices architecture, it enables decoupled communication by allowing one service to place a message into a queue without needing an immediate response from the receiver. It supports various messaging patterns, including publish/subscribe and request/reply, which helps ensure system reliability and scalability during periods of high traffic. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/razor-components@vePinRjDfSGULKw0LE9K-.md b/roadmaps/aspnet-core/content/razor-components@vePinRjDfSGULKw0LE9K-.md index c9e94e5d3..5343d4227 100644 --- a/roadmaps/aspnet-core/content/razor-components@vePinRjDfSGULKw0LE9K-.md +++ b/roadmaps/aspnet-core/content/razor-components@vePinRjDfSGULKw0LE9K-.md @@ -1,8 +1,6 @@ # Razor Components -Razor Components is a feature of [ASP.NET](http://ASP.NET) Core that allows developers to build reusable, self-contained components that can be used across multiple pages or even multiple applications. Razor Components is built on top of the Razor view engine, which allows developers to define components using a combination of Razor markup and C# code. - -Razor Components are useful for building complex, dynamic, and reusable UI elements, such as forms, tables, or dialogs, and can be used to build both small and large-scale web applications. +Razor Components are the fundamental building blocks of user interfaces in Blazor applications. They are reusable units that combine HTML markup with C# code to define how a part of a webpage should render and behave. These components are stored as files with a .razor extension and use a syntax that allows developers to integrate logic directly within the UI layout, enabling dynamic updates and event handling within the browser. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/razor-pages@qpVxwuyA2oE06MZLtEdP1.md b/roadmaps/aspnet-core/content/razor-pages@qpVxwuyA2oE06MZLtEdP1.md index e471a6169..5a1872b3c 100644 --- a/roadmaps/aspnet-core/content/razor-pages@qpVxwuyA2oE06MZLtEdP1.md +++ b/roadmaps/aspnet-core/content/razor-pages@qpVxwuyA2oE06MZLtEdP1.md @@ -1,8 +1,6 @@ # Razor Pages -Razor Pages is a feature of the [ASP.NET](http://ASP.NET) Core framework that allows developers to build web applications using a combination of Razor markup (a markup syntax for defining dynamic HTML) and C# code. Razor Pages is built on top of the [ASP.NET](http://ASP.NET) Core MVC (Model-View-Controller) framework, and provides a simpler, more intuitive way to build web pages and handle user input. - -Razor Pages are useful for building simple, self-contained web pages that do not require a complex navigation or layout structure, and are often used for building small to medium-size web applications. +Razor Pages is a page-focused framework within ASP.NET Core that simplifies the process of building dynamic web interfaces by combining HTML with C# code. It uses a file-based routing system where each page consists of a `.cshtml` file for the view and a `.cshtml.cs` file for the page model, which handles the logic for handling requests and processing data. This approach keeps the code associated with a specific UI component bundled together, making it easier to manage and develop individual pages compared to the traditional Model-View-Controller pattern. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/razor@nUE2-egUMNFQoPVrVRFPl.md b/roadmaps/aspnet-core/content/razor@nUE2-egUMNFQoPVrVRFPl.md index 28daa08a2..bf8769396 100644 --- a/roadmaps/aspnet-core/content/razor@nUE2-egUMNFQoPVrVRFPl.md +++ b/roadmaps/aspnet-core/content/razor@nUE2-egUMNFQoPVrVRFPl.md @@ -1,6 +1,6 @@ # Razor -Razor is a markup syntax for embedding server-side code in web pages. It was introduced with [ASP.NET](http://ASP.NET) MVC 3 and later became a part of [ASP.NET](http://ASP.NET) Web Pages. It allows developers to write server-side code using C# or Visual Basic and embed it in HTML markup. Its syntax is designed to be compact and easy to read. It provides a rich set of features for building web applications, such as a component model for building reusable UI, a routing system for navigation, and support for dependency injection, it also allows you to use the same libraries, frameworks, and tools that you're already familiar with from building traditional [ASP.NET](http://ASP.NET) web applications. +Razor is a markup syntax that allows developers to embed server-based code into web pages using C#. It enables the seamless integration of dynamic programming logic directly within HTML, which the server processes to generate the final output sent to the browser. This syntax simplifies the creation of web content by minimizing the amount of code required to transition between static markup and executable server-side instructions. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/real-time-communication@9Vv3OxafB6BlHhi1ZkeVO.md b/roadmaps/aspnet-core/content/real-time-communication@9Vv3OxafB6BlHhi1ZkeVO.md index 8c379fe5e..5087fb21d 100644 --- a/roadmaps/aspnet-core/content/real-time-communication@9Vv3OxafB6BlHhi1ZkeVO.md +++ b/roadmaps/aspnet-core/content/real-time-communication@9Vv3OxafB6BlHhi1ZkeVO.md @@ -1,8 +1,6 @@ -# Real Time Communication +# Real-Time Communication -Real-time communication in [ASP.NET](http://ASP.NET) refers to the ability to send and receive data between a client and a server in real-time, typically with low latency. It allows the server to push updates to the client as they happen, instead of the client having to continuously poll the server for updates. - -There are several technologies and libraries available for implementing real-time communication in [ASP.NET](http://ASP.NET), such as WebSockets, SignalR, gRPC, and more. +Real-time communication in ASP.NET Core is primarily handled through SignalR, a library that allows server-side code to push content to connected clients instantly. It facilitates bi-directional communication between the server and the browser, enabling features like live notifications, chat applications, and real-time data dashboards without requiring the client to constantly request updates. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/redis@Ts0gJ4DdwFp48LGr4YSvM.md b/roadmaps/aspnet-core/content/redis@Ts0gJ4DdwFp48LGr4YSvM.md index 0a0450370..db725b466 100644 --- a/roadmaps/aspnet-core/content/redis@Ts0gJ4DdwFp48LGr4YSvM.md +++ b/roadmaps/aspnet-core/content/redis@Ts0gJ4DdwFp48LGr4YSvM.md @@ -1,12 +1,10 @@ -# Redis +# Redis Distributed Cache -Redis is an open source (BSD licensed) which is an in-memory data structure store used as a database, cache, message broker, and streaming engine. Redis provides data structures such as strings, hashes, lists, sets, sorted sets with range queries, bitmaps, hyperloglogs, geospatial indexes, and streams. Redis has built-in replication, Lua scripting, LRU eviction, transactions, and various levels of on-disk persistence, and provides high availability via Redis Sentinel and automatic partitioning with Redis Cluster. - -You can use Redis in many programming languages. It is such a popular and widely used cache that Microsoft Azure also provides its cloud-based version with the name Azure Cache for Redis. +Redis is an open-source, in-memory data store used as a distributed cache to improve the performance and scalability of ASP.NET Core applications. It allows multiple instances of an application to share the same cached data by storing information in a centralized server rather than in the local memory of an individual web server. This approach ensures data consistency across a server farm and prevents the loss of cached information if a specific application instance restarts. Visit the following resources to learn more: +- [@roadmap@Visit the Dedicated Redis Roadmap](https://roadmap.sh/redis) - [@official@Learn how to build with Redis Stack and .NET](https://redis.io/docs/stack/get-started/tutorials/stack-dotnet/) -- [@article@Redis Cache In ASP.NET 6.0 Web API](https://www.c-sharpcorner.com/article/easily-use-redis-cache-in-asp-net-6-0-web-api/) - [@video@ASP.Net Core Distributed Caching - Redis Caching](https://www.youtube.com/watch?v=4Br-QnBo6Yw) -- [@feed@Explore top posts about Redis](https://app.daily.dev/tags/redis?ref=roadmapsh) \ No newline at end of file +- [@article@Redis Cache In ASP.NET 6.0 Web API](https://www.c-sharpcorner.com/article/easily-use-redis-cache-in-asp-net-6-0-web-api/) \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/relational@FnRxRY3uDZdTve1w-nBfc.md b/roadmaps/aspnet-core/content/relational@FnRxRY3uDZdTve1w-nBfc.md index dc6fa3b8d..1c6382803 100644 --- a/roadmaps/aspnet-core/content/relational@FnRxRY3uDZdTve1w-nBfc.md +++ b/roadmaps/aspnet-core/content/relational@FnRxRY3uDZdTve1w-nBfc.md @@ -1,8 +1,6 @@ -# Relational +# Relational Databases -A relational database is a type of database that stores data in a structured format, using tables and relationships between them. It is based on the relational model, which organizes data into one or more tables, with each table consisting of a set of rows and columns. - -The main feature of a relational database is the ability to establish relationships between tables, using a feature called a foreign key. A foreign key is a column or set of columns in one table that is used to link to the primary key of another table. This allows data to be spread across multiple tables, but still be connected and easily accessed through these relationships. +Relational databases are structured data storage systems that organize information into tables with rows and columns. They use a schema to define the relationship between data points and typically rely on Structured Query Language (SQL) to manage, query, and retrieve that data. In the ASP.NET Core ecosystem, developers frequently interact with these systems using Object-Relational Mapping tools like Entity Framework Core to bridge the gap between relational tables and object-oriented code. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/repodb@tYDVcnG0oUF3R8DwASvAh.md b/roadmaps/aspnet-core/content/repodb@tYDVcnG0oUF3R8DwASvAh.md index a8f10ffdc..c4e042d1e 100644 --- a/roadmaps/aspnet-core/content/repodb@tYDVcnG0oUF3R8DwASvAh.md +++ b/roadmaps/aspnet-core/content/repodb@tYDVcnG0oUF3R8DwASvAh.md @@ -1,8 +1,6 @@ # RepoDB -RepoDB is an open-source ORM (Object-Relational Mapping) library for .NET that simplifies the process of working with databases. It is a lightweight, fast, and easy-to-use library that provides a simple and consistent API for performing common database operations such as querying, inserting, updating, and deleting data. - -RepoDb is built on top of [ADO.NET](http://ADO.NET), which is the native data access technology in .NET, and provides a higher-level abstraction on top of it. This allows RepoDb to take advantage of the performance and scalability of [ADO.NET](http://ADO.NET) while providing a simpler and more convenient API for developers. +RepoDB is a lightweight, high-performance hybrid Object-Relational Mapper (ORM) for .NET that bridges the gap between micro-ORMs like Dapper and full-featured ORMs like Entity Framework. It allows developers to perform CRUD operations and execute complex SQL queries with minimal overhead while providing the flexibility to write raw SQL when necessary. The library is designed to offer a balance of speed and developer productivity by automating common database tasks through an easy-to-use extension-based API. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/respawn@TCswZHviRiu6SIOwUisu8.md b/roadmaps/aspnet-core/content/respawn@TCswZHviRiu6SIOwUisu8.md index f7676f375..a2bfe7254 100644 --- a/roadmaps/aspnet-core/content/respawn@TCswZHviRiu6SIOwUisu8.md +++ b/roadmaps/aspnet-core/content/respawn@TCswZHviRiu6SIOwUisu8.md @@ -1,3 +1,3 @@ # Respawn -Respawn is a small .NET utility for resetting test databases to a clean state. It intelligently deletes data by tracking dependencies between tables, so you can run integration tests quickly without manually managing cleanup between test runs. +Respawn is a small .NET utility for resetting test databases to a clean state. It intelligently deletes data by tracking dependencies between tables, so you can run integration tests quickly without manually managing cleanup between test runs. \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/rest@KJCtxH3mYsZq3hfBZ6cJF.md b/roadmaps/aspnet-core/content/rest@KJCtxH3mYsZq3hfBZ6cJF.md index 1acf8f44b..d679f0cda 100644 --- a/roadmaps/aspnet-core/content/rest@KJCtxH3mYsZq3hfBZ6cJF.md +++ b/roadmaps/aspnet-core/content/rest@KJCtxH3mYsZq3hfBZ6cJF.md @@ -1,8 +1,6 @@ # REST -REST (Representational State Transfer) is an architectural style for building web services. It is based on the principles of the HTTP protocol, and it uses the conventions of HTTP to create a standard interface for interacting with web services. - -In [ASP.NET](http://ASP.NET), REST can be used to create web services that expose data in a standardized way. RESTful web services in [ASP.NET](http://ASP.NET) are typically built using the Web API framework, which provides a set of libraries and tools for building RESTful web services. +REST, which stands for Representational State Transfer, is an architectural style for designing networked applications that rely on stateless, client-server communication. It uses standard HTTP methods such as GET, POST, PUT, and DELETE to perform operations on resources identified by unique URLs. In ASP.NET Core, developers implement RESTful services by creating controllers that map HTTP verbs to specific data actions, allowing different applications to exchange information in formats like JSON or XML. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/scalar@Zb4Gugxf7d6MoeEcfngrV.md b/roadmaps/aspnet-core/content/scalar@Zb4Gugxf7d6MoeEcfngrV.md index 464070b8a..81ffdee6c 100644 --- a/roadmaps/aspnet-core/content/scalar@Zb4Gugxf7d6MoeEcfngrV.md +++ b/roadmaps/aspnet-core/content/scalar@Zb4Gugxf7d6MoeEcfngrV.md @@ -1,3 +1,3 @@ # Scalar -Scalar is a lightweight API platform for .NET that generates interactive API documentation and a UI for testing endpoints. It integrates with ASP.NET Core as a fast, configurable alternative to the default Swagger UI, built on the OpenAPI specification. +Scalar is a lightweight API platform for .NET that generates interactive API documentation and a UI for testing endpoints. It integrates with [ASP.NET](http://ASP.NET) Core as a fast, configurable alternative to the default Swagger UI, built on the OpenAPI specification. \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/scoped@M3BW_63MFQyD8NE68dazD.md b/roadmaps/aspnet-core/content/scoped@M3BW_63MFQyD8NE68dazD.md index c96a3bd8f..78972ac4d 100644 --- a/roadmaps/aspnet-core/content/scoped@M3BW_63MFQyD8NE68dazD.md +++ b/roadmaps/aspnet-core/content/scoped@M3BW_63MFQyD8NE68dazD.md @@ -1,8 +1,6 @@ -# Scoped +# Scoped Service Lifetime -Scoped lifetime is a type of dependency injection that creates a new instance of an object for each unique request, but reuses the same instance for the same request. This means that if multiple components within the same request depend on the same service, they will all receive the same instance. However, if another request is made, a new instance of the service will be created for that request. - -Scoped lifetime is useful when you have services that are specific to a given request, such as a request-scoped database context. This allows you to have a separate and isolated instance of a service for each unique request, which can help to prevent cross-request contamination of data and improve performance. +Scoped services are created once per client request within an ASP.NET Core application. When you register a service with a scoped lifetime, the framework generates a new instance for every individual HTTP request and shares that same instance across all components that process that specific request. This ensures that data remains consistent throughout the entire lifecycle of a single user interaction while preventing the service from persisting across different, unrelated requests. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/scriban@dWB5OCvWVYkD30Op_dMwy.md b/roadmaps/aspnet-core/content/scriban@dWB5OCvWVYkD30Op_dMwy.md index aed22830d..08a6a18f8 100644 --- a/roadmaps/aspnet-core/content/scriban@dWB5OCvWVYkD30Op_dMwy.md +++ b/roadmaps/aspnet-core/content/scriban@dWB5OCvWVYkD30Op_dMwy.md @@ -1,6 +1,6 @@ # Scriban -Scriban is an open-source, lightweight template engine for .NET that is based on the Lua programming language. It is designed to be simple and easy to use, while still providing a powerful set of features for creating and manipulating templates. It provides a simple and easy-to-use API for parsing and rendering templates, and supports a wide range of features such as variables, loops, conditionals, and functions. It also provides a wide range of built-in functions for working with strings, numbers, dates, and other types of data, and also supports advanced features such as scripting and metaprogramming. +Scriban is a fast, powerful, and safe text templating language and engine for .NET. It allows developers to define dynamic templates that can be parsed and rendered with custom data objects. Because it focuses on security and performance, it is often used for generating emails, reports, or dynamic HTML content within server-side applications. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/scrutor@f212ztDU_kb7gO71Nn76L.md b/roadmaps/aspnet-core/content/scrutor@f212ztDU_kb7gO71Nn76L.md index 571872610..4345e0a5a 100644 --- a/roadmaps/aspnet-core/content/scrutor@f212ztDU_kb7gO71Nn76L.md +++ b/roadmaps/aspnet-core/content/scrutor@f212ztDU_kb7gO71Nn76L.md @@ -1,8 +1,6 @@ # Scrutor -Scrutor is an open-source library for .NET that extends the functionality of the built-in dependency injection framework in .NET Core. It provides a set of extension methods for the `IServiceCollection` interface, which can be used to register and configure services in a more convenient and flexible way. - -One of the main features of Scrutor is its ability to automatically scan assemblies for services and register them with the dependency injection container, allowing you to avoid having to manually register each service one by one. It also provides a fluent API that makes it easy to configure services, such as specifying the lifetime of a service, adding decorators, and more. +Scrutor is a library for ASP.NET Core that extends the built-in dependency injection container with additional features, primarily focused on assembly scanning and decorator support. It allows developers to automatically register services based on specific conventions or attributes, which helps reduce the amount of boilerplate code required for manual service configuration. Additionally, it provides a clean syntax for decorating existing services, making it easier to implement cross-cutting concerns like logging or caching without modifying the original implementation classes. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/search-engines@6p5atMYw3b3bXkQuXZsDV.md b/roadmaps/aspnet-core/content/search-engines@6p5atMYw3b3bXkQuXZsDV.md index 0d3c2dc68..0127a92d6 100644 --- a/roadmaps/aspnet-core/content/search-engines@6p5atMYw3b3bXkQuXZsDV.md +++ b/roadmaps/aspnet-core/content/search-engines@6p5atMYw3b3bXkQuXZsDV.md @@ -1,8 +1,6 @@ # Search Engines -A search engine in an [ASP.NET](http://ASP.NET) application is a tool or module that allows users to search for and retrieve specific information from the application's database or other data sources. Search engines can be used to perform full-text search, faceted search, and geospatial search, among other things. - -Search engines can be integrated into an [ASP.NET](http://ASP.NET) application by using libraries or frameworks that provide a .NET client for interacting with the search engine. Some popular search engines that can be integrated with an [ASP.NET](http://ASP.NET) application include Elasticsearch, Apache Solr, Sphinx, and Microsoft Azure Search. +Search engines in ASP.NET Core are specialized tools integrated into applications to provide fast, full-text search capabilities over large datasets. Unlike standard relational databases that primarily focus on structured data retrieval, these engines use indexing techniques to perform complex queries, rank results by relevance, and handle fuzzy matching. Developers typically connect ASP.NET Core applications to dedicated search platforms like Elasticsearch, Azure AI Search, or Meilisearch to improve the speed and efficiency of data discovery for end users. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/shouldly@zhn-VLGPfV6FZT2OMl6zf.md b/roadmaps/aspnet-core/content/shouldly@zhn-VLGPfV6FZT2OMl6zf.md index 41656c53f..2e84a4c5f 100644 --- a/roadmaps/aspnet-core/content/shouldly@zhn-VLGPfV6FZT2OMl6zf.md +++ b/roadmaps/aspnet-core/content/shouldly@zhn-VLGPfV6FZT2OMl6zf.md @@ -1,6 +1,6 @@ # Shouldly -Shouldly is a .NET library that provides a set of extension methods for writing expressive and readable assertions in unit tests, it's designed to be an alternative to traditional assertion libraries. In the context of [ASP.NET](http://ASP.NET), Shouldly can be used in conjunction with test frameworks such as MSTest, xUnit, and NUnit to write more expressive and readable unit tests for the application. It provides advanced features such as support for collection-specific assertions, support for asynchronous code, and support for custom types, also includes options to customize the error message. +Shouldly is an assertion library for .NET that focuses on providing human-readable error messages when tests fail. It replaces traditional assertion syntax with a fluent, natural language style, making it easier to understand exactly why a test did not meet your expectations. Instead of generic messages, it generates descriptive output based on the code being tested, which simplifies the debugging process for developers. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/signalr-core@8dvd4M0TKNyQR8dEolGNT.md b/roadmaps/aspnet-core/content/signalr-core@8dvd4M0TKNyQR8dEolGNT.md index c240a1e5c..7c4cdc018 100644 --- a/roadmaps/aspnet-core/content/signalr-core@8dvd4M0TKNyQR8dEolGNT.md +++ b/roadmaps/aspnet-core/content/signalr-core@8dvd4M0TKNyQR8dEolGNT.md @@ -1,6 +1,6 @@ # SignalR Core -SignalR is a real-time communication library for .NET that allows for the creation of real-time web applications. SignalR Core is the latest version of SignalR, which has been rebuilt from the ground up to be cross-platform and lightweight. It allows for bidirectional communication between a client (such as a web page) and a server, enabling real-time updates, notifications, and other interactions. SignalR Core can be used in a variety of scenarios such as chat applications, gaming, and real-time dashboards. It supports multiple transports like WebSockets, Server-Sent Events and Long polling. It also supports for authentication and authorization. +SignalR Core is a library that simplifies the process of adding real-time web functionality to applications by allowing server-side code to push content to connected clients instantly. It automatically manages connection management, such as handling sockets, while falling back to other compatible technologies like Server-Sent Events or Long Polling when necessary. This tool enables developers to create interactive features like live chat, dashboards, and real-time notifications by maintaining persistent connections between the server and the browser. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/singleton@y9bDrCjkDbxSIrEEtu_Mi.md b/roadmaps/aspnet-core/content/singleton@y9bDrCjkDbxSIrEEtu_Mi.md index e6b459899..123a63b7c 100644 --- a/roadmaps/aspnet-core/content/singleton@y9bDrCjkDbxSIrEEtu_Mi.md +++ b/roadmaps/aspnet-core/content/singleton@y9bDrCjkDbxSIrEEtu_Mi.md @@ -1,8 +1,6 @@ # Singleton -Singleton lifetime is a type of dependency injection that creates a single instance of an object and reuses it throughout the lifetime of the application. This means that if multiple components within the same request or across different requests depend on the same service, they will all receive the same instance of the service. - -Singleton lifetime is useful when you have services that need to maintain state or shared data across requests, such as a service that caches data or maintains a connection to a resource. +A Singleton service is created the first time it is requested or when the application starts, and the same instance is then shared across every subsequent request throughout the entire application lifetime. Because this single instance persists for the duration of the app, it is commonly used for managing shared state, configuration settings, or caching services that need to maintain data across different parts of the system. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/solr@2sY_p_8cOOBmZtDHO2Cmy.md b/roadmaps/aspnet-core/content/solr@2sY_p_8cOOBmZtDHO2Cmy.md index 21f2dfc9e..7415d0778 100644 --- a/roadmaps/aspnet-core/content/solr@2sY_p_8cOOBmZtDHO2Cmy.md +++ b/roadmaps/aspnet-core/content/solr@2sY_p_8cOOBmZtDHO2Cmy.md @@ -1,8 +1,6 @@ # Solr -Apache Solr is a search engine platform based on the Apache Lucene library. It is a standalone enterprise search server that provides a REST-like API for indexing, searching, and updating documents. Solr can be used to perform full-text search, faceted search, and geospatial search, among other things. - -Solr can be useful in [ASP.NET](http://ASP.NET) application to provide advanced search capabilities, such as full-text search, faceted search and geospatial search, which can be useful in e-commerce, content management systems, and logging and monitoring applications. It is known for its scalability, performance and its ability to handle large volumes of data with complex queries. +Solr is an open-source, enterprise-level search platform built on top of the Apache Lucene library. It provides high-performance, full-text search capabilities, hit highlighting, and faceted search features for large-scale applications. Within an ASP.NET Core environment, developers interact with Solr to index and retrieve structured or unstructured data, enabling fast and complex query operations that go beyond the limitations of traditional relational database search functions. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/specflow@9WZmjiFowydYrkHQ2xeNm.md b/roadmaps/aspnet-core/content/specflow@9WZmjiFowydYrkHQ2xeNm.md index 3c39ef9da..563dab848 100644 --- a/roadmaps/aspnet-core/content/specflow@9WZmjiFowydYrkHQ2xeNm.md +++ b/roadmaps/aspnet-core/content/specflow@9WZmjiFowydYrkHQ2xeNm.md @@ -1,6 +1,6 @@ # SpecFlow -SpecFlow is an open-source tool that allows developers to create automated acceptance tests in a natural language format, such as Gherkin. SpecFlow is commonly used in the context of [ASP.NET](http://ASP.NET) and other .NET technologies, to write acceptance tests for web applications. With SpecFlow, developers can write test scenarios using plain text in the Gherkin syntax, which uses a Given-When-Then format to describe the steps of a test. These scenarios can be written by non-technical stakeholders, such as business analysts or product owners, and can be easily understood by anyone who reads them. SpecFlow then converts these Gherkin scenarios into executable tests, which can be run using a variety of test runners, such as NUnit, xUnit, or MSTest. The tool also provides a set of bindings that allow developers to map the steps in the Gherkin scenarios to code in their application, making it easy to test specific functionality. Additionally, SpecFlow provides a set of advanced features, such as support for parameterized tests, background steps, and hooks, which allows developers to create more complex and powerful tests. +SpecFlow is a testing framework for .NET that enables Behavior Driven Development by allowing you to define application requirements and acceptance criteria in a human-readable format. It uses the Gherkin syntax, which employs plain language statements like "Given," "When," and "Then" to describe software features and scenarios. These specifications are then mapped to underlying C# code, which executes the tests to verify that the application behaves as expected. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/sphinx@Ye9WHfwZa-Fc2YDaTCmU1.md b/roadmaps/aspnet-core/content/sphinx@Ye9WHfwZa-Fc2YDaTCmU1.md index 3d258dafd..3f5af1d1b 100644 --- a/roadmaps/aspnet-core/content/sphinx@Ye9WHfwZa-Fc2YDaTCmU1.md +++ b/roadmaps/aspnet-core/content/sphinx@Ye9WHfwZa-Fc2YDaTCmU1.md @@ -1,8 +1,6 @@ # Sphinx -Sphinx is an open-source full-text search engine that can be used to index, search and analyze large volumes of data quickly and in near real-time. It is designed to handle high-traffic websites and large data sets and can be used for full-text search, faceted search, and geospatial search. - -In an [ASP.NET](http://ASP.NET) application, Sphinx can be integrated as a search engine to provide advanced search functionality to the application. There are several libraries available for integrating Sphinx with an [ASP.NET](http://ASP.NET) application, such as [SphinxQL.NET](http://SphinxQL.NET) and SphinxClient. These libraries provide a .NET client for Sphinx, which can be used to interact with the Sphinx engine from within an [ASP.NET](http://ASP.NET) application. +Sphinx is an open-source, full-text search server designed to provide fast and relevant search results for large datasets. It functions as an external indexing engine that allows developers to perform complex searches across databases, XML files, or other data sources without overloading the primary database. By integrating Sphinx into an ASP.NET Core application, developers can implement advanced features like Boolean queries, ranking, and highlighting to handle high-performance search requirements. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/sql-basics@aOJMVrTcA_I2y_QHzj7aM.md b/roadmaps/aspnet-core/content/sql-basics@aOJMVrTcA_I2y_QHzj7aM.md index 259aad4ab..f4de67ad6 100644 --- a/roadmaps/aspnet-core/content/sql-basics@aOJMVrTcA_I2y_QHzj7aM.md +++ b/roadmaps/aspnet-core/content/sql-basics@aOJMVrTcA_I2y_QHzj7aM.md @@ -1,12 +1,8 @@ -# Sql basics +# SQL Basics -SQL stands for Structured Query Language. SQL lets you access and manipulate databases SQL became a standard of the American National Standards Institute (ANSI) in 1986, and of the International Organization for Standardization (ISO) in 1987. - -Although SQL is an ANSI/ISO standard, there are different versions of the SQL language. - -However, to be compliant with the ANSI standard, they all support at least the major commands (such as SELECT, UPDATE, DELETE, INSERT, WHERE) in a similar manner. +SQL (Structured Query Language) is a standard programming language designed for managing and manipulating data held in relational databases. It allows developers to perform essential operations such as retrieving data with queries, inserting new records, updating existing information, and deleting entries from database tables. By using SQL, applications can interact with database management systems to ensure data is stored, organized, and accessed efficiently. Visit the following resources to learn more: -- [@video@SQL Tutorial - Full Database Course for Beginners](https://www.youtube.com/watch?v=HXV3zeQKqGY) -- [@feed@Explore top posts about SQL](https://app.daily.dev/tags/sql?ref=roadmapsh) \ No newline at end of file +- [@roadmap@Visit the Dedicated SQL Roadmap](https://roadmap.sh/sql) +- [@video@SQL Tutorial - Full Database Course for Beginners](https://www.youtube.com/watch?v=HXV3zeQKqGY) \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/stored-procedures@ZiK-c9zNbi5RZkKUi44wP.md b/roadmaps/aspnet-core/content/stored-procedures@ZiK-c9zNbi5RZkKUi44wP.md index 279e9a03c..b8dd34140 100644 --- a/roadmaps/aspnet-core/content/stored-procedures@ZiK-c9zNbi5RZkKUi44wP.md +++ b/roadmaps/aspnet-core/content/stored-procedures@ZiK-c9zNbi5RZkKUi44wP.md @@ -1,6 +1,6 @@ # Stored Procedures -A stored procedure is a pre-compiled collection of SQL statements that can be executed on a database server. Stored procedures are typically used to perform specific tasks, such as retrieving data from a database, inserting or updating data, or performing complex calculations. They are stored on the database server and can be called or executed from a client application or other stored procedures. Stored procedures can improve database performance by reducing the amount of SQL code needed to be executed and allowing developers to reuse common pieces of code. They can also provide security by allowing database administrators to control which users have access to specific stored procedures. +Stored procedures are prepared collections of SQL statements that are stored within a database to be executed as a single unit. When working with ASP.NET Core, these procedures allow developers to encapsulate complex logic and multiple queries on the database server side, which helps reduce the amount of data transferred between the application and the database. They are invoked by the application using command objects or Object-Relational Mapping tools like Entity Framework Core, providing a way to handle data operations securely and efficiently. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/task-scheduling@s57tKy1rajlJbKFDVXLqs.md b/roadmaps/aspnet-core/content/task-scheduling@s57tKy1rajlJbKFDVXLqs.md index 214323abb..9cbffe676 100644 --- a/roadmaps/aspnet-core/content/task-scheduling@s57tKy1rajlJbKFDVXLqs.md +++ b/roadmaps/aspnet-core/content/task-scheduling@s57tKy1rajlJbKFDVXLqs.md @@ -1,8 +1,6 @@ # Task Scheduling -Task scheduling in [ASP.NET](http://ASP.NET) refers to the process of scheduling and executing background tasks in an application. This can include tasks such as sending emails, processing data, generating reports, or performing maintenance tasks. - -In [ASP.NET](http://ASP.NET), task scheduling can be implemented using a variety of libraries and frameworks such as [Quartz.NET](http://Quartz.NET), Hangfire, Coravel and Microsoft's built-in IHostedService interface. These libraries and frameworks provide a way to schedule tasks to run at specific times or intervals, and also provide APIs for managing and monitoring the progress of scheduled tasks. +Task scheduling in ASP.NET Core involves executing background operations at specific intervals or at designated times without requiring direct user interaction. This functionality is typically implemented using the `IHostedService` interface or the `BackgroundService` base class, which allow developers to run long-running processes within the application's lifecycle. These background tasks are useful for performing recurring operations such as sending automated emails, cleaning up databases, or synchronizing external data sources. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/test-containers@8eW5BaOjJbnQ7uk4zMOiU.md b/roadmaps/aspnet-core/content/test-containers@8eW5BaOjJbnQ7uk4zMOiU.md index 7f87c6a21..0b02b201e 100644 --- a/roadmaps/aspnet-core/content/test-containers@8eW5BaOjJbnQ7uk4zMOiU.md +++ b/roadmaps/aspnet-core/content/test-containers@8eW5BaOjJbnQ7uk4zMOiU.md @@ -1,3 +1,3 @@ # Test Containers -Testcontainers is a library that runs throwaway Docker containers for your tests. The .NET version lets you spin up real instances of databases, message brokers, and other services inside integration tests, then disposes of them automatically when the tests finish. +Testcontainers is a library that runs throwaway Docker containers for your tests. The .NET version lets you spin up real instances of databases, message brokers, and other services inside integration tests, then disposes of them automatically when the tests finish. \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/testing@XofWWhlU_vWCG5oXVMZze.md b/roadmaps/aspnet-core/content/testing@XofWWhlU_vWCG5oXVMZze.md index 76ed606e3..4987e67b7 100644 --- a/roadmaps/aspnet-core/content/testing@XofWWhlU_vWCG5oXVMZze.md +++ b/roadmaps/aspnet-core/content/testing@XofWWhlU_vWCG5oXVMZze.md @@ -1,6 +1,6 @@ # Testing -Testing in [ASP.NET](http://ASP.NET) is the process of evaluating the performance, functionality, and overall correctness of an application developed using the [ASP.NET](http://ASP.NET) framework. There are several types of testing that can be performed on an [ASP.NET](http://ASP.NET) application, including unit testing, integration testing, acceptance testing and E2E testing. Each type of testing has a different focus and is used at a different stage of the development process. Common testing frameworks for [ASP.NET](http://ASP.NET) include MSTest, XUnit, NUnit, Selenium, Playwright, Puppeteer, Cypress, Specflow, Cucumber, and LightBDD. +Testing in ASP.NET Core involves verifying that your application components function correctly and meet the specified requirements. Developers use various approaches such as unit testing to validate individual methods or classes, integration testing to ensure different modules work together seamlessly, and functional testing to evaluate the application from the user's perspective. These processes utilize testing frameworks like xUnit, NUnit, or MSTest along with built-in tools to automate the validation of business logic, database interactions, and API endpoints to maintain code reliability. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/transient@-N0XM0-VtCZ6QMo2YyMD-.md b/roadmaps/aspnet-core/content/transient@-N0XM0-VtCZ6QMo2YyMD-.md index 26584e0fa..f54280207 100644 --- a/roadmaps/aspnet-core/content/transient@-N0XM0-VtCZ6QMo2YyMD-.md +++ b/roadmaps/aspnet-core/content/transient@-N0XM0-VtCZ6QMo2YyMD-.md @@ -1,8 +1,6 @@ # Transient -Transient lifetime is a type of dependency injection that creates a new instance of an object each time it is requested. This means that if multiple components within the same request or across different requests depend on the same service, they will each receive a new instance of the service. - -Transient lifetime is useful when you have services that are stateless and do not need to maintain any data between requests, such as a service that performs a simple calculation or returns data from a database. +Transient services are created every time they are requested from the service container. This lifecycle is ideal for lightweight, stateless services because a new instance is provided for every controller or service that requires it. Since these objects are not shared across different parts of the application, they avoid issues related to shared state. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/triggers@2f_CJMnXwPxjMEwm5P_QJ.md b/roadmaps/aspnet-core/content/triggers@2f_CJMnXwPxjMEwm5P_QJ.md index ae42ec5a5..ffce7c593 100644 --- a/roadmaps/aspnet-core/content/triggers@2f_CJMnXwPxjMEwm5P_QJ.md +++ b/roadmaps/aspnet-core/content/triggers@2f_CJMnXwPxjMEwm5P_QJ.md @@ -1,10 +1,6 @@ # Triggers -Triggers are special type of stored procedures that are automatically executed in response to specific events that occur within a database. These events can include: - -* Data modification events (INSERT, UPDATE, DELETE) on a specific table or view. -* Data definition events (CREATE, ALTER, DROP) on specific database objects such as tables or views. -* Logon events (CONNECT, DISCONNECT) that occur when a user connects to or disconnects from the database. +A trigger is a specialized type of stored procedure in a database that automatically executes in response to specific events on a particular table or view. These events typically include data modification actions such as inserting, updating, or deleting records. Database administrators and developers use triggers to enforce complex business rules, maintain audit trails, or ensure referential integrity across related data sets within the storage layer. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/web-sockets@tBl8neu3tJd5GPwGfJbjZ.md b/roadmaps/aspnet-core/content/web-sockets@tBl8neu3tJd5GPwGfJbjZ.md index 3b9344589..0688e255a 100644 --- a/roadmaps/aspnet-core/content/web-sockets@tBl8neu3tJd5GPwGfJbjZ.md +++ b/roadmaps/aspnet-core/content/web-sockets@tBl8neu3tJd5GPwGfJbjZ.md @@ -1,11 +1,10 @@ -# Web Sockets +# WebSockets -WebSockets is a protocol that allows for real-time, bidirectional communication between a client and a server. It is based on the same principle as HTTP, but it uses a different protocol to establish and maintain a connection between the client and the server. Once a connection is established, WebSockets enables the client and server to send messages to each other in real-time. - -In [ASP.NET](http://ASP.NET), WebSockets can be used to create real-time, highly interactive web applications. The [ASP.NET](http://ASP.NET) Core framework provides built-in support for WebSockets through the Microsoft.AspNetCore.WebSockets package. This package provides a set of classes and methods that make it easy to create and manage WebSockets connections. +WebSockets provide a persistent, full-duplex communication channel over a single TCP connection between a client and a server. This technology enables real-time data transfer, allowing servers to push updates to connected clients immediately without the need for the client to constantly request new information. In ASP.NET Core, the middleware handles the WebSocket handshake and manages the ongoing connection, making it suitable for applications like chat platforms, live dashboards, or collaborative tools. Visit the following resources to learn more: - [@article@WebSockets support in ASP.NET](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/websockets?view=aspnetcore-7.0) - [@article@Understanding WebSockets with ASP.NET](https://sahansera.dev/understanding-websockets-with-aspnetcore-5/) +- [@article@WebSocket vs HTTP: Which Protocol Should You Use?](https://roadmap.sh/network-engineer/websocket-vs-http) - [@article@Writing a WebSocket server in ASP.NET](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API/Writing_WebSocket_server) \ No newline at end of file diff --git a/roadmaps/aspnet-core/content/webapplicationfactory@Xx5G09n4WWnnydCgxnL0A.md b/roadmaps/aspnet-core/content/webapplicationfactory@Xx5G09n4WWnnydCgxnL0A.md index a87b79552..909a814d3 100644 --- a/roadmaps/aspnet-core/content/webapplicationfactory@Xx5G09n4WWnnydCgxnL0A.md +++ b/roadmaps/aspnet-core/content/webapplicationfactory@Xx5G09n4WWnnydCgxnL0A.md @@ -1,6 +1,6 @@ # WebApplicationFactory -Web Application Factory (WAF) is a built-in feature of the [ASP.NET](http://ASP.NET) Core framework that allows developers to create and configure a web application in a programmatic way. It provides a simple and flexible way to set up a web application for testing, without the need for a web server or a browser. The WAF can be used to create a test server that can be used to run integration tests or end-to-end tests for an [ASP.NET](http://ASP.NET) Core web application, this allows developers to test the web application in a realistic environment, without the need for a physical web server or a browser. The WAF can be configured to use different services, middleware, and settings, depending on the needs of the application, this allows developers to easily set up a web application that is configured specifically for testing. The WAF also allows developers to test the web application against different configurations, such as different databases, different authentication providers, and different hosting environments. +WebApplicationFactory is a specialized class in ASP.NET Core that simplifies the process of creating a test server for integration testing. It allows developers to host an application in memory, making it possible to send HTTP requests to the system and verify the complete response cycle without needing to deploy the code to a web server. By utilizing this tool, you can easily configure custom services or replace real database connections with mocks to ensure your API endpoints behave as expected in a real-world execution environment. Visit the following resources to learn more: diff --git a/roadmaps/aspnet-core/content/xunit@R8C6s53RYjkRVma0nCJpy.md b/roadmaps/aspnet-core/content/xunit@R8C6s53RYjkRVma0nCJpy.md index 7a2c5d6d7..b06199498 100644 --- a/roadmaps/aspnet-core/content/xunit@R8C6s53RYjkRVma0nCJpy.md +++ b/roadmaps/aspnet-core/content/xunit@R8C6s53RYjkRVma0nCJpy.md @@ -1,6 +1,6 @@ # xUnit -xUnit is a unit testing framework for the .NET framework, it's an open-source testing framework that provides a set of attributes and classes that can be used to create unit tests. In the context of [ASP.NET](http://ASP.NET), xUnit can be used to write unit tests for web applications built using the [ASP.NET](http://ASP.NET) framework. xUnit provides features such as support for data-driven tests, support for parallel test execution, and support for test discovery and execution, it also provides support for test isolation which allows developers to run tests in isolation from each other. xUnit is a popular alternative to other testing frameworks like MSTest and it does not rely on a test runner, instead relies on a console runner that can be run from the command line. +xUnit is a free, open-source, community-focused unit testing tool for the .NET framework. It follows a clean and developer-friendly design that isolates tests into individual methods, ensuring that each test run is independent and predictable. It provides a robust set of assertions and attributes that help developers verify that specific portions of code behave as expected during the development process. Visit the following resources to learn more: