private void UpdateSettingsFromGui() { if (!EscherAttributeContentValidator.IsValidCsdlEntityTypeName(entityNameTextBox.Text)) { baseTypeComboBox.Enabled = false; entitySetTextBox.Enabled = false; groupBox2.Enabled = false; } else { groupBox2.Enabled = true; baseTypeComboBox.Enabled = true; if (BaseEntityType == null) { entitySetTextBox.Enabled = true; groupBox2.Enabled = true; var proposedEntitySetName = ModelHelper.ConstructProposedEntitySetName(_model.Artifact, EntityName); entitySetTextBox.Text = ModelHelper.GetUniqueName(typeof(EntitySet), _model.FirstEntityContainer, proposedEntitySetName); keyPropertyCheckBox.Checked = true; } else { keyPropertyCheckBox.Checked = false; entitySetTextBox.Enabled = false; entitySetTextBox.Text = BaseEntityType.EntitySet.LocalName.Value; groupBox2.Enabled = false; } } }
private static void PopluateReplacementDictionary(Project project, Dictionary <string, string> replacementsDictionary, string modelName) { // create a "fixed" version that removes non-valid characters and leading underscores var fixedModelName = XmlConvert.EncodeName(modelName).TrimStart('_'); // make sure that the model name is a valid xml attribute value if (!EscherAttributeContentValidator.IsValidXmlAttributeValue(fixedModelName)) { VsUtils.ShowErrorDialog( string.Format( CultureInfo.CurrentCulture, Resources.ModelObjectItemWizard_NonValidXmlAttributeValue, modelName)); Marshal.ThrowExceptionForHR(VSConstants.E_ABORT); } // set the value to be used for namespace in blank models replacementsDictionary.Add("$namespace$", fixedModelName); // set the value to be used for EntityContainerName in blank models var entityContainerName = PackageManager.Package.ConnectionManager.ConstructUniqueEntityContainerName( fixedModelName + EntityContainerNameSuffix, project); replacementsDictionary.Add("$conceptualEntityContainerName$", entityContainerName); // set default value of the EnablePluralization flag dependent on current culture var pluralizationDefault = (CultureInfo.CurrentCulture.TwoLetterISOLanguageName == "en").ToString(); replacementsDictionary.Add("$enablePluralization$", pluralizationDefault); }
private void ValidateName(ValidationContext context) { if (!EscherAttributeContentValidator.IsValidCsdlPropertyName(Name)) { var message = String.Format(CultureInfo.CurrentCulture, Resources.Error_PropertyNameInvalid, Name); context.LogError(message, Properties.Resources.ErrorCode_PropertyNameInvalid, this); } }
// <summary> // Returns a string which is valid as a model namespace given the // proposedModelNamespace as a starting point. // </summary> // <param name="proposedModelNamespace">The proposed model namespace</param> // <param name="defaultModelNamespace">The model namespace to use if removal of invalid chars results in an empty string</param> internal static string ConstructValidModelNamespace(string proposedModelNamespace, string defaultModelNamespace) { Debug.Assert(!string.IsNullOrWhiteSpace(defaultModelNamespace), "defaultModelNamespace must not be null or empty"); if (IsValidModelNamespace(proposedModelNamespace)) { return(proposedModelNamespace); } if (String.IsNullOrEmpty(proposedModelNamespace)) { return(defaultModelNamespace); } var trialModelNamespace = proposedModelNamespace.Replace("<", "").Replace(">", "").Replace("&", ""); if (!EscherAttributeContentValidator.IsValidXmlAttributeValue(trialModelNamespace) || string.IsNullOrEmpty(trialModelNamespace)) { return(defaultModelNamespace); } if (IsValidModelNamespace(trialModelNamespace)) { // if trialModelNamespace is now valid just return it return(trialModelNamespace); } // if trialModelNamespace is invalid must be an invalid identifier // try stripping any leading numbers while (trialModelNamespace.Length > 0 && !Char.IsLetter(trialModelNamespace[0])) { trialModelNamespace = trialModelNamespace.Substring(1); } if (String.IsNullOrEmpty(trialModelNamespace)) { return(defaultModelNamespace); } if (IsValidModelNamespace(trialModelNamespace)) { return(trialModelNamespace); } // try adding a one to the end trialModelNamespace += "1"; if (IsValidModelNamespace(trialModelNamespace)) { return(trialModelNamespace); } // give up and return default return(defaultModelNamespace); }
/// <summary> /// Do the following when an EntityType changes: /// - Update roles in related Associations /// </summary> /// <param name="e"></param> public override void ElementPropertyChanged(ElementPropertyChangedEventArgs e) { base.ElementPropertyChanged(e); // if the element is deleted or about to be deleted, this rule will get fired. // Just return immediately here because we don't care if the entity-type's property has changed. if (e.ModelElement.IsDeleted || e.ModelElement.IsDeleting) { return; } var changedEntity = e.ModelElement as EntityType; Debug.Assert(changedEntity != null); Debug.Assert(changedEntity.EntityDesignerViewModel != null); if (changedEntity != null && changedEntity.EntityDesignerViewModel != null) { var viewModel = changedEntity.EntityDesignerViewModel; var tx = ModelUtils.GetCurrentTx(e.ModelElement.Store); Debug.Assert(tx != null); // don't do the auto update stuff if we are in the middle of deserialization if (tx != null && !tx.IsSerializing) { // are they changing the name? if (e.DomainProperty.Id == NameableItem.NameDomainPropertyId) { // if we are creating this Entity, there is no 'change' to do if (viewModel.ModelXRef.GetExisting(changedEntity) == null) { return; } if (!EscherAttributeContentValidator.IsValidCsdlEntityTypeName(changedEntity.Name)) { throw new InvalidOperationException( String.Format(CultureInfo.CurrentCulture, Resources.Error_EntityNameInvalid, changedEntity.Name)); } if (ModelUtils.IsUniqueName(changedEntity, changedEntity.Name, viewModel.EditingContext) == false) { throw new InvalidOperationException( String.Format(CultureInfo.CurrentCulture, Resources.Error_EntityNameDuplicate, changedEntity.Name)); } ViewModelChangeContext.GetNewOrExistingContext(tx).ViewModelChanges.Add(new EntityTypeChange(changedEntity)); } } } }
private void associationNameTextBox_TextChanged(object sender, EventArgs e) { if (!EscherAttributeContentValidator.IsValidCsdlAssociationName(AssociationName)) { end1GroupBox.Enabled = false; end2GroupBox.Enabled = false; } else { end1GroupBox.Enabled = true; end2GroupBox.Enabled = true; } }
private void ValidateNamespace(ValidationContext context) { if (String.IsNullOrEmpty(this.Namespace)) { string message = String.Format(CultureInfo.CurrentCulture, Properties.Resources.Error_ModelNamespaceEmpty); context.LogError(message, Properties.Resources.ErrorCode_ModelNamespaceEmpty, this); } else if (EscherAttributeContentValidator.IsValidCSDLNamespaceName(this.Namespace) == false) { string message = String.Format(CultureInfo.CurrentCulture, Properties.Resources.Error_ModelNamespaceInvalid, this.Namespace); context.LogError(message, Properties.Resources.ErrorCode_ModelNamespaceInvalid, this); } }
public string this[string propertyName] { get { if (Parent == null || (String.IsNullOrEmpty(Name) && String.IsNullOrEmpty(Value))) { return(String.Empty); } var sb = new StringBuilder(); if (propertyName == null || propertyName == "Name") { if (string.IsNullOrWhiteSpace(Name) || !EscherAttributeContentValidator.IsValidCsdlEnumMemberName(Name)) { sb.AppendLine(String.Format(CultureInfo.CurrentCulture, Resources.EnumDialog_ErrorEnumMemberBadname, Name)); } else if (Parent.Members.Count(etm => String.Compare(etm.Name, Name, StringComparison.CurrentCulture) == 0) > 1) { sb.AppendLine( String.Format(CultureInfo.CurrentCulture, Resources.EnumDialog_ErrorEnumMemberDuplicateName, Name)); } } if (propertyName == null || propertyName == "Value") { if (string.IsNullOrEmpty(Value) == false) // we will validate if the user entered white spaces. { var type = ModelHelper.UnderlyingEnumTypes.FirstOrDefault( t => String.CompareOrdinal(t.Name, Parent.SelectedUnderlyingType) == 0); Debug.Assert( type != null, "The type :" + Parent.SelectedUnderlyingType + " is not a valid underlying type for an enum."); // if value is not null or empty, we will validate the input based on enum type's underlying type. if (type != null && ModelHelper.IsValidValueForType(type, Value) == false) { sb.AppendLine(String.Format(CultureInfo.CurrentCulture, Model.Resources.BadEnumTypeMemberValue, Value)); } } } return(sb.ToString()); } }
internal override void DetermineIfArtifactIsDesignerSafe() { // XmlSchemaValidator by default does not report any errors or warning if the namespace of the validated document // does not match the targetNamespace in the schema considering the schema not being applicable. With XmlReader // it is possible to pass XmlSchemaValidationFlags.ReportValidationWarnings to be notified if this happens. However // it is not possible to pass this flag when using XDocument.Validate. Therefore before trying to validate the Xml // we just check that this is a known edmx namespace. If it is not we set the flag to false and skip validating. if (IsDesignerSafe = SchemaManager.GetEDMXNamespaceNames().Contains(XDocument.Root.Name.NamespaceName)) { XDocument.Validate( EscherAttributeContentValidator.GetInstance(SchemaVersion).EdmxSchemaSet, (sender, args) => IsDesignerSafe = false); } }
// <summary> // This method will return validation error for a given property (if there is one). // </summary> public string this[string propertyName] { get { if (propertyName == "Name") { string errorMessage; if (string.IsNullOrWhiteSpace(_name) || !EscherAttributeContentValidator.IsValidCsdlEnumTypeName(_name)) { return(String.Format(CultureInfo.CurrentCulture, Resources.EnumDialog_ErrorEnumTypeBadname, _name)); } else if (IsNew && ModelHelper.IsUniqueName(typeof(EnumType), _artifact.ConceptualModel, _name, true, out errorMessage) == false) { return(Resources.EnumDialog_EnsureEnumTypeUnique); } // if the name has changed, ensure that it will be unique across other types. else if (IsNew == false && string.CompareOrdinal(_enumType.Name.Value, Name) != 0 && ModelHelper.IsUniqueNameForExistingItem(_enumType, Name, true, out errorMessage) == false) { return(errorMessage); } } else if (propertyName == "ExternalTypeName") { if (IsReferenceExternalType && String.IsNullOrWhiteSpace(ExternalTypeName)) { return(Resources.EnumDialog_ErrorEnterValueForExternalTypeName); } } return(String.Empty); } }
protected override void InvokeInternal(CommandProcessorContext cpc) { if (null == _conceptualEntityModel) { Debug.Fail("Null ConceptualEntityModel"); return; } var artifact = _conceptualEntityModel.Artifact; if (null == artifact) { Debug.Fail("Null Artifact"); return; } var artifactSet = artifact.ArtifactSet; if (null == artifactSet) { Debug.Fail("Null ArtifactSet"); return; } // make sure this name doesn't conflict with an EntityContainer name foreach (var bec in _conceptualEntityModel.EntityContainers()) { if (_newNamespace == bec.LocalName.Value) { var msg = string.Format( CultureInfo.CurrentCulture, Resources.EntityContainerNameConflictsWithNamespaceName, _newNamespace); throw new CommandValidationFailedException(msg); } } // check to see if the new namespace is valid if (EscherAttributeContentValidator.GetInstance(artifact.SchemaVersion) .IsValidAttributeValue(_newNamespace, _conceptualEntityModel.Namespace)) { var previousConceptualNamespace = _conceptualEntityModel.Namespace.Value; if (string.IsNullOrEmpty(previousConceptualNamespace)) { Debug.Fail("Null or empty conceptual namespace"); return; } // find all Symbols in the ArtifactSet which have first part // equal to existing previousConceptualNamespace var allElementsWithConceptualNamespaceSymbol = artifactSet.GetElementsContainingFirstSymbolPart(previousConceptualNamespace); // change all references which include the namespace to the new namespace foreach (var element in allElementsWithConceptualNamespaceSymbol) { var itemBindings = element.GetDependentBindings(); foreach (var itemBinding in itemBindings) { itemBinding.UpdateRefNameNamespaces( previousConceptualNamespace, _newNamespace); } } // now update the namespace attribute itself _conceptualEntityModel.Namespace.Value = _newNamespace; // symbols need to be recalculated throughout the // CSDL, MSL & DesignerInfo sections, and bindings need to be rebound ... XmlModelHelper.NormalizeAndResolve(_conceptualEntityModel); if (artifact.MappingModel() != null) { XmlModelHelper.NormalizeAndResolve(artifact.MappingModel()); } if (artifact.DesignerInfo() != null) { XmlModelHelper.NormalizeAndResolve(artifact.DesignerInfo()); } } else { // if not a valid namespace, throw an error message var msg = string.Format(CultureInfo.CurrentCulture, Resources.InvalidNamespaceName, _newNamespace); throw new CommandValidationFailedException(msg); } }
/// <summary> /// Do the following when an Entity changes: /// - Update roles in related Associations /// </summary> /// <param name="e"></param> public override void ElementPropertyChanged(ElementPropertyChangedEventArgs e) { base.ElementPropertyChanged(e); var changedNavigationProperty = e.ModelElement as NavigationProperty; Debug.Assert(changedNavigationProperty != null); Debug.Assert( changedNavigationProperty.EntityType != null && changedNavigationProperty.EntityType.EntityDesignerViewModel != null); if ((changedNavigationProperty != null) && (changedNavigationProperty.EntityType != null) && (changedNavigationProperty.EntityType.EntityDesignerViewModel != null)) { var tx = ModelUtils.GetCurrentTx(e.ModelElement.Store); Debug.Assert(tx != null); // don't do the auto update stuff if we are in the middle of deserialization if (tx != null && !tx.IsSerializing) { var viewModel = changedNavigationProperty.EntityType.EntityDesignerViewModel; if (e.DomainProperty.Id == NameableItem.NameDomainPropertyId) { // if we are creating this, the old name will be empty so there is no 'change' to do if (String.IsNullOrEmpty((string)e.OldValue)) { return; } if (!EscherAttributeContentValidator.IsValidCsdlNavigationPropertyName(changedNavigationProperty.Name)) { throw new InvalidOperationException( String.Format( CultureInfo.CurrentCulture, Resources.Error_NavigationPropertyNameInvalid, changedNavigationProperty.Name)); } var modelEntityType = viewModel.ModelXRef.GetExisting(changedNavigationProperty.EntityType) as Model.Entity.EntityType; Debug.Assert(modelEntityType != null, "modelEntityType is null"); // ensure name is unique if (modelEntityType.LocalName.Value.Equals(changedNavigationProperty.Name, StringComparison.Ordinal)) { var msg = string.Format( CultureInfo.CurrentCulture, Model.Resources.Error_MemberNameSameAsParent, changedNavigationProperty.Name, modelEntityType.LocalName.Value); throw new InvalidOperationException(msg); } else if (!EDMModelUtils.IsUniquePropertyName(modelEntityType, changedNavigationProperty.Name, true)) { var msg = string.Format( CultureInfo.CurrentCulture, Model.Resources.Error_MemberNameNotUnique, changedNavigationProperty.Name, modelEntityType.LocalName.Value); throw new InvalidOperationException(msg); } ViewModelChangeContext.GetNewOrExistingContext(tx) .ViewModelChanges.Add(new NavigationPropertyChange(changedNavigationProperty)); } } } }
protected override void OnClosing(CancelEventArgs e) { base.OnClosing(e); if (_needsValidation) { _needsValidation = false; string msg = null; if (!EscherAttributeContentValidator.IsValidCsdlAssociationName(AssociationName)) { VsUtils.ShowErrorDialog(DialogsResource.NewAssociationDialog_InvalidAssociationNameMsg); e.Cancel = true; associationNameTextBox.Focus(); } else if (navigationPropertyCheckbox.Checked && !EscherAttributeContentValidator.IsValidCsdlNavigationPropertyName(End1NavigationPropertyName)) { VsUtils.ShowErrorDialog(DialogsResource.NewAssociationDialog_InvalidNavigationPropertyNameMsg); e.Cancel = true; navigationProperty1TextBox.Focus(); } else if (navigationProperty2Checkbox.Checked && !EscherAttributeContentValidator.IsValidCsdlNavigationPropertyName(End2NavigationPropertyName)) { VsUtils.ShowErrorDialog(DialogsResource.NewAssociationDialog_InvalidNavigationPropertyNameMsg); e.Cancel = true; navigationProperty2TextBox.Focus(); } else if (!ModelHelper.IsUniqueName(typeof(Association), End1Entity.Parent, AssociationName, false, out msg)) { VsUtils.ShowErrorDialog(DialogsResource.NewAssociationDialog_EnsureUniqueNameMsg); e.Cancel = true; associationNameTextBox.Focus(); } else if (navigationPropertyCheckbox.Checked && End1NavigationPropertyName.Equals(End1Entity.LocalName.Value, StringComparison.Ordinal)) { VsUtils.ShowErrorDialog(DialogsResource.SameEntityAndPropertyNameMsg); e.Cancel = true; navigationProperty1TextBox.Focus(); } else if (navigationPropertyCheckbox.Checked && !ModelHelper.IsUniquePropertyName(End1Entity, End1NavigationPropertyName, true)) { VsUtils.ShowErrorDialog(DialogsResource.NewAssociationDialog_EnsureUniquePropertyNameMsg); e.Cancel = true; navigationProperty1TextBox.Focus(); } else if (End2NavigationPropertyName.Equals(End2Entity.LocalName.Value, StringComparison.Ordinal)) { VsUtils.ShowErrorDialog(DialogsResource.SameEntityAndPropertyNameMsg); e.Cancel = true; navigationProperty2TextBox.Focus(); } else if (navigationProperty2Checkbox.Checked && !ModelHelper.IsUniquePropertyName(End2Entity, End2NavigationPropertyName, true) || (End1Entity == End2Entity && navigationProperty2Checkbox.Checked && End2NavigationPropertyName.Equals(End1NavigationPropertyName, StringComparison.Ordinal))) { VsUtils.ShowErrorDialog(DialogsResource.NewAssociationDialog_EnsureUniquePropertyNameMsg); e.Cancel = true; navigationProperty2TextBox.Focus(); } } }
// <summary> // Returns whether the proposedModelNamespace is valid as a model namespace. // </summary> // <param name="proposedModelNamespace">The proposed model namespace</param> internal static bool IsValidModelNamespace(string proposedModelNamespace) { return (!string.IsNullOrEmpty(proposedModelNamespace) && EscherAttributeContentValidator.IsValidCsdlNamespaceName(proposedModelNamespace)); }
internal override bool IsXmlValid() { // If there is a VSXmlModelProvider, we should be able to find a docdata for it. // In any other case, it doesn't matter whether there is document data or not. var docData = VSHelpers.GetDocData(PackageManager.Package, Uri.LocalPath); Debug.Assert( !(XmlModelProvider is VSXmlModelProvider) || docData != null, "Using a VSXmlModelProvider but docData is null for Artifact!"); try { XmlDocument xmldoc; if (docData != null) { var textLines = VSHelpers.GetVsTextLinesFromDocData(docData); Debug.Assert(textLines != null, "Failed to get IVSTextLines from docdata"); xmldoc = EdmUtils.SafeLoadXmlFromString(VSHelpers.GetTextFromVsTextLines(textLines)); } else { // If there is no docdata then attempt to create the XmlDocument from the internal // XLinq tree in the artifact xmldoc = new XmlDocument(); xmldoc.Load(XDocument.CreateReader()); } // For the most part, the Edmx schema version of an artifact should be in sync with the schema version // that is compatible with the project's target framework; except when the user adds an existing edmx to a project (the version could be different). // For all cases, we always want to validate using the XSD's version that matches the artifact's version. var documentSchemaVersion = base.SchemaVersion; Debug.Assert( EntityFrameworkVersion.IsValidVersion(documentSchemaVersion), "The EF Schema Version is not valid. Value:" + (documentSchemaVersion != null ? documentSchemaVersion.ToString() : "null")); // does the XML parse? If not, the load call below will throw if (EntityFrameworkVersion.IsValidVersion(documentSchemaVersion)) { var nsMgr = SchemaManager.GetEdmxNamespaceManager(xmldoc.NameTable, documentSchemaVersion); // Do XSD validation on the document. xmldoc.Schemas = EscherAttributeContentValidator.GetInstance(documentSchemaVersion).EdmxSchemaSet; var svec = new SchemaValidationErrorCollector(); // remove runtime specific lines // find the ConceptualModel Schema node RemoveRunTimeNode(xmldoc, "/edmx:Edmx/edmx:Configurations", nsMgr); RemoveRunTimeNode(xmldoc, "/edmx:Edmx/edmx:Runtime/edmx:ConceptualModels", nsMgr); RemoveRunTimeNode(xmldoc, "/edmx:Edmx/edmx:Runtime/edmx:StorageModels", nsMgr); RemoveRunTimeNode(xmldoc, "/edmx:Edmx/edmx:Runtime/edmx:Mappings", nsMgr); xmldoc.Validate(svec.ValidationCallBack); return(svec.ErrorCount == 0); } } catch { } return(false); }
internal override AttributeContentValidator GetAttributeContentValidator(EFArtifact artifact) { return(EscherAttributeContentValidator.GetInstance(artifact.SchemaVersion)); }
internal override bool OnWizardFinish() { using (new VsUtils.HourglassHelper()) { UpdateSettingsFromGui(); } // // validate app config connection name // if (checkBoxSaveInAppConfig.Checked) { var id = textBoxAppConfigConnectionName.Text; if (!EscherAttributeContentValidator.IsValidCsdlEntityContainerName(id) || !_identifierUtil.IsValidIdentifier(id)) { VsUtils.ShowErrorDialog( string.Format(CultureInfo.CurrentCulture, Resources.ConnectionStringNonValidIdentifier, id)); textBoxAppConfigConnectionName.Focus(); _isFocusSet = true; return(false); } // only check that the connection string name is new if started in // 'PerformAllFunctionality' mode if (ModelBuilderWizardForm.WizardMode.PerformAllFunctionality == Wizard.Mode) { string connectionString; if (ConnectionManager.GetExistingConnectionStrings(_configFileUtils).TryGetValue(id, out connectionString) && !string.Equals(textBoxConnectionString.Text, connectionString, StringComparison.Ordinal)) { VsUtils.ShowErrorDialog( string.Format(CultureInfo.CurrentCulture, Resources.ConnectionStringDuplicateIdentifer, id)); textBoxAppConfigConnectionName.Focus(); _isFocusSet = true; return(false); } } } // the Model Namespace and the Entity Container name must differ if (ModelBuilderWizardForm.ModelNamespaceAndEntityContainerNameSame(Wizard.ModelBuilderSettings)) { var s = Resources.NamespaceAndEntityContainerSame; VsUtils.ShowErrorDialog( String.Format(CultureInfo.CurrentCulture, s, Wizard.ModelBuilderSettings.AppConfigConnectionPropertyName)); textBoxAppConfigConnectionName.Focus(); _isFocusSet = true; return(false); } try { // this might cause dataConnection to include some sensitive data into connectionString // the Open function also can cause DDEX to put up a prompt for the username/password for an existing connection // that does not have any saved password information. _dataConnection.Open(); if (!IsDataValid) { sensitiveInfoTextBox.Enabled = true; allowSensitiveInfoButton.Checked = false; allowSensitiveInfoButton.Enabled = true; disallowSensitiveInfoButton.Checked = false; disallowSensitiveInfoButton.Enabled = true; var result = VsUtils.ShowMessageBox( PackageManager.Package, Resources.SensitiveDataInfoText, OLEMSGBUTTON.OLEMSGBUTTON_YESNOCANCEL, OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_THIRD, OLEMSGICON.OLEMSGICON_QUERY); switch (result) { case DialogResult.Yes: allowSensitiveInfoButton.Checked = true; break; case DialogResult.No: disallowSensitiveInfoButton.Checked = true; break; default: Wizard.OnValidationStateChanged(this); return(false); } } } catch (DataConnectionOpenCanceledException) { return(false); } catch (Exception e) { // show error dialog ModelBuilderWizardForm.ShowDatabaseConnectionErrorDialog(e); return(false); } finally { if (_dataConnection.State != DataConnectionState.Closed) { _dataConnection.Close(); } } return(true); }
protected override void OnClosing(CancelEventArgs e) { base.OnClosing(e); if (_needsValidation) { _needsValidation = false; if (!EscherAttributeContentValidator.IsValidCsdlEntityTypeName(entityNameTextBox.Text)) { VsUtils.ShowErrorDialog(DialogsResource.NewEntityDialog_InvalidEntityNameMsg); e.Cancel = true; entityNameTextBox.Focus(); } else { string msg; if (!ModelHelper.IsUniqueName(typeof(EntityType), _model, entityNameTextBox.Text, false, out msg)) { VsUtils.ShowErrorDialog(DialogsResource.NewEntityDialog_EnsureUniqueNameMsg); e.Cancel = true; entityNameTextBox.Focus(); return; } if (entitySetTextBox.Enabled) { if (!EscherAttributeContentValidator.IsValidCsdlEntitySetName(EntitySetName)) { VsUtils.ShowErrorDialog(DialogsResource.NewEntityDialog_InvalidEntitySetMsg); e.Cancel = true; entitySetTextBox.Focus(); return; } if (!ModelHelper.IsUniqueName(typeof(EntitySet), _model.FirstEntityContainer, EntitySetName, false, out msg)) { VsUtils.ShowErrorDialog(DialogsResource.NewEntityDialog_EnsureUniqueSetNameMsg); e.Cancel = true; entitySetTextBox.Focus(); return; } } if (propertyNameTextBox.Enabled) { if (!EscherAttributeContentValidator.IsValidCsdlPropertyName(propertyNameTextBox.Text)) { VsUtils.ShowErrorDialog(DialogsResource.NewEntityDialog_InvalidKeyPropertyNameMsg); e.Cancel = true; propertyNameTextBox.Focus(); return; } else if (propertyNameTextBox.Text.Equals(EntityName, StringComparison.Ordinal)) { VsUtils.ShowErrorDialog(DialogsResource.SameEntityAndPropertyNameMsg); e.Cancel = true; propertyNameTextBox.Focus(); return; } } } } }