public class UriBinder : HttpProcessor
{
    private static List<UriBinding> _bindings;
 
    static UriBinder()
    {
        _bindings = new List<UriBinding>();
    }
 
    public static void AddUriBinding<TModel>(string name, string matchRegex, Func<int, object> modelFactory)

//in startup
UriBinder.AddUriBinding<Contact>("contact", "contact/(.+)", 
    cid => ContactsHandler._contacts.Single(c => c.ContactID == cid));
 
//request is http://contactmanager/contact/1 
 
//the resource takes contact as a param
public class ContactHandler {
    public Contact Get(Contact contact)
    {

var config = ResourceConfiguration.Configure("ContactManager").
    Conventions(c =>
        {
            c.PostMethod(m => m.Name.StartsWith("Updated"));
            c.DeleteMethod(m => m.Name.StartsWith("Remove"));
            c.Uri<MyUriConvention>();
            c.Model<MyModelConvention>();
        }
    ).
    ResourceScanner<MyResourceScanner>().

var config = ResourceConfiguration.Configure("ContactManager").
    Conventions(c =>
        {
            c.Method("POST").To(m => m.Name.StartsWith("Updated"));
            c.Method("DELETE").To(m => m.Name.StartsWith("Remove"));
            c.Uri<MyUriConvention>();
            c.Model<MyModelConvention>();
        }
    ).
    ResourceScanner<MyResourceScanner>().

var config = ResourceConfiguration.Configure("ContactManager").
    Conventions(c =>
        {
            c.Method("POST").To(m => m.Name.StartsWith("Updated"));
            c.Method("DELETE").To(m => m.Name.StartsWith("Remove"));
            c.Uri(t => GetUriFromType(t));
            c.Model(t => GetModelFromResource(t));
        }
    ).
    ResourceScanner<MyResourceScanner>().

var config = ResourceConfiguration.Configure.
    Conventions(c=>
        {
            c.
                Method("Post").Convention(m => m.Name.StartsWith("Updated")).
                Method("Delete").Convention(m => m.Name.StartsWith("Remove")).
                UriConvention(t => GetUriFromType(t)).
                ModelConvention(t => GetModelFromResource(t));
        }
    ).

ServiceHost.Create<EchoService>
  .Uri("http://MySite.com")
      .EndPoint<IEcho>
         .Address("...")
         .Binding<BasicHttpBinding>

[HandleError]
public class HomeController : Controller
{
    public ActionResult Index()
    {
        ViewData["Message"] = "Welcome to ASP.NET MVC!";
 
        return View();
    }

[ServiceContract]
[AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)]
// NOTE: If the service is renamed, remember to update the global.asax.cs file
public class MessageService
{
    [WebGet(UriTemplate = "/Method1?a={var1}&b={var2}")]
    [CompositeOperationBehavior("MessageService")]
    public Message GetMessage(string var1, string var2)
    {

routes.AddRoute<OrdersResource>("/Orders");
routes.AddRoute<OrdersResource>("/Orders/{Order}")
 
public class OrdersResource {
  //dependencies can be injected
  public OrdersResource(IRepository<Order> orderRepository) {
  }
 
  public JsonResponseMessage GetOrders() {}  // allows explict mapping for contentneg based on return value
  public XmlResponseMessage GetOrders() {}

using System;
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Primitives;
using System.ComponentModel.Composition.Hosting;
 
namespace Microsoft.ComponentModel.Composition
{
    public static class CompositionInitializerEx
    {
        public static void SatisfyImports(ComposablePart part, bool allowRecomposition = false)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel.Composition;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.ComponentModel.Composition.Hosting;
 
namespace Given_two_order_view_models
{

 
public static class CatalogExtensions
{
    public static IEnumerable<Assembly> ToAssemblies(this ComposablePartCatalog catalog)
    {
        return catalog.Parts.Select(p => ((Type) ReflectionModelServices.GetPartType(p).Value).Assembly).Distinct();
    }
}
 

public static class ExportFactoryExtensions
{
    public static T GetInstance<T>(this ExportFactory<T> factory)
    {
        var export = factory.CreateExport();
        return export.Value;
    }
}

using System; 
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;
using System.ComponentModel.Composition.Primitives;
using System.Linq;
using System.Text;
 
public class ConfigurationExportProvider : ExportProvider

[Export(typeof(IModuleManager))]
public class ModuleManager : IModuleManager
{
    [ImportMany]
    public IEnumerable<Lazy<IModule>> Modules { get; set; }
 
    public void Load()
    {
        foreach(var lazyModule in Modules)
        {

public class StoryFrameEditorViewModel : ViewModel
{
    public StoryFrameEditorViewModel()
    {
        _template = Field<StoryFrameTemplate>("Template");
    }
    
    private BackingField<StoryFrameTemplate> _template; 
    public StoryFrameTemplate Template
    {

#region $entity$
 
public IQueryable<$entity$> Get$entities$()
{
    return this.DataContext.$entities$;
}
 
public void Insert$entity$($entity$ current$entity$)
{
    this.DataContext.$entities$.InsertOnSubmit(current$entity$);

[Export]
public class OrderView {
  [Import("OrderViewViewModel")]
  public object ViewModel {
    get{return this.DataContext;}
    set{this.DataContext = value;}
  }
}
 
[Export]

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;
 
namespace DynamicObjectContracts
{
    public class Program

public class ViewModelInitializer<TViewModel,TModel> where TViewModel : IViewModel<TModel>
{
    private Func<TViewModel> _viewModelFactory;
 
    public ViewModelInitializer(Func<TViewModel> viewModelFactory)
    {
        _viewModelFactory = viewModelFactory;
    }
 
    public void Initialize(FrameworkElement view, TModel model)

// Below RecentlyUsedTrackerConfiguration provides configuration information through property exports. MEF pulls on the property getters and exports that info. 
// If the part needs to be data drvien, you can still access a service behind the scenes in the getter (or the constructor) to get the info.
 
public class RecentlyUsedTrackerConfiguration
{
  public RecentlyUsedTrackerConfiguration()
  {
     //set values here
  }

public static class AsyncTestExtensions
{
    public static void EnqueueUntilLoaded(this SilverlightTest test, FrameworkElement element, params Action[] actions)
    {
        var isLoaded = false;
        element.Loaded += (s, e) => isLoaded = true;
        test.EnqueueConditional(() => isLoaded);
        test.EnqueueCallback(actions);
        test.EnqueueTestComplete();
    }

namespace System.ComponentModel.Composition.Hosting
{
    public class DeploymentCatalog : ComposablePartCatalog, INotifyComposablePartCatalogChanged
    {
        public DeploymentCatalog();
        public DeploymentCatalog(string uri);
        public DeploymentCatalog(Uri uri);
        public override IQueryable<ComposablePartDefinition> Parts { get; }
        public Uri Uri { get; }

using System.ComponentModel.Composition;
using Microsoft.Practices.Composite.Events;
 
//this version uses a static backing field so that the instance is automatically shared across all containers.
public class EventAggregatorPart
{
    private static IEventAggregator _eventAggregator;
 
    static EventAggregatorPart()
    {