public void SQLCETest()
        {
            UITestRunner.Execute(TestContext.TestName,
                                 () =>
            {
                var sqlCeInputs = new Dictionary <string, object>
                {
                    {
                        "SsdlInput",
                        TestUtils.LoadEmbeddedResource("EFDesigner.InProcTests.TestData.AssocBetSubtypesV2SQLCE40.ssdl")
                    },
                    {
                        "ExistingSsdlInput",
                        TestUtils.LoadEmbeddedResource(
                            "EFDesigner.InProcTests.TestData.AssocBetSubtypesV2SQLCE40_Existing.ssdl")
                    },
                    {
                        "TemplatePath",
                        @"$(VSEFTools)\DBGen\SSDLToSQL10.tt"
                    }
                };

                var sqlCeParameterBag = new EdmParameterBag(
                    null,
                    null,
                    EntityFrameworkVersion.Version2,
                    "System.Data.SqlServerCe.4.0",
                    "4.0",
                    null,
                    "dbo",
                    "TestDb",
                    @"$(VSEFTools)\DBGen\SSDLToSQL10.tt",
                    @"D:\Foo\Blah\t3est.edmx");

                var outputs = InvokeWorkflowActivity <SsdlToDdlActivity>(sqlCeInputs, sqlCeParameterBag);
                object ddlObj;
                if (outputs.TryGetValue("DdlOutput", out ddlObj))
                {
                    Assert.AreEqual(
                        TestUtils.LoadEmbeddedResource("EFDesigner.InProcTests.Baselines.WorkflowActivityTests_SQLCETest.bsl"),
                        ScrubSQLCEDDL((string)ddlObj));
                }
                else
                {
                    Assert.Fail("Could not find DDL output from SSDL to DDL activity for SQL CE");
                }
            });
        }
        internal static WorkflowApplication CreateDatabaseScriptGenerationWorkflow(
            SynchronizationContext syncContext,
            Project project,
            string artifactPath,
            FileInfo workflowFileInfo,
            string templatePath,
            EdmItemCollection edmItemCollection,
            string existingSsdl,
            string existingMsl,
            string databaseSchemaName,
            string databaseName,
            string providerInvariantName,
            string providerConnectionString,
            string providerManifestToken,
            Version targetVersion,
            Action <WorkflowApplicationCompletedEventArgs> workflowCompletedHandler,
            Func <WorkflowApplicationUnhandledExceptionEventArgs, UnhandledExceptionAction> unhandledExceptionHandler)
        {
            // Inputs are specific to the workflow. No need to provide a strongly typed bag here
            // because the workflow has to define these.
            var inputs = new Dictionary <string, object>
            {
                { EdmConstants.csdlInputName, edmItemCollection },
                { EdmConstants.existingSsdlInputName, existingSsdl },
                { EdmConstants.existingMslInputName, existingMsl }
            };

            // Initialize the AssemblyLoader. This will cache project/website references and proffer assembly
            // references to the XamlSchemaContext as well as the OutputGeneratorActivities
            var assemblyLoader = new DatabaseGenerationAssemblyLoader(project, VsUtils.GetVisualStudioInstallDir());

            // Parameters can be used throughout the workflow. These are more ubiquitous than inputs and
            // so they do not need to be defined ahead of time in the workflow.
            var edmWorkflowSymbolResolver = new EdmParameterBag(
                syncContext, assemblyLoader, targetVersion, providerInvariantName, providerManifestToken, providerConnectionString,
                databaseSchemaName, databaseName, templatePath, artifactPath);

            // Deserialize the XAML file into a Activity
            Activity modelFirstWorkflowElement;

            using (var stream = workflowFileInfo.OpenRead())
            {
                using (
                    var xamlXmlReader = new XamlXmlReader(XmlReader.Create(stream), new DatabaseGenerationXamlSchemaContext(assemblyLoader))
                    )
                {
                    modelFirstWorkflowElement = ActivityXamlServices.Load(xamlXmlReader);
                }
            }

            // Create a WorkflowInstance from the WorkflowElement and pass in the inputs
            var workflowInstance = new WorkflowApplication(modelFirstWorkflowElement, inputs);

            // Attach a SymbolResolver for external parameters; this is like the ParameterBag
            var symbolResolver = new SymbolResolver();

            symbolResolver.Add(typeof(EdmParameterBag).Name, edmWorkflowSymbolResolver);

            workflowInstance.Extensions.Add(symbolResolver);
            workflowInstance.Completed            = workflowCompletedHandler;
            workflowInstance.OnUnhandledException = unhandledExceptionHandler;

            return(workflowInstance);
        }
        internal static WorkflowApplication CreateDatabaseScriptGenerationWorkflow(
            SynchronizationContext syncContext,
            Project project,
            string artifactPath,
            FileInfo workflowFileInfo,
            string templatePath,
            EdmItemCollection edmItemCollection,
            string existingSsdl,
            string existingMsl,
            string databaseSchemaName,
            string databaseName,
            string providerInvariantName,
            string providerConnectionString,
            string providerManifestToken,
            Version targetVersion,
            Action<WorkflowApplicationCompletedEventArgs> workflowCompletedHandler,
            Func<WorkflowApplicationUnhandledExceptionEventArgs, UnhandledExceptionAction> unhandledExceptionHandler)
        {
            // Inputs are specific to the workflow. No need to provide a strongly typed bag here
            // because the workflow has to define these.
            var inputs = new Dictionary<string, object>
                {
                    { EdmConstants.csdlInputName, edmItemCollection },
                    { EdmConstants.existingSsdlInputName, existingSsdl },
                    { EdmConstants.existingMslInputName, existingMsl }
                };

            // Initialize the AssemblyLoader. This will cache project/website references and proffer assembly
            // references to the XamlSchemaContext as well as the OutputGeneratorActivities
            var assemblyLoader = new DatabaseGenerationAssemblyLoader(project, VsUtils.GetVisualStudioInstallDir());

            // Parameters can be used throughout the workflow. These are more ubiquitous than inputs and
            // so they do not need to be defined ahead of time in the workflow.
            var edmWorkflowSymbolResolver = new EdmParameterBag(
                syncContext, assemblyLoader, targetVersion, providerInvariantName, providerManifestToken, providerConnectionString,
                databaseSchemaName, databaseName, templatePath, artifactPath);

            // Deserialize the XAML file into a Activity
            Activity modelFirstWorkflowElement;
            using (var stream = workflowFileInfo.OpenRead())
            {
                using (
                    var xamlXmlReader = new XamlXmlReader(XmlReader.Create(stream), new DatabaseGenerationXamlSchemaContext(assemblyLoader))
                    )
                {
                    modelFirstWorkflowElement = ActivityXamlServices.Load(xamlXmlReader);
                }
            }

            // Create a WorkflowInstance from the WorkflowElement and pass in the inputs
            var workflowInstance = new WorkflowApplication(modelFirstWorkflowElement, inputs);

            // Attach a SymbolResolver for external parameters; this is like the ParameterBag
            var symbolResolver = new SymbolResolver();
            symbolResolver.Add(typeof(EdmParameterBag).Name, edmWorkflowSymbolResolver);

            workflowInstance.Extensions.Add(symbolResolver);
            workflowInstance.Completed = workflowCompletedHandler;
            workflowInstance.OnUnhandledException = unhandledExceptionHandler;

            return workflowInstance;
        }
        private IDictionary <string, object> InvokeWorkflowActivity <A>(Dictionary <string, object> inputs, EdmParameterBag parameterBag)
            where A : Activity, new()
        {
            var invoker = new WorkflowInvoker(new A());

            var symbolResolver = new SymbolResolver();

            symbolResolver.Add(typeof(EdmParameterBag).Name, parameterBag);
            invoker.Extensions.Add(symbolResolver);

            return(invoker.Invoke(inputs));
        }
        public static bool Generate(EdmItemCollection csdl, out String ssdl, out String msl, List<Exception> errors)
        {
            String SsdlOut = null;
            String MslOut = null;

            bool HasErrors = false;

            var version = EntityFrameworkVersions.Version3;
            var inputs = new Dictionary<string, object>()
                                          {
                                           {"CsdlInput", csdl},
                                           {"OutputGeneratorType", typeof(CsdlToSsdl).AssemblyQualifiedName },
                                           {"MslOutputGeneratorType", typeof(CsdlToMsl).AssemblyQualifiedName }
                                          };

            var resolver = new SymbolResolver();
            var edmParameterBag = new EdmParameterBag(
                                                     null, // syncContext
                                                     null, // assemblyLoader
                                                     version, // targetVersion
                                                     "System.Data.SqlClient", // providerInvariantName
                                                     "2008", // providerManifestToken
                                                     null, // providerConnectionString
                                                     "dbo", // databaseSchemaName
                                                     null, // databaseName
                                                     null, // ddlTemplatePath
                                                     null // edmxPath
                                                     );
            resolver.Add(typeof(EdmParameterBag).Name, edmParameterBag);

            var activity = new CsdlToSsdlAndMslActivity();
            var wfa = new WorkflowApplication(activity, inputs);
            wfa.Extensions.Add(resolver);

            AutoResetEvent syncEvent = new AutoResetEvent(false);
            AutoResetEvent idleEvent = new AutoResetEvent(false);

            wfa.Completed = delegate(WorkflowApplicationCompletedEventArgs e)
            {
                syncEvent.Set();
                SsdlOut = (string)e.Outputs["SsdlOutput"];
                MslOut = (string)e.Outputs["MslOutput"];
            };

            wfa.Aborted = e =>
            {
                syncEvent.Set();
                errors.Add(e.Reason);
                HasErrors = true;
            };

            wfa.OnUnhandledException = e =>
            {
                syncEvent.Set();
                errors.Add(e.UnhandledException);
                HasErrors = true;
                return UnhandledExceptionAction.Cancel;
            };

            wfa.Run();

            // Loop until the workflow completes.
            WaitHandle[] handles = new WaitHandle[] { syncEvent, idleEvent };
            while (WaitHandle.WaitAny(handles) != 0)
            {
            }

            ssdl = SsdlOut;
            msl = MslOut;
            return HasErrors;
        }
        public static bool Generate(String Ssdl, String exSsdl, string edmxPath, out String ddl, List<Exception> errors)
        {
            String DdlOut = null;
            bool HasErrors = false;

            Version version = EntityFrameworkVersions.Version3;
            var inputs = new Dictionary<string, object>()
                                          {
                                           {"ExistingSsdlInput", exSsdl},
                                           {"SsdlInput", Ssdl }
                                          };

            var resolver = new SymbolResolver();
            var edmParameterBag = new EdmParameterBag(
                                                     null, // syncContext
                                                     null, // assemblyLoader
                                                     version, // targetVersion
                                                     "System.Data.SqlClient", // providerInvariantName
                                                     "2008", // providerManifestToken
                                                     "none", // providerConnectionString
                                                     "dbo", // databaseSchemaName
                                                     "Dummy", // databaseName
                //TODO - get ddlTemplatePath from registry?
                                                     @"C:\Program Files (x86)\Microsoft Visual Studio 11.0\Common7\IDE\Extensions\Microsoft\Entity Framework Tools\DBGen\SSDLToSQL10.tt", // ddlTemplatePath
                                                     edmxPath // edmxPath
                                                     );

            resolver.Add(typeof(EdmParameterBag).Name, edmParameterBag);

            SsdlToDdlActivity activity = new SsdlToDdlActivity();
            var wfa = new WorkflowApplication(activity, inputs);
            wfa.Extensions.Add(resolver);

            AutoResetEvent syncEvent = new AutoResetEvent(false);
            AutoResetEvent idleEvent = new AutoResetEvent(false);

            wfa.Completed = delegate(WorkflowApplicationCompletedEventArgs e)
            {
                syncEvent.Set();
                DdlOut = (string)e.Outputs["DdlOutput"];
            };

            wfa.Aborted = e =>
            {
                syncEvent.Set();
                errors.Add(e.Reason);
                HasErrors = false;
            };

            wfa.OnUnhandledException = e =>
            {
                syncEvent.Set();
                errors.Add(e.UnhandledException);
                HasErrors = false;
                return UnhandledExceptionAction.Cancel;
            };

            wfa.Run();

            // Loop until the workflow completes.
            WaitHandle[] handles = new WaitHandle[] { syncEvent, idleEvent };
            while (WaitHandle.WaitAny(handles) != 0)
            {
            }

            ddl = DdlOut;
            return HasErrors;
        }