public void RunFinished()
{
if (_edmxItem == null)
{
if (_modelBuilderSettings.GenerationOption == ModelGenerationOption.EmptyModelCodeFirst
|| _modelBuilderSettings.GenerationOption == ModelGenerationOption.CodeFirstFromDatabase)
{
Debug.Assert(
_modelBuilderSettings.ModelBuilderEngine == null ^
_modelBuilderSettings.GenerationOption == ModelGenerationOption.CodeFirstFromDatabase,
"Model should be null for Empty Model and not null CodeFirst from database");
AddCodeFirstItems();
}
return;
}
var fileExtension = Path.GetExtension(_edmxItem.FileNames[1]);
Debug.Assert(
_modelBuilderSettings.Project.Equals(_edmxItem.ContainingProject),
"ActiveSolutionProject is not the EDMX file's containing project");
using (new VsUtils.HourglassHelper())
{
var package = PackageManager.Package;
Window window = null;
try
{
ConfigFileHelper.UpdateConfig(_modelBuilderSettings);
// save the model generated in the wizard UI.
if (_modelBuilderSettings.GenerationOption == ModelGenerationOption.GenerateFromDatabase)
{
var writingModelWatch = new Stopwatch();
writingModelWatch.Start();
var modelEdmx = ((EdmxModelBuilderEngine)_modelBuilderSettings.ModelBuilderEngine).Edmx;
if (!string.Equals(fileExtension, EntityDesignArtifact.ExtensionEdmx, StringComparison.OrdinalIgnoreCase))
{
// convert the file if this isn't EDMX
var edmxFileInfo = new FileInfo(_edmxItem.FileNames[1]);
var conversionContext = new ModelConversionContextImpl(
_edmxItem.ContainingProject,
_edmxItem,
edmxFileInfo,
_modelBuilderSettings.TargetSchemaVersion,
modelEdmx);
VSArtifact.DispatchToConversionExtensions(
EscherExtensionPointManager.LoadModelConversionExtensions(),
fileExtension,
conversionContext,
loading: false);
File.WriteAllText(edmxFileInfo.FullName, conversionContext.OriginalDocument);
}
else
{
// we need to use XmlWriter to output so that XmlDeclaration is preserved.
using (var modelWriter = XmlWriter.Create(
_edmxItem.FileNames[1],
new XmlWriterSettings { Indent = true }))
{
modelEdmx.WriteTo(modelWriter);
}
}
writingModelWatch.Stop();
VsUtils.LogOutputWindowPaneMessage(
_edmxItem.ContainingProject,
string.Format(
CultureInfo.CurrentCulture,
Properties.Resources.WritingModelTimeMsg,
writingModelWatch.Elapsed));
}
// set the ItemType for the generated .edmx file
if (_modelBuilderSettings.VSApplicationType != VisualStudioProjectSystem.Website
&& string.Equals(
fileExtension,
EntityDesignArtifact.ExtensionEdmx,
StringComparison.OrdinalIgnoreCase))
{
_edmxItem.Properties.Item(ItemTypePropertyName).Value = EntityDeployBuildActionName;
}
// now open created file in VS using default viewer
window = _edmxItem.Open(Constants.vsViewKindPrimary);
Debug.Assert(window != null, "Unable to get window for created edmx file");
}
finally
{
package.ModelGenErrorCache.RemoveErrors(_edmxItem.FileNames[1]);
}
// Construct an editing context and make all final edits that require the file is opened.
var edmxFileUri = new Uri(_edmxItem.FileNames[1]);
var designArtifact =
package.ModelManager.GetNewOrExistingArtifact(
edmxFileUri, new VSXmlModelProvider(package, package)) as EntityDesignArtifact;
Debug.Assert(
designArtifact != null,
"artifact should be of type EntityDesignArtifact but received type " + designArtifact.GetType().FullName);
Debug.Assert(
designArtifact.StorageModel != null, "designArtifact StorageModel cannot be null for Uri " + edmxFileUri.AbsolutePath);
Debug.Assert(
designArtifact.ConceptualModel != null,
"designArtifact ConceptualModel cannot be null for Uri " + edmxFileUri.AbsolutePath);
if (designArtifact != null
&& designArtifact.StorageModel != null
&& designArtifact.ConceptualModel != null)
{
var designerSafeBeforeAddingTemplates = designArtifact.IsDesignerSafe;
var editingContext =
package.DocumentFrameMgr.EditingContextManager.GetNewOrExistingContext(designArtifact.Uri);
Debug.Assert(editingContext != null, "Null EditingContext for artifact " + edmxFileUri.AbsolutePath);
if (editingContext != null)
{
// Add DbContext templates when generation is GenerateFromDatabase. (connection is configured)
if (_modelBuilderSettings.GenerationOption == ModelGenerationOption.GenerateFromDatabase)
{
new DbContextCodeGenerator().AddDbContextTemplates(
_edmxItem,
_modelBuilderSettings.UseLegacyProvider);
}
// Create FunctionImports for every new Function
var cp = PrepareCommandsAndIntegrityChecks(_modelBuilderSettings, editingContext, designArtifact);
if (DbContextCodeGenerator.TemplateSupported(_edmxItem.ContainingProject, package))
{
// Add command setting CodeGenerationStrategy to "None" for EmptyModel. (connection is not yet configured)
// NOTE: For EmptyModel, the templates will be added after the connection is configured.
// (i.e. during "Generate Database from Model" or "Refresh from Database")
if (_modelBuilderSettings.GenerationOption == ModelGenerationOption.EmptyModel)
{
var cmd = EdmUtils.SetCodeGenStrategyToNoneCommand(designArtifact);
if (cmd != null)
{
if (cp == null)
{
var cpc = new CommandProcessorContext(
editingContext,
EfiTransactionOriginator.CreateNewModelId,
Resources.Tx_SetCodeGenerationStrategy);
cp = new CommandProcessor(cpc, cmd);
}
else
{
cp.EnqueueCommand(cmd);
}
}
}
}
else
{
// Templates not supported, add reference to SDE. (.NET Framework 3.5)
VsUtils.AddProjectReference(_edmxItem.ContainingProject, "System.Data.Entity");
}
if (cp != null)
{
cp.Invoke();
}
// save the artifact to make it look as though updates were part of creation
_edmxItem.Save();
if (_modelBuilderSettings.GenerationOption == ModelGenerationOption.GenerateFromDatabase
&& !designerSafeBeforeAddingTemplates)
{
// If the artifact became safe after adding references we need to reload it (this can happen
// on .NET Framework 4 where we would originally create a v3 edmx if the user selected EF6 -
// the artifact will be flagged as invalid since there is no runtime which could handle v3
// but after we added references to EF6 the artifacts becomes valid and need to be reloaded).
designArtifact.DetermineIfArtifactIsDesignerSafe();
if (designArtifact.IsDesignerSafe)
{
Debug.Assert(!designArtifact.IsDirty, "Reloading dirty artifact - changes will be lost.");
// Since the artifact was originally not valid we did not create the diagram for it.
// Using ReloadDocData will cause the diagram to be recreated. Note we don't need to
// reload the artifact itself since it has not changed.
((DocData)
VSHelpers.GetDocData(package, designArtifact.Uri.LocalPath)).ReloadDocData(0);
}
}
}
if (window != null)
{
window.Activate();
}
}
}
}
internal string DispatchSaveToExtensions(
IServiceProvider serviceProvider, ProjectItem projectItem, string fileContents,
Lazy<IModelConversionExtension, IEntityDesignerConversionData>[] converters,
Lazy<IModelTransformExtension>[] serializers)
{
Debug.Assert(projectItem != null, "projectItem != null");
Debug.Assert(fileContents != null, "bufferText != null");
Debug.Assert(serializers != null && converters != null, "extensions must not be null");
Debug.Assert(serializers.Any() || converters.Any(), "at least one extension expected");
ModelTransformContextImpl transformContext = null;
ModelConversionContextImpl conversionContext = null;
try
{
var original = XDocument.Parse(fileContents, LoadOptions.PreserveWhitespace);
var targetSchemaVersion = EdmUtils.GetEntityFrameworkVersion(projectItem.ContainingProject, serviceProvider);
Debug.Assert(targetSchemaVersion != null, "we should not get here for Misc projects");
transformContext = new ModelTransformContextImpl(projectItem, targetSchemaVersion, original);
// call the extensions that can save EDMX files first (even if we aren't going to end up in an EDMX file, let them process)
VSArtifact.DispatchToSerializationExtensions(serializers, transformContext, loading: false);
// get the extension of the file being loaded (might not be EDMX); this API will include the preceeding "."
var fileInfo = new FileInfo(FileName);
var fileExtension = fileInfo.Extension;
// now if this is not an EDMX file, hand off to the extension who can convert it to the writable content
if (!string.Equals(fileExtension, EntityDesignArtifact.ExtensionEdmx, StringComparison.OrdinalIgnoreCase))
{
// the current document coming from the serializers becomes our original
conversionContext = new ModelConversionContextImpl(
projectItem.ContainingProject, projectItem, fileInfo, targetSchemaVersion, transformContext.CurrentDocument);
// we aren't loading an EDMX file, so call the extensions who can process this file extension
// when this finishes, then output should be a valid EDMX document
VSArtifact.DispatchToConversionExtensions(converters, fileExtension, conversionContext, false);
// we are done saving, so get bufferText from the OriginalDocument
// TODO use Utf8StringWriter here somehow?
return conversionContext.OriginalDocument;
}
else
{
// we are saving an EDMX file, so get bufferText from the XDocument
using (var writer = new Utf8StringWriter())
{
transformContext.CurrentDocument.Save(writer, SaveOptions.None);
return writer.ToString();
}
}
}
catch (XmlException)
{
// Don't do anything here. We will want to gracefully step out of the extension loading
// and let the core designer handle this.
return fileContents;
}
finally
{
var errorList = ErrorListHelper.GetExtensionErrorList(serviceProvider);
errorList.Clear();
// log any errors
if (conversionContext != null)
{
if (conversionContext.Errors.Count > 0)
{
ErrorListHelper.LogExtensionErrors(conversionContext.Errors, projectItem);
}
conversionContext.Dispose();
}
if (transformContext != null)
{
if (transformContext.Errors.Count > 0)
{
ErrorListHelper.LogExtensionErrors(transformContext.Errors, projectItem);
}
transformContext.Dispose();
}
}
}
internal static bool TryGetBufferViaExtensions(
IServiceProvider serviceProvider, ProjectItem projectItem, string fileContents,
Lazy<IModelConversionExtension, IEntityDesignerConversionData>[] converters,
Lazy<IModelTransformExtension>[] serializers, out string documentViaExtensions,
out List<ExtensionError> errors)
{
Debug.Assert(serviceProvider != null, "serviceProvider != null");
Debug.Assert(projectItem != null, "projectItem != null");
Debug.Assert(VsUtils.EntityFrameworkSupportedInProject(projectItem.ContainingProject, serviceProvider, false));
Debug.Assert(serializers != null && converters != null, "extensions must not be null");
Debug.Assert(serializers.Any() || converters.Any(), "at least one extension expected");
errors = new List<ExtensionError>();
documentViaExtensions = "";
ModelConversionContextImpl conversionContext = null;
ModelTransformContextImpl transformContext = null;
try
{
var targetSchemaVersion =
EdmUtils.GetEntityFrameworkVersion(projectItem.ContainingProject, serviceProvider);
Debug.Assert(targetSchemaVersion != null, "should not get here for a Misc project");
// get the extension of the file being loaded (might not be EDMX); this API will include the preceeding "."
var filePath = projectItem.get_FileNames(1);
var fileExtension = Path.GetExtension(filePath);
XDocument originalDocument = null;
// see if we are loading an EDMX file or not, and if we have any converters
if (!string.Equals(
fileExtension, EntityDesignArtifact.ExtensionEdmx,
StringComparison.OrdinalIgnoreCase))
{
conversionContext = new ModelConversionContextImpl(
projectItem.ContainingProject, projectItem, new FileInfo(filePath),
targetSchemaVersion, fileContents);
// we aren't loading an EDMX file, so call the extensions who can process this file extension
// when this finishes, then output should be a valid EDMX document
VSArtifact.DispatchToConversionExtensions(converters, fileExtension, conversionContext, true);
// we are done with the non-EDMX extensions so CurrentDocument will be a valid EDMX document
// create the serialization context for further extensions to act on
transformContext = new ModelTransformContextImpl(
projectItem, targetSchemaVersion, conversionContext.CurrentDocument);
}
else
{
// we are loading an EDMX file, we can parse file contents into an XDocument
try
{
originalDocument = XDocument.Parse(fileContents, LoadOptions.PreserveWhitespace);
transformContext = new ModelTransformContextImpl(
projectItem, targetSchemaVersion, originalDocument);
}
catch (XmlException)
{
// If there's an error here, don't do anything. We will want to gracefully step out of the extension loading
// since the designer itself won't load.
}
}
if (transformContext != null
&& originalDocument != null)
{
// now dispatch to those that want to work on EDMX files
VSArtifact.DispatchToSerializationExtensions(serializers, transformContext, true);
// TODO: this does not seem to be correct if severity is Message or Warning
if (transformContext.Errors.Count == 0)
{
// see if any extension changed things. Note that we need to compare the serialization of
// the XDocuments together since the original buffer may have different whitespace after creating the XDocument.
// TODO: Why not use XNode.DeepEquals()?
string newBufferContents;
using (var currentDocWriter = new Utf8StringWriter())
{
transformContext.CurrentDocument.Save(currentDocWriter, SaveOptions.None);
newBufferContents = currentDocWriter.ToString();
}
string originalBufferContents;
using (var originalDocWriter = new Utf8StringWriter())
{
originalDocument.Save(originalDocWriter, SaveOptions.None);
originalBufferContents = originalDocWriter.ToString();
}
if (!string.Equals(originalBufferContents, newBufferContents, StringComparison.Ordinal))
{
documentViaExtensions = newBufferContents;
return true;
}
}
else
{
errors.AddRange(transformContext.Errors);
return false;
}
}
}
finally
{
var errorList = ErrorListHelper.GetExtensionErrorList(serviceProvider);
errorList.Clear();
// log any errors
if (conversionContext != null
&& conversionContext.Errors.Count > 0)
{
ErrorListHelper.LogExtensionErrors(conversionContext.Errors, projectItem);
}
if (transformContext != null
&& transformContext.Errors.Count > 0)
{
ErrorListHelper.LogExtensionErrors(transformContext.Errors, projectItem);
}
}
return false;
}
