.NET Framework
Hanterad utvidgningsram

ASP.NET asp.net-mvc C# Language Entity Framework JavaScript Regular Expressions SQL Microsoft SQL Server Visual Basic .NET Language wpf
Sök…


Anmärkningar

En av MEF: s stora fördelar jämfört med andra tekniker som stöder inversion-of-control-mönstret är att det stöder att lösa beroenden som inte är kända vid designtid utan att behöva mycket (om någon) konfiguration.

Alla exempel kräver en hänvisning till System.ComponentModel.Composition-enheten.

Dessutom använder alla (grundläggande) exempel dessa som exempel på affärsobjekt: 

using System.Collections.ObjectModel;

namespace Demo
{
    public sealed class User
    {
        public User(int id, string name)
        {
            this.Id = id;
            this.Name = name;
        }

        public int Id { get; }
        public string Name { get; }
        public override string ToString() => $"User[Id: {this.Id}, Name={this.Name}]";
    }

    public interface IUserProvider
    {
        ReadOnlyCollection<User> GetAllUsers();
    }
}

Exportera en typ (Basic)

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel.Composition;

namespace Demo
{
    [Export(typeof(IUserProvider))]
    public sealed class UserProvider : IUserProvider
    {
        public ReadOnlyCollection<User> GetAllUsers()
        {
            return new List<User>
            {
                new User(0, "admin"),
                new User(1, "Dennis"),
                new User(2, "Samantha"),
            }.AsReadOnly();
        }
    }
}

Detta kan definieras praktiskt taget var som helst; allt som är viktigt är att applikationen vet var man ska leta efter den (via ComposablePartCatalogs som den skapar).

Importera (grundläggande)

using System;
using System.ComponentModel.Composition;

namespace Demo
{
    public sealed class UserWriter
    {
        [Import(typeof(IUserProvider))]
        private IUserProvider userProvider;

        public void PrintAllUsers()
        {
            foreach (User user in this.userProvider.GetAllUsers())
            {
                Console.WriteLine(user);
            }
        }
    }
}

Detta är en typ som är beroende av en IUserProvider , som kan definieras var som helst. Som det föregående exemplet är allt som betyder att applikationen vet var man ska leta efter den matchande exporten (via ComposablePartCatalogs som den skapar).

Ansluter (Basic)

Se de andra (grundläggande) exemplen ovan. 

using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;

namespace Demo
{
    public static class Program
    {
        public static void Main()
        {
            using (var catalog = new ApplicationCatalog())
            using (var exportProvider = new CatalogExportProvider(catalog))
            using (var container = new CompositionContainer(exportProvider))
            {
                exportProvider.SourceProvider = container;

                UserWriter writer = new UserWriter();

                // at this point, writer's userProvider field is null
                container.ComposeParts(writer);

                // now, it should be non-null (or an exception will be thrown).
                writer.PrintAllUsers();
            }
        }
    }
}

Så länge något i applikationens sökväg för montering har [Export(typeof(IUserProvider))] kommer UserWriter motsvarande import att vara nöjd och användarna skrivs ut.

Andra typer av kataloger (t.ex. DirectoryCatalog ) kan användas istället för (eller förutom) ApplicationCatalog , för att leta på andra platser efter export som tillfredsställer importen.



Modified text is an extract of the original Stack Overflow Documentation
Licensierat under CC BY-SA 3.0
Inte anslutet till Stack Overflow