Simple Introduction to Extensible Applications with the Managed Extensions Framework

infoblog » Simple Introduction to Extensible Applications with the Managed Extensions Framework

Mon, 29 Sep 2008 18:36:44 GMT

PingBack from http://blog.a-foton.ru/index.php/2008/09/29/simple-introduction-to-extensible-applications-with-the-managed-extensions-framework/

re: Simple Introduction to Extensible Applications with the Managed Extensions Framework

joewood — Mon, 29 Sep 2008 19:55:27 GMT

Very nice tutorial.

How about an option to dynamically bind. So if you drop a new DLL in the directory it would be added into the container and bound at runtime - without having to restart.

Also like to see some options for synchronous/asynchronous calling patterns in outgoing interfaces where there's more than one target. Maybe an opportunity to incorporate WF.

re: Simple Introduction to Extensible Applications with the Managed Extensions Framework

Jason Olson — Mon, 29 Sep 2008 20:36:52 GMT

Hey Joe, regarding dynamically binding... while Brad didn't show it here, it is supported in the current methods via "rebinding." The reason the app needs to be restarted here in Brad's demo is he outputs the messages and then effectively ends the app.

re: Simple Introduction to Extensible Applications with the Managed Extensions Framework

Will — Mon, 29 Sep 2008 20:49:23 GMT

I'd love to see one of these frameworks move the linking logic into a much lower level in the type resolution call stack.

This is great and all, but what happens when a type is resolved from within code you can't control? For instance, during xaml or xml deserialization. You can't rewrite the serializers to use the MEF to identify, load and compose types that aren't known at compile time or within any loaded assemblies....

re: Simple Introduction to Extensible Applications with the Managed Extensions Framework

iCe — Mon, 29 Sep 2008 23:59:51 GMT

I see great oportunity within the logging app block to greatly extend the loggers you want without providing any explicit implementation.

re: Simple Introduction to Extensible Applications with the Managed Extensions Framework

Robert — Tue, 30 Sep 2008 02:02:54 GMT

I have a few questions about MEF: What about System.Addin? Couldn´t that be done with it? What is the difference between MEF and System.Addin?

re: Simple Introduction to Extensible Applications with the Managed Extensions Framework

joewood — Tue, 30 Sep 2008 04:49:45 GMT

Thanks Jason.

Also I would ask how this works with start-up configuration - like IoC containers.

re: Simple Introduction to Extensible Applications with the Managed Extensions Framework

Hank — Tue, 30 Sep 2008 08:21:54 GMT

I have searched the NET and I should say I have not come across an article like this which is so easy to understand and learn the concepts.

cheers

re: Simple Introduction to Extensible Applications with the Managed Extensions Framework

Glenn Block — Tue, 30 Sep 2008 08:55:16 GMT

@Robert, Krys has a good article on this here. http://blogs.msdn.com/kcwalina/archive/2008/06/13/MAFMEF.aspx

The bits that he wrote the article based on are old, however the principle still stands. MAF is primarily focused on add-in activation and isolation. MEF is concerned with discovery and compostion of clr-types, which includes types activated through MAF. There is some overlap though, however in the places where they overlap, the functionality supports the primary goals of each framework.

More MEF Samples and launch of MEF contrib.

My Technobabble — Tue, 30 Sep 2008 09:11:11 GMT

The past few weeks, the momentum has picked up around samples using MEF. In my last post I mentioned

Extensible Applications with the Managed Extensions Framework

Daniel's blog — Tue, 30 Sep 2008 09:41:05 GMT

Brad Abrams has a post on his blog Simple Introduction to Extensible Applications with the Managed Extensions

8am and The Managed Extensibility Framework

Casey Charlton - Insane World — Tue, 30 Sep 2008 10:06:01 GMT

Brad Abrams can always be relied upon for a great post - and the latest whizzy thing to come from Microsoft

8am and The Managed Extensibility Framework

Community Blogs — Tue, 30 Sep 2008 10:49:51 GMT

Brad Abrams can always be relied upon for a great post - and the latest whizzy thing to come from Microsoft

re: Simple Introduction to Extensible Applications with the Managed Extensions Framework

BorekB — Tue, 30 Sep 2008 11:02:51 GMT

This is great introduction. There might be a small typo - IOutputString interface should contain OutputString() instead of OutputStringToConsole().

Simple Introduction to Extensible Applications with the MEF

DotNetKicks.com — Tue, 30 Sep 2008 11:09:26 GMT

You've been kicked (a good thing) - Trackback from DotNetKicks.com

re: Simple Introduction to Extensible Applications with the Managed Extensions Framework

Ganesh — Tue, 30 Sep 2008 16:23:32 GMT

Excellent KISS approach.

I have only one doubt,

The second example looks like the export happens by type rather than the property. This would mean any dll loaded by a catalog if it has a exported string it will show that as a message.

The other thing is what someone had already said, this whole idea of loading dlls by reflection should happen at a very low level.

There are other issues with the MEF approach and calls for enhancements. For example

1) securing a class to be loaded based on authentication,

2) getting the other dlls that are used by the one loaded is another I can think of.

3) Loading dlls from different sources.

re: Simple Introduction to Extensible Applications with the Managed Extensions Framework

joshka — Tue, 30 Sep 2008 17:25:33 GMT

The feed item for this is borked and loses formatting.

re: Simple Introduction to Extensible Applications with the Managed Extensions Framework

Dave R. — Tue, 30 Sep 2008 20:58:56 GMT

Thank you for the post. I have a few queries:

1) Will MEF be a separate download with source, a DLL-only download, or will it become part of the Framework?

2) It seems a little like an 'everything including the kitchen sink' approach. For simple client-side apps that, say, just want to dynamically load extensions, this is going to add quite a lot to download sizes. This is what stopped me from using things like Application Blocks in the past - they seem focused on the Enterprise rather than the more casual developer. Can we pick and choose from the catalogs should we only want to use one type?

3) You mention that there are many different catalog types. If this is the case, wouldn't it be preferable to rely on the container constructor to recognise both the type and whether it's being passed a single container or a List of them? It seems a bit tortuous to have to setup an AggregatingComposablePartCatalog, add other catalogs to that, then pass it to the container. I think it would be less hassle for devs if we could just create a container without having to be explicit about the catalogs. Also could there be an overloaded Catalog constructor instead of all the separate types? For example:

// 'Catalog' instead of 'AttributedAssemblyPartCatalog'

var myCatalog = new Catalog(Assembly.GetExecutingAssembly());

var container = new CompositionContainer(myCatalog);

container.AddPart(this);

...

var cats = new List<Catalog>() { new Catalog(Assembly.GetExecutingAssembly()), new Catalog("C:\\My Types") };

var container = new container(cats);

container.AddPart(this);

...

3) Hasn't this been covered by other extensibility frameworks?

Sorry if this seems a little negative. I do look forward to having a play with the release and reading about it further.

re: Simple Introduction to Extensible Applications with the Managed Extensions Framework

Ganesh — Tue, 30 Sep 2008 21:20:48 GMT

In the example under Taking MEF to next level, the Interface is well known to the application as well as the MEF'd dll. This would mean that a dynamic loading will only be possible for those dlls that support that interface.

So from that example it looks like, an application implementing MEF should be well aware of what interface(s) it is going to implement. hmmmm.,,,,,,

re: Simple Introduction to Extensible Applications with the Managed Extensions Framework

chrisplasun@hotmail.com — Tue, 30 Sep 2008 21:39:58 GMT

How do AppDomains fit into this? Or do they at all?

re: Simple Introduction to Extensible Applications with the Managed Extensions Framework

Ganesh — Tue, 30 Sep 2008 23:42:43 GMT

for single applications where the classes are in the same assembly, won't the code below be easier to implement?

<code>

private ArrayList getTasks()

{

ArrayList allTasks = new ArrayList();

Assembly assembly = Assembly.Load(Assembly.GetCallingAssembly().FullName );

foreach (Type type in assembly.GetTypes())

{

if (type.IsClass == true)

{

// create an instance of the object

try

{

object taskable = type.GetInterface ("ITask");

if (taskable != null)

{

object ClassObj = Activator.CreateInstance(type);

if (ClassObj is ITask )

{

allTasks.Add((ITask)ClassObj);

}

catch(MissingMethodException ex)

{

Console.WriteLine (ex.Message);

}

return allTasks;

}

</code>

where ITask is the interface.

The above code will instantiate all classes in the executing assembly that implements ITask

for loading from other assemblies, one can use "LoadFile" or "LoadFrom" method of Assembly class

This will work in all versions of .net framework in my opinion

And in the main logic , all one has to do is to,

ArrayList taskStack = getTasks();

foreach(ITask aTask in taskStack)

{

aTask.execute ();

}

Doesn't the code do the same thing what MEF does?

re: Simple Introduction to Extensible Applications with the Managed Extensions Framework

Glenn Block — Wed, 01 Oct 2008 08:18:48 GMT

@Dave

1. MEF will continue to ship on Codeplex for now, but will be rolled into the framework.

2. Catalogs load things on demand. So if all you are asking for is a logger in a single assembly, ONLY that assembly will load, and only upon instantiation. If that logger has a dependency on another assembly, then it will load as well.

3. Good points on the catalog. We are working on syntactic sugar to do this. One apporach is have a hosting api that contains all the common things you need to do. For example it would accept a list of folders which behind the scenes will end up having a DirectoryPartCatalog created. The api will be a helper which creates the resolver and catalogs behind the scenes allowing the client to simply write one line of code. Does this make sense?

Thanks for the feedback, keep it coming!

Regards

Glenn

re: Simple Introduction to Extensible Applications with the Managed Extensions Framework

Glenn Block — Wed, 01 Oct 2008 08:25:10 GMT

@chrisplasun

MEF doesn't handle isolation as this is what System.Addin is for. MEF can work with System.Addin to allow it activate parts in a separate app domain / process. We don't provide the plumbing for this out of the box, but our model supports it.

Thanks

re: Simple Introduction to Extensible Applications with the Managed Extensions Framework

Jomit — Wed, 01 Oct 2008 14:43:50 GMT

Excellent Brad,

Simple & Effective. The last example was more interesting.

Thanks

Jomit

Simple Introduction to Extensible Applications with the Managed Extensions Framework

GHA — Wed, 01 Oct 2008 15:17:19 GMT

Simple Introduction to Extensible Applications with the Managed Extensions Framework

re: Simple Introduction to Extensible Applications with the Managed Extensions Framework

Dave R. — Thu, 02 Oct 2008 02:43:10 GMT

Hi Glenn,

Many thanks for the response. The 'syntactic sugar' you mention is exactly the sort of thing that sounds very useful, especially if it shields us mere mortals from having to do a lot of the plumbing for simple scenarios.

It would be fantastic if you could share some of the API mock-ups with us - I'm passionate about this after reading Brad's FDG book ;)

使用托管扩展性框架（MEF）创建可扩展应用的简介

Joycode@Ab110.com — Fri, 03 Oct 2008 21:15:11 GMT

【原文地址】 Simple Introduction to Extensible Applications with the Managed Extensions Framework 【原文发表日期】

re: Simple Introduction to Extensible Applications with the Managed Extensions Framework

Richie Scott — Tue, 07 Oct 2008 01:10:54 GMT

Excellent blog Brad - can you tell me where you think MEF fits with Unity, replace or complement?

Thanks

re: Simple Introduction to Extensible Applications with the Managed Extensions Framework

Cleve Littlefield — Wed, 08 Oct 2008 01:07:56 GMT

I would love to see another article under the same writing approach that compares MEF to System.AddIn (as one other person commented) and/or any generic IoC container like StructureMap, Unity, Castle Windsor...

What are the overlaps, dependencies, differences?

Excellent Article on Managed Extensions Framework and writing Addin-based Applications from Brad Abrams

Thoughts and Ideas on Semantics and Contexts — Wed, 08 Oct 2008 12:42:50 GMT

hi there, also I've talked a little bit in this blog on practical writing of Add-in-based applications,

re: Simple Introduction to Extensible Applications with the Managed Extensions Framework

Glenn Block — Thu, 09 Oct 2008 09:37:16 GMT

Hi Dave

Here is a snippet which we've been toying with just to illustrate the thinking

In your Main method of your program you would do something like:

static void Main(args[] string) {

var CompositionHost = new CompositionHost(".\");

CompositionHost.Run(args)

}

this would then import an IApplicationStart that has a Start method and would kick off composition.

[Export(typeof(IApplicationStart))

public class ApplicationStart : IApplicationStart

{

void Run(string[] args){}

[Import]

ISomeService Service{get;set;}

}

The host class would manage the container behind the scenes, automatically import the App Start and execute it. Having the App Start part imported would being the composition satisfying any it's imports, it's imports imports, and so on.

Because App Start is an interface, you can host it wherever you like for example in an App.Xaml.cs, or the Main for a winform app, or even in a Web Service host.

Does this seem useful? Any feedback would be appreciated.

Extensible Applications with MEF

Guy kolbis — Sun, 12 Oct 2008 14:41:25 GMT

MEF stands for " M anaged E xtensions F ramework". The idea behinds it is to allow reuse and

Managed Extensibility Framework (MEF) Demo

Brad Abrams — Thu, 06 Nov 2008 16:55:54 GMT

The Managed Extensibility Framework (MEF) is a new feature of .NET 4 (and will work on 3.5 as well) that

Managed Extensibility Framework (MEF) Demo

Brad Abrams — Sat, 08 Nov 2008 06:10:26 GMT

The Managed Extensibility Framework (MEF) is a new feature of .NET 4 (and will work on 3.5 as well) that

re: Simple Introduction to Extensible Applications with the Managed Extensions Framework

Bill Sithiro — Fri, 28 Nov 2008 11:12:30 GMT

Good programmers have been implementing similar approaches to this since like... forever! Not that I don't like it, I think it would be great if this becomes mainstream in the .NET world having a common way of implementing plug-in/add-in/extentending architecture. But, I have a question, what if the class with the color text output that came later could apply the same behaviour to the earlier monochrome ones. How hard would that be to implement?