.NET Framework
Managed Extensibility Framework

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


Opmerkingen

Een van de grote voordelen van MEF ten opzichte van andere technologieën die het inversie van besturingspatroon ondersteunen, is dat het ondersteuning biedt voor het oplossen van afhankelijkheden die niet bekend waren tijdens het ontwerp, zonder veel (eventuele) configuratie nodig te hebben.

Alle voorbeelden vereisen een verwijzing naar de assemblage System.ComponentModel.Composition.

Ook gebruiken alle (basis) voorbeelden deze als hun voorbeeld bedrijfsobjecten: 

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();
    }
}

Een type exporteren (basis)

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();
        }
    }
}

Dit kan vrijwel overal worden gedefinieerd; het enige dat telt is dat de applicatie weet waar het naar moet zoeken (via de ComposablePartCatalogs die het creëert).

Importeren (basis)

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);
            }
        }
    }
}

Dit is een type dat afhankelijk is van een IUserProvider , die overal kan worden gedefinieerd. Net als in het vorige voorbeeld is het enige dat telt dat de toepassing weet waar de overeenkomende export moet worden gezocht (via de ComposablePartCatalogs die wordt gemaakt).

Verbinden (basis)

Zie de andere (basis) voorbeelden hierboven. 

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();
            }
        }
    }
}

Zolang iets in het zoekpad van de toepassing [Export(typeof(IUserProvider))] , is de overeenkomstige import van UserWriter tevreden en worden de gebruikers afgedrukt.

Andere typen catalogi (bijv. DirectoryCatalog ) kunnen in plaats van (of als aanvulling op) ApplicationCatalog worden gebruikt om op andere plaatsen te zoeken naar export die aan de import voldoet.



Modified text is an extract of the original Stack Overflow Documentation
Licentie onder CC BY-SA 3.0
Niet aangesloten bij Stack Overflow