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);
}
}