/// <summary> /// Loads a MetaModel instance into the default partition of the given store. /// </summary> /// <param name="serializationResult">Stores serialization result from the load operation.</param> /// <param name="store">The new MetaModel instance will be created into the default partition of this store.</param> /// <param name="fileName">Name of the file from which the MetaModel instance will be deserialized.</param> /// <param name="schemaResolver"> /// An ISchemaResolver that allows the serializer to do schema validation on the root element (and everything inside it). /// If null is passed, schema validation will not be performed. /// </param> /// <param name="validationController"> /// A ValidationController that will be used to do load-time validation (validations with validation category "Load"). If null /// is passed, load-time validation will not be performed. /// </param> /// <param name="serializerLocator"> /// An ISerializerLocator that will be used to locate any additional domain model types required to load the model. Can be null. /// </param> /// <returns>The loaded MetaModel instance.</returns> public virtual global::Tum.FamilyTreeDSL.FamilyTreeModel LoadModel(DslModeling::SerializationResult serializationResult, DslModeling::Store store, string fileName, DslModeling::ISchemaResolver schemaResolver, DslValidation::ValidationController validationController, DslModeling::ISerializerLocator serializerLocator) { #region Check Parameters if (store == null) throw new global::System.ArgumentNullException("store"); #endregion return this.LoadModelFamilyTreeModel(serializationResult, store.DefaultPartition, fileName, schemaResolver, validationController, serializerLocator); }
private void ValidateServiceMultiplicity (DslValidation::ValidationContext context) { if (this.ServiceContract == null) { context.LogViolation(DslValidation::ViolationType.Error, string.Format(global::System.Globalization.CultureInfo.CurrentCulture, Microsoft.Practices.ServiceFactory.ServiceContracts.ServiceContractDslDomainModel.SingletonResourceManager.GetString("MinimumMultiplicityMissingLink"), "Service", this.Name, "ServiceContract"), "DSL0001", this); } } // ValidateServiceMultiplicity
private void ValidateAggregateStateMultiplicity (DslValidation::ValidationContext context) { if (this.BoundedContext == null) { context.LogViolation(DslValidation::ViolationType.Error, string.Format(global::System.Globalization.CultureInfo.CurrentCulture, FourDeep.Dizzle.DizzleDomainModel.SingletonResourceManager.GetString("MinimumMultiplicityMissingLink"), "AggregateState", this.Name, "BoundedContext"), "DSL0001", this); } } // ValidateAggregateStateMultiplicity
private void ValidateCustomizableElementSchemaBaseMultiplicity (DslValidation::ValidationContext context) { if (this.Policy == null) { context.LogViolation(DslValidation::ViolationType.Error, string.Format(global::System.Globalization.CultureInfo.CurrentCulture, NuPattern.Runtime.Schema.PatternModelDomainModel.SingletonResourceManager.GetString("MinimumMultiplicityMissingLink"), "CustomizableElementSchema", this.Name, "Policy"), "DSL0001", this); } } // ValidateCustomizableElementSchemaBaseMultiplicity
private void ValidatePatternSchemaMultiplicity (DslValidation::ValidationContext context) { if (this.Views.Count == 0) { context.LogViolation(DslValidation::ViolationType.Error, string.Format(global::System.Globalization.CultureInfo.CurrentCulture, NuPattern.Runtime.Schema.PatternModelDomainModel.SingletonResourceManager.GetString("MinimumMultiplicityMissingLink"), "PatternSchema", this.Name, "Views"), "DSL0001", this); } } // ValidatePatternSchemaMultiplicity
private void ValidateExampleModelMultiplicity (DslValidation::ValidationContext context) { if (this.Processes.Count == 0) { context.LogViolation(DslValidation::ViolationType.Error, string.Format(global::System.Globalization.CultureInfo.CurrentCulture, DmitriNesteruk.AsyncDsl.AsyncDslDomainModel.SingletonResourceManager.GetString("MinimumMultiplicityMissingLink"), "ExampleModel", "", "Processes"), "DSL0001", this); } } // ValidateExampleModelMultiplicity
public virtual HostDesignerModel LoadModel(DslModeling::SerializationResult serializationResult, DslModeling::Partition partition, string fileName, DslModeling::ISchemaResolver schemaResolver, DslValidation::ValidationController validationController, DslModeling::ISerializerLocator serializerLocator) { #region Check Parameters if (serializationResult == null) throw new global::System.ArgumentNullException("serializationResult"); if (partition == null) throw new global::System.ArgumentNullException("partition"); if (string.IsNullOrEmpty(fileName)) throw new global::System.ArgumentNullException("fileName"); #endregion // Ensure there is a transaction for this model to Load in. if (!partition.Store.TransactionActive) { throw new global::System.InvalidOperationException(HostDesignerDomainModel.SingletonResourceManager.GetString("MissingTransaction")); } HostDesignerModel modelRoot = null; DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(partition.Store); DslModeling::DomainClassXmlSerializer modelRootSerializer = directory.GetSerializer(HostDesignerModel.DomainClassId); global::System.Diagnostics.Debug.Assert(modelRootSerializer != null, "Cannot find serializer for HostDesignerModel!"); if (modelRootSerializer != null) { using (global::System.IO.FileStream fileStream = global::System.IO.File.OpenRead(fileName)) { using (DslModeling::Transaction postT = partition.Store.TransactionManager.BeginTransaction("PostLoad Model", true)) { DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, fileStream.Name, serializationResult); this.InitializeSerializationContext(partition, serializationContext, true); DslModeling::TransactionContext transactionContext = new DslModeling::TransactionContext(); transactionContext.Add(DslModeling::SerializationContext.TransactionContextKey, serializationContext); using (DslModeling::Transaction t = partition.Store.TransactionManager.BeginTransaction("Load Model from " + fileName, true, transactionContext)) { // Ensure there is some content in the file. Blank (or almost blank, to account for encoding header bytes, etc.) // files will cause a new root element to be created and returned. if (fileStream.Length > 5) { try { global::System.Xml.XmlReaderSettings settings = HostDesignerSerializationHelper.Instance.CreateXmlReaderSettings(serializationContext, false); using (global::System.Xml.XmlReader reader = global::System.Xml.XmlReader.Create(fileStream, settings)) { // Attempt to read the encoding. reader.Read(); // Move to the first node - will be the XmlDeclaration if there is one. global::System.Text.Encoding encoding; if (this.TryGetEncoding(reader, out encoding)) { serializationResult.Encoding = encoding; } // Load any additional domain models that are required DslModeling::SerializationUtilities.ResolveDomainModels(reader, serializerLocator, partition.Store); reader.MoveToContent(); modelRoot = modelRootSerializer.TryCreateInstance(serializationContext, reader, partition) as HostDesignerModel; if (modelRoot != null && !serializationResult.Failed) { this.ReadRootElement(serializationContext, modelRoot, reader, schemaResolver); } } } catch (global::System.Xml.XmlException xEx) { DslModeling::SerializationUtilities.AddMessage( serializationContext, DslModeling::SerializationMessageKind.Error, xEx ); } } if(modelRoot == null && !serializationResult.Failed) { // create model root if it doesn't exist. modelRoot = this.CreateModelHelper(partition); } if (t.IsActive) t.Commit(); } // End Inner Tx // Fire PostLoad customization code whether load has succeeded or not // Provide a method in a partial class with the following signature: ///// <summary> ///// Customize Model Loading. ///// </summary> ///// <param name="serializationResult">Stores serialization result from the load operation.</param> ///// <param name="partition">Partition in which the new HostDesignerModel instance will be created.</param> ///// <param name="fileName">Name of the file from which the HostDesignerModel instance will be deserialized.</param> ///// <param name="modelRoot">The root of the file that was loaded.</param> // private void OnPostLoadModel(DslModeling::SerializationResult serializationResult, DslModeling::Partition partition, string fileName, HostDesignerModel modelRoot ) this.OnPostLoadModel(serializationResult, partition, fileName, modelRoot); if (serializationResult.Failed) { // Serialization error encountered, rollback the middle transaction. modelRoot = null; postT.Rollback(); } if (postT.IsActive) postT.Commit(); } // End PostLoad Tx // Do load-time validation if a ValidationController is provided. if (!serializationResult.Failed && validationController != null) { using (new SerializationValidationObserver(serializationResult, validationController)) { validationController.Validate(partition, DslValidation::ValidationCategories.Load); } } } } return modelRoot; }
private void ValidateMonikerAmbiguity(DslValidation::ValidationContext context) { // Don't run this rule when deserializing - any ambiguous monikers will // already have stopped the file from loading. if (this.Store.InSerializationTransaction) { return; } global::System.Collections.Generic.IDictionary<global::System.Guid, DslModeling::IMonikerResolver> monikerResolvers = HostDesignerSerializationHelper.Instance.GetMonikerResolvers(this.Store); foreach (DslModeling::ModelElement element in this.Store.ElementDirectory.AllElements) { global::System.Guid domainModelId = element.GetDomainClass().DomainModel.Id; DslModeling::IMonikerResolver monikerResolver = null; if (monikerResolvers.TryGetValue(domainModelId, out monikerResolver) && monikerResolver != null) { DslModeling::SimpleMonikerResolver simpleMonikerResolver = monikerResolver as DslModeling::SimpleMonikerResolver; if (simpleMonikerResolver != null) { try { simpleMonikerResolver.ProcessAddedElement(element); } catch (DslModeling::AmbiguousMonikerException amEx) { // Ambiguous moniker detected. context.LogError( string.Format( global::System.Globalization.CultureInfo.CurrentCulture, HostDesignerDomainModel.SingletonResourceManager.GetString("AmbiguousMoniker"), amEx.Moniker, DslModeling::SerializationUtilities.GetElementName(element), DslModeling::SerializationUtilities.GetElementName(amEx.Element) ), "AmbiguousMoniker", this, amEx.Element ); } } } } // Clean up the created moniker resolvers after the check. foreach (DslModeling::IMonikerResolver monikerResolver in monikerResolvers.Values) { DslModeling::SimpleMonikerResolver simpleMonikerResolver = monikerResolver as DslModeling::SimpleMonikerResolver; if (simpleMonikerResolver != null) simpleMonikerResolver.Reset(); } monikerResolvers.Clear(); }
/// <summary> /// Add ValidationExtensionRegistrar to the ValidationController and handle related MEF Initialization operations /// </summary> /// <param name="validationController"></param> partial void SetValidationExtensionRegistrar(DslValidation::ValidationController validationController);
public virtual ExampleModel LoadModelAndDiagram(DslModeling::SerializationResult serializationResult, DslModeling::Partition modelPartition, string modelFileName, DslModeling::Partition diagramPartition, string diagramFileName, DslModeling::ISchemaResolver schemaResolver, DslValidation::ValidationController validationController) { #region Check Parameters if (serializationResult == null) throw new global::System.ArgumentNullException("serializationResult"); if (modelPartition == null) throw new global::System.ArgumentNullException("modelPartition"); if (diagramPartition == null) throw new global::System.ArgumentNullException("diagramPartition"); if (string.IsNullOrEmpty(diagramFileName)) throw new global::System.ArgumentNullException("diagramFileName"); #endregion ExampleModel modelRoot; // Ensure there is an outer transaction spanning both model and diagram load, so moniker resolution works properly. if (!diagramPartition.Store.TransactionActive) { throw new global::System.InvalidOperationException(AsyncDslDomainModel.SingletonResourceManager.GetString("MissingTransaction")); } modelRoot = this.LoadModel(serializationResult, modelPartition, modelFileName, schemaResolver, validationController); if (serializationResult.Failed) { // don't try to deserialize diagram data if model load failed. return modelRoot; } AsyncDslDiagram diagram = null; DslModeling::DomainClassXmlSerializer diagramSerializer = this.Directory.GetSerializer(AsyncDslDiagram.DomainClassId); global::System.Diagnostics.Debug.Assert(diagramSerializer != null, "Cannot find serializer for AsyncDslDiagram"); if (diagramSerializer != null) { if(!global::System.IO.File.Exists(diagramFileName)) { // missing diagram file indicates we should create a new diagram. diagram = this.CreateDiagramHelper(diagramPartition, modelRoot); } else { using (global::System.IO.FileStream fileStream = global::System.IO.File.OpenRead(diagramFileName)) { DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(this.Directory, fileStream.Name, serializationResult); // Set up MonikerResolver for AsyncDsl. this.SetupMonikerResolver(serializationContext, diagramPartition.Store); using (DslModeling::Transaction t = diagramPartition.Store.TransactionManager.BeginTransaction("LoadDiagram", true)) { // Ensure there is some content in the file. Blank (or almost blank, to account for encoding header bytes, etc.) // files will cause a new diagram to be created and returned if (fileStream.Length > 5) { global::System.Xml.XmlReaderSettings settings = new global::System.Xml.XmlReaderSettings(); try { using (global::System.Xml.XmlReader reader = global::System.Xml.XmlReader.Create(fileStream, settings)) { reader.MoveToContent(); diagram = diagramSerializer.TryCreateInstance(serializationContext, reader, diagramPartition) as AsyncDslDiagram; if (diagram != null) { // Note: the actual instance we get back from TryCreateInstance() can be of a derived type of AsyncDslDiagram, // so we need to find the correct serializer instance to deserialize the element properly. DslModeling::DomainClassXmlSerializer instanceSerializer = this.Directory.GetSerializer(diagram.GetDomainClass().Id); global::System.Diagnostics.Debug.Assert(instanceSerializer != null, "Cannot find serializer for " + diagram.GetDomainClass().Name + "!"); instanceSerializer.ReadRootElement(serializationContext, diagram, reader, schemaResolver); } } } catch (global::System.Xml.XmlException xEx) { DslModeling::SerializationUtilities.AddMessage( serializationContext, DslModeling::SerializationMessageKind.Error, xEx ); } if (serializationResult.Failed) { // Serialization error encountered, rollback the transaction. diagram = null; t.Rollback(); } } if(diagram == null && !serializationResult.Failed) { // Create diagram if it doesn't exist diagram = this.CreateDiagramHelper(diagramPartition, modelRoot); } if (t.IsActive) t.Commit(); } // End inner Tx // Do load-time validation if a ValidationController is provided. if (!serializationResult.Failed && validationController != null) { using (new SerializationValidationObserver(serializationResult, validationController)) { validationController.Validate(diagramPartition, DslValidation::ValidationCategories.Load); } } } } if (diagram != null) { if (!serializationResult.Failed) { // Succeeded. diagram.ModelElement = modelRoot; diagram.PostDeserialization(true); this.CheckForOrphanedShapes(diagram, serializationResult); } else { // Failed. diagram.PostDeserialization(false); } } } return modelRoot; }
/// <summary> /// Loads a ExampleModel instance. /// </summary> /// <param name="serializationResult">Stores serialization result from the load operation.</param> /// <param name="partition">Partition in which the new ExampleModel instance will be created.</param> /// <param name="fileName">Name of the file from which the ExampleModel instance will be deserialized.</param> /// <param name="schemaResolver"> /// An ISchemaResolver that allows the serializer to do schema validation on the root element (and everything inside it). /// If null is passed, schema validation will not be performed. /// </param> /// <param name="validationController"> /// A ValidationController that will be used to do load-time validation (validations with validation category "Load"). If null /// is passed, load-time validation will not be performed. /// </param> /// <returns>The loaded ExampleModel instance.</returns> public virtual ExampleModel LoadModel(DslModeling::SerializationResult serializationResult, DslModeling::Partition partition, string fileName, DslModeling::ISchemaResolver schemaResolver, DslValidation::ValidationController validationController) { #region Check Parameters if (serializationResult == null) throw new global::System.ArgumentNullException("serializationResult"); if (partition == null) throw new global::System.ArgumentNullException("partition"); if (string.IsNullOrEmpty(fileName)) throw new global::System.ArgumentNullException("fileName"); #endregion // Ensure there is a transaction for this model to Load in. if (!partition.Store.TransactionActive) { throw new global::System.InvalidOperationException(AsyncDslDomainModel.SingletonResourceManager.GetString("MissingTransaction")); } ExampleModel modelRoot = null; DslModeling::DomainClassXmlSerializer modelRootSerializer = this.Directory.GetSerializer(ExampleModel.DomainClassId); global::System.Diagnostics.Debug.Assert(modelRootSerializer != null, "Cannot find serializer for ExampleModel!"); if (modelRootSerializer != null) { using (global::System.IO.FileStream fileStream = global::System.IO.File.OpenRead(fileName)) { using (DslModeling::Transaction t = partition.Store.TransactionManager.BeginTransaction("Load Model from " + fileName, true)) { DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(this.Directory, fileStream.Name, serializationResult); // Set up MonikerResolver for AsyncDsl. this.SetupMonikerResolver(serializationContext, partition.Store); // Ensure there is some content in the file. Blank (or almost blank, to account for encoding header bytes, etc.) // files will cause a new root element to be created and returned. if (fileStream.Length > 5) { global::System.Xml.XmlReaderSettings settings = new global::System.Xml.XmlReaderSettings(); try { using (global::System.Xml.XmlReader reader = global::System.Xml.XmlReader.Create(fileStream, settings)) { reader.MoveToContent(); modelRoot = modelRootSerializer.TryCreateInstance(serializationContext, reader, partition) as ExampleModel; if (modelRoot != null && !serializationResult.Failed) { // Note: the actual instance we get back from TryCreateInstance() can be of a derived type of ExampleModel, // so we need to find the correct serializer instance to deserialize the element properly. DslModeling::DomainClassXmlSerializer instanceSerializer = this.Directory.GetSerializer(modelRoot.GetDomainClass().Id); global::System.Diagnostics.Debug.Assert(instanceSerializer != null, "Cannot find serializer for " + modelRoot.GetDomainClass().Name + "!"); instanceSerializer.ReadRootElement(serializationContext, modelRoot, reader, schemaResolver); } } } catch (global::System.Xml.XmlException xEx) { DslModeling::SerializationUtilities.AddMessage( serializationContext, DslModeling::SerializationMessageKind.Error, xEx ); } } if(modelRoot == null && !serializationResult.Failed) { // create model root if it doesn't exist. modelRoot = this.CreateModelHelper(partition); } if (t.IsActive) t.Commit(); } // End Inner Tx // Do load-time validation if a ValidationController is provided. if (!serializationResult.Failed && validationController != null) { using (new SerializationValidationObserver(serializationResult, validationController)) { validationController.Validate(partition, DslValidation::ValidationCategories.Load); } } } } return modelRoot; }
/// <summary> /// Loads a ExampleModel instance into the default partition of the given store, and ignore serialization result. /// </summary> /// <param name="store">The new ExampleModel instance will be created into the default partition of this store.</param> /// <param name="fileName">Name of the file from which the ExampleModel instance will be deserialized.</param> /// <param name="schemaResolver"> /// An ISchemaResolver that allows the serializer to do schema validation on the root element (and everything inside it). /// If null is passed, schema validation will not be performed. /// </param> /// <param name="validationController"> /// A ValidationController that will be used to do load-time validation (validations with validation category "Load"). If null /// is passed, load-time validation will not be performed. /// </param> /// <returns>The loaded ExampleModel instance.</returns> public virtual ExampleModel LoadModel(DslModeling::Store store, string fileName, DslModeling::ISchemaResolver schemaResolver, DslValidation::ValidationController validationController) { #region Check Parameters if (store == null) throw new global::System.ArgumentNullException("store"); #endregion return this.LoadModel(new DslModeling::SerializationResult(), store.DefaultPartition, fileName, schemaResolver, validationController); }
public MetaModel LoadModel(DslModeling::SerializationResult serializationResult, DslModeling::Partition partition, string fileName, DslModeling::ISchemaResolver schemaResolver, DslValidation::ValidationController validationController, DslModeling::ISerializerLocator serializerLocator, bool bStartT) { return LoadModel(serializationResult, partition, fileName, schemaResolver, validationController, serializerLocator, true, false); }
/// <summary> /// Called with validation messages are added. /// </summary> protected override void OnValidationMessageAdded(DslValidation::ValidationMessage addedMessage) { #region Check Parameters global::System.Diagnostics.Debug.Assert(addedMessage != null); #endregion if (addedMessage != null && this.serializationResult != null) { // Record the validation message as a serialization message. DslModeling::SerializationUtilities.AddValidationMessage(this.serializationResult, addedMessage); } base.OnValidationMessageAdded(addedMessage); }
public virtual HostDesignerModel LoadModelAndDiagram(DslModeling::SerializationResult serializationResult, DslModeling::Partition modelPartition, string modelFileName, DslModeling::Partition diagramPartition, string diagramFileName, DslModeling::ISchemaResolver schemaResolver, DslValidation::ValidationController validationController, DslModeling::ISerializerLocator serializerLocator) { #region Check Parameters if (serializationResult == null) throw new global::System.ArgumentNullException("serializationResult"); if (modelPartition == null) throw new global::System.ArgumentNullException("modelPartition"); if (diagramPartition == null) throw new global::System.ArgumentNullException("diagramPartition"); if (string.IsNullOrEmpty(diagramFileName)) throw new global::System.ArgumentNullException("diagramFileName"); #endregion HostDesignerModel modelRoot; // Ensure there is an outer transaction spanning both model and diagram load, so moniker resolution works properly. if (!diagramPartition.Store.TransactionActive) { throw new global::System.InvalidOperationException(HostDesignerDomainModel.SingletonResourceManager.GetString("MissingTransaction")); } modelRoot = this.LoadModel(serializationResult, modelPartition, modelFileName, schemaResolver, validationController, serializerLocator); if (serializationResult.Failed) { // don't try to deserialize diagram data if model load failed. return modelRoot; } HostDesignerDiagram diagram = null; DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(diagramPartition.Store); DslModeling::DomainClassXmlSerializer diagramSerializer = directory.GetSerializer(HostDesignerDiagram.DomainClassId); global::System.Diagnostics.Debug.Assert(diagramSerializer != null, "Cannot find serializer for HostDesignerDiagram"); if (diagramSerializer != null) { if(!global::System.IO.File.Exists(diagramFileName)) { // missing diagram file indicates we should create a new diagram. diagram = this.CreateDiagramHelper(diagramPartition, modelRoot); } else { using (global::System.IO.FileStream fileStream = global::System.IO.File.OpenRead(diagramFileName)) { DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, fileStream.Name, serializationResult); this.InitializeSerializationContext(diagramPartition, serializationContext, true); DslModeling::TransactionContext transactionContext = new DslModeling::TransactionContext(); transactionContext.Add(DslModeling::SerializationContext.TransactionContextKey, serializationContext); using (DslModeling::Transaction postT = diagramPartition.Store.TransactionManager.BeginTransaction("PostLoad Model and Diagram", true, transactionContext)) { using (DslModeling::Transaction t = diagramPartition.Store.TransactionManager.BeginTransaction("LoadDiagram", true, transactionContext)) { // Ensure there is some content in the file. Blank (or almost blank, to account for encoding header bytes, etc.) // files will cause a new diagram to be created and returned if (fileStream.Length > 5) { global::System.Xml.XmlReaderSettings settings = HostDesignerSerializationHelper.Instance.CreateXmlReaderSettings(serializationContext, false); try { using (global::System.Xml.XmlReader reader = global::System.Xml.XmlReader.Create(fileStream, settings)) { reader.MoveToContent(); diagram = diagramSerializer.TryCreateInstance(serializationContext, reader, diagramPartition) as HostDesignerDiagram; if (diagram != null) { this.ReadRootElement(serializationContext, diagram, reader, schemaResolver); } } } catch (global::System.Xml.XmlException xEx) { DslModeling::SerializationUtilities.AddMessage( serializationContext, DslModeling::SerializationMessageKind.Error, xEx ); } if (serializationResult.Failed) { // Serialization error encountered, rollback the transaction. diagram = null; t.Rollback(); } } if(diagram == null && !serializationResult.Failed) { // Create diagram if it doesn't exist diagram = this.CreateDiagramHelper(diagramPartition, modelRoot); } if (t.IsActive) t.Commit(); } // End inner Tx // Fire PostLoad customization code whether Load succeeded or not // Provide a method in a partial class with the following signature: ///// <summary> ///// Customize Model and Diagram Loading. ///// </summary> ///// <param name="serializationResult">Stores serialization result from the load operation.</param> ///// <param name="modelPartition">Partition in which the new DslLibrary instance will be created.</param> ///// <param name="modelFileName">Name of the file from which the DslLibrary instance will be deserialized.</param> ///// <param name="diagramPartition">Partition in which the new DslDesignerDiagram instance will be created.</param> ///// <param name="diagramFileName">Name of the file from which the DslDesignerDiagram instance will be deserialized.</param> ///// <param name="modelRoot">The root of the file that was loaded.</param> ///// <param name="diagram">The diagram matching the modelRoot.</param> // private void OnPostLoadModelAndDiagram(DslModeling::SerializationResult serializationResult, DslModeling::Partition modelPartition, string modelFileName, DslModeling::Partition diagramPartition, string diagramFileName, HostDesignerModel modelRoot, HostDesignerDiagram diagram) this.OnPostLoadModelAndDiagram(serializationResult, modelPartition, modelFileName, diagramPartition, diagramFileName, modelRoot, diagram); if (serializationResult.Failed) { // Serialization error encountered, rollback the middle transaction. modelRoot = null; postT.Rollback(); } if (postT.IsActive) postT.Commit(); } // End MiddleTx // Do load-time validation if a ValidationController is provided. if (!serializationResult.Failed && validationController != null) { using (new SerializationValidationObserver(serializationResult, validationController)) { validationController.Validate(diagramPartition, DslValidation::ValidationCategories.Load); } } } } if (diagram != null) { if (!serializationResult.Failed) { // Succeeded. diagram.ModelElement = modelRoot; diagram.PostDeserialization(true); this.CheckForOrphanedShapes(diagram, serializationResult); } else { // Failed. diagram.PostDeserialization(false); } } } return modelRoot; }
public override nHydrateModel LoadModelAndDiagram(DslModeling::SerializationResult serializationResult, DslModeling::Partition modelPartition, string modelFileName, DslModeling::Partition diagramPartition, string diagramFileName, DslModeling::ISchemaResolver schemaResolver, DslValidation::ValidationController validationController, DslModeling::ISerializerLocator serializerLocator) { var modelRoot = base.LoadModelAndDiagram(serializationResult, modelPartition, modelFileName, diagramPartition, diagramFileName, schemaResolver, validationController, serializerLocator); _model = modelRoot; //Verify that we can open the model var thisAssem = System.Reflection.Assembly.GetExecutingAssembly(); var thisAssemName = thisAssem.GetName(); var toolVersion = thisAssemName.Version; var modelVersion = new Version(0, 0); var dslVersion = new Version(0, 0); if (!string.IsNullOrEmpty(modelRoot.ModelVersion)) modelVersion = new Version(modelRoot.ModelVersion); if (toolVersion < modelVersion) throw new Exception("This model was created with newer version of the modeler. Please install version '" + modelVersion.ToString() + "' or higher."); try { var document = new XmlDocument(); document.LoadXml(File.ReadAllText(modelFileName)); var attr = document.DocumentElement.Attributes["dslVersion"]; if (attr != null) { dslVersion = new Version(attr.Value); } } catch { } //When saved the new version will be this tool version modelRoot.ModelVersion = LAST_MODEL_MODEL_COMPATIBLE; modelRoot.ModelFileName = modelFileName; modelRoot.IsDirty = false; var mainInfo = new FileInfo(modelFileName); var modelName = mainInfo.Name.Replace(".nhydrate", ".model"); if (modelRoot.ModelToDisk) { //Load from disk store nHydrate.Dsl.Custom.SQLFileManagement.LoadFromDisk(modelRoot, mainInfo.DirectoryName, modelRoot.Partition.Store, modelName); #region Watch Folder //var modelFolder = nHydrate.Dsl.Custom.SQLFileManagement.GetModelFolder(mainInfo.DirectoryName, modelName); //_watchFolder.Path = modelFolder; //_watchFolder.IncludeSubdirectories = true; //_watchFolder.NotifyFilter = System.IO.NotifyFilters.FileName | // NotifyFilters.LastWrite | // NotifyFilters.Size | // NotifyFilters.CreationTime | // NotifyFilters.DirectoryName; //_watchFolder.Changed += new FileSystemEventHandler(FolderChangedEvent); //_watchFolder.Created += new FileSystemEventHandler(FolderChangedEvent); //_watchFolder.Deleted += new FileSystemEventHandler(FolderChangedEvent); //_watchFolder.Renamed += new System.IO.RenamedEventHandler(FolderFileRenamedEvent); //try //{ // _watchFolder.EnableRaisingEvents = true; //} //catch (ArgumentException) //{ // //Do Nothing //} #endregion } else { try { var f = nHydrate.Dsl.Custom.SQLFileManagement.GetModelFolder(mainInfo.DirectoryName, modelName); if (Directory.Exists(f)) Directory.Delete(f, true); } catch { } } modelRoot.IsDirty = false; //SyncServer //var syncServerFile = modelFileName + ".syncserver"; //modelRoot.SyncServerURL = nHydrate.SyncServer.Client.SyncDomain.LoadSyncServerConfig(syncServerFile); //Alphabetized columns if need be //foreach (var entity in modelRoot.Entities) //{ // entity.Fields.Sort((x, y) => x.Name.CompareTo(y.Name)); //} #region Load Indexes //For now load the indexes into the REAL indexes collection //This should only happens the first time using (var transaction = modelRoot.Store.TransactionManager.BeginTransaction(Guid.NewGuid().ToString())) { LoadInitialIndexes(modelRoot); transaction.Commit(); } #endregion #region Handle the Precedence if (modelRoot.StoredProcedures.Count > 0) modelRoot.MaxPrecedenceOrder = Math.Max(modelRoot.StoredProcedures.Max(x => x.PrecedenceOrder), modelRoot.MaxPrecedenceOrder); if (modelRoot.Views.Count > 0) modelRoot.MaxPrecedenceOrder = Math.Max(modelRoot.Views.Max(x => x.PrecedenceOrder), modelRoot.MaxPrecedenceOrder); if (modelRoot.Functions.Count > 0) modelRoot.MaxPrecedenceOrder = Math.Max(modelRoot.Functions.Max(x => x.PrecedenceOrder), modelRoot.MaxPrecedenceOrder); modelRoot.StoredProcedures.Where(x => x.PrecedenceOrder == 0).ToList().ForEach(x => x.PrecedenceOrder = ++modelRoot.MaxPrecedenceOrder); modelRoot.Views.Where(x => x.PrecedenceOrder == 0).ToList().ForEach(x => x.PrecedenceOrder = ++modelRoot.MaxPrecedenceOrder); modelRoot.Functions.Where(x => x.PrecedenceOrder == 0).ToList().ForEach(x => x.PrecedenceOrder = ++modelRoot.MaxPrecedenceOrder); #endregion #region Load the refactorizations if (File.Exists(modelFileName)) { var fi = new FileInfo(modelFileName); if (fi.Length > 5) { var document = new XmlDocument(); document.Load(modelFileName); if (document.DocumentElement != null) { var refactorList = document.DocumentElement.SelectSingleNode("refactorizations"); if (refactorList != null) { foreach (XmlNode n in refactorList.ChildNodes) { //if (XmlHelper.GetAttributeValue(n, "type", string.Empty) == "guidtoid") //{ // modelRoot.Refactorizations.Add(new RefactorChangeGuidToID((XmlElement)n)); //} //else if (XmlHelper.GetAttributeValue(n, "type", string.Empty) == "guidtoididtoguid") //{ // modelRoot.Refactorizations.Add(new RefactorChangeIDToGuid((XmlElement)n)); //} if (XmlHelper.GetAttributeValue(n, "type", string.Empty) == "splittable") { modelRoot.Refactorizations.Add(new RefactorTableSplit((XmlElement)n)); } else if (XmlHelper.GetAttributeValue(n, "type", string.Empty) == "combinetable") { modelRoot.Refactorizations.Add(new RefactorTableCombine((XmlElement)n)); } } } } } } #endregion //If using modules from a previous model version then perform this one time action of //assigning the indexes to all modules so user will not be confronted with a a huge action to perform after upgrade if (dslVersion <= new Version(5, 1, 2, 118) && modelRoot.UseModules) { using (var transaction = modelRoot.Store.TransactionManager.BeginTransaction(Guid.NewGuid().ToString())) { foreach (var module in modelRoot.Modules) { var contained = module.GetEntities().ToList(); foreach (var index in modelRoot.Entities.Where(x => contained.Contains(x)).SelectMany(x => x.IndexList)) { _model.IndexModules.Add(new IndexModule(_model.Partition) { IndexID = index.Id, ModuleId = module.Id }); } } transaction.Commit(); } } return modelRoot; }
public MetaModel LoadModel(DslModeling::SerializationResult serializationResult, DslModeling::Partition partition, string fileName, DslModeling::ISchemaResolver schemaResolver, DslValidation::ValidationController validationController, DslModeling::ISerializerLocator serializerLocator, bool bStartT, bool bIsTopMost) { #region Model #region Check Parameters if (serializationResult == null) throw new global::System.ArgumentNullException("serializationResult"); if (partition == null) throw new global::System.ArgumentNullException("partition"); if (string.IsNullOrEmpty(fileName)) throw new global::System.ArgumentNullException("fileName"); #endregion // Ensure there is a transaction for this model to Load in. if (!partition.Store.TransactionActive) { throw new global::System.InvalidOperationException(LanguageDSLDomainModel.SingletonResourceManager.GetString("MissingTransaction")); } MetaModel modelRoot = null; DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(partition.Store); DslModeling::DomainClassXmlSerializer modelRootSerializer = directory.GetSerializer(MetaModel.DomainClassId); global::System.Diagnostics.Debug.Assert(modelRootSerializer != null, "Cannot find serializer for MetaModel!"); if (modelRootSerializer != null) { using (global::System.IO.FileStream fileStream = global::System.IO.File.OpenRead(fileName)) { DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, fileStream.Name, serializationResult); this.InitializeSerializationContext(partition, serializationContext, true); DslModeling::TransactionContext transactionContext = new DslModeling::TransactionContext(); transactionContext.Add(DslModeling::SerializationContext.TransactionContextKey, serializationContext); DslModeling::Transaction t = null; if (bStartT) { t = partition.Store.TransactionManager.BeginTransaction("Load Model from " + fileName, true, transactionContext); } // Ensure there is some content in the file. Blank (or almost blank, to account for encoding header bytes, etc.) // files will cause a new root element to be created and returned. if (fileStream.Length > 5) { try { global::System.Xml.XmlReaderSettings settings = LanguageDSLSerializationHelper.Instance.CreateXmlReaderSettings(serializationContext, false); using (global::System.Xml.XmlReader reader = global::System.Xml.XmlReader.Create(fileStream, settings)) { // Attempt to read the encoding. reader.Read(); // Move to the first node - will be the XmlDeclaration if there is one. global::System.Text.Encoding encoding; if (this.TryGetEncoding(reader, out encoding)) { serializationResult.Encoding = encoding; } // Load any additional domain models that are required DslModeling::SerializationUtilities.ResolveDomainModels(reader, serializerLocator, partition.Store); reader.MoveToContent(); modelRoot = modelRootSerializer.TryCreateInstance(serializationContext, reader, partition) as MetaModel; if (modelRoot != null && !serializationResult.Failed) { modelRoot.BaseDirectory = MetaModelLibraryBase.GetBaseDirectory(fileName); modelRoot.FilePath = fileName; this.ReadRootElement(serializationContext, modelRoot, reader, schemaResolver); } } } catch (global::System.Xml.XmlException xEx) { DslModeling::SerializationUtilities.AddMessage( serializationContext, DslModeling::SerializationMessageKind.Error, xEx ); } } if (modelRoot == null && !serializationResult.Failed) { // create model root if it doesn't exist. modelRoot = this.CreateModelHelper(partition); modelRoot.BaseDirectory = MetaModelLibraryBase.GetBaseDirectory(fileName); modelRoot.FilePath = fileName; } if (bStartT) if (t.IsActive) t.Commit(); // Do load-time validation if a ValidationController is provided. if (!serializationResult.Failed && validationController != null) { using (new SerializationValidationObserver(serializationResult, validationController)) { validationController.Validate(partition, DslValidation::ValidationCategories.Load); } } } } #endregion MetaModel model = modelRoot; if (bIsTopMost) model.IsTopMost = true; #region Diagrams System.IO.FileInfo info = new System.IO.FileInfo(fileName); string fileNameDiagram = info.DirectoryName + "\\" + info.Name.Remove(info.Name.Length - info.Extension.Length, info.Extension.Length) + DiagramExtension; View view = null; if (System.IO.File.Exists(fileNameDiagram)) { //DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(partition.Store); DslModeling::DomainClassXmlSerializer viewSerializer = directory.GetSerializer(View.DomainClassId); global::System.Diagnostics.Debug.Assert(viewSerializer != null, "Cannot find serializer for View!"); if (viewSerializer != null) { using (global::System.IO.FileStream fileStream = global::System.IO.File.OpenRead(fileNameDiagram)) { DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, fileStream.Name, serializationResult); this.InitializeSerializationContext(partition, serializationContext, true); DslModeling::TransactionContext transactionContext = new DslModeling::TransactionContext(); transactionContext.Add(DslModeling::SerializationContext.TransactionContextKey, serializationContext); DslModeling::Transaction t = null; if (bStartT) t = partition.Store.TransactionManager.BeginTransaction("Load Model from " + fileNameDiagram, true, transactionContext); // Ensure there is some content in the file. Blank (or almost blank, to account for encoding header bytes, etc.) // files will cause a new root element to be created and returned. if (fileStream.Length > 5) { try { global::System.Xml.XmlReaderSettings settings = LanguageDSLSerializationHelper.Instance.CreateXmlReaderSettings(serializationContext, false); using (global::System.Xml.XmlReader reader = global::System.Xml.XmlReader.Create(fileStream, settings)) { // Attempt to read the encoding. reader.Read(); // Move to the first node - will be the XmlDeclaration if there is one. global::System.Text.Encoding encoding; if (this.TryGetEncoding(reader, out encoding)) { serializationResult.Encoding = encoding; } reader.MoveToContent(); view = viewSerializer.TryCreateInstance(serializationContext, reader, partition) as View; if (view != null && !serializationResult.Failed) { // Use a validating reader if possible viewSerializer.Read(serializationContext, view, reader); model.View = view; } } } catch (global::System.Xml.XmlException xEx) { DslModeling::SerializationUtilities.AddMessage( serializationContext, DslModeling::SerializationMessageKind.Error, xEx ); } } if (bStartT) if (t.IsActive) t.Commit(); } } } #endregion //if( bIsTopMost ) SerializationPostProcessor.PostProcessModelLoad(model); return model; }
/// <summary> /// Loads a HostDesignerModel instance and its associated diagram file into the default partition of the given store, and ignore serialization result. /// </summary> /// <param name="store">The new HostDesignerModel instance will be created into the default partition of this store.</param> /// <param name="modelFileName">Name of the file from which the HostDesignerModel instance will be deserialized.</param> /// <param name="diagramFileName">Name of the file from which the HostDesignerDiagram instance will be deserialized.</param> /// <param name="schemaResolver"> /// An ISchemaResolver that allows the serializer to do schema validation on the root element (and everything inside it). /// If null is passed, schema validation will not be performed. /// </param> /// <param name="validationController"> /// A ValidationController that will be used to do load-time validation (validations with validation category "Load"). If null /// is passed, load-time validation will not be performed. /// </param> /// <param name="serializerLocator"> /// An ISerializerLocator that will be used to locate any additional domain model types required to load the model. Can be null. /// </param> /// <returns>The loaded HostDesignerModel instance.</returns> public virtual HostDesignerModel LoadModelAndDiagram(DslModeling::Store store, string modelFileName, string diagramFileName, DslModeling::ISchemaResolver schemaResolver, DslValidation::ValidationController validationController, DslModeling::ISerializerLocator serializerLocator) { return this.LoadModelAndDiagram(new DslModeling::SerializationResult(), store, modelFileName, diagramFileName, schemaResolver, validationController, serializerLocator); }
/// <summary> /// Loads a EntityDesignerViewModel instance and its associated diagram file into the default partition of the given store, and ignore serialization result. /// </summary> /// <param name="store">The new EntityDesignerViewModel instance will be created into the default partition of this store.</param> /// <param name="modelFileName">Name of the file from which the EntityDesignerViewModel instance will be deserialized.</param> /// <param name="diagramFileName">Name of the file from which the EntityDesignerDiagram instance will be deserialized.</param> /// <param name="schemaResolver"> /// An ISchemaResolver that allows the serializer to do schema validation on the root element (and everything inside it). /// If null is passed, schema validation will not be performed. /// </param> /// <param name="validationController"> /// A ValidationController that will be used to do load-time validation (validations with validation category "Load"). If null /// is passed, load-time validation will not be performed. /// </param> /// <returns>The loaded EntityDesignerViewModel instance.</returns> internal virtual global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.EntityDesignerViewModel LoadModelAndDiagram(DslModeling::Store store, string modelFileName, string diagramFileName, DslModeling::ISchemaResolver schemaResolver, DslValidation::ValidationController validationController, DslModeling::ISerializerLocator serializerLocator) { return this.LoadModelAndDiagram(new DslModeling::SerializationResult(), store, modelFileName, diagramFileName, schemaResolver, validationController, serializerLocator); }
/// <summary> /// Loads a HostDesignerModel instance and its associated diagram file into the default partition of the given store. /// </summary> /// <param name="serializationResult">Stores serialization result from the load operation.</param> /// <param name="store">The new HostDesignerModel instance will be created into the default partition of this store.</param> /// <param name="modelFileName">Name of the file from which the HostDesignerModel instance will be deserialized.</param> /// <param name="diagramFileName">Name of the file from which the HostDesignerDiagram instance will be deserialized.</param> /// <param name="schemaResolver"> /// An ISchemaResolver that allows the serializer to do schema validation on the root element (and everything inside it). /// If null is passed, schema validation will not be performed. /// </param> /// <param name="validationController"> /// A ValidationController that will be used to do load-time validation (validations with validation category "Load"). If null /// is passed, load-time validation will not be performed. /// </param> /// <param name="serializerLocator"> /// An ISerializerLocator that will be used to locate any additional domain model types required to load the model. Can be null. /// </param> /// <returns>The loaded HostDesignerModel instance.</returns> public virtual HostDesignerModel LoadModelAndDiagram(DslModeling::SerializationResult serializationResult, DslModeling::Store store, string modelFileName, string diagramFileName, DslModeling::ISchemaResolver schemaResolver, DslValidation::ValidationController validationController, DslModeling::ISerializerLocator serializerLocator) { #region Check Parameters if (store == null) throw new global::System.ArgumentNullException("store"); #endregion DslModeling::Partition diagramPartition = new DslModeling::Partition(store); return this.LoadModelAndDiagram(serializationResult, store.DefaultPartition, modelFileName, diagramPartition, diagramFileName, schemaResolver, validationController, serializerLocator); }
public override MetaModel LoadModel(SerializationResult serializationResult, Store store, string fileName, ISchemaResolver schemaResolver, DslValidation.ValidationController validationController, ISerializerLocator serializerLocator) { return LoadModel(serializationResult, store.DefaultPartition, fileName, schemaResolver, validationController, serializerLocator, true, true); }
/// <summary> /// Constructor /// </summary> internal SerializationValidationObserver(DslModeling::SerializationResult serializationResult, DslValidation::ValidationController validationController) { #region Check Parameters global::System.Diagnostics.Debug.Assert(serializationResult != null); global::System.Diagnostics.Debug.Assert(validationController != null); #endregion this.serializationResult = serializationResult; this.validationController = validationController; // Subscribe to validation messages. this.validationController.AddObserver(this); }
private void ValidateMonikerAmbiguity(DslValidation::ValidationContext context) { global::System.Collections.Generic.IDictionary<global::System.Guid, DslModeling::IMonikerResolver> monikerResolvers = AsyncDslSerializationHelper.Instance.GetMonikerResolvers(this.Store); foreach (DslModeling::ModelElement element in this.Store.ElementDirectory.AllElements) { global::System.Guid domainModelId = element.GetDomainClass().DomainModel.Id; DslModeling::IMonikerResolver monikerResolver = null; if (monikerResolvers.TryGetValue(domainModelId, out monikerResolver) && monikerResolver != null) { DslModeling::SimpleMonikerResolver simpleMonikerResolver = monikerResolver as DslModeling::SimpleMonikerResolver; if (simpleMonikerResolver != null) { try { simpleMonikerResolver.ProcessAddedElement(element); } catch (DslModeling::AmbiguousMonikerException amEx) { // Ambiguous moniker detected. context.LogError( string.Format( global::System.Globalization.CultureInfo.CurrentCulture, AsyncDslDomainModel.SingletonResourceManager.GetString("AmbiguousMoniker"), amEx.Moniker, DslModeling::SerializationUtilities.GetElementName(element), DslModeling::SerializationUtilities.GetElementName(amEx.Element) ), "AmbiguousMoniker", this, amEx.Element ); } } } } // Clean up the created moniker resolvers after the check. foreach (DslModeling::IMonikerResolver monikerResolver in monikerResolvers.Values) { DslModeling::SimpleMonikerResolver simpleMonikerResolver = monikerResolvers as DslModeling::SimpleMonikerResolver; if (simpleMonikerResolver != null) simpleMonikerResolver.Dispose(); } monikerResolvers.Clear(); }
public virtual global::Tum.VModellXT.VModell LoadModelVModell(DslModeling::SerializationResult serializationResult, DslModeling::Partition partition, string fileName, DslModeling::ISchemaResolver schemaResolver, DslValidation::ValidationController validationController, DslModeling::ISerializerLocator serializerLocator) { #region Check Parameters if (serializationResult == null) throw new global::System.ArgumentNullException("serializationResult"); if (partition == null) throw new global::System.ArgumentNullException("partition"); if (string.IsNullOrEmpty(fileName)) throw new global::System.ArgumentNullException("fileName"); #endregion DslEditorModeling::DomainModelStore dStore = (DslEditorModeling::DomainModelStore)partition.Store; if( dStore == null) throw new global::System.ArgumentNullException("dStore"); //dStore.WaitForWritingLockRelease(); // Ensure there is a transaction for this model to Load in. if (!partition.Store.TransactionActive) { throw new global::System.InvalidOperationException(VModellXTDomainModel.SingletonResourceManager.GetString("MissingTransaction")); } global::Tum.VModellXT.VModell modelRoot = null; DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(partition.Store); DslModeling::DomainClassXmlSerializer modelRootSerializer = directory.GetSerializer(global::Tum.VModellXT.VModell.DomainClassId); global::System.Diagnostics.Debug.Assert(modelRootSerializer != null, "Cannot find serializer for VModell!"); if (modelRootSerializer != null) { global::System.IO.FileStream fileStream = null; try { fileStream = global::System.IO.File.OpenRead(fileName); DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, fileStream.Name, serializationResult); this.InitializeSerializationContext(partition, serializationContext, true); DslModeling::TransactionContext transactionContext = new DslModeling::TransactionContext(); transactionContext.Add(DslModeling::SerializationContext.TransactionContextKey, serializationContext); //using (DslModeling::Transaction t = partition.Store.TransactionManager.BeginTransaction("Load Model from " + fileName, true, transactionContext)) //{ // Ensure there is some content in the file. Blank (or almost blank, to account for encoding header bytes, etc.) // files will cause a new root element to be created and returned. if (fileStream.Length > 5) { global::System.Xml.XmlReaderSettings settings = VModellXTSerializationHelper.Instance.CreateXmlReaderSettings(serializationContext, false); using (global::System.Xml.XmlReader reader = global::System.Xml.XmlReader.Create(fileStream, settings)) { try { // Attempt to read the encoding. reader.Read(); // Move to the first node - will be the XmlDeclaration if there is one. global::System.Text.Encoding encoding; if (this.TryGetEncoding(reader, out encoding)) { serializationResult.Encoding = encoding; } // Load any additional domain models that are required //DslModeling::SerializationUtilities.ResolveDomainModels(reader, serializerLocator, partition.Store); reader.MoveToContent(); modelRoot = modelRootSerializer.TryCreateInstance(serializationContext, reader, partition) as global::Tum.VModellXT.VModell; if (modelRoot != null && !serializationResult.Failed) { modelRoot.DomainFilePath = fileName; this.ReadRootElementVModell(serializationContext, modelRoot, reader, schemaResolver); } fileStream.Dispose(); } catch (global::System.Xml.XmlException xEx) { DslModeling::SerializationUtilities.AddMessage( serializationContext, DslModeling::SerializationMessageKind.Error, xEx ); } finally { fileStream = null; } } } if(modelRoot == null && !serializationResult.Failed) { // create model root if it doesn't exist. modelRoot = this.CreateModelHelperVModell(partition); modelRoot.DomainFilePath = fileName; } //if (t.IsActive) // t.Commit(); //} // Do load-time validation if a ValidationController is provided. if (!serializationResult.Failed && validationController != null) { using (new SerializationValidationObserver(serializationResult, validationController)) { validationController.Validate(partition, DslValidation::ValidationCategories.Load); } } } finally { if( fileStream != null ) fileStream.Dispose(); } } return modelRoot; }
/// <summary> /// Loads a EntityDesignerViewModel instance into the default partition of the given store. /// </summary> /// <param name="serializationResult">Stores serialization result from the load operation.</param> /// <param name="store">The new EntityDesignerViewModel instance will be created into the default partition of this store.</param> /// <param name="fileName">Name of the file from which the EntityDesignerViewModel instance will be deserialized.</param> /// <param name="schemaResolver"> /// An ISchemaResolver that allows the serializer to do schema validation on the root element (and everything inside it). /// If null is passed, schema validation will not be performed. /// </param> /// <param name="validationController"> /// A ValidationController that will be used to do load-time validation (validations with validation category "Load"). If null /// is passed, load-time validation will not be performed. /// </param> /// <returns>The loaded EntityDesignerViewModel instance.</returns> internal virtual global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.EntityDesignerViewModel LoadModel(DslModeling::SerializationResult serializationResult, DslModeling::Store store, string fileName, DslModeling::ISchemaResolver schemaResolver, DslValidation::ValidationController validationController, DslModeling::ISerializerLocator serializerLocator) { #region Check Parameters if (store == null) throw new global::System.ArgumentNullException("store"); #endregion return this.LoadModel(serializationResult, store.DefaultPartition, fileName, schemaResolver, validationController, serializerLocator); }