The principle purpose of MEF is extensibility; to serve as a &#39;plug-in&#39; framework for when the author of the application and the author of the plug-in (*extension*) are different and have no particular knowledge of each other beyond a published interface (*contract*) library. 

Another problem space MEF addresses that&#39;s different from the usual IoC suspects, and one of MEFs strengths, is [extension] discovery. It has a lot of, well, extensible discovery mechanisms that operate on metadata you can associate with extensions. From the MEF CodePlex site:

*&quot;MEF allows tagging extensions with additonal metadata which facilitates rich querying and filtering&quot;*

Combined with an ability to delay-load tagged extensions, being able to interrogate extension metadata *prior* to loading opens the door to a slew of interesting scenarios and substantially enables capabilities such as [plug-in] versioning. 

MEF also has &#39;Contract Adapters&#39; which allow extensions to be &#39;adapted&#39; or &#39;transformed&#39; (*from type &gt; to type*) with complete control over the details of those transforms. Contract Adapters open up another creative front relative to just what &#39;discovery&#39; means and entails.

Again, MEFs &#39;intent&#39; is tightly focused on anonymous plug-in extensibility, something that very much differentiates it from other IoC containers. So while MEF can be used for composition, that&#39;s merely a small intersection of its capabilities relative to other IoCs, with which I suspect we&#39;ll be seeing a lot of incestuous interplay going forward.

IoC containers focus on those things you know i.e. I know I will use one logger in a Unit Test, and a different Logger in my app. MEF focuses on those things you don&#39;t, there are 1 to n loggers that may appear in my system.


Scott Hanselman and I covered this topic in more detail in the recent hanselminutes.

http://www.hanselminutes.com/default.aspx?showID=166 

&gt; **Possible Duplicate:**  
&gt; [JavaScript: var functionName = function() {} vs function functionName() {}](https://stackoverflow.com/questions/336859/javascript-var-functionname-function-vs-function-functionname)  

&lt;!-- End of automatically inserted text --&gt;

What&#39;s the difference between:

    function sum(x, y) {
      return x+y;
    }

    // and 
  
    var sum = function (x, y) {
        return x+y;
    }

Why is one used over the other?



The difference between the two functions? (&quot;function x&quot; vs &quot;var x = function&quot;)

I create a web application (WAR) and deploy it on Tomcat. In the *webapp* there is a page with a form where an administrator can enter some configuration data. I don&#39;t want to store this data in an DBMS, but just in an XML file on the file system. Where to put it?

I would like to put the file somewhere in the directory tree where the application itself is deployed. Should my configuration file be in the *WEB-INF* directory? Or put it somewhere else? 

And what is the Java code to use in a servlet to find the absolute path of the directory? Or can it be accessed with a relative path?

What is the best place to store a configuration file in a Java web application (WAR)?

What problems does MEF (Managed Extensibility Framework) solves that cannot be solved by existing IoC/DI containers?

MEF (Managed Extensibility Framework) vs IoC/DI

<p>What problems does MEF (Managed Extensibility Framework) solves that cannot be solved by existing IoC/DI containers?</p>


I&#39;m a long-time Windows developer, having cut my teeth on win32 and early COM.  I&#39;ve been working with .NET since 2001, so I&#39;m pretty fluent in C# and the CLR.  I&#39;d never heard of Castle Windsor until I started participating in Stack Overflow.  I&#39;ve read the Castle Windsor &quot;Getting Started&quot; guide, but it&#39;s not clicking.

Teach this old dog new tricks, and tell me why I should be integrating Castle Windsor into my enterprise apps.

What is Castle Windsor, and why should I care?

&lt;!-- language-all: c# --&gt;

I am writing a component that, given a ZIP file, needs to:

 1. Unzip the file.
 2. Find a specific dll among the unzipped files.
 3. Load that dll through reflection and invoke a method on it.

I&#39;d like to unit test this component.

I&#39;m tempted to write code that deals directly with the file system:

    void DoIt()
    {
       Zip.Unzip(theZipFile, &quot;C:\\foo\\Unzipped&quot;);
       System.IO.File myDll = File.Open(&quot;C:\\foo\\Unzipped\\SuperSecret.bar&quot;);
       myDll.InvokeSomeSpecialMethod();
    }

 But folks often say, &quot;Don&#39;t write unit tests that rely on the file system, database, network, etc.&quot;

If I were to write this in a unit-test friendly way, I suppose it would look like this:

    void DoIt(IZipper zipper, IFileSystem fileSystem, IDllRunner runner)
    {
       string path = zipper.Unzip(theZipFile);
       IFakeFile file = fileSystem.Open(path);
       runner.Run(file);
    }

Yay! Now it&#39;s testable; I can feed in test doubles (mocks) to the DoIt method. But at what cost? I&#39;ve now had to define 3 new interfaces just to make this testable. And what, exactly, am I testing? I&#39;m testing that my DoIt function properly interacts with its dependencies. It doesn&#39;t test that the zip file was unzipped properly, etc.

It doesn&#39;t feel like I&#39;m testing functionality anymore. It feels like I&#39;m just testing class interactions.

**My question is this**: what&#39;s the proper way to unit test something that is dependent on the file system?

*edit* I&#39;m using .NET, but the concept could apply Java or native code too.

Unit testing code with a file system dependency

There have been several questions already posted with specific questions about [dependency injection][1], such as when to use it and what frameworks are there for it. However,

**What is dependency injection and when/why should or shouldn&#39;t it be used?**

  [1]: http://en.wikipedia.org/wiki/Dependency_injection


What is dependency injection?

I understand benefits of dependency injection itself. Let&#39;s take Spring for instance. I also understand benefits of other Spring featureslike AOP, helpers of different kinds, etc. I&#39;m just wondering, what are the benefits of XML configuration such as:

    &lt;bean id=&quot;Mary&quot; class=&quot;foo.bar.Female&quot;&gt;
      &lt;property name=&quot;age&quot; value=&quot;23&quot;/&gt;
    &lt;/bean&gt;
    &lt;bean id=&quot;John&quot; class=&quot;foo.bar.Male&quot;&gt;
      &lt;property name=&quot;girlfriend&quot; ref=&quot;Mary&quot;/&gt;
    &lt;/bean&gt;

compared to plain old java code such as:

    Female mary = new Female();
    mary.setAge(23);
    Male john = new Male();
    john.setGirlfriend(mary);

which is easier debugged, compile time checked and can be understood by anyone who knows only java.
So what is the main purpose of a dependency injection framework? (or a piece of code that shows its benefits.)


----------


**UPDATE:**&lt;br/&gt;
In case of

    IService myService;// ...
    public void doSomething() {  
      myService.fetchData();
    }
How can IoC framework guess which implementation of myService I want to be injected if there is more than one? If there is only one implementation of given interface, and I let IoC container automatically decide to use it, it will be broken after a second implementation appears. And if there is intentionally only one possible implementation of an interface then you do not need to inject it.

It would be really interesting to see small piece of configuration for IoC which shows it&#39;s benefits. I&#39;ve been using Spring for a while and I can not provide such example. And I can show single lines which demonstrate benefits of hibernate, dwr, and other frameworks which I use.


----------


**UPDATE 2:**&lt;br/&gt;
I realize that IoC configuration can be changed without recompiling. Is it really such a good idea? I can understand when someone wants to change DB credentials without recompiling - he may be not developer. In your practice, how often someone else other than developer changes IoC configuration? I think that for developers there is no effort to recompile that particular class instead of changing configuration. And for non-developer you would probably want to make his life easier and provide some simpler configuration file.


----------


**UPDATE 3:**&lt;br/&gt;

&gt; External configuration of mapping between interfaces and their concrete implementations 

What is so good in making it extenal? You don&#39;t make all your code external, while you definitely can - just place it in ClassName.java.txt file, read and compile manually on the fly - wow, you avoided recompiling. Why should compiling be avoided?!

&gt; You save coding time because you provide mappings declaratively, not in a procedural code 

I understand that sometimes declarative approach saves time. For example, I declare only once a mapping between a bean property and a DB column and hibernate uses this mapping while loading, saving, building SQL based on HSQL, etc. This is where the declarative approach works. In case of Spring (in my example), declaration had more lines and had the same expressiveness as corresponding code. If there is an example when such declaration is shorter than code - I would like to see it.

&gt;Inversion of Control principle allows for easy unit testing because you can replace real implementations with fake ones (like replacing SQL database with an in-memory one)

I do understand inversion of control benefits (I prefer to call the design pattern discussed here as Dependency Injection, because IoC is more general - there are many kinds of control, and we are inverting only one of them - control of initialization). I was asking why someone ever needs something other than a programming language for it. I definitely can replace real implementations with fake ones using code. And this code will express same thing as configuration - it will just initialize fields with fake values.

    mary = new FakeFemale();

I do understand benefits of DI. I do not understand what benefits are added by external XML configuration compared to configuring code that does the same. I do not think that compiling should be avoided - I compile every day and I&#39;m still alive. I think configuration of DI is bad example of declarative approach. Declaration can be useful if is declared once AND is used many times in different ways - like hibernate cfg, where mapping between bean property and DB column is used for saving, loading, building search queries, etc. Spring DI configuration can be easily translated to configuring code, like in the beginning of this question, can it not? And it is used only for bean initialization, isn&#39;t it? Which means a declarative approach does not add anything here, does it?

When I declare hibernate mapping, I just give hibernate some information, and it works based on it - I do not tell it what to do. In case of spring, my declaration tells spring exactly wht to do - so why declare it, why not just do it?


----------


**LAST UPDATE:**&lt;br/&gt;
Guys, a lot of answers are telling me about dependency injection, which I KNOW IS GOOD.
The question is about purpose of DI configuration instead of initializing code - I tend to think that initializing code is shorter and clearer.
The only answer I got so far to my question, is that it avoids recompiling, when the configuration changes. I guess I should post another question, because it is a big secret for me, why compiling should be avoided in this case.

What are the benefits of dependency injection containers?

Is there a framework equivalent to Guice (http://code.google.com/p/google-guice) for Python?

Python Dependency Injection Framework

What&#39;s pros and cons of using Enterprise Library Unity vs other IoC containers (Windsor, Spring.Net, Autofac ..)?

Enterprise Library Unity vs Other IoC Containers

I&#39;ve been reading the articles on MSDN about Unity (Dependency Injection, Inversion of Control), but I think I need it explained in simple terms (or simple examples). I&#39;m familiar with the MVPC pattern (we use it here), but I just can&#39;t really grasp this Unity thing yet, and I think it&#39;s the next step in our application design.

Can someone explain Microsoft Unity?

I have a Generic Type Interface and want a constructor of an object to take in the Generic Interface.  
Like:

    public Constructor(int blah, IGenericType&lt;T&gt; instance)
    {}

I want the code that creates this object to specify the IGenericType (use Inversion of Control).  I have not seen a way for this to happen.  Any suggestions to accomplish this?

I want someone to create the object like:

    Constructor varname = new Constructor(1, new GenericType&lt;int&gt;());


Generic Type in constructor

I&#39;ve been using [Dependency Injection][1] (DI) for a while, injecting either in a constructor, property, or method.  I&#39;ve never felt a need to use an [Inversion of Control][2] (IoC) container.  However, the more I read, the more pressure I feel from the community to use an IoC container.

I played with .NET containers like [StructureMap](http://docs.structuremap.net), [NInject](http://www.ninject.org), [Unity](http://unity.codeplex.com), and [Funq](http://funq.codeplex.com).  I still fail to see how an IoC container is going to benefit / improve my code.

I&#39;m also afraid to start using a container at work because many of my co-workers will see code which they don&#39;t understand. Many of them may be reluctant to learn new technology.

Please, convince me that I need to use an IoC container.  I&#39;m going to use these arguments when I talk to my fellow developers at work.

  [1]: http://en.wikipedia.org/wiki/Dependency_injection
  [2]: http://en.wikipedia.org/wiki/Inversion_of_control

Why do I need an IoC container as opposed to straightforward DI code?

The Managed Extensibility Framework (MEF) and Managed AddIn Framework (MAF, aka System.AddIn) seem to accomplish very similar tasks. According to this Stack Overflow question, [Is MEF a replacement for System.Addin?][1], you can even use both at the same time. 

When would you choose to use one vs. the other? Under what circumstances would you choose to use both together?


  [1]: https://stackoverflow.com/questions/124040/is-mef-a-replacement-for-system-addin

Choosing between MEF and MAF (System.AddIn)

Looking at Microsoft&#39;s Managed Extensibility Framework (MEF) and various IoC containers (such as Unity), I am failing to see when to use one type of solution over the other.  More specifically, it seems like MEF handles most IoC type patterns and that an IoC container like Unity would not be as necessary.  

Ideally, I would like to see a good use case where an IoC container would be used instead of, or in addition to, MEF. 

MEF vs. any IoC

I watched the DNR TV episode with Glenn Block and it looks like MEF would be useful for my company.  I am trying to find out more information on it&#39;s strengths and weaknesses and some sample projects that use it.  Are there any good blogs/tutorials on using MEF?

Note: I use C#, so if the examples are in C#, that would be awesome.

Where can I learn about MEF?

I am looking for a simple and secure way to access plugins from a .NET application. Although I imagine that this is a very common requirement, I am struggling to find anything that meets all my needs:

 - The host application will discover and load its plugin assemblies at runtime
 - Plugins will be created by unknown 3rd parties, so they must be sandboxed to prevent them from executing malicious code
 - A common interop assembly will contain types that are referenced by both the host and its plugins
 - Each plugin assembly will contain one or more classes that implement a common plugin interface
 - When initializing a plugin instance, the host will pass it a reference to itself in the form of a host interface
 - The host will call into the plugin via its common interface and the plugins may call into the host likewise
 - The host and the plugins will exchange data in the form of the types defined in the interop assembly (including generic types)

I have investigated both MEF and MAF, but I am struggling to see how either of them can be made to fit the bill.

Assuming my understanding is correct, MAF is unable to support the passing of generic types across its isolation boundary, which is essential to my application. (MAF is also very complex to implement, but I would be prepared to work with this if I could solve the generic type problem).

MEF is almost a perfect solution, but appears to fall short on the security requirement, as it loads its extension assemblies in the same AppDomain as the host, and thus apparently prevents sandboxing.

I have seen &lt;a href=&quot;https://stackoverflow.com/questions/3402109&quot;&gt;this question&lt;/a&gt;, which talks of running MEF in a sandboxed mode, but doesn&#39;t describe how. &lt;a href=&quot;http://visualstudiomagazine.com/articles/2009/04/01/working-with-mef.aspx&quot;&gt;This post&lt;/a&gt; states that &quot;when using MEF you must trust extensions not to run malicious code, or offer protection via Code Access Security&quot; but, again, it doesn&#39;t describe how. Finally, there is &lt;a href=&quot;http://blogs.microsoft.co.il/blogs/bnaya/archive/2010/01/01/securing-the-mef-directory-catalog.aspx&quot;&gt;this post&lt;/a&gt;, which describes how to prevent unknown plugins from being loaded, but this is not appropriate to my situation, as even legitimate plugins will be unknown.

I have succeeded in applying .NET 4.0 security attributes to my assemblies and they are correctly respected by MEF, but I don&#39;t see how this helps me to lock out malicous code, as many of the framework methods that might be a security threat (such as methods of &lt;code&gt;System.IO.File&lt;/code&gt;) are marked as &lt;code&gt;SecuritySafeCritical&lt;/code&gt;, which means that they are accessible from &lt;code&gt;SecurityTransparent&lt;/code&gt; assemblies. Am I missing something here? Is there some additonal step I can take to to tell MEF that it should provide internet privileges to plugin assemblies?

Finally, I have also looked at creating my own simple sandboxed plugin architecture, using a separate AppDomain, as described &lt;a href=&quot;http://msdn.microsoft.com/en-us/library/bb763046.aspx&quot;&gt;here&lt;/a&gt;. However, as far as I can see, this technique only allows me to use late binding to invoke static methods on classes in an untrusted assembly. When I try to extend this approach to create an instance of one of my plugin classes, the returned instance cannot be cast to the common plugin interface, which means that it is impossible for the host application to call into it. Is there some technique I can use to get strongly-typed proxy access across the AppDomain boundary?

I apologize for the length of this question; the reason was to show all the avenues that I have already investigated, in the hope that somebody can suggest something new to try.

Many thanks for your ideas,
Tim

Looking for a practical approach to sandboxing .NET plugins

I just start study DI (I&#39;m working on WPF/Silverlight but I have a plan to move to ASP.NET). After I read some DI articles from internet there are two Frameworks that I&#39;m interested in, MEF and Unity. I want to know what is the real-world different between them and which one is good to go.

Content Type	Original Author	Original Content on Stackoverflow
Question	alex	View Question on Stackoverflow
Solution 1 - Dependency Injection	J Healy	View Answer on Stackoverflow
Solution 2 - Dependency Injection	Glenn Block	View Answer on Stackoverflow
Solution 3 - Dependency Injection	Glenn Block	View Answer on Stackoverflow

MEF (Managed Extensibility Framework) vs IoC/DI

Dependency Injection Problem Overview

Dependency Injection Solutions

Solution 1 - Dependency Injection

Solution 2 - Dependency Injection

Solution 3 - Dependency Injection

What is the best place to store a configuration file in a Java web application (WAR)?

The difference between the two functions? ("function x" vs "var x = function")

Attributions