private void Config(IProfileRegistry config, ITypeProvider typeProvider)
        {
            var largeMessageBodyTempPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), Guid.NewGuid().ToString());

            config.For<ILogger>()
                .Use<ConsoleLogger>()
                .Singleton();

            config.For<ILargeMessageBodyStore>()
                .Use(c => new FileSystemStorageBuilder().Configure()
                    .WithStorageDirectory(largeMessageBodyTempPath)
                    .WithLogger(c.GetInstance<ILogger>())
                    .Build())
                .Singleton();

            config.For<IBus>()
                .Use(c => new BusBuilder().Configure()
                    .WithNames("IntegrationTestHarness", Environment.MachineName)
                    .WithConnectionString(@"Endpoint=sb://shouldnotexist.example.com/;SharedAccessKeyName=IntegrationTestHarness;SharedAccessKey=borkborkbork=")
                    .WithLargeMessageStorage(sc => sc.WithLargeMessageBodyStore(c.GetInstance<ILargeMessageBodyStore>())
                        .WithMaxSmallMessageSize(50 * 1024)
                        .WithMaxLargeMessageSize(1024 * 1024))
                    .WithTypesFrom(typeProvider)
                    .WithDefaultTimeout(TimeSpan.FromSeconds(10))
                    .WithLogger(c.GetInstance<ILogger>())
                    .Build())
                .Singleton();
        }

        internal static Type GetContextType(ITypeProvider typeProvider, Activity currentActivity)
        {
            Type contextType = null;
            string className = String.Empty;
            Activity rootActivity = null;

            if (Helpers.IsActivityLocked(currentActivity))
            {
                rootActivity = Helpers.GetDeclaringActivity(currentActivity);
            }
            else
            {
                rootActivity = Helpers.GetRootActivity(currentActivity);
            }

            if (rootActivity != null)
            {
                className = rootActivity.GetValue(WorkflowMarkupSerializer.XClassProperty) as string;
                if (!String.IsNullOrEmpty(className))
                    contextType = typeProvider.GetType(className, false);

                if (contextType == null)
                    contextType = typeProvider.GetType(rootActivity.GetType().FullName);

                // If all else fails (likely, we don't have a type provider), it's the root activity type.
                if (contextType == null)
                    contextType = rootActivity.GetType();
            }

            return contextType;
        }

 public IDependencyResolver Create(ITypeProvider typeProvider)
 {
     var kernel = new StandardKernel();
     kernel.Components.Remove<IMissingBindingResolver, SelfBindingResolver>();
     kernel.RegisterNimbus(typeProvider);
     return kernel.Get<IDependencyResolver>();
 }

        private static Bus CreateBus(IWindsorContainer container, ITypeProvider typeProvider)
        {
            var configRetriever = container.Resolve<IGetEnvironmentConfiguration>();
            
            try
            {
                // Get the Azure Service Bus connection string, app name, and unique name for this running instance
                string connectionString = configRetriever.GetSetting(AzureServiceBusConnectionStringKey);
                string appName = configRetriever.AppName;
                string uniqueName = configRetriever.UniqueInstanceId;

                Bus bus = new BusBuilder().Configure()
                                          .WithConnectionString(connectionString)
                                          .WithNames(appName, uniqueName)
                                          .WithJsonSerializer()
                                          .WithWindsorDefaults(container)
                                          .WithTypesFrom(typeProvider)
                                          .Build();
                bus.Start();
                return bus;
            }
            finally
            {
                container.Release(configRetriever);
            }
        }

        public static ContainerBuilder RegisterNimbus(this ContainerBuilder builder, ITypeProvider typeProvider)
        {
            builder.RegisterTypes(typeProvider.AllHandlerTypes())
                   .AsImplementedInterfaces()
                   .InstancePerLifetimeScope();

            builder.RegisterType<AutofacMulticastEventHandlerFactory>()
                   .AsImplementedInterfaces()
                   .SingleInstance();

            builder.RegisterType<AutofacCompetingEventHandlerFactory>()
                   .AsImplementedInterfaces()
                   .SingleInstance();

            builder.RegisterType<AutofacCommandHandlerFactory>()
                   .AsImplementedInterfaces()
                   .SingleInstance();

            builder.RegisterType<AutofacRequestHandlerFactory>()
                   .AsImplementedInterfaces()
                   .SingleInstance();

            builder.RegisterType<AutofacMulticastRequestHandlerFactory>()
                   .AsImplementedInterfaces()
                   .SingleInstance();

            return builder;
        }

 public RuleValidation(Activity activity, ITypeProvider typeProvider, bool checkStaticType)
 {
     this.errors = new ValidationErrorCollection();
     this.typesUsed = new Dictionary<string, Type>(0x10);
     this.activeParentNodes = new Stack<CodeExpression>();
     this.expressionInfoMap = new Dictionary<CodeExpression, RuleExpressionInfo>();
     this.typeRefMap = new Dictionary<CodeTypeReference, Type>();
     if (activity == null)
     {
         throw new ArgumentNullException("activity");
     }
     if (typeProvider == null)
     {
         throw new ArgumentNullException("typeProvider");
     }
     this.thisType = ConditionHelper.GetContextType(typeProvider, activity);
     this.typeProvider = typeProvider;
     this.checkStaticType = checkStaticType;
     if (checkStaticType)
     {
         this.authorizedTypes = WorkflowCompilationContext.Current.GetAuthorizedTypes();
         this.typesUsedAuthorized = new Dictionary<string, Type>();
         this.typesUsedAuthorized.Add(voidTypeName, voidType);
     }
 }

        private void BuildContainer(ITypeProvider typeProvider)
        {
            if (_container != null) throw new InvalidOperationException("This factory is only supposed to be used to construct one test subject.");

            _container = new WindsorContainer();
            _container.RegisterNimbus(typeProvider);
        }

        public AzureQueueManager(Func<NamespaceManager> namespaceManager,
                                 Func<MessagingFactory> messagingFactory,
                                 AutoDeleteOnIdleSetting autoDeleteOnIdle,
                                 DefaultMessageTimeToLiveSetting defaultMessageTimeToLive,
                                 DefaultTimeoutSetting defaultTimeout,
                                 EnableDeadLetteringOnMessageExpirationSetting enableDeadLetteringOnMessageExpiration,
                                 GlobalPrefixSetting globalPrefix,
                                 MaxDeliveryAttemptSetting maxDeliveryAttempts,
                                 IPathFactory pathFactory,
                                 IRetry retry,
                                 ISqlFilterExpressionGenerator sqlFilterExpressionGenerator,
                                 ITypeProvider typeProvider)
        {
            _namespaceManager = namespaceManager;
            _messagingFactory = messagingFactory;
            _maxDeliveryAttempts = maxDeliveryAttempts;
            _retry = retry;
            _typeProvider = typeProvider;
            _defaultMessageTimeToLive = defaultMessageTimeToLive;
            _autoDeleteOnIdle = autoDeleteOnIdle;
            _defaultTimeout = defaultTimeout;
            _enableDeadLetteringOnMessageExpiration = enableDeadLetteringOnMessageExpiration;
            _globalPrefix = globalPrefix;
            _sqlFilterExpressionGenerator = sqlFilterExpressionGenerator;
            _pathFactory = pathFactory;

            _knownTopics = new ThreadSafeLazy<ConcurrentSet<string>>(FetchExistingTopics);
            _knownSubscriptions = new ThreadSafeLazy<ConcurrentSet<string>>(FetchExistingSubscriptions);
            _knownQueues = new ThreadSafeLazy<ConcurrentSet<string>>(FetchExistingQueues);
        }

        public static ContainerBuilder RegisterNimbus(this ContainerBuilder builder, ITypeProvider typeProvider)
        {
            foreach (var handlerType in typeProvider.AllHandlerTypes())
            {
                var handlerInterfaceTypes = handlerType.GetInterfaces().Where(typeProvider.IsClosedGenericHandlerInterface);
                foreach (var interfaceType in handlerInterfaceTypes)
                {
                    builder.RegisterType(handlerType)
                           .Named(handlerType.FullName, interfaceType)
                           .InstancePerLifetimeScope();
                }
            }

            builder.RegisterSource(new ContravariantRegistrationSource());
            typeProvider.InterceptorTypes
                        .Do(t => builder.RegisterType(t)
                                        .AsSelf()
                                        .InstancePerLifetimeScope())
                        .Done();

            builder.RegisterInstance(typeProvider)
                   .AsImplementedInterfaces()
                   .SingleInstance();

            builder.RegisterType<AutofacDependencyResolver>()
                   .As<IDependencyResolver>()
                   .SingleInstance();

            return builder;
        }

 internal static Type GetContextType(ITypeProvider typeProvider, Activity currentActivity)
 {
     Type type = null;
     string str = string.Empty;
     Activity declaringActivity = null;
     if (System.Workflow.Activities.Common.Helpers.IsActivityLocked(currentActivity))
     {
         declaringActivity = System.Workflow.Activities.Common.Helpers.GetDeclaringActivity(currentActivity);
     }
     else
     {
         declaringActivity = System.Workflow.Activities.Common.Helpers.GetRootActivity(currentActivity);
     }
     if (declaringActivity != null)
     {
         str = declaringActivity.GetValue(WorkflowMarkupSerializer.XClassProperty) as string;
         if (!string.IsNullOrEmpty(str))
         {
             type = typeProvider.GetType(str, false);
         }
         if (type == null)
         {
             type = typeProvider.GetType(declaringActivity.GetType().FullName);
         }
         if (type == null)
         {
             type = declaringActivity.GetType();
         }
     }
     return type;
 }

 private RTTypeWrapper(ITypeProvider typeProvider, Type runtimeType, Type[] typeArgs)
 {
     this.memberMapping = new Hashtable();
     this.boundedTypes = new Hashtable(new TypeArrayComparer());
     if (runtimeType == null)
     {
         throw new ArgumentNullException("runtimeType");
     }
     if (runtimeType.Assembly == null)
     {
         throw new ArgumentException(SR.GetString("Error_InvalidArgumentValue"), "runtimeType");
     }
     this.typeProvider = typeProvider;
     this.runtimeType = runtimeType;
     if (!this.IsGenericTypeDefinition)
     {
         throw new ArgumentException(SR.GetString("Error_InvalidArgumentValue"), "runtimeType");
     }
     this.typeArgs = new Type[typeArgs.Length];
     for (int i = 0; i < typeArgs.Length; i++)
     {
         this.typeArgs[i] = typeArgs[i];
         if (this.typeArgs[i] == null)
         {
             throw new ArgumentException(SR.GetString("Error_InvalidArgumentValue"), "typeArgs");
         }
     }
 }

        internal DoYourThingConfigurationConfigurator(ITypeProvider typeProvider, Action<IConfigurationSetting> registerAsSingleton)
        {
            _typeProvider = typeProvider;
            _registerAsSingleton = registerAsSingleton;

            _settingKeyConventions.AddRange(SettingKeyConventions.BuiltInConventions);
        }

        public SettingsRegistrationService(IConfigInjectorLogger logger,
                                           ITypeProvider typeProvider,
                                           ISettingKeyConvention[] settingKeyConventions,
                                           ISettingsReader settingsReader,
                                           ISettingsOverrider settingsOverrider,
                                           SettingValueConverter settingValueConverter,
                                           bool allowEntriesInWebConfigThatDoNotHaveSettingsClasses,
                                           Action<IConfigurationSetting> registerAsSingleton)
        {
            if (logger == null) throw new ArgumentNullException("logger");
            if (typeProvider == null) throw new ArgumentNullException("typeProvider");
            if (settingKeyConventions == null) throw new ArgumentNullException("settingKeyConventions");
            if (settingsReader == null) throw new ArgumentNullException("settingsReader");
            if (settingsOverrider == null) throw new ArgumentNullException("settingsOverrider");
            if (settingValueConverter == null) throw new ArgumentNullException("settingValueConverter");
            if (registerAsSingleton == null) throw new ArgumentNullException("registerAsSingleton");

            _logger = logger;
            _typeProvider = typeProvider;
            _settingKeyConventions = settingKeyConventions;
            _settingsReader = settingsReader;
            _settingsOverrider = settingsOverrider;
            _settingValueConverter = settingValueConverter;
            _allowEntriesInWebConfigThatDoNotHaveSettingsClasses = allowEntriesInWebConfigThatDoNotHaveSettingsClasses;
            _registerAsSingleton = registerAsSingleton;
        }

        public SourcesWindow(ITypeProvider typeProvider, ISourceNavigator sourceNavigator,
			ISourcesProvider sourcesProvider
)
        {
            this.typeProvider = typeProvider;
            this.sourceNavigator = sourceNavigator;
            this.sourcesProvider = sourcesProvider;
        }

        public static IBindingRoot RegisterNimbus(this IBindingRoot kernel, ITypeProvider typeProvider)
        {
            kernel.Bind<IDependencyResolver>().To<NinjectDependencyResolver>().InSingletonScope();
            kernel.Bind<ITypeProvider>().ToConstant(typeProvider).InSingletonScope();

            BindAllHandlerInterfaces(kernel, typeProvider);

            return kernel;
        }

        private static IEnumerable<Type> SelectHandlerInterfaces(Type type, ITypeProvider typeProvider)
        {
            var handlerInterfaces = type
                .GetInterfaces()
                .Where(typeProvider.IsClosedGenericHandlerInterface)
                .ToArray();

            return handlerInterfaces;
        }

        public MainWindow(
			IDebuggerSession session,
			ITypeProvider typeProvider,
			DebuggerWindowManager windowManager
		)
        {
            this.session = session;
            this.typeProvider = typeProvider;
            this.windowManager = windowManager;
        }

        protected static DbModel BuildModel(BoundedContextElement context, ITypeProvider typeProvider = null)
        {
            var builder = CreateBuilder(CreateMetadataProvider(MockSource(context)), typeProvider);
            var contextId = context.Identity.Id;
            var model = builder.Build(EffortProvider, contextId);

            model.Dump();

            return model;
        }

        public DebuggerSession(IVirtualMachine virtualMachine,
			IExecutionProvider executionProvider, ITypeProvider typeProvider,
			IThreadProvider threadProvider, IBreakpointProvider breakpointProvider)
        {
            VM = virtualMachine;
            ExecutionProvider = executionProvider;
            ThreadProvider = threadProvider;
            TypeProvider = typeProvider;
            BreakpointProvider = breakpointProvider;
        }

        public DebuggerSession(IVirtualMachine vm, ITypeProvider typeProvider,
			IExecutionProvider executionProvider, IThreadProvider threadProvider,
			IBreakpointProvider breakpointProvider)
        {
            this.typeProvider = typeProvider;
            this.executionProvider = executionProvider;
            this.threadProvider = threadProvider;
            this.breakpointProvider = breakpointProvider;
            this.vm = vm;
        }