Adds readme for more extension items (#77865)

src/libraries/Microsoft.Extensions.Caching.Memory/README.md

@@ -0,0 +1,13 @@
+# Microsoft.Extensions.Caching.Memory
+
+In-memory caching provides a general purpose memory implementation of the core caching abstractions provided under `Microsoft.Extensions.Caching.Abstractions` and it is great for apps that run in a single server, where all cached data rents memory in the app's process.
+
+Documentation can be found at https://learn.microsoft.com/en-us/dotnet/core/extensions/caching.
+
+## Contribution Bar
+- [x] [We consider new features, new APIs, bug fixes, and performance changes](../../libraries/README.md#primary-bar)
+
+The APIs and functionality need more investment in the upcoming .NET releases.
+
+## Deployment
+[Microsoft.Extensions.Caching.Memory](https://www.nuget.org/packages/Microsoft.Extensions.Caching.Memory) is included in the ASP.NET Core shared framework. The package is deployed as out-of-band (OOB) too and can be referenced into projects directly.

src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/README.md

@@ -0,0 +1,24 @@
+# Microsoft.Extensions.DependencyInjection.Abstractions
+
+`Microsoft.Extensions.DependencyInjection.Abstractions` contains a core DI abstraction that allows for building different kinds of dependency injection containers to retrieve services from that have been registered with different lifetimes.
+
+Documentation can be found at https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection.
+
+## Contribution Bar
+- [x] [We consider new features, new APIs, bug fixes, and performance changes](../../libraries/README.md#primary-bar)
+
+The APIs and functionality need more investment in the upcoming .NET releases.
+
+## Deployment
+[Microsoft.Extensions.DependencyInjection.Abstractions](https://www.nuget.org/packages/Microsoft.Extensions.DependencyInjection.Abstractions) is included in the ASP.NET Core shared framework. The package is deployed as out-of-band (OOB) too and can be referenced into projects directly.
+
+## Using other containers with Microsoft.Extensions.DependencyInjection
+
+* [**Autofac**](https://autofac.readthedocs.org/en/latest/integration/aspnetcore.html)
+* [**DryIoc**](https://www.nuget.org/packages/DryIoc.Microsoft.DependencyInjection)
+* [**Grace**](https://www.nuget.org/packages/Grace.DependencyInjection.Extensions)
+* [**Lamar**](https://www.nuget.org/packages/Lamar.Microsoft.DependencyInjection)
+* [**LightInject**](https://github.com/seesharper/LightInject.Microsoft.DependencyInjection)
+* [**StructureMap**](https://github.com/structuremap/StructureMap.Microsoft.DependencyInjection)
+* [**Stashbox**](https://github.com/z4kn4fein/stashbox-extensions-dependencyinjection)
+* [**Unity**](https://www.nuget.org/packages/Unity.Microsoft.DependencyInjection/)

src/libraries/Microsoft.Extensions.DependencyModel/README.md

@@ -0,0 +1,45 @@
+# Microsoft.Extensions.DependencyModel
+
+`Microsoft.Extensions.DependencyModel` provides abstractions for reading .deps files. When a .NET application is compiled, the SDK generates a JSON manifest file (<ApplicationName>.deps.json) that contains information about application dependencies. You can use `Microsoft.Extensions.DependencyModel` to read information from this manifest at run time. This is useful when you want to dynamically compile code (for example, using Roslyn Emit API) referencing the same dependencies as your main application.
+
+By default, the dependency manifest contains information about the application's target framework and runtime dependencies. Set the PreserveCompilationContext project property to true to additionally include information about reference assemblies used during compilation.
+
+For more information, see the documentation:
+
+- .deps.json file format
+- Microsoft.Extensions.DependencyModel namespace
+- Microsoft.Extensions.DependencyModel.DependencyContext
+
+## Contribution Bar
+- [x] [We consider new features, new APIs, bug fixes, and performance changes](https://github.com/dotnet/runtime/tree/main/src/libraries#contribution-bar)
+
+The APIs and functionality are mature, but do get extended occasionally.
+
+# Example
+
+The following example shows how to display the list of assemblies used when compiling the current application. Include `<PreserveCompilationContext>true</PreserveCompilationContext>` in your project file to run this example.
+
+```c#
+using System;
+using Microsoft.Extensions.DependencyModel;
+
+class Program
+{
+    static void Main()
+    {
+        Console.WriteLine("Compilation libraries:");
+        Console.WriteLine();
+
+        foreach (CompilationLibrary lib in DependencyContext.Default.CompileLibraries)
+        {
+            foreach (string path in lib.ResolveReferencePaths())
+            {
+                Console.WriteLine(path);
+            }
+        }
+    }
+}
+```
+
+## Deployment
+[Microsoft.Extensions.DependencyModel](https://www.nuget.org/packages/Microsoft.Extensions.DependencyModel) is deployed as out-of-band (OOB) too and can be referenced into projects directly.

src/libraries/Microsoft.Extensions.Hosting.Abstractions/README.md

@@ -0,0 +1,21 @@
+# Microsoft.Extensions.Hosting.Abstractions
+
+`Microsoft.Extensions.Hosting.Abstractions` contains a core hosting abstraction providing the pattern for using the extensions libraries to host user code in an application. Hosting helps configure Logging, Configuration, DI, and to wire up specific application models like ASP.NET Core that are built on top of hosting.
+
+Hosting provides as a primitive the concept of a hosted service, which is how application models like ASP.NET Core integrate with the host. Users often write hosted services as to handle their own application concerns.
+
+Hosting provides good integration for long-running console applications, windows services, ASP.NET Core.
+
+Documentation can be found at https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.hosting.
+
+## Contribution Bar
+- [x] [We consider new features, new APIs, bug fixes, and performance changes](../../libraries/README.md#primary-bar)
+
+The APIs and functionality are mature and there is no active plan for investment but we are open to explore ideas to invest in it in more depth in the future. The ideal future investments here may be to:
+
+- Support all .NET Core application models like: WinForms, WPF, UWP, Xamarin, Short-running (batch) console jobs, Blazor (client)
+- Support for idle/pause in hosted services.
+- Support more base-classes for hosted services like timer-based and trigger-based
+
+## Deployment
+[Microsoft.Extensions.Hosting.Abstractions](https://www.nuget.org/packages/Microsoft.Extensions.Hosting.Abstractions) is included in the ASP.NET Core shared framework. The package is deployed as out-of-band (OOB) too and can be referenced into projects directly.

src/libraries/Microsoft.Extensions.Hosting.Systemd/README.md

@@ -0,0 +1,13 @@
+# Microsoft.Extensions.Hosting.Systemd
+
+`Microsoft.Extensions.Hosting.Systemd` contains implementation for using hosting in Systemd Services.
+
+Documentation can be found at https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.hosting.
+
+## Contribution Bar
+- [x] [We consider new features, new APIs, bug fixes, and performance changes](https://github.com/dotnet/runtime/tree/main/src/libraries#contribution-bar)
+
+The APIs and functionality are mature, but do get extended occasionally.
+
+## Deployment
+[Microsoft.Extensions.Hosting.Systemd](https://www.nuget.org/packages/Microsoft.Extensions.Hosting.Systemd) is included in the ASP.NET Core shared framework. The package is deployed as out-of-band (OOB) too and can be referenced into projects directly.

src/libraries/Microsoft.Extensions.Hosting.WindowsServices/README.md

@@ -0,0 +1,13 @@
+# Microsoft.Extensions.Hosting.WindowsServices
+
+`Microsoft.Extensions.Hosting.WindowsServices` contains implementation for using hosting in Windows Services.
+
+Documentation can be found at https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.hosting.
+
+## Contribution Bar
+- [x] [We consider new features, new APIs, bug fixes, and performance changes](https://github.com/dotnet/runtime/tree/main/src/libraries#contribution-bar)
+
+The APIs and functionality are mature, but do get extended occasionally.
+
+## Deployment
+[Microsoft.Extensions.Hosting.WindowsServices](https://www.nuget.org/packages/Microsoft.Extensions.Hosting.WindowsServices) is included in the ASP.NET Core shared framework. The package is deployed as out-of-band (OOB) too and can be referenced into projects directly.

src/libraries/Microsoft.Extensions.Http/README.md

@@ -0,0 +1,14 @@
+# Microsoft.Extensions.Http
+
+`Microsoft.Extensions.Http` provides an implementation of an HttpClient factory as a pattern for configuring and retrieving named HttpClients in a composable way. The HttpClient factory provides extensibility to plug in DelegatingHandlers that address cross-cutting concerns such as service location, load balancing, and reliability. The default HttpClient factory provides built-in diagnostics and logging and manages the lifetimes of connections in a performant way.
+
+Commonly Used Types:
+- System.Net.Http.IHttpClientFactory
+
+## Contribution Bar
+- [x] [We consider new features, new APIs, bug fixes, and performance changes](https://github.com/dotnet/runtime/tree/main/src/libraries#contribution-bar)
+
+The APIs and functionality are mature, but do get extended occasionally.
+
+## Deployment
+[Microsoft.Extensions.Http](https://www.nuget.org/packages/Microsoft.Extensions.Http) is deployed as out-of-band (OOB) too and can be referenced into projects directly.

src/libraries/Microsoft.Extensions.Logging.EventSource/README.md

@@ -0,0 +1,14 @@
+# Microsoft.Extensions.Logging.EventSource
+
+`Microsoft.Extensions.Logging.EventSource` provides a basic implementation for the built-in event source logger provider. Using `Microsoft.Extensions.Logging.EventSource.LoggingEventSource` which is the bridge from all ILogger-based logging to EventSource/EventListener logging, logging can be enabled by enabling the event source called "Microsoft-Extensions-Logging".
+
+Documentation can be found at https://learn.microsoft.com/en-us/dotnet/core/extensions/logging.
+
+## Contribution Bar
+- [x] [We consider new features, new APIs, bug fixes, and performance changes](../../libraries/README.md#primary-bar)
+- [x] [We consider PRs that target this library for improvements to the logging source generator](../../libraries/README.md#secondary-bars)
+
+The APIs and functionality are mature, but do get extended occasionally.
+
+## Deployment
+[Microsoft.Extensions.Logging.EventSource](https://www.nuget.org/packages/Microsoft.Extensions.Logging.EventSource) is included in the ASP.NET Core shared framework. The package is deployed as out-of-band (OOB) too and can be referenced into projects directly.

src/libraries/Microsoft.Extensions.Logging.TraceSource/README.md

@@ -0,0 +1,14 @@
+# Microsoft.Extensions.Logging.TraceSource
+
+`Microsoft.Extensions.Logging.TraceSource` provides a basic implementation for the built-in TraceSource logger provider. This logger logs messages to a trace listener by writing messages with `System.Diagnostics.TraceSource.TraceEvent()`.
+
+Documentation can be found at https://learn.microsoft.com/en-us/dotnet/core/extensions/logging.
+
+## Contribution Bar
+- [x] [We consider new features, new APIs, bug fixes, and performance changes](../../libraries/README.md#primary-bar)
+- [x] [We consider PRs that target this library for improvements to the logging source generator](../../libraries/README.md#secondary-bars)
+
+The APIs and functionality are mature, but do get extended occasionally.
+
+## Deployment
+[Microsoft.Extensions.Logging.TraceSource](https://www.nuget.org/packages/Microsoft.Extensions.Logging.TraceSource) is included in the ASP.NET Core shared framework. The package is deployed as out-of-band (OOB) too and can be referenced into projects directly.

src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/README.md

@@ -0,0 +1,13 @@
+# Microsoft.Extensions.Options
+
+`Microsoft.Extensions.Options.ConfigurationExtensions` provides additional configuration-specific functionality related to Options.
+
+Documentation can be found at https://learn.microsoft.com/en-us/dotnet/core/extensions/options.
+
+## Contribution Bar
+- [x] [We consider new features, new APIs, bug fixes, and performance changes](../../libraries/README.md#primary-bar)
+
+Although the types are mature, the code base continues to evolve for better performance.
+
+## Deployment
+[Microsoft.Extensions.Options.ConfigurationExtensions](https://www.nuget.org/packages/Microsoft.Extensions.Options.ConfigurationExtensions) is not included in the shared framework. The package is deployed as out-of-band (OOB) and needs to be installed into projects directly.

src/libraries/Microsoft.Extensions.Options.DataAnnotations/README.md

@@ -0,0 +1,13 @@
+# Microsoft.Extensions.Options
+
+`Microsoft.Extensions.Options.DataAnnotations` provides additional DataAnnotations specific functionality related to Options..
+
+Documentation can be found at https://learn.microsoft.com/en-us/dotnet/core/extensions/options.
+
+## Contribution Bar
+- [x] [We consider new features, new APIs, bug fixes, and performance changes](../../libraries/README.md#primary-bar)
+
+Although the types are mature, the code base continues to evolve for better performance.
+
+## Deployment
+[Microsoft.Extensions.Options.DataAnnotations](https://www.nuget.org/packages/Microsoft.Extensions.Options.DataAnnotations) is not included in the shared framework. The package is deployed as out-of-band (OOB) and needs to be installed into projects directly.

src/libraries/Microsoft.Extensions.Options/README.md

@@ -1,6 +1,6 @@
 # Microsoft.Extensions.Options
 
-`Microsoft.Extensions.Options` acts as a bridge between configuration, DI, and a higher level libraries. This library is the glue for how an app developer uses DI to configure the behavior of a library like HttpClient Factory. This also enables user to get a strongly-typed view of their configuration.
+`Microsoft.Extensions.Options` provides a strongly typed way of specifying and accessing settings using dependency injection and acts as a bridge between configuration, DI, and higher level libraries. This library is the glue for how an app developer uses DI to configure the behavior of a library like HttpClient Factory. This also enables user to get a strongly-typed view of their configuration.
 
 Documentation can be found at https://learn.microsoft.com/en-us/dotnet/core/extensions/options.
 

src/libraries/Microsoft.Extensions.Primitives/README.md

@@ -0,0 +1,16 @@
+# Microsoft.Extensions.Primitives
+
+`Microsoft.Extensions.Primitives` contains isolated types that are used in many places within console or ASP.NET Core applications using framework extensions.
+
+Commonly Used Types:
+- Microsoft.Extensions.Primitives.IChangeToken
+- Microsoft.Extensions.Primitives.StringValues
+- Microsoft.Extensions.Primitives.StringSegment
+
+## Contribution Bar
+- [x] [We consider new features, new APIs, bug fixes, and performance changes](https://github.com/dotnet/runtime/tree/main/src/libraries#contribution-bar)
+
+The APIs and functionality are mature, but do get extended occasionally.
+
+## Deployment
+[Microsoft.Extensions.Primitives](https://www.nuget.org/packages/Microsoft.Extensions.Primitives) is included in the ASP.NET Core shared framework. The package is deployed as out-of-band (OOB) too and can be referenced into projects directly.