public class PluginSnippetCompiler
{
    public PluginSnippetCompiler(IAssemblyReferenceCollector assemblyReferenceCollector)
    {
        if (assemblyReferenceCollector == null)
            throw new ArgumentNullException("assemblyReferenceCollector");

        _AssemblyReferenceCollector = assemblyReferenceCollector;
    }

    private readonly IAssemblyReferenceCollector _AssemblyReferenceCollector;

    private IEnumerable<Diagnostic> _Diagnostics = Enumerable.Empty<Diagnostic>();

    public IEnumerable<Diagnostic> Errors
    {
        get
        {
            return _Diagnostics
                .Where(d => d.Severity == DiagnosticSeverity.Error);
        }
    }

    public IEnumerable<Diagnostic> Warnings
    {
        get
        {
            return _Diagnostics
                .Where(d => d.Severity == DiagnosticSeverity.Warning);
        }
    }

    private string GetOutputAssemblyName(string name)
    {
        return String.Format("RoslynPlugins.Snippets.{0}", name);
    }

    /// <summary>
    /// Compiles source code at runtime into an assembly. The assembly will automatically include all
    /// the same assembly references as the main RoslynPlugins assembly, so you can call any function which is
    /// available from within the deployed RoslynPlugins. Compilation errors and warnings can be obtained from 
    /// the Errors and Warnings properties.
    /// </summary>
    /// <param name="name">The name of the class, e.g., HelloWorldGenerator</param>
    /// <param name="script">Source code such as the contents of HelloWorldGenerator.cs</param>
    /// <returns>The compiled assembly in memory. If there were errors, it will return null.</returns>
    public Assembly Compile(string name, string script)
    {
        if (name == null)
            throw new ArgumentNullException("name");

        if (script == null)
            throw new ArgumentNullException("script");

        string outputAssemblyName = GetOutputAssemblyName(name);

        var defaultImplementationAssembly = typeof(HelloWorldGenerator).Assembly;
        var assemblyReferences = _AssemblyReferenceCollector.CollectMetadataReferences(defaultImplementationAssembly);

        // Parse the script to a SyntaxTree
        var syntaxTree = CSharpSyntaxTree.ParseText(script);

        // Compile the SyntaxTree to an in memory assembly
        var compilation = CSharpCompilation.Create(outputAssemblyName,
            new[] { syntaxTree },
            assemblyReferences,
            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));

        using (var outputStream = new MemoryStream())
        {
            using (var pdbStream = new MemoryStream())
            {
                // Emit assembly to streams. Throw an exception if there are any compilation errors
                var result = compilation.Emit(outputStream, pdbStream: pdbStream);

                // Populate the _diagnostics property in order to read Errors and Warnings
                _Diagnostics = result.Diagnostics;

                if (result.Success)
                {
                    return Assembly.Load(outputStream.ToArray(), pdbStream.ToArray());
                }
                else
                {
                    return null;
                }
            }
        }
    }
}

public class AssemblyReferenceCollector : IAssemblyReferenceCollector
{
    public IEnumerable<MetadataReference> CollectMetadataReferences(Assembly assembly)
    {
        var referencedAssemblyNames = assembly.GetReferencedAssemblies();

        var references = new List<MetadataReference>();
        foreach (AssemblyName assemblyName in referencedAssemblyNames)
        {
            var loadedAssembly = Assembly.Load(assemblyName);
            references
                .Add(new MetadataFileReference(loadedAssembly.Location));
        }

        references
            .Add(new MetadataFileReference(assembly.Location)); // add a reference to 'self', i.e., NetMWC

        return references;
    }
}

public class PluginLocator
{
    public PluginLocator(PluginAssemblyCache pluginAssemblyCache)
    {
        if (pluginAssemblyCache == null)
            throw new ArgumentNullException("pluginAssemblyCache");

        _PluginAssemblyCache = pluginAssemblyCache;
    }

    private readonly PluginAssemblyCache _PluginAssemblyCache;

    public Type Locate<T>()
    {
        return Locate(new[] { typeof(T) });
    }

    protected Type Locate(IEnumerable<Type> serviceTypes)
    {
        var implementingClasses = AssemblyExplorer.GetImplementingClasses(_PluginAssemblyCache.GetAssemblies(), serviceTypes);

        if (implementingClasses.Any())
        {
            if (implementingClasses.Count() > 1)
                throw new Exception("More than one plugin class found which implements " + String.Join(" + ", serviceTypes.Select(t => t.ToString())));
            else
                return implementingClasses.Single();
        }
        return null;
    }
}

/// <summary>
/// This class maintains a list of runtime-compiled in memory assemblies loaded from the plugins
/// available via the provider. It is a singleton class.
/// </summary>
public class PluginAssemblyCache
{
    public PluginAssemblyCache(IPluginSnippetProvider pluginSnippetProvider, PluginLoader pluginLoader)
    {
        if (pluginSnippetProvider == null)
            throw new ArgumentNullException("pluginSnippetProvider");
        _PluginSnippetProvider = pluginSnippetProvider;

        if (pluginLoader == null)
            throw new ArgumentNullException("pluginLoader");
        _PluginLoader = pluginLoader;
    }

    private class CacheEntry
    {
        public string Name { get; set; }
        public Version Version { get; set; }
        public Assembly Assembly { get; set; }
    }

    private readonly IPluginSnippetProvider _PluginSnippetProvider;
    private readonly PluginLoader _PluginLoader;

    private List<CacheEntry> _Cache = new List<CacheEntry>();

    private void Add(string name, string version, Assembly assembly)
    {
        var cacheEntry =
            new CacheEntry()
            {
                Name = name,
                Version = new Version(version),
                Assembly = assembly
            };
        _Cache.Add(cacheEntry);
    }

    private void RefreshCache()
    {
        var pluginScriptContainers = _PluginSnippetProvider.GetPlugins();

        // Add a new assembly for any new or updated plugin
        foreach (var pluginScriptContainer in pluginScriptContainers)
        {
            var name = pluginScriptContainer.Name;
            var version = pluginScriptContainer.Version;
            if (!_Cache.Any(a => a.Name == name && a.Version == new Version(version)))
            {
                var assembly = _PluginLoader.Load(pluginScriptContainer);
                Add(name, version, assembly);
            }
        }

        // Remove any assemblies which we no longer have a plugin for.
        _Cache
            .RemoveAll(cacheEntry =>
                !pluginScriptContainers
                    .Select(plugin => plugin.Name)
                    .Contains(cacheEntry.Name));
    }

    public IEnumerable<Assembly> GetAssemblies()
    {
        RefreshCache();

        // Return only the assemblies with the highest version numbers
        return _Cache
            .GroupBy(d => d.Name)
            .Select(g => g
                    .OrderByDescending(d => d.Version)
                    .First()
                    .Assembly);
    }
}