ASP.NET Framework HttpApplicationHost

La bibliothèque d’adaptateurs System.Web permet aux applications ASP.NET Framework d’utiliser le modèle d’hôte générique .NET, ce qui offre des fonctionnalités d’infrastructure d’application modernes aux projets ASP.NET Framework traditionnels. Cette approche permet d’accéder à l’injection de dépendances, à la journalisation, à la configuration et à d’autres services standard dans les applications .NET modernes, tout en conservant la compatibilité avec le code ASP.NET Framework existant.

Pourquoi utiliser le modèle d’hôte

L’adoption du modèle d’hôte générique dans les applications ASP.NET Framework offre plusieurs avantages clés :

  • Injection de dépendances : accès au conteneur d’injection de dépendances intégré utilisé dans .NET moderne, ce qui permet une meilleure testabilité, une facilité de maintenance et une séparation des préoccupations
  • Journalisation unifiée : Intégration avec Microsoft.Extensions.Logging, offrant une expérience de journalisation cohérente dans votre application et l’accès à différents fournisseurs de journalisation
  • Configuration moderne : utilisez le système de configuration à partir de .NET moderne, notamment la prise en charge des fichiers JSON, des variables d’environnement, des secrets utilisateur et d’autres sources de configuration.
  • Chemin de migration : préparez votre codebase pour la migration vers ASP.NET Core en adoptant des modèles modernes de manière incrémentielle tout en conservant votre application ASP.NET Framework existante
  • Valeurs par défaut du service : tirez parti des paramètres par défaut du service et des modèles d’infrastructure d’application standardisés couramment utilisés dans les applications .NET modernes

Configuration de l’hôte générique

Pour configurer le modèle hôte générique dans une application ASP.NET Framework, inscrivez l’hôte dans la Application_Start méthode de votre Global.asax.cs fichier :

using System.Web;
using Microsoft.AspNetCore.SystemWebAdapters.Hosting;
using Microsoft.Extensions.Hosting;

namespace MvcApp
{
    public class MvcApplication : HttpApplication
    {
        protected void Application_Start()
        {
            HttpApplicationHost.RegisterHost(builder =>
            {
                builder.AddServiceDefaults();
                builder.AddSystemWebDependencyInjection();
                builder.AddSystemWebAdapters();
            });

            // Existing ASP.NET Framework configuration
            AreaRegistration.RegisterAllAreas();
            GlobalConfiguration.Configure(WebApiConfig.Register);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);
        }
    }
}

La HttpApplicationHost.RegisterHost méthode configure un hôte générique qui s’exécute en même temps que votre application ASP.NET Framework. Le générateur d’hôtes accepte la configuration par le biais de méthodes d’extension qui ajoutent différentes fonctionnalités.

Injection de dépendances

La AddSystemWebDependencyInjection méthode active l’injection de dépendances dans votre application ASP.NET Framework. Les services inscrits auprès de la collection de services de l’hôte générique deviennent disponibles pour les contrôleurs, les gestionnaires et d’autres composants.

Cette méthode d’extension est une méthode interne qui sera générée à partir de la source en fonction de ce que vous avez référencé. Les infrastructures suivantes sont prises en charge :

Note

La builder.AddSystemWebDependencyInjection() méthode d’extension est générée par un générateur source C# et est disponible uniquement dans les projets C#. Pour les applications VB.NET, créez une bibliothèque de classes C# intermédiaire qui référence les packages ASP.NET L’API MVC/Web et SystemWebAdapters. Configurez l’injection de dépendances dans cette bibliothèque et exposez une méthode publique que votre projet VB.NET peut appeler.

Inscription de services

Inscrivez des services auprès du conteneur d'injection de dépendances en accédant à la propriété Services sur le constructeur d'hôte :

HttpApplicationHost.RegisterHost(builder =>
{    
    builder.AddSystemWebDependencyInjection();
    builder.AddSystemWebAdapters();

    builder.Services.AddScoped<IMyService, MyService>();
    builder.Services.AddSingleton<IDataRepository, DataRepository>();
});

Pour plus d’informations sur la personnalisation du système d’injection de dépendances, notamment le remplacement du conteneur de service, consultez la documentation complète : Injection de dépendances dans ASP.NET Core.

Si vous remplacez actuellement les hooks d’injection de dépendances dans l’infrastructure ASP.NET, vous devez effectuer une mise à jour vers le modèle actuel pour votre injection de dépendances et supprimer les intégrations existantes pour WebForms/MVC4/WebAPI.

Consommation de services

Une fois inscrits, les services peuvent être injectés dans des contrôleurs MVC, des contrôleurs d’API web et d’autres composants qui prennent en charge l’injection de dépendances :

public class HomeController : Controller
{
    private readonly IMyService _myService;
    private readonly ILogger<HomeController> _logger;

    public HomeController(IMyService myService, ILogger<HomeController> logger)
    {
        _myService = myService;
        _logger = logger;
    }

    public ActionResult Index()
    {
        _logger.LogInformation("Loading home page");
        var data = _myService.GetData();
        return View(data);
    }
}

Dans une demande, un ensemble de services délimité peut être récupéré par une méthode d’extension spéciale :

var myService = HttpContext.Current.GetRequestServices().GetService(typeof(ISomeType));

Avertissement

HttpContext implémente IServiceProvider afin que vous puissiez voir les méthodes d’extension pour obtenir des services à partir de celui-ci. Toutefois, il n’est pas implémenté de manière à récupérer des services utiles d’un conteneur enregistré. Une erreur s’affiche si vous tentez de l’utiliser et que vous devez d’abord utiliser la GetRequestServices() méthode d’extension.

Logging

L’hôte générique s’intègre Microsoft.Extensions.Logging, fournissant une infrastructure de journalisation moderne pour votre application ASP.NET Framework.

Utilisation des enregistreurs d’événements

Injectez ILogger<T> dans vos classes pour journaliser les messages :

public class OrderService : IOrderService
{
    private readonly ILogger<OrderService> _logger;

    public OrderService(ILogger<OrderService> logger)
    {
        _logger = logger;
    }

    public void ProcessOrder(int orderId)
    {
        _logger.LogInformation("Processing order {OrderId}", orderId);
        
        try
        {
            // Process order logic
            _logger.LogDebug("Order {OrderId} processed successfully", orderId);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error processing order {OrderId}", orderId);
            throw;
        }
    }
}

Pour plus d’informations sur la personnalisation et l’utilisation de la journalisation, notamment l’intégration à vos propres fournisseurs, consultez Journalisation dans .NET et ASP.NET Core.

Paramétrage

L’hôte générique prend en charge le système de configuration .NET moderne, notamment les fichiers JSON, les variables d’environnement et d’autres sources de configuration. Par défaut, HttpApplicationHost utilise des modèles de configuration standard (tels que appsettings.json et appsettings.{Environment}.json) et inclut automatiquement des valeurs depuis AppSettings et ConnectionStrings pour assurer la compatibilité avec les applications ASP.NET Framework existantes.

Accès à la configuration

Injecter IConfiguration pour accéder aux valeurs de configuration :

public class EmailService : IEmailService
{
    private readonly string _smtpServer;
    private readonly ILogger<EmailService> _logger;

    public EmailService(IConfiguration configuration, ILogger<EmailService> logger)
    {
        _smtpServer = configuration["Email:SmtpServer"];
        _logger = logger;
    }

    public void SendEmail(string to, string subject, string body)
    {
        _logger.LogInformation("Sending email to {Recipient} via {SmtpServer}", to, _smtpServer);
        // Email sending logic
    }
}

Pour le code qui ne peut pas utiliser l’injection de dépendances, utilisez la classe d’assistance statique AppConfiguration pour accéder aux valeurs de configuration :

using Microsoft.AspNetCore.SystemWebAdapters;

var configValue = AppConfiguration.GetSetting("SomeSettings");
var connStr = AppConfiguration.GetConnectionString("connection-string-name");

Cela fonctionnera à la fois sur les applications ASP.NET Core et ASP.NET Framework qui font référence Microsoft.AspNetCore.SystemWebAdapters et fourniront l’accès à l’actuel IConfiguration.

Utilisation du modèle d’options

Le modèle d’options fournit un accès fortement typé aux sections de configuration :

public class EmailSettings
{
    public string SmtpServer { get; set; }
    public int Port { get; set; }
    public string Username { get; set; }
}

// Register options
HttpApplicationHost.RegisterHost(builder =>
{
    builder.Services.Configure<EmailSettings>(
        builder.Configuration.GetSection("Email"));

    builder.AddSystemWebDependencyInjection();
    builder.AddSystemWebAdapters();
});

// Consume options
public class EmailService : IEmailService
{
    private readonly EmailSettings _settings;
    private readonly ILogger<EmailService> _logger;

    public EmailService(IOptions<EmailSettings> options, ILogger<EmailService> logger)
    {
        _settings = options.Value;
        _logger = logger;
    }
}

Pour les scénarios de configuration avancés, notamment les sources de configuration personnalisées et les paramètres spécifiques à l’environnement, consultez Configuration dans ASP.NET Core.

Stratégies de migration

La conversion complète en modèle hôte générique peut ne pas être nécessaire pour les projets plus petits, mais peut faciliter la migration pour les projets plus volumineux. Si vous avez réussi à effectuer cette conversion, vous pouvez remplacer l’utilisation de HttpApplicationHost par celle de WebApplication dans ASP.NET Core.

Lors de la migration vers cette configuration, de petites modifications incrémentielles vous aideront à garantir une conversion réussie. L’ordre recommandé pour la migration ici serait le suivant :

  1. Ajoutez une inscription d’hôte initiale :

    HttpApplicationHost.RegisterHost(builder =>
{
});

  2. Mise à jour pour utiliser l’injection de dépendance Microsoft Extensions :

    HttpApplicationHost.RegisterHost(builder =>
{
    builder.AddSystemWebDependencyInjection();
});

    Lors de cette opération, vous devrez peut-être adapter vos conteneurs actuels en fonction de leur propre documentation pour l'intégration à l'injection de dépendances de Microsoft Extensions.

  3. Identifiez votre système de journalisation et intégrez-le à l’infrastructure de journalisation de l’extension Microsoft. Décidez si vous souhaitez continuer à utiliser les types d’enregistreurs d’événements de votre système existant ou à migrer vers les ILogger<> types que HttpApplicationHost fournira.

  4. Remplacez tous les appels vers AppSettings et ConnectionStrings par le nouvel appel équivalent AppConfiguration . Vous devez faire référence Microsoft.AspNetCore.SystemWebAdapters au projet dans lequel vous souhaitez effectuer cette opération.

  5. Commencez à utiliser le modèle d'options pour convertir la configuration en POCO, qui peut être transmis à des services consommateurs à l'aide du système de DI intégré.

  6. Déplacer vos paramètres vers web.configappsettings.json

Ressources supplémentaires

  • Last updated on