Utilisation des AppDomain en .NET

procedure TWinForm.LoadPlugins;
 var dir : DirectoryInfo;
 var i : Integer;
 var iplug : IPlugins;
 var menuI : MenuItem;
 var path : string;
 var setup : AppDomainSetup;
 var vartype : string;
 var varfile: FileInfo;
 begin
  path := Application.StartupPath + '/Plugins/';
 
  {$REGION 'Création du domaine d''application et chargement de la librairie de chargement '}
  setup := AppDomain.CurrentDomain.SetupInformation;
  setup.PrivateBinPath := path;
  setup.ShadowCopyFiles := 'false';
  self.pluginsDomain := AppDomain.CreateDomain('pluginsDomain', nil, setup);
  self.loader := (self.pluginsDomain.CreateInstanceFromAndUnwrap('AssemblyLoader.dll', 'AssemblyLoader.Loader')) as Loader;
  {$ENDREGION}
  dir := DirectoryInfo.Create(path);
  i := 0;
  for varfile in dir.GetFiles('*.dll') do
    begin
      vartype := varfile.Name.Replace(varfile.Extension, '');
      self.loader.Load(vartype);
      iplug := self.loader.CreateInstanceOf(i, vartype + '.' + vartype) as IPlugins;
      menuI := MenuItem.Create(iplug.Text);
      Include(menuI.Click,self.MenuItemClick);
      if (iplug.IndexMenuItem = 0) then
        begin
          self.menuItem1.MenuItems.Add(menuI);
        end
      else
        begin
          self.menuItem2.MenuItems.Add(menuI);
        end;
      self.plugins.Add(menuI, iplug);
      Math.Min(Interlocked.Increment(i), i - 1);
    end;
 end;
procedure TWinForm.MenuItemClick(o : System.Object; e : System.EventArgs);
 begin
  IPlugins(self.plugins[o]).Traitement(self.data);
  //Pour l'actualisation des données dans le propertyDataGrid
  self.propertyGrid1.SelectedObject := self.data
 end;
procedure TWinForm.MainFormClosing(sender: System.Object; e: System.ComponentModel.CancelEventArgs);
begin
  self.loader := nil;
  self.plugins := nil;
  AppDomain.Unload(self.pluginsDomain);
end;

unit appDomainSecureData;
 
interface
uses
   datasecure;
type
   IPlugins = interface
     function  get_IndexMenuItem : Integer;
     function  get_Text : string;
     function Traitement(data : VeryImportanteData) : boolean;
     property  IndexMenuItem : Integer read get_IndexMenuItem;
     property  Text : string read get_Text;
   end;
implementation
end.

unit  datasecure;
 
interface
type
  [Serializable]
  VeryImportanteData = class
  strict private
    var varname : string;
    var varfirstName : string;
    var vartel : string;
  public
    function get_Name : string;
    function get_FirstName : string;
    function get_Tel : string;
    procedure set_Name(value : string);
    procedure set_FirstName(value : string);
    procedure set_Tel(value : string);
    constructor Create;
    property Name : string read get_Name write set_Name;
    property FirstName : string read get_FirstName write set_FirstName;
    property Tel : string read get_Tel write set_Tel;
  end;
 
implementation
 constructor VeryImportanteData.Create;
 begin
  inherited Create()
 end;
 function VeryImportanteData.get_Name : string;
 begin
      Result := self.varname
 end;
 function VeryImportanteData.get_FirstName : string;
 begin
      Result := self.varfirstName
 end;
 function VeryImportanteData.get_Tel : string;
 begin
      Result := self.vartel
 end;
 procedure VeryImportanteData.set_Name(value: string);
 begin
      self.varname := value
 end;
 procedure VeryImportanteData.set_FirstName(value: string);
 begin
      self.varfirstName := value
 end;
 procedure VeryImportanteData.set_Tel(value: string);
 begin
      self.vartel := value
 end;
end.

unit appPluginsInconnu;
 
interface
uses
  appDomainSecureData, dataSecure;
type
  PluginsInconnu =  Class(MarshalByRefObject, IPlugins)
  public
    constructor Create;
    function get_IndexMenuItem : Integer;
    function get_Text : string;
    function Traitement(data : VeryImportanteData) : Boolean;
    property IndexMenuItem:Integer read get_IndexMenuItem;
    property Text:string read get_Text;
  end;
 
implementation
constructor PluginsInconnu.Create;
begin
  inherited Create;
end;
{$REGION ' appDomainSecureData.IPlugins interface implementation '}
function PluginsInconnu.get_IndexMenuItem : Integer;
begin
   Result := 1
end;
function PluginsInconnu.get_Text : string;
begin
   Result := 'PluginsInconnu'
end;
function PluginsInconnu.Traitement(data : VeryImportanteData) : Boolean;
begin
  data.Name := 'Je fais n''importe quoi avec le nom';
  Console.WriteLine('Traitement effectué');
  Result := true;
end;
{$ENDREGION}
end.

type
  PluginClass = class(System.Windows.Forms.UserControl, IPlugin)
  //Nous ne modifions rien au reste de la classe ...

//...
uses
 //...
  datasecure;
type
  frmMain = class(System.Windows.Forms.Form)
  strict private
     Components: System.ComponentModel.Container;
     tabControl1 : TabControl;
     procedure InitializeComponent;
     var pluginsDomain: AppDomain;
     procedure UnLoadAppDomain;
     //...
  public
    constructor Create;
  end;
//...
constructor frmMain.Create;
var loader : appLoader.Loader;
var obj : TObject;
var setup : AppDomainSetup;
var tp : TabPage;
begin
  inherited Create;
  InitializeComponent;
  setup := AppDomain.CurrentDomain.SetupInformation;
  setup.ShadowCopyFiles := 'false';
  //Creer un nouveau domaine d'application.
  self.pluginsDomain := AppDomain.CreateDomain('PluginsDomain', nil, setup);
  // Créer une instance du plugin dans le domaine principal
  // CreateInstanceFromAndUnWrap retourne un objet de type object.
  loader := (pluginsDomain.CreateInstanceFromAndUnwrap('AssemblyLoader.dll', 'AssemblyLoader.Loader')) as Loader;
  loader.Load('Plugin1.dll');
  obj := loader.CreateInstanceOf(0,'PluginApp.PluginClass');
  //Exécuter la fonction de traitement..
  MessageBox.Show('Chargement de ' + IPlugin(obj).Traitement);
  //Instancier un tabPage ayant comme titre "Ma page".
  tp := TabPage.Create('Ma page');
  //Ajout au tabPage d'un composant visuel du plugin
  // obj étant de type object, le transTypage en IPlugin est nécessaire.
  tp.Controls.Add(IPlugin(obj).VisualComponent);
  // Ajout du tabPage au TabControl.
  tabControl1.TabPages.Add(tp);
end;
 
procedure  frmMain.UnLoadAppDomain;
begin
    AppDomain.Unload(self.pluginsDomain);
end;

[STAThread]
procedure Main(args : array of string);
 //Declarer un objet de données pour les tests de transfert entre les deux versions de l'application
 var data : DataObject;
 //Declarer un setup de domaine
 var setup : AppDomainSetup;
 var loader : Loader;
 begin
  data := DataObject.Create('text1', 4 as TObject);
  //Initialiser setup à partir du domaine courant, car les assemblies sont dans le même répertoire
  setup := AppDomain.CurrentDomain.SetupInformation;
  //Interdire les copies fantômes des assemblies.
  setup.ShadowCopyFiles := 'false';
  //Creer le nouveau domaine d'application qui va charger la form.
  MainClass.formDomain := AppDomain.CreateDomain('formDomain', nil, setup);
  //Instancier un loader dans le nouveau domaine d'application.
  loader := (MainClass.formDomain.CreateInstanceFromAndUnwrap('AssemblyLoader.dll','AssemblyLoader.Loader')) as Loader;
  //Executer le chargement dans le domaine d'application de formDomain.
  loader.Load('appDomainAutoPatchable');
  //Recuperer une référence sur une instance de IForm à travers les appDomains
  iform := (loader.CreateInstanceOf(0, 'appDomainAutoPatchable.MainForm')) as IForm;
  //Passer l'objet data.
  iform.Data := data;
  //Lancer la form dans l'autre appDomain.
  iform.Run;
  //Décharger l'appDomain formDomain.
  AppDomain.Unload(MainClass.formDomain);
  //Mettre à jour la librairie contenant la form.
  MainClass.Update;
  //Recréer le domaine d'application.
  MainClass.formDomain := AppDomain.CreateDomain('formDomain', nil, setup);
  loader := (MainClass.formDomain.CreateInstanceFromAndUnwrap('AssemblyLoader.dll', 'AssemblyLoader.Loader')) as Loader;
  loader.Load('appDomainAutoPatchable');
  iform := (loader.CreateInstanceOf(0, 'appDomainAutoPatchable.MainForm')) as IForm;
  iform.Data := data;
  iform.Run;
  //La form à été mise à jour sans perte de données.
end;