mcs/class/referencesource/System.Data.Entity.Design/System/Data/EntityModel/Emitters/NavigationPropertyEmitter.cs

   1 //---------------------------------------------------------------------
   2 // <copyright file="NavigationPropertyEmitter.cs" company="Microsoft">
   3 //      Copyright (c) Microsoft Corporation.  All rights reserved.
   4 // </copyright>
   5 //
   6 // @owner       Microsoft
   7 // @backupOwner Microsoft
   8 //---------------------------------------------------------------------
   9
  10 using System;
  11 using System.CodeDom;
  12 using System.Data;
  13 using System.Collections.Generic;
  14 using System.Data.Entity.Design;
  15 using Som=System.Data.EntityModel.SchemaObjectModel;
  16 using System.Data.Metadata.Edm;
  17 using System.Diagnostics;
  18 using System.Data.Entity.Design.SsdlGenerator;
  19 using System.Data.Entity.Design.Common;
  20
  21
  22 namespace System.Data.EntityModel.Emitters
  23 {
  24     /// <summary>
  25     /// Summary description for NavigationPropertyEmitter.
  26     /// </summary>
  27     internal sealed class NavigationPropertyEmitter : PropertyEmitterBase
  28     {
  29         private const string ValuePropertyName = "Value";
  30
  31         /// <summary>
  32         ///
  33         /// </summary>
  34         /// <param name="generator"></param>
  35         /// <param name="navigationProperty"></param>
  36         public NavigationPropertyEmitter(ClientApiGenerator generator, NavigationProperty navigationProperty, bool declaringTypeUsesStandardBaseType)
  37             : base(generator, navigationProperty, declaringTypeUsesStandardBaseType)
  38         {
  39         }
  40
  41         /// <summary>
  42         /// Generate the navigation property
  43         /// </summary>
  44         /// <param name="typeDecl">The type to add the property to.</param>
  45         protected override void EmitProperty(CodeTypeDeclaration typeDecl)
  46         {
  47             EmitNavigationProperty(typeDecl);
  48         }
  49
  50         /// <summary>
  51         /// Generate the navigation property specified
  52         /// </summary>
  53         /// <param name="typeDecl">The type to add the property to.</param>
  54         private void EmitNavigationProperty( CodeTypeDeclaration typeDecl )
  55         {
  56             // create a regular property
  57             CodeMemberProperty property = EmitNavigationProperty(Item.ToEndMember, false);
  58             typeDecl.Members.Add(property);
  59
  60             if (Item.ToEndMember.RelationshipMultiplicity != RelationshipMultiplicity.Many)
  61             {
  62                 // create a ref property
  63                 property = EmitNavigationProperty(Item.ToEndMember, true);
  64                 typeDecl.Members.Add(property);
  65
  66             }
  67         }
  68
  69         /// <summary>
  70         /// Generate a navigation property
  71         /// </summary>
  72         /// <param name="target">the other end</param>
  73         /// <param name="referenceProperty">True to emit Reference navigation property</param>
  74         /// <returns>the generated property</returns>
  75         private CodeMemberProperty EmitNavigationProperty(RelationshipEndMember target, bool referenceProperty)
  76         {
  77             CodeTypeReference typeRef = GetReturnType(target, referenceProperty);
  78
  79             // raise the PropertyGenerated event
  80             PropertyGeneratedEventArgs eventArgs = new PropertyGeneratedEventArgs(Item,
  81                                                                                   null, // no backing field
  82                                                                                   typeRef);
  83             this.Generator.RaisePropertyGeneratedEvent(eventArgs);
  84
  85             // [System.ComponentModel.Browsable(false)]
  86             // public TargetType TargetName
  87             // public EntityReference<TargetType> TargetName
  88             // or
  89             // public EntityCollection<targetType> TargetNames
  90             CodeMemberProperty property = new CodeMemberProperty();
  91             if (referenceProperty)
  92             {
  93                 AttributeEmitter.AddBrowsableAttribute(property);
  94                 Generator.AttributeEmitter.EmitGeneratedCodeAttribute(property);
  95             }
  96             else
  97             {
  98                 Generator.AttributeEmitter.EmitNavigationPropertyAttributes(Generator, target, property, eventArgs.AdditionalAttributes);
  99
 100                 // Only reference navigation properties are currently currently supported with XML serialization
 101                 // and thus we should use the XmlIgnore and SoapIgnore attributes on other property types.
 102                 AttributeEmitter.AddIgnoreAttributes(property);
 103             }
 104
 105             AttributeEmitter.AddDataMemberAttribute(property);
 106
 107             CommentEmitter.EmitSummaryComments(Item, property.Comments);
 108
 109             property.Name = Item.Name;
 110             if (referenceProperty)
 111             {
 112                 property.Name += "Reference";
 113                 if (IsNameAlreadyAMemberName(Item.DeclaringType, property.Name, Generator.LanguageAppropriateStringComparer))
 114                 {
 115                     Generator.AddError(Strings.GeneratedNavigationPropertyNameConflict(Item.Name, Item.DeclaringType.Name, property.Name),
 116                         ModelBuilderErrorCode.GeneratedNavigationPropertyNameConflict,
 117                         EdmSchemaErrorSeverity.Error, Item.DeclaringType.FullName, property.Name);
 118                 }
 119             }
 120
 121             if (eventArgs.ReturnType != null && !eventArgs.ReturnType.Equals(typeRef))
 122             {
 123                 property.Type = eventArgs.ReturnType;
 124             }
 125             else
 126             {
 127                 property.Type = typeRef;
 128             }
 129
 130             property.Attributes = MemberAttributes.Final;
 131
 132             CodeMethodInvokeExpression getMethod = EmitGetMethod(target);
 133             CodeExpression getReturnExpression;
 134
 135             property.Attributes |= AccessibilityFromGettersAndSetters(Item);
 136             // setup the accessibility of the navigation property setter and getter
 137             MemberAttributes propertyAccessibility = property.Attributes & MemberAttributes.AccessMask;
 138             PropertyEmitter.AddGetterSetterFixUp(Generator.FixUps, GetFullyQualifiedPropertyName(property.Name),
 139                 PropertyEmitter.GetGetterAccessibility(Item), propertyAccessibility, true);
 140             PropertyEmitter.AddGetterSetterFixUp(Generator.FixUps, GetFullyQualifiedPropertyName(property.Name),
 141                 PropertyEmitter.GetSetterAccessibility(Item), propertyAccessibility, false);
 142
 143             if (target.RelationshipMultiplicity != RelationshipMultiplicity.Many)
 144             {
 145
 146                 // insert user-supplied Set code here, before the assignment
 147                 //
 148                 List<CodeStatement> additionalSetStatements = eventArgs.AdditionalSetStatements;
 149                 if (additionalSetStatements != null && additionalSetStatements.Count > 0)
 150                 {
 151                     try
 152                     {
 153                         property.SetStatements.AddRange(additionalSetStatements.ToArray());
 154                     }
 155                     catch (ArgumentNullException ex)
 156                     {
 157                         Generator.AddError(Strings.InvalidSetStatementSuppliedForProperty(Item.Name),
 158                                            ModelBuilderErrorCode.InvalidSetStatementSuppliedForProperty,
 159                                            EdmSchemaErrorSeverity.Error,
 160                                            ex);
 161                     }
 162                 }
 163
 164                 CodeExpression valueRef =  new CodePropertySetValueReferenceExpression();
 165                 if(typeRef != eventArgs.ReturnType)
 166                 {
 167                     // we need to cast to the actual type
 168                     valueRef = new CodeCastExpression(typeRef, valueRef);
 169                 }
 170
 171                 if (referenceProperty)
 172                 {
 173                     // get
 174                     //     return ((IEntityWithRelationships)this).RelationshipManager.GetRelatedReference<TTargetEntity>("CSpaceQualifiedRelationshipName", "TargetRoleName");
 175                     getReturnExpression = getMethod;
 176
 177                     // set
 178                     // if (value != null)
 179                     // {
 180                     //    ((IEntityWithRelationships)this).RelationshipManager.InitializeRelatedReference<TTargetEntity>"CSpaceQualifiedRelationshipName", "TargetRoleName", value);
 181                     // }
 182
 183                     CodeMethodReferenceExpression initReferenceMethod = new CodeMethodReferenceExpression();
 184                     initReferenceMethod.MethodName = "InitializeRelatedReference";
 185
 186                     initReferenceMethod.TypeArguments.Add(Generator.GetLeastPossibleQualifiedTypeReference(GetEntityType(target)));
 187                     initReferenceMethod.TargetObject = new CodePropertyReferenceExpression(
 188                         new CodeCastExpression(TypeReference.IEntityWithRelationshipsTypeBaseClass, ThisRef),
 189                         "RelationshipManager");
 190
 191                     // relationships aren't backed by types so we won't map the namespace
 192                     // or we can't find the relationship again later
 193                     string cspaceNamespaceNameQualifiedRelationshipName = target.DeclaringType.FullName;
 194
 195                     property.SetStatements.Add(
 196                         new CodeConditionStatement(
 197                             EmitExpressionDoesNotEqualNull(valueRef),
 198                             new CodeExpressionStatement(
 199                                 new CodeMethodInvokeExpression(
 200                                 initReferenceMethod, new CodeExpression[] {
 201                                     new CodePrimitiveExpression(cspaceNamespaceNameQualifiedRelationshipName), new CodePrimitiveExpression(target.Name), valueRef}))));
 202                 }
 203                 else
 204                 {
 205                     CodePropertyReferenceExpression valueProperty = new CodePropertyReferenceExpression(getMethod, ValuePropertyName);
 206
 207                     // get
 208                     //     return ((IEntityWithRelationships)this).RelationshipManager.GetRelatedReference<TTargetEntity>("CSpaceQualifiedRelationshipName", "TargetRoleName").Value;
 209                     getReturnExpression = valueProperty;
 210
 211                     // set
 212                     //     ((IEntityWithRelationships)this).RelationshipManager.GetRelatedReference<TTargetEntity>("CSpaceQualifiedRelationshipName", "TargetRoleName").Value = value;
 213                     property.SetStatements.Add(
 214                         new CodeAssignStatement(valueProperty, valueRef));
 215                 }
 216             }
 217             else
 218             {
 219                 // get
 220                 //     return ((IEntityWithRelationships)this).RelationshipManager.GetRelatedCollection<TTargetEntity>("CSpaceQualifiedRelationshipName", "TargetRoleName");
 221                 getReturnExpression = getMethod;
 222
 223                 // set
 224                 // if (value != null)
 225                 // {
 226                 //    ((IEntityWithRelationships)this).RelationshipManager.InitializeRelatedCollection<TTargetEntity>"CSpaceQualifiedRelationshipName", "TargetRoleName", value);
 227                 // }
 228                 CodeExpression valueRef = new CodePropertySetValueReferenceExpression();
 229
 230                 CodeMethodReferenceExpression initCollectionMethod = new CodeMethodReferenceExpression();
 231                 initCollectionMethod.MethodName = "InitializeRelatedCollection";
 232
 233                 initCollectionMethod.TypeArguments.Add(Generator.GetLeastPossibleQualifiedTypeReference(GetEntityType(target)));
 234                 initCollectionMethod.TargetObject = new CodePropertyReferenceExpression(
 235                     new CodeCastExpression(TypeReference.IEntityWithRelationshipsTypeBaseClass, ThisRef),
 236                     "RelationshipManager");
 237
 238                 // relationships aren't backed by types so we won't map the namespace
 239                 // or we can't find the relationship again later
 240                 string cspaceNamespaceNameQualifiedRelationshipName = target.DeclaringType.FullName;
 241
 242                 property.SetStatements.Add(
 243                     new CodeConditionStatement(
 244                         EmitExpressionDoesNotEqualNull(valueRef),
 245                         new CodeExpressionStatement(
 246                             new CodeMethodInvokeExpression(
 247                             initCollectionMethod, new CodeExpression[] {
 248                                     new CodePrimitiveExpression(cspaceNamespaceNameQualifiedRelationshipName), new CodePrimitiveExpression(target.Name), valueRef}))));
 249
 250             }
 251
 252             // if additional Get statements were specified by the event subscriber, insert them now
 253             //
 254             List<CodeStatement> additionalGetStatements = eventArgs.AdditionalGetStatements;
 255             if (additionalGetStatements != null && additionalGetStatements.Count > 0)
 256             {
 257                 try
 258                 {
 259                     property.GetStatements.AddRange(additionalGetStatements.ToArray());
 260                 }
 261                 catch (ArgumentNullException ex)
 262                 {
 263                     Generator.AddError(Strings.InvalidGetStatementSuppliedForProperty(Item.Name),
 264                                        ModelBuilderErrorCode.InvalidGetStatementSuppliedForProperty,
 265                                        EdmSchemaErrorSeverity.Error,
 266                                        ex);
 267                 }
 268             }
 269
 270             property.GetStatements.Add(new CodeMethodReturnStatement(getReturnExpression));
 271
 272             return property;
 273         }
 274
 275         internal static bool IsNameAlreadyAMemberName(StructuralType type, string generatedPropertyName, StringComparison comparison)
 276         {
 277             foreach (EdmMember member in type.Members)
 278             {
 279                 if (member.DeclaringType == type &&
 280                     member.Name.Equals(generatedPropertyName, comparison))
 281                 {
 282                     return true;
 283                 }
 284             }
 285
 286             return false;
 287         }
 288
 289         private string GetFullyQualifiedPropertyName(string propertyName)
 290         {
 291             return Item.DeclaringType.FullName + "." + propertyName;
 292         }
 293
 294         /// <summary>
 295         /// Gives the SchemaElement back cast to the most
 296         /// appropriate type
 297         /// </summary>
 298         private new NavigationProperty Item
 299         {
 300             get
 301             {
 302                 return base.Item as NavigationProperty;
 303             }
 304         }
 305
 306         /// <summary>
 307         /// Get the return type for the get method, given the target end
 308         /// </summary>
 309         /// <param name="target"></param>
 310         /// <param name="referenceMethod">true if the is the return type for a reference property</param>
 311         /// <returns>the return type for a target</returns>
 312         private CodeTypeReference GetReturnType(RelationshipEndMember target, bool referenceMethod)
 313         {
 314             CodeTypeReference returnType = Generator.GetLeastPossibleQualifiedTypeReference(GetEntityType(target));
 315             if (referenceMethod)
 316             {
 317                 returnType = TypeReference.AdoFrameworkGenericDataClass("EntityReference", returnType);
 318             }
 319             else if (target.RelationshipMultiplicity == RelationshipMultiplicity.Many)
 320             {
 321                 returnType = TypeReference.AdoFrameworkGenericDataClass("EntityCollection", returnType);
 322             }
 323
 324             return returnType;
 325         }
 326
 327
 328         private static EntityTypeBase GetEntityType(RelationshipEndMember endMember)
 329         {
 330             Debug.Assert(endMember.TypeUsage.EdmType.BuiltInTypeKind == BuiltInTypeKind.RefType, "not a reference type");
 331             EntityTypeBase type = ((RefType)endMember.TypeUsage.EdmType).ElementType;
 332             return type;
 333         }
 334
 335         /// <summary>
 336         /// Emit the GetRelatedCollection or GetRelatedReference methods
 337         /// </summary>
 338         /// <param name="target">Target end of the relationship</param>
 339         /// <returns>Expression to invoke the appropriate method</returns>
 340         private CodeMethodInvokeExpression EmitGetMethod(RelationshipEndMember target)
 341         {
 342             // ((IEntityWithRelationships)this).RelationshipManager.GetRelatedReference<TargetType>("CSpaceQualifiedRelationshipName", "TargetRoleName");
 343             // or
 344             // ((IEntityWithRelationships)this).RelationshipManager.GetRelatedCollection<TargetType>("CSpaceQualifiedRelationshipName", "TargetRoleName");
 345
 346             CodeMethodReferenceExpression getMethod = new CodeMethodReferenceExpression();
 347             if (target.RelationshipMultiplicity != RelationshipMultiplicity.Many)
 348                 getMethod.MethodName = "GetRelatedReference";
 349             else
 350                 getMethod.MethodName = "GetRelatedCollection";
 351
 352             getMethod.TypeArguments.Add(Generator.GetLeastPossibleQualifiedTypeReference(GetEntityType(target)));
 353             getMethod.TargetObject = new CodePropertyReferenceExpression(
 354                 new CodeCastExpression(TypeReference.IEntityWithRelationshipsTypeBaseClass, ThisRef),
 355                 "RelationshipManager");
 356
 357             // relationships aren't backed by types so we won't map the namespace
 358             // or we can't find the relationship again later
 359             string cspaceNamespaceNameQualifiedRelationshipName = target.DeclaringType.FullName;
 360             return new CodeMethodInvokeExpression(
 361                 getMethod, new CodeExpression[] { new CodePrimitiveExpression(cspaceNamespaceNameQualifiedRelationshipName), new CodePrimitiveExpression(target.Name)});
 362         }
 363     }
 364 }