/// <summary>
/// Validate an MetadataProperty object
/// </summary>
/// <param name="item">The MetadataProperty object to validate</param>
/// <param name="errors">An error collection for adding validation errors</param>
/// <param name="validatedItems">A dictionary keeping track of items that have been validated</param>
private void ValidateMetadataProperty(MetadataProperty item, List <EdmItemError> errors, HashSet <MetadataItem> validatedItems)
{
// Validate only for user added item attributes, for system attributes, we can skip validation
if (item.PropertyKind == PropertyKind.Extended)
{
ValidateItem(item, errors, validatedItems);
// Check that this member has a name
if (string.IsNullOrEmpty(item.Name))
{
AddError(errors, new EdmItemError(System.Data.Entity.Strings.Validator_MetadataPropertyHasNoName, item));
}
if (item.TypeUsage == null)
{
AddError(errors, new EdmItemError(System.Data.Entity.Strings.Validator_ItemAttributeHasNullTypeUsage, item));
}
else
{
InternalValidate(item.TypeUsage, errors, validatedItems);
}
}
}
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)] //For EdmItemCollection constructor call.
//Since we pass in empty collection for paths, we do not have any resource exposure here.
private IList<EdmSchemaError> InternalGenerateMetadata()
{
if (_modelEntityContainer != null)
{
_modelEntityContainer = null;
_mappingLookups = null;
_edmItemCollection = null;
}
LoadMethodSessionState session = new LoadMethodSessionState();
try
{
session.EdmItemCollection = new EdmItemCollection();
if (this.GenerateForeignKeyProperties && this._targetEntityFrameworkVersion < EntityFrameworkVersions.Version2)
{
session.AddError(Strings.UnableToGenerateForeignKeyPropertiesForV1, ModelBuilderErrorCode.UnableToGenerateForeignKeyPropertiesForV1, EdmSchemaErrorSeverity.Error, null);
return session.Errors;
}
List<AssociationSet> storeAssociationSets = new List<AssociationSet>();
CollectAllFkProperties(session);
EntityContainer modelEntityContainer = new EntityContainer(_modelEntityContainerName, DataSpace.CSpace);
// create the EntityTypes and EntitySets, and save up the AssociationSets for later.
foreach (EntitySetBase storeSet in _storeEntityContainer.BaseEntitySets)
{
switch (storeSet.BuiltInTypeKind)
{
case BuiltInTypeKind.AssociationSet:
// save these, and create them after the EntityTypes and EntitySets have been created
string errorMessage;
if (this.GenerateForeignKeyProperties || !EntityStoreSchemaGenerator.IsFkPartiallyContainedInPK(((AssociationSet)storeSet).ElementType, out errorMessage))
{
storeAssociationSets.Add((AssociationSet)storeSet);
}
else
{
session.AddError(errorMessage, ModelBuilderErrorCode.UnsupportedForeinKeyPattern, EdmSchemaErrorSeverity.Error, null);
}
break;
case BuiltInTypeKind.EntitySet:
EntitySet set = (EntitySet)storeSet;
session.CandidateCollapsedAssociations.Add(set, new OneToOneMappingSerializer.CollapsedEntityAssociationSet(set));
break;
default:
// error
throw EDesignUtil.MissingGenerationPatternForType(storeSet.BuiltInTypeKind);
}
}
foreach (AssociationSet storeAssociationSet in storeAssociationSets)
{
SaveAssociationForCollapsedAssociationCandidate(session, storeAssociationSet);
}
Set<AssociationSet> associationSetsFromCollapseCandidateRejects = new Set<AssociationSet>();
IEnumerable<OneToOneMappingSerializer.CollapsedEntityAssociationSet> invalidCandidates = FindAllInvalidCollapsedAssociationCandidates(session);
// now that we have gone through all of the association sets,
foreach (OneToOneMappingSerializer.CollapsedEntityAssociationSet collapsed in invalidCandidates)
{
session.CandidateCollapsedAssociations.Remove(collapsed.EntitySet);
// just create the entity set and save the association set to be added later
EntitySet entitySet = CreateModelEntitySet(session, collapsed.EntitySet);
modelEntityContainer.AddEntitySetBase(entitySet);
associationSetsFromCollapseCandidateRejects.AddRange(collapsed.AssociationSets);
}
// create all the associations for the invalid collapsed entity association candidates
foreach (AssociationSet storeAssociationSet in (IEnumerable<AssociationSet>)associationSetsFromCollapseCandidateRejects)
{
if (!IsAssociationPartOfCandidateCollapsedAssociation(session, storeAssociationSet))
{
AssociationSet set = CreateModelAssociationSet(session, storeAssociationSet);
modelEntityContainer.AddEntitySetBase(set);
}
}
// save the set that needs to be created and mapped
session.MappingLookups.CollapsedEntityAssociationSets.AddRange(session.CandidateCollapsedAssociations.Values);
// do this in a seperate loop so we are sure all the necessary EntitySets have been created
foreach (OneToOneMappingSerializer.CollapsedEntityAssociationSet collapsed in session.MappingLookups.CollapsedEntityAssociationSets)
{
AssociationSet set = CreateModelAssociationSet(session, collapsed);
modelEntityContainer.AddEntitySetBase(set);
}
if (this._targetEntityFrameworkVersion >= EntityFrameworkVersions.Version2)
{
Debug.Assert(EntityFrameworkVersions.Latest == EntityFrameworkVersions.Version3, "Did you add a new framework version");
// add LazyLoadingEnabled=true to the EntityContainer
MetadataProperty lazyLoadingAttribute =
new MetadataProperty(
DesignXmlConstants.EdmAnnotationNamespace + ":" + DesignXmlConstants.LazyLoadingEnabled,
TypeUsage.CreateStringTypeUsage(
PrimitiveType.GetEdmPrimitiveType(
PrimitiveTypeKind.String),
false,
false),
true);
modelEntityContainer.AddMetadataProperties(new List<MetadataProperty>() { lazyLoadingAttribute });
this._hasAnnotationNamespace = true;
}
// Map store functions to function imports.
MapFunctions(session, modelEntityContainer);
if (!EntityStoreSchemaGenerator.HasErrorSeverityErrors(session.Errors))
{
// add them to the collection so they will work if someone wants to use the collection
foreach (EntityType type in session.MappingLookups.StoreEntityTypeToModelEntityType.Values)
{
type.SetReadOnly();
session.EdmItemCollection.AddInternal(type);
}
foreach (AssociationType type in session.MappingLookups.StoreAssociationTypeToModelAssociationType.Values)
{
type.SetReadOnly();
session.EdmItemCollection.AddInternal(type);
}
foreach (OneToOneMappingSerializer.CollapsedEntityAssociationSet set in session.MappingLookups.CollapsedEntityAssociationSets)
{
set.ModelAssociationSet.ElementType.SetReadOnly();
session.EdmItemCollection.AddInternal(set.ModelAssociationSet.ElementType);
}
modelEntityContainer.SetReadOnly();
session.EdmItemCollection.AddInternal(modelEntityContainer);
_modelEntityContainer = modelEntityContainer;
_mappingLookups = session.MappingLookups;
_edmItemCollection = session.EdmItemCollection;
}
}
catch (Exception e)
{
if (MetadataUtil.IsCatchableExceptionType(e))
{
// an exception in the code is definitely an error
string message = EDesignUtil.GetMessagesFromEntireExceptionChain(e);
session.AddError(message,
ModelBuilderErrorCode.UnknownError,
EdmSchemaErrorSeverity.Error,
e);
}
else
{
throw;
}
}
return session.Errors;
}
internal static MetadataProperty CreateMetadataPropertyFromOtherNamespaceXmlArtifact(string xmlNamespaceUri, string artifactName, object value)
{
MetadataProperty property;
property = new MetadataProperty(xmlNamespaceUri + ":" + artifactName,
TypeUsage.Create(EdmProviderManifest.Instance.GetPrimitiveType(PrimitiveTypeKind.String)),
value);
return property;
}
