public void Code_first_built_complex_types_matches_som_loaded_complex_types() { var context = new ShopContext_v1(); var compiledModel = context.InternalContext.CodeFirstModel; var builder = compiledModel.CachedModelBuilder.Clone(); var databaseMapping = builder.Build(ProviderRegistry.Sql2008_ProviderInfo).DatabaseMapping; var itemCollection = new EdmItemCollection(databaseMapping.Model); var complexTypes = databaseMapping.Model.ComplexTypes.ToList(); var somComplexTypes = itemCollection.GetItems<ComplexType>(); Assert.Equal(complexTypes.Count(), somComplexTypes.Count()); foreach (var complexType in complexTypes) { var somComplexType = somComplexTypes.Single(e => e.Name == complexType.Name); Assert.Equal(complexType.NamespaceName, somComplexType.NamespaceName); Assert.Equal(complexType.Identity, somComplexType.Identity); Assert.Equal(complexType.Abstract, somComplexType.Abstract); Assert.Equal(complexType.FullName, somComplexType.FullName); Assert.Equal(complexType.Members.Count, somComplexType.Members.Count); } }
public void Code_first_built_complex_types_matches_som_loaded_complex_types() { var context = new ShopContext_v1(); var compiledModel = context.InternalContext.CodeFirstModel; var builder = compiledModel.CachedModelBuilder.Clone(); var databaseMapping = builder.Build(ProviderRegistry.Sql2008_ProviderInfo).DatabaseMapping; var itemCollection = new EdmItemCollection(databaseMapping.Model); var complexTypes = databaseMapping.Model.ComplexTypes.ToList(); var somComplexTypes = itemCollection.GetItems <ComplexType>(); Assert.Equal(complexTypes.Count(), somComplexTypes.Count()); foreach (var complexType in complexTypes) { var somComplexType = somComplexTypes.Single(e => e.Name == complexType.Name); Assert.Equal(complexType.NamespaceName, somComplexType.NamespaceName); Assert.Equal(complexType.Identity, somComplexType.Identity); Assert.Equal(complexType.Abstract, somComplexType.Abstract); Assert.Equal(complexType.FullName, somComplexType.FullName); Assert.Equal(complexType.Members.Count, somComplexType.Members.Count); } }
public virtual void CreateRelationships(EdmItemCollection edmItemCollection) { foreach (var cspaceAssociation in edmItemCollection.GetItems <AssociationType>()) { Debug.Assert(cspaceAssociation.RelationshipEndMembers.Count == 2, "Relationships are assumed to have exactly two ends"); if (CspaceToOspace.ContainsKey(cspaceAssociation)) { // don't try to load relationships that we already know about continue; } var ospaceEndTypes = new EdmType[2]; if (CspaceToOspace.TryGetValue( GetRelationshipEndType(cspaceAssociation.RelationshipEndMembers[0]), out ospaceEndTypes[0]) && CspaceToOspace.TryGetValue( GetRelationshipEndType(cspaceAssociation.RelationshipEndMembers[1]), out ospaceEndTypes[1])) { Debug.Assert(ospaceEndTypes[0] is StructuralType); Debug.Assert(ospaceEndTypes[1] is StructuralType); // if we can find both ends of the relationship, then create it var ospaceAssociation = new AssociationType( cspaceAssociation.Name, cspaceAssociation.NamespaceName, cspaceAssociation.IsForeignKey, DataSpace.OSpace); for (var i = 0; i < cspaceAssociation.RelationshipEndMembers.Count; i++) { var ospaceEndType = (EntityType)ospaceEndTypes[i]; var cspaceEnd = cspaceAssociation.RelationshipEndMembers[i]; ospaceAssociation.AddKeyMember( new AssociationEndMember(cspaceEnd.Name, ospaceEndType.GetReferenceType(), cspaceEnd.RelationshipMultiplicity)); } AddToTypesInAssembly(ospaceAssociation); LoadedTypes.Add(ospaceAssociation.FullName, ospaceAssociation); CspaceToOspace.Add(cspaceAssociation, ospaceAssociation); } } }
public virtual void CreateRelationships(EdmItemCollection edmItemCollection) { foreach (var cspaceAssociation in edmItemCollection.GetItems<AssociationType>()) { Debug.Assert(cspaceAssociation.RelationshipEndMembers.Count == 2, "Relationships are assumed to have exactly two ends"); if (CspaceToOspace.ContainsKey(cspaceAssociation)) { // don't try to load relationships that we already know about continue; } var ospaceEndTypes = new EdmType[2]; if (CspaceToOspace.TryGetValue( GetRelationshipEndType(cspaceAssociation.RelationshipEndMembers[0]), out ospaceEndTypes[0]) && CspaceToOspace.TryGetValue( GetRelationshipEndType(cspaceAssociation.RelationshipEndMembers[1]), out ospaceEndTypes[1])) { Debug.Assert(ospaceEndTypes[0] is StructuralType); Debug.Assert(ospaceEndTypes[1] is StructuralType); // if we can find both ends of the relationship, then create it var ospaceAssociation = new AssociationType( cspaceAssociation.Name, cspaceAssociation.NamespaceName, cspaceAssociation.IsForeignKey, DataSpace.OSpace); for (var i = 0; i < cspaceAssociation.RelationshipEndMembers.Count; i++) { var ospaceEndType = (EntityType)ospaceEndTypes[i]; var cspaceEnd = cspaceAssociation.RelationshipEndMembers[i]; ospaceAssociation.AddKeyMember( new AssociationEndMember(cspaceEnd.Name, ospaceEndType.GetReferenceType(), cspaceEnd.RelationshipMultiplicity)); } AddToTypesInAssembly(ospaceAssociation); LoadedTypes.Add(ospaceAssociation.FullName, ospaceAssociation); CspaceToOspace.Add(cspaceAssociation, ospaceAssociation); } } }
[Fact] // CodePlex 2051 public void Can_load_model_after_assembly_version_of_types_changes() { var edmItemCollection = new EdmItemCollection(new[] { XDocument.Parse(CsdlWithVersion).CreateReader() }); Assert.Null(GetClrType(edmItemCollection.GetItems<EntityType>().Single(e => e.Name == "Man"))); }
private bool LoadAssemblyFromCache( Assembly assembly, bool loadReferencedAssemblies, EdmItemCollection edmItemCollection, Action <String> logLoadMessage) { // Code First already did type loading if (OSpaceTypesLoaded) { return(true); } // If all the containers (usually only one) have the UseClrTypes annotation then use the Code First loader even // when using an EDMX. if (edmItemCollection != null) { var containers = edmItemCollection.GetItems <EntityContainer>(); if (containers.Any() && containers.All( c => c.Annotations.Any( a => a.Name == XmlConstants.UseClrTypesAnnotationWithPrefix && ((string)a.Value).ToUpperInvariant() == "TRUE"))) { lock (LoadAssemblyLock) { if (!OSpaceTypesLoaded) { new CodeFirstOSpaceLoader().LoadTypes(edmItemCollection, this); Debug.Assert(OSpaceTypesLoaded); } return(true); } } } // Check if its loaded in the cache - if the call is for loading referenced assemblies, make sure that all referenced // assemblies are also loaded KnownAssemblyEntry entry; if (_knownAssemblies.TryGetKnownAssembly(assembly, _loaderCookie, edmItemCollection, out entry)) { // Proceed if only we need to load the referenced assemblies and they are not loaded if (loadReferencedAssemblies == false) { // don't say we loaded anything, unless we actually did before return(entry.CacheEntry.TypesInAssembly.Count != 0); } else if (entry.ReferencedAssembliesAreLoaded) { // this assembly was part of a all hands reference search return(true); } } lock (LoadAssemblyLock) { // Check after acquiring the lock, since the known assemblies might have got modified // Check if the assembly is already loaded. The reason we need to check if the assembly is already loaded, is that if (_knownAssemblies.TryGetKnownAssembly(assembly, _loaderCookie, edmItemCollection, out entry)) { // Proceed if only we need to load the referenced assemblies and they are not loaded if (loadReferencedAssemblies == false || entry.ReferencedAssembliesAreLoaded) { return(true); } } Dictionary <string, EdmType> typesInLoading; List <EdmItemError> errors; var knownAssemblies = new KnownAssembliesSet(_knownAssemblies); // Load the assembly from the cache AssemblyCache.LoadAssembly( assembly, loadReferencedAssemblies, knownAssemblies, edmItemCollection, logLoadMessage, ref _loaderCookie, out typesInLoading, out errors); // Throw if we have encountered errors if (errors.Count != 0) { throw EntityUtil.InvalidSchemaEncountered(Helper.CombineErrorMessage(errors)); } // We can encounter new assemblies, but they may not have any time in them if (typesInLoading.Count != 0) { // No errors, so go ahead and add the types and make them readonly // The existence of the loading lock tells us whether we should be thread safe or not, if we need // to be thread safe. We don't need to actually use the lock because the caller should have done // it already. // Recheck the assemblies added, another list is created just to match up the collection type // taken in by AddRange() AddLoadedTypes(typesInLoading); } // Update the value of known assemblies _knownAssemblies = knownAssemblies; return(typesInLoading.Count != 0); } }
private bool LoadAssemblyFromCache( Assembly assembly, bool loadReferencedAssemblies, EdmItemCollection edmItemCollection, Action <string> logLoadMessage) { if (this.OSpaceTypesLoaded) { return(true); } if (edmItemCollection != null) { ReadOnlyCollection <EntityContainer> items = edmItemCollection.GetItems <EntityContainer>(); if (items.Any <EntityContainer>() && items.All <EntityContainer>((Func <EntityContainer, bool>)(c => c.Annotations.Any <MetadataProperty>((Func <MetadataProperty, bool>)(a => { if (a.Name == "http://schemas.microsoft.com/ado/2013/11/edm/customannotation:UseClrTypes") { return(((string)a.Value).ToUpperInvariant() == "TRUE"); } return(false); }))))) { lock (this.LoadAssemblyLock) { if (!this.OSpaceTypesLoaded) { new CodeFirstOSpaceLoader((CodeFirstOSpaceTypeFactory)null).LoadTypes(edmItemCollection, this); } return(true); } } } KnownAssemblyEntry entry; if (this._knownAssemblies.TryGetKnownAssembly(assembly, this._loaderCookie, edmItemCollection, out entry)) { if (!loadReferencedAssemblies) { return(entry.CacheEntry.TypesInAssembly.Count != 0); } if (entry.ReferencedAssembliesAreLoaded) { return(true); } } lock (this.LoadAssemblyLock) { if (this._knownAssemblies.TryGetKnownAssembly(assembly, this._loaderCookie, edmItemCollection, out entry) && (!loadReferencedAssemblies || entry.ReferencedAssembliesAreLoaded)) { return(true); } KnownAssembliesSet knownAssemblies = new KnownAssembliesSet(this._knownAssemblies); Dictionary <string, EdmType> typesInLoading; List <EdmItemError> errors; AssemblyCache.LoadAssembly(assembly, loadReferencedAssemblies, knownAssemblies, edmItemCollection, logLoadMessage, ref this._loaderCookie, out typesInLoading, out errors); if (errors.Count != 0) { throw EntityUtil.InvalidSchemaEncountered(Helper.CombineErrorMessage((IEnumerable <EdmItemError>)errors)); } if (typesInLoading.Count != 0) { this.AddLoadedTypes(typesInLoading); } this._knownAssemblies = knownAssemblies; return(typesInLoading.Count != 0); } }