public void AddElement(IEdmEntityContainerElement element)
{
EdmUtil.CheckArgumentNull <IEdmEntityContainerElement>(element, "element");
this.containerElements.Add(element);
EdmContainerElementKind containerElementKind = element.ContainerElementKind;
switch (containerElementKind)
{
case EdmContainerElementKind.None:
{
throw new InvalidOperationException(Strings.EdmEntityContainer_CannotUseElementWithTypeNone);
}
case EdmContainerElementKind.EntitySet:
{
RegistrationHelper.AddElement <IEdmEntitySet>((IEdmEntitySet)element, element.Name, this.entitySetDictionary, new Func <IEdmEntitySet, IEdmEntitySet, IEdmEntitySet>(RegistrationHelper.CreateAmbiguousEntitySetBinding));
return;
}
case EdmContainerElementKind.FunctionImport:
{
RegistrationHelper.AddFunction <IEdmFunctionImport>((IEdmFunctionImport)element, element.Name, this.functionImportDictionary);
return;
}
}
throw new InvalidOperationException(Strings.UnknownEnumVal_ContainerElementKind(element.ContainerElementKind));
}
/// <summary>
/// Adds an entity container element to this entity container.
/// </summary>
/// <param name="element">The element to add.</param>
public void AddElement(IEdmEntityContainerElement element)
{
EdmUtil.CheckArgumentNull(element, "element");
this.containerElements.Add(element);
switch (element.ContainerElementKind)
{
case EdmContainerElementKind.EntitySet:
RegistrationHelper.AddElement((IEdmEntitySet)element, element.Name, this.entitySetDictionary, RegistrationHelper.CreateAmbiguousEntitySetBinding);
break;
case EdmContainerElementKind.Singleton:
RegistrationHelper.AddElement((IEdmSingleton)element, element.Name, this.singletonDictionary, RegistrationHelper.CreateAmbiguousSingletonBinding);
break;
case EdmContainerElementKind.ActionImport:
case EdmContainerElementKind.FunctionImport:
RegistrationHelper.AddOperationImport((IEdmOperationImport)element, element.Name, this.operationImportDictionary);
break;
case EdmContainerElementKind.None:
throw new InvalidOperationException(Edm.Strings.EdmEntityContainer_CannotUseElementWithTypeNone);
default:
throw new InvalidOperationException(Edm.Strings.UnknownEnumVal_ContainerElementKind(element.ContainerElementKind));
}
}
private Dictionary <string, IEdmEntitySet> ComputeEntitySetDictionary()
{
Dictionary <string, IEdmEntitySet> strs = new Dictionary <string, IEdmEntitySet>();
foreach (IEdmEntitySet edmEntitySet in this.Elements.OfType <IEdmEntitySet>())
{
RegistrationHelper.AddElement <IEdmEntitySet>(edmEntitySet, edmEntitySet.Name, strs, new Func <IEdmEntitySet, IEdmEntitySet, IEdmEntitySet>(RegistrationHelper.CreateAmbiguousEntitySetBinding));
}
return(strs);
}
private Dictionary <string, IEdmSingleton> ComputeSingletonDictionary()
{
Dictionary <string, IEdmSingleton> sets = new Dictionary <string, IEdmSingleton>();
foreach (IEdmSingleton singleton in this.Elements.OfType <IEdmSingleton>())
{
RegistrationHelper.AddElement(singleton, singleton.Name, sets, RegistrationHelper.CreateAmbiguousSingletonBinding);
}
return(sets);
}
private Dictionary <string, IEdmEntitySet> ComputeEntitySetDictionary()
{
Dictionary <string, IEdmEntitySet> sets = new Dictionary <string, IEdmEntitySet>();
foreach (IEdmEntitySet entitySet in this.Elements.OfType <IEdmEntitySet>())
{
RegistrationHelper.AddElement(entitySet, entitySet.Name, sets, RegistrationHelper.CreateAmbiguousEntitySetBinding);
}
return(sets);
}
private void AddSchema(CsdlSchema schema)
{
CsdlSemanticsSchema schemaWrapper = new CsdlSemanticsSchema(this, schema);
this.schemata.Add(schemaWrapper);
foreach (IEdmSchemaType type in schemaWrapper.Types)
{
CsdlSemanticsStructuredTypeDefinition structuredType = type as CsdlSemanticsStructuredTypeDefinition;
if (structuredType != null)
{
string baseTypeNamespace;
string baseTypeName;
string baseTypeFullName = ((CsdlNamedStructuredType)structuredType.Element).BaseTypeName;
if (baseTypeFullName != null)
{
EdmUtil.TryGetNamespaceNameFromQualifiedName(baseTypeFullName, out baseTypeNamespace, out baseTypeName);
if (baseTypeName != null)
{
List <IEdmStructuredType> derivedTypes;
if (!this.derivedTypeMappings.TryGetValue(baseTypeName, out derivedTypes))
{
derivedTypes = new List <IEdmStructuredType>();
this.derivedTypeMappings[baseTypeName] = derivedTypes;
}
derivedTypes.Add(structuredType);
}
}
}
RegisterElement(type);
}
foreach (CsdlSemanticsAssociation association in schemaWrapper.Associations)
{
RegistrationHelper.AddElement(association, association.Namespace + "." + association.Name, this.associationDictionary, CreateAmbiguousAssociationBinding);
}
foreach (IEdmFunction function in schemaWrapper.Functions)
{
RegisterElement(function);
}
foreach (IEdmValueTerm valueTerm in schemaWrapper.ValueTerms)
{
RegisterElement(valueTerm);
}
foreach (IEdmEntityContainer container in schemaWrapper.EntityContainers)
{
RegisterElement(container);
}
foreach (CsdlAnnotations schemaOutOfLineAnnotations in schema.OutOfLineAnnotations)
{
string target = schemaOutOfLineAnnotations.Target;
string replaced = schemaWrapper.ReplaceAlias(target);
if (replaced != null)
{
target = replaced;
}
List <CsdlSemanticsAnnotations> annotations;
if (!this.outOfLineAnnotations.TryGetValue(target, out annotations))
{
annotations = new List <CsdlSemanticsAnnotations>();
this.outOfLineAnnotations[target] = annotations;
}
annotations.Add(new CsdlSemanticsAnnotations(schemaWrapper, schemaOutOfLineAnnotations));
}
foreach (CsdlUsing used in schema.Usings)
{
this.SetNamespaceAlias(used.Namespace, used.Alias);
}
var edmVersion = this.GetEdmVersion();
if (edmVersion == null || edmVersion < schema.Version)
{
this.SetEdmVersion(schema.Version);
}
}
private void AddSchema(CsdlSchema schema)
{
CsdlSemanticsSchema item = new CsdlSemanticsSchema(this, schema);
this.schemata.Add(item);
foreach (IEdmSchemaType type in item.Types)
{
CsdlSemanticsStructuredTypeDefinition definition = type as CsdlSemanticsStructuredTypeDefinition;
if (definition != null)
{
string baseTypeName = ((CsdlNamedStructuredType)definition.Element).BaseTypeName;
if (baseTypeName != null)
{
string str;
string str2;
EdmUtil.TryGetNamespaceNameFromQualifiedName(baseTypeName, out str, out str2);
if (str2 != null)
{
List <IEdmStructuredType> list;
if (!this.derivedTypeMappings.TryGetValue(str2, out list))
{
list = new List <IEdmStructuredType>();
this.derivedTypeMappings[str2] = list;
}
list.Add(definition);
}
}
}
base.RegisterElement(type);
}
foreach (CsdlSemanticsAssociation association in item.Associations)
{
RegistrationHelper.AddElement <IEdmAssociation>(association, association.Namespace + "." + association.Name, this.associationDictionary, new Func <IEdmAssociation, IEdmAssociation, IEdmAssociation>(CsdlSemanticsModel.CreateAmbiguousAssociationBinding));
}
foreach (IEdmFunction function in item.Functions)
{
base.RegisterElement(function);
}
foreach (IEdmValueTerm term in item.ValueTerms)
{
base.RegisterElement(term);
}
foreach (IEdmEntityContainer container in item.EntityContainers)
{
base.RegisterElement(container);
}
foreach (CsdlAnnotations annotations in schema.OutOfLineAnnotations)
{
List <CsdlSemanticsAnnotations> list2;
string target = annotations.Target;
string str5 = item.ReplaceAlias(target);
if (str5 != null)
{
target = str5;
}
if (!this.outOfLineAnnotations.TryGetValue(target, out list2))
{
list2 = new List <CsdlSemanticsAnnotations>();
this.outOfLineAnnotations[target] = list2;
}
list2.Add(new CsdlSemanticsAnnotations(item, annotations));
}
foreach (CsdlUsing @using in schema.Usings)
{
this.SetNamespaceAlias(@using.Namespace, @using.Alias);
}
Version edmVersion = this.GetEdmVersion();
if ((edmVersion == null) || (edmVersion < schema.Version))
{
this.SetEdmVersion(schema.Version);
}
}
