Exemple #1
0
        void fromKey_Removed(object sender, EventArgs e)
        {
            ModelMemberProperty modelMemberProperty = (ModelMemberProperty)sender;

            _keys.RemoveAll(k => k.Item1 == modelMemberProperty);
            RemoveKeyFrom(modelMemberProperty);
        }
Exemple #2
0
 internal void UpdateKeyName(ModelEntityType entityType, ModelMemberProperty memberProperty, string oldName, string newName)
 {
     try
     {
         if (entityType == FromEntitySet.EntityType)
         {
             foreach (XmlElement key in _associationElement.SelectNodes("edm:ReferentialConstraint/edm:Dependent/edm:PropertyRef[@Name=" + XmlHelpers.XPathLiteral(oldName) + "]", NSM))
             {
                 key.SetAttribute("Name", newName);
             }
         }
         else if (entityType == ToEntitySet.EntityType)
         {
             foreach (XmlElement key in _associationElement.SelectNodes("edm:ReferentialConstraint/edm:Principal/edm:PropertyRef[@Name=" + XmlHelpers.XPathLiteral(oldName) + "]", NSM))
             {
                 key.SetAttribute("Name", newName);
             }
         }
         else
         {
             throw new ArgumentException("The entity type " + entityType.Name + " does not participate in the association " + this.Name);
         }
     }
     catch (Exception ex)
     {
         try
         {
             ExceptionTools.AddExceptionData(ex, this);
         }
         catch { }
         throw;
     }
 }
Exemple #3
0
 /// <summary>
 /// Adds a scalar member to this entity type.
 /// </summary>
 /// <param name="name">Name of the new member property.</param>
 /// <param name="type">Type of the new member property.</param>
 /// <param name="nullable">Nullable; true or false.</param>
 /// <param name="ordinal">Ordinal position within the entity type.</param>
 /// <returns>A ModelMemberProperty object.</returns>
 public ModelMemberProperty AddMember(string name, Type type, bool nullable, int ordinal)
 {
     try
     {
         if (!MemberProperties.Where(mp => mp.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase)).Any() &&
             !NavigationProperties.Any(np => np.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase)) &&
             name != this.Name)
         {
             ModelMemberProperty mp = new ModelMemberProperty(base.ParentFile, this, name, ordinal, _entityTypeElement);
             mp.Type     = type;
             mp.Nullable = nullable;
             _memberProperties.Add(name, mp);
             mp.NameChanged += new EventHandler <NameChangeArgs>(prop_NameChanged);
             mp.Removed     += new EventHandler(prop_Removed);
             return(mp);
         }
         else
         {
             throw new ArgumentException("A property with the name " + name + " already exist in the type " + this.Name);
         }
     }
     catch (Exception ex)
     {
         try
         {
             ExceptionTools.AddExceptionData(ex, this);
         }
         catch { }
         throw;
     }
 }
Exemple #4
0
        void mmp_Removed(object sender, EventArgs e)
        {
            ModelMemberProperty modelMemberProperty = (ModelMemberProperty)sender;

            _memberMappings.RemoveAll(mmp => mmp.Item2 == modelMemberProperty);
            RemoveMemberMapping(modelMemberProperty);
        }
Exemple #5
0
        void toKey_Removed(object sender, EventArgs e)
        {
            ModelMemberProperty modelMemberProperty = (ModelMemberProperty)sender;

            _keys.RemoveAll(k => k.Item2 == modelMemberProperty);
            RemoveKeyTo(modelMemberProperty);
        }
Exemple #6
0
 /// <summary>
 /// Adds a new scalar member to the type
 /// </summary>
 /// <param name="name">Member name</param>
 /// <param name="type">Member type. Must be a EDM compatible CLR type.</param>
 /// <param name="nullable">Nullable or non-nullable?</param>
 /// <returns>A ModelMemberProperty object corresponding to the new member.</returns>
 public ModelMemberProperty AddMember(string name, Type type, bool nullable)
 {
     try
     {
         if (!MemberProperties.Where(mp => mp.Name == name).Any() &&
             name != this.Name)
         {
             ModelMemberProperty mp = new ModelMemberProperty(base.ParentFile, this, name, _complexTypeElement);
             mp.Type     = type;
             mp.Nullable = nullable;
             _memberProperties.Add(name, mp);
             mp.NameChanged += new EventHandler <NameChangeArgs>(prop_NameChanged);
             mp.Removed     += new EventHandler(prop_Removed);
             return(mp);
         }
         else
         {
             throw new ArgumentException("A property with the name " + name + " already exist in the type " + this.Name);
         }
     }
     catch (Exception ex)
     {
         try
         {
             ExceptionTools.AddExceptionData(ex, this);
         }
         catch { }
         throw;
     }
 }
 internal CSDLType(ModelMemberProperty modelMemberProperty)
 {
     this.Name = modelMemberProperty.Name;
     this.CLRTypeName = modelMemberProperty.TypeName;
     this.MaxLength = modelMemberProperty.MaxLength;
     this.Nullable = modelMemberProperty.Nullable;
     this.Precision = modelMemberProperty.Precision;
     this.Scale = modelMemberProperty.Scale;
     this.FixedLength = modelMemberProperty.FixedLength;
     this.IsUnicode = modelMemberProperty.IsUnicode;
     this.CompareIsUnicode = true;
 }
Exemple #8
0
 internal CSDLType(ModelMemberProperty modelMemberProperty)
 {
     this.Name             = modelMemberProperty.Name;
     this.CLRTypeName      = modelMemberProperty.TypeName;
     this.MaxLength        = modelMemberProperty.MaxLength;
     this.Nullable         = modelMemberProperty.Nullable;
     this.Precision        = modelMemberProperty.Precision;
     this.Scale            = modelMemberProperty.Scale;
     this.FixedLength      = modelMemberProperty.FixedLength;
     this.IsUnicode        = modelMemberProperty.IsUnicode;
     this.CompareIsUnicode = true;
 }
Exemple #9
0
 /// <summary>
 /// Removes a key pair based on the dependent key member
 /// </summary>
 /// <param name="modelMemberProperty">Dependent key member</param>
 public void RemoveKeyFrom(ModelMemberProperty modelMemberProperty)
 {
     try
     {
         foreach (Tuple <ModelMemberProperty, ModelMemberProperty> key in Keys.Where(k => k.Item1 == modelMemberProperty))
         {
             RemoveKey(key);
         }
     }
     catch (Exception ex)
     {
         try
         {
             ExceptionTools.AddExceptionData(ex, this);
         }
         catch { }
         throw;
     }
 }
Exemple #10
0
        /// <summary>
        /// Removes all scalar member mappings for a specific conceptual model member.
        /// </summary>
        /// <param name="modelMemberProperty">Conceptual model member to remove mappings for.</param>
        public void RemoveMemberMapping(ModelMemberProperty modelMemberProperty)
        {
            _memberMappings.RemoveAll(mm => mm.Item2 == modelMemberProperty);

            foreach (XmlElement scalarProperty in _esmElement.SelectNodes("map:EntityTypeMapping/map:MappingFragment//map:ScalarProperty[@Name=" + XmlHelpers.XPathLiteral(modelMemberProperty.Name) + "]", NSM))
            {
                XmlNode parentNode = scalarProperty.ParentNode;
                if (parentNode != null)
                {
                    parentNode.RemoveChild(scalarProperty);

                    //if this was the last child node, remove the wrapper
                    if (!parentNode.HasChildNodes)
                    {
                        parentNode.ParentNode.RemoveChild(parentNode);
                    }
                }
            }
        }
Exemple #11
0
 /// <summary>
 /// Retrieves a scalar member in this entity type, or creates it if not found
 /// </summary>
 /// <param name="name">Name of the member property.</param>
 /// <param name="type">Type of the new member property.</param>
 /// <param name="nullable">Nullable; true or false.</param>
 /// <param name="ordinal">Ordinal position within the entity type.</param>
 /// <returns>A ModelMemberProperty object.</returns>
 public ModelMemberProperty GetOrCreateMember(string name, Type type, bool nullable, int ordinal)
 {
     try
     {
         ModelMemberProperty modelMemberProperty = MemberProperties.FirstOrDefault(mp => mp.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase));
         if (modelMemberProperty == null)
         {
             modelMemberProperty = AddMember(name, type, nullable, ordinal);
         }
         return(modelMemberProperty);
     }
     catch (Exception ex)
     {
         try
         {
             ExceptionTools.AddExceptionData(ex, this);
         }
         catch { }
         throw;
     }
 }
Exemple #12
0
        /// <summary>
        /// Adds a key pair to the association. This should involve a member in the principal entity type and the corresponding member in the dependent entity type
        /// </summary>
        /// <param name="fromKey">A member of the principal entity type</param>
        /// <param name="toKey">A member of the dependent entity type</param>
        /// <returns></returns>
        public Tuple <ModelMemberProperty, ModelMemberProperty> AddKey(ModelMemberProperty fromKey, ModelMemberProperty toKey)
        {
            if (fromKey == null)
            {
                throw new ArgumentNullException("fromKey");
            }
            if (toKey == null)
            {
                throw new ArgumentNullException("toKey");
            }

            Tuple <ModelMemberProperty, ModelMemberProperty> newKey = new Tuple <ModelMemberProperty, ModelMemberProperty>(fromKey, toKey);

            fromKey.Removed += new EventHandler(fromKey_Removed);
            toKey.Removed   += new EventHandler(toKey_Removed);

            _keys.Add(newKey);

            XmlElement fromKeyContainer = (XmlElement)_associationElement.SelectSingleNode("edm:ReferentialConstraint/edm:Dependent", NSM);

            if (fromKeyContainer != null)
            {
                XmlElement fromKeyElement = EDMXDocument.CreateElement("PropertyRef", NameSpaceURIcsdl);
                fromKeyElement.SetAttribute("Name", fromKey.Name);
                fromKeyContainer.AppendChild(fromKeyElement);
            }

            XmlElement toKeyContainer = (XmlElement)_associationElement.SelectSingleNode("edm:ReferentialConstraint/edm:Principal", NSM);

            if (toKeyContainer != null)
            {
                XmlElement toKeyElement = EDMXDocument.CreateElement("PropertyRef", NameSpaceURIcsdl);
                toKeyElement.SetAttribute("Name", toKey.Name);
                toKeyContainer.AppendChild(toKeyElement);
            }

            return(newKey);
        }
Exemple #13
0
        /// <summary>
        /// Adds a complex type mapping
        /// </summary>
        /// <param name="complexTypeReference">Model member property referencing the complex type property</param>
        /// <param name="memberProperty">Model member property</param>
        /// <param name="storeMemberProperty">Store member property</param>
        public void AddComplexMapping(ModelMemberProperty complexTypeReference, ModelMemberProperty memberProperty, StoreMemberProperty storeMemberProperty)
        {
            //find the appropriate mapping fragment
            string storeEntitySetName = storeMemberProperty.EntityType.EntitySet.Name;

            foreach (XmlElement mappingFragment in _esmElement.SelectNodes("map:EntityTypeMapping/map:MappingFragment[@StoreEntitySet=" + XmlHelpers.XPathLiteral(storeEntitySetName) + "]", NSM))
            {
                if (mappingFragment != null)
                {
                    XmlElement complexProperty = (XmlElement)mappingFragment.SelectSingleNode("map:ComplexProperty[@Name=" + XmlHelpers.XPathLiteral(complexTypeReference.Name) + "]", NSM);
                    if (complexProperty == null)
                    {
                        complexProperty = EDMXDocument.CreateElement("ComplexProperty", NameSpaceURImap);
                        complexProperty.SetAttribute("Name", complexTypeReference.Name);
                        complexProperty.SetAttribute("TypeName", complexTypeReference.TypeName);
                        mappingFragment.AppendChild(complexProperty);
                    }

                    string          entityTypeName = EDMXUtils.StripTypeOf(((XmlElement)mappingFragment.ParentNode).GetAttribute("TypeName"));
                    ModelEntityType entityType     = ParentFile.ConceptualModel.EntityTypes.FirstOrDefault(et => et.FullName == entityTypeName || et.AliasName == entityTypeName);

                    XmlElement scalarProperty = EDMXDocument.CreateElement("ScalarProperty", NameSpaceURImap);
                    scalarProperty.SetAttribute("Name", memberProperty.Name);
                    scalarProperty.SetAttribute("ColumnName", storeMemberProperty.Name);
                    complexProperty.AppendChild(scalarProperty);

                    _memberMappings.Add(new Tuple <StoreMemberProperty, ModelMemberProperty, ModelEntityType>(storeMemberProperty, memberProperty, entityType));

                    storeMemberProperty.Removed += new EventHandler(smp_Removed);
                    memberProperty.Removed      += new EventHandler(mmp_Removed);
                }
                else
                {
                    throw new ArgumentException("The store entity set " + storeEntitySetName + " is not associated with the model entity set " + this.ModelEntitySet.Name);
                }
            }
        }
Exemple #14
0
        private void EnumerateKeys()
        {
            try
            {
                //get hold of key propertyrefs
                XmlNodeList fromKeys = _associationElement.SelectNodes("edm:ReferentialConstraint/edm:Dependent/edm:PropertyRef", NSM);
                XmlNodeList toKeys   = _associationElement.SelectNodes("edm:ReferentialConstraint/edm:Principal/edm:PropertyRef", NSM);

                //number of keys?
                int keyCount = Math.Max(fromKeys.Count, toKeys.Count);
                int keyNo    = 0;
                while (keyNo < keyCount)
                {
                    //get the from entity type member
                    ModelMemberProperty fromKey = null;
                    if (fromKeys.Count > keyNo)
                    {
                        XmlElement fromElement = (XmlElement)fromKeys[keyNo];
                        if (fromElement != null)
                        {
                            string fromName = fromElement.GetAttribute("Name");
                            fromKey = FromEntitySet.EntityType.MemberProperties.FirstOrDefault(mp => mp.Name == fromName);
                            if (fromKey == null && FromEntitySet.EntityType.HasSubTypes)
                            {
                                //check if it is a subtype member
                                fromKey = FromEntitySet.EntityType.SubTypes.SelectMany(t => t.MemberProperties).FirstOrDefault(mp => mp.Name == fromName);
                            }
                        }
                    }

                    //get the to entity type member
                    ModelMemberProperty toKey = null;
                    if (toKeys.Count > keyNo)
                    {
                        XmlElement toElement = (XmlElement)toKeys[keyNo];
                        if (toElement != null)
                        {
                            string toName = toElement.GetAttribute("Name");
                            toKey = ToEntitySet.EntityType.MemberProperties.FirstOrDefault(mp => mp.Name == toName);
                            if (toKey == null && ToEntitySet.EntityType.HasSubTypes)
                            {
                                //check if it is a subtype member
                                toKey = ToEntitySet.EntityType.SubTypes.SelectMany(t => t.MemberProperties).FirstOrDefault(mp => mp.Name == toName);
                            }
                        }
                    }

                    Tuple <ModelMemberProperty, ModelMemberProperty> key = null;
                    if (!_keys.Any(k => k.Item1.Equals(fromKey) && k.Item2.Equals(toKey)))
                    {
                        key = new Tuple <ModelMemberProperty, ModelMemberProperty>(fromKey, toKey);
                        _keys.Add(key);
                    }
                    else
                    {
                        key = _keys.FirstOrDefault(k => k.Item1.Equals(fromKey) && k.Item2.Equals(toKey));
                    }

                    if (fromKey != null)
                    {
                        fromKey.Removed += new EventHandler(fromKey_Removed);
                    }
                    if (toKey != null)
                    {
                        toKey.Removed += new EventHandler(toKey_Removed);
                    }

                    keyNo++;
                }

                _keysEnumerated = true;
            }
            catch (Exception ex)
            {
                try
                {
                    ExceptionTools.AddExceptionData(ex, this);
                }
                catch { }
                throw;
            }
        }
        /// <summary>
        /// Removes all scalar member mappings for a specific conceptual model member.
        /// </summary>
        /// <param name="modelMemberProperty">Conceptual model member to remove mappings for.</param>
        public void RemoveMemberMapping(ModelMemberProperty modelMemberProperty)
        {
            _memberMappings.RemoveAll(mm => mm.Item2 == modelMemberProperty);

            foreach (XmlElement scalarProperty in _esmElement.SelectNodes("map:EntityTypeMapping/map:MappingFragment//map:ScalarProperty[@Name=" + XmlHelpers.XPathLiteral(modelMemberProperty.Name) + "]", NSM))
            {
                XmlNode parentNode = scalarProperty.ParentNode;
                if (parentNode != null)
                {
                    parentNode.RemoveChild(scalarProperty);

                    //if this was the last child node, remove the wrapper
                    if (!parentNode.HasChildNodes)
                    {
                        parentNode.ParentNode.RemoveChild(parentNode);
                    }
                }
            }
        }
        /// <summary>
        /// Adds a member mapping from a conceptual model scalar member to a storage model scalar member, with a entity type specified
        /// </summary>
        /// <param name="modelMemberProperty">Conceptual model scalar member to map</param>
        /// <param name="storeMemberProperty">Storage model scalar member to map to</param>
        /// <param name="modelEntityType">Model entity type to specify in the EntityTypeMapping for this member mapping.</param>
        public void AddMemberMapping(ModelMemberProperty modelMemberProperty, StoreMemberProperty storeMemberProperty, ModelEntityType modelEntityType)
        {
            if (modelEntityType != _modelEntitySet.EntityType && !modelEntityType.IsSubtypeOf(_modelEntitySet.EntityType))
            {
                throw new ArgumentException("The model member does not belong to the mapped entity type or a subclass of the mapped entity type.");
            }

            if (storeMemberProperty.EntityType.EntitySet != null)
            {
                //find the appropriate mapping fragment
                string storeEntitySetName = storeMemberProperty.EntityType.EntitySet.Name;

                //get hold of the type mapping
                XmlElement entityTypeMapping = (XmlElement)_esmElement.SelectSingleNode("map:EntityTypeMapping[@TypeName=" + XmlHelpers.XPathLiteral(modelEntityType.FullName) + " or @TypeName=" + XmlHelpers.XPathLiteral("IsTypeOf(" + modelEntityType.FullName + ")") + " or @TypeName=" + XmlHelpers.XPathLiteral(modelEntityType.AliasName) + " or @TypeName=" + XmlHelpers.XPathLiteral("IsTypeOf(" + modelEntityType.AliasName + ")") + "]", NSM);
                if (entityTypeMapping == null)
                {
                    //not found - create
                    entityTypeMapping = EDMXDocument.CreateElement("EntityTypeMapping", NameSpaceURImap);
                    _esmElement.AppendChild(entityTypeMapping);

                    entityTypeMapping.SetAttribute("TypeName", modelEntityType.FullName);
                }

                XmlElement mappingFragment = (XmlElement)entityTypeMapping.SelectSingleNode("map:MappingFragment[@StoreEntitySet=" + XmlHelpers.XPathLiteral(storeEntitySetName) + "]", NSM);
                if (mappingFragment == null)
                {
                    mappingFragment = EDMXDocument.CreateElement("MappingFragment", NameSpaceURImap);
                    entityTypeMapping.AppendChild(mappingFragment);

                    mappingFragment.SetAttribute("StoreEntitySet", storeEntitySetName);

                    if (_storeEntitySetsEnumerated == true)
                    {
                        StoreEntitySet storeEntitySet = _csMapping.ParentFile.StorageModel.EntitySets.FirstOrDefault(es => es.Name.Equals(storeEntitySetName, StringComparison.InvariantCultureIgnoreCase));
                        if (storeEntitySet != null)
                        {
                            storeEntitySet.Removed += new EventHandler(storeEntitySet_Removed);
                            _storeEntitySets.Add(storeEntitySet);
                        }
                    }
                }

                if (mappingFragment != null)
                {
                    if (mappingFragment.SelectSingleNode("map:ScalarProperty[@Name=" + XmlHelpers.XPathLiteral(modelMemberProperty.Name) + "][@ColumnName=" + XmlHelpers.XPathLiteral(storeMemberProperty.Name) + "]", NSM) == null)
                    {
                        XmlElement scalarProperty = EDMXDocument.CreateElement("ScalarProperty", NameSpaceURImap);
                        scalarProperty.SetAttribute("Name", modelMemberProperty.Name);
                        scalarProperty.SetAttribute("ColumnName", storeMemberProperty.Name);
                        mappingFragment.AppendChild(scalarProperty);

                        _memberMappings.Add(new Tuple<StoreMemberProperty, ModelMemberProperty, ModelEntityType>(storeMemberProperty, modelMemberProperty, modelEntityType));

                        storeMemberProperty.Removed += new EventHandler(smp_Removed);
                        modelMemberProperty.Removed += new EventHandler(mmp_Removed);

                        storeMemberProperty.CSMappingsUpdated();
                        modelMemberProperty.CSMappingsUpdated();
                    }
                    else
                    {
                        System.Diagnostics.Debug.Assert(false);
                    }
                }
                else
                {
                    throw new ArgumentException("The store entity set " + storeEntitySetName + " is not associated with the model entity set " + this.ModelEntitySet.Name);
                }
            }
            else
            {
                throw new InvalidOperationException("The store entity type " + (storeMemberProperty.EntityType != null ? storeMemberProperty.EntityType.Name : "[unknown]") + " is not associated with an entity set.");
            }
        }
 /// <summary>
 /// Adds a member mapping from a conceptual model scalar member to a storage model scalar member.
 /// </summary>
 /// <param name="modelMemberProperty">Conceptual model scalar member to map</param>
 /// <param name="storeMemberProperty">Storage model scalar member to map to</param>
 public void AddMemberMapping(ModelMemberProperty modelMemberProperty, StoreMemberProperty storeMemberProperty)
 {
     AddMemberMapping(modelMemberProperty, storeMemberProperty, modelMemberProperty.EntityType);
 }
        /// <summary>
        /// Adds a complex type mapping
        /// </summary>
        /// <param name="complexTypeReference">Model member property referencing the complex type property</param>
        /// <param name="memberProperty">Model member property</param>
        /// <param name="storeMemberProperty">Store member property</param>
        public void AddComplexMapping(ModelMemberProperty complexTypeReference, ModelMemberProperty memberProperty, StoreMemberProperty storeMemberProperty)
        {
            //find the appropriate mapping fragment
            string storeEntitySetName = storeMemberProperty.EntityType.EntitySet.Name;
            foreach (XmlElement mappingFragment in _esmElement.SelectNodes("map:EntityTypeMapping/map:MappingFragment[@StoreEntitySet=" + XmlHelpers.XPathLiteral(storeEntitySetName) + "]", NSM))
            {
                if (mappingFragment != null)
                {
                    XmlElement complexProperty = (XmlElement)mappingFragment.SelectSingleNode("map:ComplexProperty[@Name=" + XmlHelpers.XPathLiteral(complexTypeReference.Name) + "]", NSM);
                    if (complexProperty == null)
                    {
                        complexProperty = EDMXDocument.CreateElement("ComplexProperty", NameSpaceURImap);
                        complexProperty.SetAttribute("Name", complexTypeReference.Name);
                        complexProperty.SetAttribute("TypeName", complexTypeReference.TypeName);
                        mappingFragment.AppendChild(complexProperty);
                    }

                    string entityTypeName = EDMXUtils.StripTypeOf(((XmlElement)mappingFragment.ParentNode).GetAttribute("TypeName"));
                    ModelEntityType entityType = ParentFile.ConceptualModel.EntityTypes.FirstOrDefault(et => et.FullName == entityTypeName || et.AliasName == entityTypeName);

                    XmlElement scalarProperty = EDMXDocument.CreateElement("ScalarProperty", NameSpaceURImap);
                    scalarProperty.SetAttribute("Name", memberProperty.Name);
                    scalarProperty.SetAttribute("ColumnName", storeMemberProperty.Name);
                    complexProperty.AppendChild(scalarProperty);

                    _memberMappings.Add(new Tuple<StoreMemberProperty, ModelMemberProperty, ModelEntityType>(storeMemberProperty, memberProperty, entityType));

                    storeMemberProperty.Removed += new EventHandler(smp_Removed);
                    memberProperty.Removed += new EventHandler(mmp_Removed);
                }
                else
                {
                    throw new ArgumentException("The store entity set " + storeEntitySetName + " is not associated with the model entity set " + this.ModelEntitySet.Name);
                }
            }
        }
 /// <summary>
 /// Removes a key pair based on the dependent key member
 /// </summary>
 /// <param name="modelMemberProperty">Dependent key member</param>
 public void RemoveKeyFrom(ModelMemberProperty modelMemberProperty)
 {
     try
     {
         foreach (Tuple<ModelMemberProperty, ModelMemberProperty> key in Keys.Where(k => k.Item1 == modelMemberProperty))
         {
             RemoveKey(key);
         }
     }
     catch (Exception ex)
     {
         try
         {
             ExceptionTools.AddExceptionData(ex, this);
         }
         catch { }
         throw;
     }
 }
Exemple #20
0
        private void EnumerateMemberMappings()
        {
            foreach (XmlElement sp in _esmElement.SelectNodes("map:EntityTypeMapping/map:MappingFragment/map:ScalarProperty", NSM))
            {
                string modelPropertyName = sp.GetAttribute("Name");
                string entityTypeName    = EDMXUtils.StripTypeOf(((XmlElement)sp.ParentNode.ParentNode).GetAttribute("TypeName"));

                ModelEntityType     entityType = ParentFile.ConceptualModel.EntityTypes.FirstOrDefault(et => et.FullName == entityTypeName || et.AliasName == entityTypeName);
                ModelMemberProperty mmp        = entityType.MemberProperties.FirstOrDefault(mp => mp.Name == modelPropertyName);

                if (mmp != null)
                {
                    string         storeEntitySetName = ((XmlElement)sp.ParentNode).GetAttribute("StoreEntitySet");
                    StoreEntitySet ses = ParentFile.StorageModel.EntitySets.FirstOrDefault(es => es.Name.Equals(storeEntitySetName, StringComparison.InvariantCultureIgnoreCase));

                    if (ses != null)
                    {
                        string storePropertyName = sp.GetAttribute("ColumnName");
                        StoreMemberProperty smp  = ses.EntityType.MemberProperties.FirstOrDefault(mp => mp.Name.Equals(storePropertyName, StringComparison.InvariantCultureIgnoreCase));

                        if (smp != null)
                        {
                            _memberMappings.Add(new Tuple <StoreMemberProperty, ModelMemberProperty, ModelEntityType>(smp, mmp, entityType));

                            smp.Removed += new EventHandler(smp_Removed);
                            mmp.Removed += new EventHandler(mmp_Removed);
                        }
                    }
                }
            }
            foreach (XmlElement sp in _esmElement.SelectNodes("map:EntityTypeMapping/map:MappingFragment/map:ComplexProperty/map:ScalarProperty", NSM))
            {
                string modelPropertyName = sp.GetAttribute("Name");

                string           complexTypeName = EDMXUtils.StripTypeOf(((XmlElement)sp.ParentNode).GetAttribute("TypeName"));
                ModelComplexType complexType     = ParentFile.ConceptualModel.ComplexTypes.FirstOrDefault(ct => ct.FullName == complexTypeName || ct.AliasName == complexTypeName);

                string          entityTypeName = EDMXUtils.StripTypeOf(((XmlElement)sp.ParentNode.ParentNode.ParentNode).GetAttribute("TypeName"));
                ModelEntityType entityType     = ParentFile.ConceptualModel.EntityTypes.FirstOrDefault(et => et.FullName == entityTypeName || et.AliasName == entityTypeName);

                ModelMemberProperty mmp = null;
                if (complexType != null)
                {
                    mmp = complexType.MemberProperties.FirstOrDefault(mp => mp.Name == modelPropertyName);

                    if (mmp != null)
                    {
                        string         storeEntitySetName = ((XmlElement)sp.ParentNode.ParentNode).GetAttribute("StoreEntitySet");
                        StoreEntitySet ses = ParentFile.StorageModel.EntitySets.FirstOrDefault(es => es.Name.Equals(storeEntitySetName, StringComparison.InvariantCultureIgnoreCase));

                        if (ses != null)
                        {
                            string storePropertyName = sp.GetAttribute("ColumnName");
                            StoreMemberProperty smp  = ses.EntityType.MemberProperties.FirstOrDefault(mp => mp.Name.Equals(storePropertyName, StringComparison.InvariantCultureIgnoreCase));

                            if (smp != null)
                            {
                                _memberMappings.Add(new Tuple <StoreMemberProperty, ModelMemberProperty, ModelEntityType>(smp, mmp, entityType));

                                smp.Removed += new EventHandler(smp_Removed);
                                mmp.Removed += new EventHandler(mmp_Removed);
                            }
                        }
                    }
                }
            }
            _memberMappingsEnumerated = true;
        }
Exemple #21
0
        /// <summary>
        /// Adds a member mapping from a conceptual model scalar member to a storage model scalar member, with a entity type specified
        /// </summary>
        /// <param name="modelMemberProperty">Conceptual model scalar member to map</param>
        /// <param name="storeMemberProperty">Storage model scalar member to map to</param>
        /// <param name="modelEntityType">Model entity type to specify in the EntityTypeMapping for this member mapping.</param>
        public void AddMemberMapping(ModelMemberProperty modelMemberProperty, StoreMemberProperty storeMemberProperty, ModelEntityType modelEntityType)
        {
            if (modelEntityType != _modelEntitySet.EntityType && !modelEntityType.IsSubtypeOf(_modelEntitySet.EntityType))
            {
                throw new ArgumentException("The model member does not belong to the mapped entity type or a subclass of the mapped entity type.");
            }

            if (storeMemberProperty.EntityType.EntitySet != null)
            {
                //find the appropriate mapping fragment
                string storeEntitySetName = storeMemberProperty.EntityType.EntitySet.Name;

                //get hold of the type mapping
                XmlElement entityTypeMapping = (XmlElement)_esmElement.SelectSingleNode("map:EntityTypeMapping[@TypeName=" + XmlHelpers.XPathLiteral(modelEntityType.FullName) + " or @TypeName=" + XmlHelpers.XPathLiteral("IsTypeOf(" + modelEntityType.FullName + ")") + " or @TypeName=" + XmlHelpers.XPathLiteral(modelEntityType.AliasName) + " or @TypeName=" + XmlHelpers.XPathLiteral("IsTypeOf(" + modelEntityType.AliasName + ")") + "]", NSM);
                if (entityTypeMapping == null)
                {
                    //not found - create
                    entityTypeMapping = EDMXDocument.CreateElement("EntityTypeMapping", NameSpaceURImap);
                    _esmElement.AppendChild(entityTypeMapping);

                    entityTypeMapping.SetAttribute("TypeName", modelEntityType.FullName);
                }

                XmlElement mappingFragment = (XmlElement)entityTypeMapping.SelectSingleNode("map:MappingFragment[@StoreEntitySet=" + XmlHelpers.XPathLiteral(storeEntitySetName) + "]", NSM);
                if (mappingFragment == null)
                {
                    mappingFragment = EDMXDocument.CreateElement("MappingFragment", NameSpaceURImap);
                    entityTypeMapping.AppendChild(mappingFragment);

                    mappingFragment.SetAttribute("StoreEntitySet", storeEntitySetName);

                    if (_storeEntitySetsEnumerated == true)
                    {
                        StoreEntitySet storeEntitySet = _csMapping.ParentFile.StorageModel.EntitySets.FirstOrDefault(es => es.Name.Equals(storeEntitySetName, StringComparison.InvariantCultureIgnoreCase));
                        if (storeEntitySet != null)
                        {
                            storeEntitySet.Removed += new EventHandler(storeEntitySet_Removed);
                            _storeEntitySets.Add(storeEntitySet);
                        }
                    }
                }

                if (mappingFragment != null)
                {
                    if (mappingFragment.SelectSingleNode("map:ScalarProperty[@Name=" + XmlHelpers.XPathLiteral(modelMemberProperty.Name) + "][@ColumnName=" + XmlHelpers.XPathLiteral(storeMemberProperty.Name) + "]", NSM) == null)
                    {
                        XmlElement scalarProperty = EDMXDocument.CreateElement("ScalarProperty", NameSpaceURImap);
                        scalarProperty.SetAttribute("Name", modelMemberProperty.Name);
                        scalarProperty.SetAttribute("ColumnName", storeMemberProperty.Name);
                        mappingFragment.AppendChild(scalarProperty);

                        _memberMappings.Add(new Tuple <StoreMemberProperty, ModelMemberProperty, ModelEntityType>(storeMemberProperty, modelMemberProperty, modelEntityType));

                        storeMemberProperty.Removed += new EventHandler(smp_Removed);
                        modelMemberProperty.Removed += new EventHandler(mmp_Removed);

                        storeMemberProperty.CSMappingsUpdated();
                        modelMemberProperty.CSMappingsUpdated();
                    }
                    else
                    {
                        System.Diagnostics.Debug.Assert(false);
                    }
                }
                else
                {
                    throw new ArgumentException("The store entity set " + storeEntitySetName + " is not associated with the model entity set " + this.ModelEntitySet.Name);
                }
            }
            else
            {
                throw new InvalidOperationException("The store entity type " + (storeMemberProperty.EntityType != null ? storeMemberProperty.EntityType.Name : "[unknown]") + " is not associated with an entity set.");
            }
        }
        /// <summary>
        /// Adds a key pair to the association. This should involve a member in the principal entity type and the corresponding member in the dependent entity type
        /// </summary>
        /// <param name="fromKey">A member of the principal entity type</param>
        /// <param name="toKey">A member of the dependent entity type</param>
        /// <returns></returns>
        public Tuple<ModelMemberProperty, ModelMemberProperty> AddKey(ModelMemberProperty fromKey, ModelMemberProperty toKey)
        {
            if (fromKey == null) { throw new ArgumentNullException("fromKey"); }
            if (toKey == null) { throw new ArgumentNullException("toKey"); }

            Tuple<ModelMemberProperty, ModelMemberProperty> newKey = new Tuple<ModelMemberProperty, ModelMemberProperty>(fromKey, toKey);

            fromKey.Removed += new EventHandler(fromKey_Removed);
            toKey.Removed += new EventHandler(toKey_Removed);

            _keys.Add(newKey);

            XmlElement fromKeyContainer = (XmlElement)_associationElement.SelectSingleNode("edm:ReferentialConstraint/edm:Dependent", NSM);
            if (fromKeyContainer != null)
            {
                XmlElement fromKeyElement = EDMXDocument.CreateElement("PropertyRef", NameSpaceURIcsdl);
                fromKeyElement.SetAttribute("Name", fromKey.Name);
                fromKeyContainer.AppendChild(fromKeyElement);
            }

            XmlElement toKeyContainer = (XmlElement)_associationElement.SelectSingleNode("edm:ReferentialConstraint/edm:Principal", NSM);
            if (toKeyContainer != null)
            {
                XmlElement toKeyElement = EDMXDocument.CreateElement("PropertyRef", NameSpaceURIcsdl);
                toKeyElement.SetAttribute("Name", toKey.Name);
                toKeyContainer.AppendChild(toKeyElement);
            }

            return newKey;
        }
 /// <summary>
 /// Adds a new scalar member to the type
 /// </summary>
 /// <param name="name">Member name</param>
 /// <param name="type">Member type. Must be a EDM compatible CLR type.</param>
 /// <param name="nullable">Nullable or non-nullable?</param>
 /// <returns>A ModelMemberProperty object corresponding to the new member.</returns>
 public ModelMemberProperty AddMember(string name, Type type, bool nullable)
 {
     try
     {
         if (!MemberProperties.Where(mp => mp.Name == name).Any()
             && name != this.Name)
         {
             ModelMemberProperty mp = new ModelMemberProperty(base.ParentFile, this, name, _complexTypeElement);
             mp.Type = type;
             mp.Nullable = nullable;
             _memberProperties.Add(name, mp);
             mp.NameChanged += new EventHandler<NameChangeArgs>(prop_NameChanged);
             mp.Removed += new EventHandler(prop_Removed);
             return mp;
         }
         else
         {
             throw new ArgumentException("A property with the name " + name + " already exist in the type " + this.Name);
         }
     }
     catch (Exception ex)
     {
         try
         {
             ExceptionTools.AddExceptionData(ex, this);
         }
         catch { }
         throw;
     }
 }
 /// <summary>
 /// Adds a scalar member to this entity type.
 /// </summary>
 /// <param name="name">Name of the new member property.</param>
 /// <param name="type">Type of the new member property.</param>
 /// <param name="nullable">Nullable; true or false.</param>
 /// <param name="ordinal">Ordinal position within the entity type.</param>
 /// <returns>A ModelMemberProperty object.</returns>
 public ModelMemberProperty AddMember(string name, Type type, bool nullable, int ordinal)
 {
     try
     {
         if (!MemberProperties.Where(mp => mp.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase)).Any()
             && !NavigationProperties.Any(np => np.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase))
             && name != this.Name)
         {
             ModelMemberProperty mp = new ModelMemberProperty(base.ParentFile, this, name, ordinal, _entityTypeElement);
             mp.Type = type;
             mp.Nullable = nullable;
             _memberProperties.Add(name, mp);
             mp.NameChanged += new EventHandler<NameChangeArgs>(prop_NameChanged);
             mp.Removed += new EventHandler(prop_Removed);
             return mp;
         }
         else
         {
             throw new ArgumentException("A property with the name " + name + " already exist in the type " + this.Name);
         }
     }
     catch (Exception ex)
     {
         try
         {
             ExceptionTools.AddExceptionData(ex, this);
         }
         catch { }
         throw;
     }
 }
Exemple #25
0
 /// <summary>
 /// Adds a member mapping from a conceptual model scalar member to a storage model scalar member.
 /// </summary>
 /// <param name="modelMemberProperty">Conceptual model scalar member to map</param>
 /// <param name="storeMemberProperty">Storage model scalar member to map to</param>
 public void AddMemberMapping(ModelMemberProperty modelMemberProperty, StoreMemberProperty storeMemberProperty)
 {
     AddMemberMapping(modelMemberProperty, storeMemberProperty, modelMemberProperty.EntityType);
 }
 internal void UpdateKeyName(ModelEntityType entityType, ModelMemberProperty memberProperty, string oldName, string newName)
 {
     try
     {
         if (entityType == FromEntitySet.EntityType)
         {
             foreach (XmlElement key in _associationElement.SelectNodes("edm:ReferentialConstraint/edm:Dependent/edm:PropertyRef[@Name=" + XmlHelpers.XPathLiteral(oldName) + "]", NSM))
             {
                 key.SetAttribute("Name", newName);
             }
         }
         else if (entityType == ToEntitySet.EntityType)
         {
             foreach (XmlElement key in _associationElement.SelectNodes("edm:ReferentialConstraint/edm:Principal/edm:PropertyRef[@Name=" + XmlHelpers.XPathLiteral(oldName) + "]", NSM))
             {
                 key.SetAttribute("Name", newName);
             }
         }
         else
         {
             throw new ArgumentException("The entity type " + entityType.Name + " does not participate in the association " + this.Name);
         }
     }
     catch (Exception ex)
     {
         try
         {
             ExceptionTools.AddExceptionData(ex, this);
         }
         catch { }
         throw;
     }
 }