CLR via C reading notes - loading and AppDomain

### scene
The company has a project , need TeamA And TeamB Work together （ Or two companies decide to develop a program together ）, Both are developed according to the agreed interface .TeamA Your program needs to be loaded TeamB Development methods , In this way, the whole software can be completed . in addition ,TeamA The program needs to be set TeamB Security permissions and other basic settings of the plug-in , avoid TeamB The plug-in of is broken TeamA Developed programs . As shown in the figure below ：

namely , Both need you , But I have to limit you ！
### Solution ：
stay C# You can use AppDomain Form a safe area , take TeamB To isolate the plug-ins . And then use C# Loading function , Load the plug-in , Then run the methods in the plug-in ！ Security and isolation are realized ！
### Code
Define interface first . The interface documents are as follows ：
#### Interface definition

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HostSDK
{
    public interface IAddIn
    {
        string DoSometing(int x);
    }
}

A simple interface agreed by both parties . Here is TeamB The concrete realization of ：
#### Plug in implementation

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using HostSDK;

namespace AddInType
{
    public class PlugInTeamB: MarshalByRefObject, IAddIn
    {
        public string DoSometing(int x)
        {
            return "B Add in method ：" + 2 * x + "\n DoSomething The method is AppDomain by ：" + AppDomain.CurrentDomain.FriendlyName;
        }
    }
}

A very simple implementation , But be careful , At this point, the plug-in inherits MarshalByRefObject Base class .
#### The actual call

using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using HostSDK;

namespace ReflectionDemo
{
    class Program
    {
        public static void Main(string[] args)
        {
            // Get the path of the add in 
            string AddInDir = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);

            // Show the current AppDomain
            Console.WriteLine(" At present AppDomain by ："+ AppDomain.CurrentDomain.FriendlyName);

            // First step (1)： Under a certain path , Find all of them first DLL, Then filter according to the conditions 
            string[] AddInAssemblies = Directory.GetFiles(AddInDir, "*.dll");

            foreach (string item in AddInAssemblies)
            {
                Console.WriteLine(" Name of the add in to be found ：{0}",item);
            }

            // First step (2)： Filter by criteria 
            List<Type> AddInType = new List<Type>();
            List<string> assemblyList = new List<string>();
            foreach (string item in AddInAssemblies)
            {
                Assembly AddInAssembly = Assembly.LoadFrom(item);

                foreach (Type t in AddInAssembly.GetExportedTypes())
                {
                    if (t.IsClass && typeof(IAddIn).IsAssignableFrom(t))
                    {
                        AddInType.Add(t);
                        assemblyList.Add(AddInAssembly.FullName);
                    }
                }
            }

            // First step (3): Show what has been found DLL Related information 
            Console.WriteLine(" After finding , Already found ："+ assemblyList.Count+", As follows :");
            foreach (string item in assemblyList)
            {
                Console.WriteLine("      What has been found assembly Information name ："+item);
            }


            // The second step ： Create a new AppDomain, And in the new AppDomain Create instance in , And call related methods 
            AppDomain sandBoxAppDomain = AppDomain.CreateDomain("SandBoxAppDomain", null, null);
            // new AppDomain Create instance in , And call related methods 
            IAddIn addInB=(IAddIn)sandBoxAppDomain.CreateInstanceAndUnwrap(assemblyList[0], "AddInType.PlugInTeamB");
            Console.WriteLine(" call TeamB Methods , The return information of the method is as follows ："+addInB.DoSometing(2));


            // The third step ： uninstall AppDomain
            AppDomain.Unload(sandBoxAppDomain);


            Console.Read();
        }
    }
}

#### Actual output

#### The code download
Link later -Mark
### explain
stay “ Plug in implementation ” in , The code is ：

public class PlugInTeamB: MarshalByRefObject, IAddIn
    {
        public string DoSometing(int x)
        .....
    }

It does MarshalByRefObject Base class , So the final output is ：“DoSomething The method is AppDomain by ：SandBoxAppDomain”
If the base class is removed , Then add Serializable Of Attribute, The output will be ：“DoSomething The method is AppDomain by ：ReflectionDemo.exe”

This involves passing by value or by reference
#### summary
Use the small... Above demo, You can create a small “ Hot plug ” Isolation procedure for . More to the point , Third parties can be specified DLL The path to load