Partage via

Transfert de type dans le Common Language Runtime

Le transfert de type vous permet de déplacer un type vers un autre assembly sans avoir à recompiler les applications qui utilisent l’assembly d’origine.

Par exemple, supposons qu’une application utilise la Example classe dans un assembly nommé Utility.dll. Les développeurs de Utility.dll peuvent décider de refactoriser l’assembly et, dans le processus, ils peuvent déplacer la Example classe vers un autre assembly. Si l’ancienne version de Utility.dll est remplacée par la nouvelle version de Utility.dll et son assembly complémentaire, l’application qui utilise la Example classe échoue, car elle ne peut pas localiser la Example classe dans la nouvelle version de Utility.dll.

Les développeurs de Utility.dll peuvent éviter cela en transférant les demandes de la Example classe à l’aide de l’attribut TypeForwardedToAttribute . Si l’attribut a été appliqué à la nouvelle version de Utility.dll, les demandes de la Example classe sont transférées à l’assembly qui contient désormais la classe. L’application existante continue de fonctionner normalement, sans recompilation.

Transférer un type

Il existe quatre étapes pour transférer un type :

  1. Déplacez le code source du type de l'assemblage d'origine vers l'assemblage de destination.

  2. Dans l'assembly où le type était situé, ajoutez un TypeForwardedToAttribute pour le type qui a été déplacé. Le code suivant montre l’attribut d’un type nommé Example qui a été déplacé.

     [assembly:TypeForwardedToAttribute(Example::typeid)]

     [assembly:TypeForwardedToAttribute(typeof(Example))]

  3. Compilez l’assembly qui contient maintenant le type.

  4. Recompilez l'assembly où le type se trouvait auparavant, avec une référence à l'assembly qui contient désormais le type. Par exemple, si vous compilez un fichier C# à partir de la ligne de commande, utilisez l’option Références (options du compilateur C#) pour spécifier l’assembly qui contient le type. En C++, utilisez la directive #using dans le fichier source pour spécifier l’assembly qui contient le type.

Exemple de transfert de type C#

Continuez à partir de l’exemple de description construit ci-dessus, imaginez que vous développez le Utility.dll et que vous avez une classe Example. Utility.csproj est une bibliothèque de classes de base :

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsing>true</ImplicitUsing>
  </PropertyGroup>

</Project>

La classe Example fournit quelques propriétés et remplacements Object.ToString:

using System;

namespace Common.Objects;

public class Example
{
    public string Message { get; init; } = "Hi friends!";

    public Guid Id { get; init; } = Guid.NewGuid();

    public DateOnly Date { get; init; } = DateOnly.FromDateTime(DateTime.Today);

    public sealed override string ToString() =>
        $"[{Id} - {Date}]: {Message}";
}

Imaginez maintenant qu’il existe un projet consommant et qu’il est représenté dans l’assembly Consommateur . Ce projet utilisateur fait référence à l’assembly Utilitaire. Par exemple, il instancie l’objet Example et l’écrit dans la console dans son fichier Program.cs :

using System;
using Common.Objects;

Example example = new();

Console.WriteLine(example);

Lorsque l’application consommatrice s’exécute, elle génère l’état de l’objet Example . À ce stade, il n’existe aucun transfert de type, car Le fichier Consume.csproj fait référence à Utility.csproj. Toutefois, le développeur de l’assembly Utility décide de supprimer l’objet Example dans le cadre d’une refactorisation. Ce type est déplacé vers un common.csproj nouvellement créé.

En supprimant ce type de l'assembly Utility, les développeurs introduisent un changement cassant. Tous les projets d'utilisation seront interrompus lors de la mise à jour vers la dernière version de l'assembly Utility.

Au lieu d’exiger que les projets d'utilisation ajoutent une nouvelle référence à l’assembly Common , vous pouvez transférer le type. Étant donné que ce type a été supprimé de l’assembly Utility, vous devez faire en sorte que Utility.csproj référence Common.csproj :

<ItemGroup>
  <ProjectReference Include="..\Common\Common.csproj" />
</ItemGroup>

Le projet C# précédent fait désormais référence à l’assembly Commun nouvellement créé. Il pourrait s'agir d'un PackageReference ou d'un ProjectReference. L’assembly Utility doit fournir les informations de transfert de type. Par convention, les déclarations de transfert de type de convention sont généralement encapsulées dans un seul fichier nommé TypeForwarders, considérez le fichier TypeForwarders.cs C# suivant dans l’assembly utilitaire :

using System.Runtime.CompilerServices;
using Common.Objects;

[assembly:TypeForwardedTo(typeof(Example))]

L’assembly Utility fait référence à l’assembly Common et transmet le type Example. Si vous devez compiler l’assembly Utility avec les déclarations de transfert de type et déposer la dll Utility.dll dans le bac Consuming, l’application d'utilisation fonctionnera sans avoir besoin d'être compilée.

Voir aussi