/// <summary>
/// Gets the value for the EDMX version of the <paramref name="model"/>.
/// </summary>
/// <param name="model">Model the version has been set for.</param>
/// <returns>The version.</returns>
public static Version GetEdmxVersion(this IEdmModel model)
{
EdmUtil.CheckArgumentNull(model, "model");
return(model.GetAnnotationValue <Version>(model, EdmConstants.InternalUri, CsdlConstants.EdmxVersionAnnotation));
}
/// <summary>
/// Converts <paramref name="edmValue"/> to a <see cref="Microsoft.OData.Edm.TimeOfDay"/> value.
/// </summary>
/// <param name="edmValue">The EDM value to be converted.</param>
/// <returns>Converted TimeOfDay.</returns>
/// <exception cref="InvalidCastException">Exception is thrown if <paramref name="edmValue"/> is not <see cref="IEdmTimeOfDayValue"/>.</exception>
internal static TimeOfDay AsClrTimeOfDay(IEdmValue edmValue)
{
EdmUtil.CheckArgumentNull(edmValue, "edmValue");
return(((IEdmTimeOfDayValue)edmValue).Value);
}
/// <summary>
/// Converts <paramref name="edmValue"/> to a <see cref="System.Decimal"/> value.
/// </summary>
/// <param name="edmValue">The EDM value to be converted.</param>
/// <returns>Converted decimal.</returns>
/// <exception cref="InvalidCastException">Exception is thrown if <paramref name="edmValue"/> is not <see cref="IEdmDecimalValue"/>.</exception>
internal static decimal AsClrDecimal(IEdmValue edmValue)
{
EdmUtil.CheckArgumentNull(edmValue, "edmValue");
return(((IEdmDecimalValue)edmValue).Value);
}
/// <summary>
/// Initializes a new instance of the <see cref="EdmBinaryConstant"/> class.
/// </summary>
/// <param name="type">Type of the integer.</param>
/// <param name="value">Integer value represented by this value.</param>
public EdmBinaryConstant(IEdmBinaryTypeReference type, byte[] value)
: base(type)
{
EdmUtil.CheckArgumentNull(value, "value");
this.value = value;
}
/// <summary>
/// Converts <paramref name="edmValue"/> to a <see cref="System.Int64"/> value.
/// </summary>
/// <param name="edmValue">The EDM value to be converted.</param>
/// <returns>Converted integer.</returns>
/// <exception cref="InvalidCastException">Exception is thrown if <paramref name="edmValue"/> is not <see cref="IEdmIntegerValue"/>.</exception>
internal static Int64 AsClrInt64(IEdmValue edmValue)
{
EdmUtil.CheckArgumentNull(edmValue, "edmValue");
return(((IEdmIntegerValue)edmValue).Value);
}
/// <summary>
/// Initializes a new instance of the ValidationRuleSet class.
/// </summary>
/// <param name="baseSet">Ruleset whose rules should be contained in this set.</param>
/// <param name="newRules">Additional rules to add to the set.</param>
public ValidationRuleSet(IEnumerable <ValidationRule> baseSet, IEnumerable <ValidationRule> newRules)
: this(EdmUtil.CheckArgumentNull(baseSet, "baseSet").Concat(EdmUtil.CheckArgumentNull(newRules, "newRules")))
{
}
/// <summary>
/// Initializes a new instance of <see cref="EdmReferentialConstraint"/>.
/// </summary>
/// <param name="propertyPairs">The set of property pairs from the referential constraint.</param>
public EdmReferentialConstraint(IEnumerable <EdmReferentialConstraintPropertyPair> propertyPairs)
{
EdmUtil.CheckArgumentNull(propertyPairs, "propertyPairs");
this.propertyPairs = propertyPairs.ToList();
}
private IEdmValue Eval(IEdmExpression expression, IEdmStructuredValue context)
{
Func <IEdmValue[], IEdmValue> func = null;
IEdmStructuredTypeReference edmStructuredTypeReference;
IEdmCollectionTypeReference edmCollectionTypeReference;
object traceString;
EdmExpressionKind expressionKind = expression.ExpressionKind;
switch (expressionKind)
{
case EdmExpressionKind.BinaryConstant:
{
return((IEdmBinaryConstantExpression)expression);
}
case EdmExpressionKind.BooleanConstant:
{
return((IEdmBooleanConstantExpression)expression);
}
case EdmExpressionKind.DateTimeConstant:
{
return((IEdmDateTimeConstantExpression)expression);
}
case EdmExpressionKind.DateTimeOffsetConstant:
{
return((IEdmDateTimeOffsetConstantExpression)expression);
}
case EdmExpressionKind.DecimalConstant:
{
return((IEdmDecimalConstantExpression)expression);
}
case EdmExpressionKind.FloatingConstant:
{
return((IEdmFloatingConstantExpression)expression);
}
case EdmExpressionKind.GuidConstant:
{
return((IEdmGuidConstantExpression)expression);
}
case EdmExpressionKind.IntegerConstant:
{
return((IEdmIntegerConstantExpression)expression);
}
case EdmExpressionKind.StringConstant:
{
return((IEdmStringConstantExpression)expression);
}
case EdmExpressionKind.TimeConstant:
{
return((IEdmTimeConstantExpression)expression);
}
case EdmExpressionKind.Null:
{
return((IEdmNullExpression)expression);
}
case EdmExpressionKind.Record:
{
IEdmRecordExpression edmRecordExpression = (IEdmRecordExpression)expression;
EdmExpressionEvaluator.DelayedExpressionContext delayedExpressionContext = new EdmExpressionEvaluator.DelayedExpressionContext(this, context);
List <IEdmPropertyValue> edmPropertyValues = new List <IEdmPropertyValue>();
foreach (IEdmPropertyConstructor property in edmRecordExpression.Properties)
{
edmPropertyValues.Add(new EdmExpressionEvaluator.DelayedRecordProperty(delayedExpressionContext, property));
}
if (edmRecordExpression.DeclaredType != null)
{
edmStructuredTypeReference = edmRecordExpression.DeclaredType.AsStructured();
}
else
{
edmStructuredTypeReference = null;
}
EdmStructuredValue edmStructuredValue = new EdmStructuredValue(edmStructuredTypeReference, edmPropertyValues);
return(edmStructuredValue);
}
case EdmExpressionKind.Collection:
{
IEdmCollectionExpression edmCollectionExpression = (IEdmCollectionExpression)expression;
EdmExpressionEvaluator.DelayedExpressionContext delayedExpressionContext1 = new EdmExpressionEvaluator.DelayedExpressionContext(this, context);
List <IEdmDelayedValue> edmDelayedValues = new List <IEdmDelayedValue>();
foreach (IEdmExpression element in edmCollectionExpression.Elements)
{
edmDelayedValues.Add(this.MapLabeledExpressionToDelayedValue(element, delayedExpressionContext1, context));
}
if (edmCollectionExpression.DeclaredType != null)
{
edmCollectionTypeReference = edmCollectionExpression.DeclaredType.AsCollection();
}
else
{
edmCollectionTypeReference = null;
}
EdmCollectionValue edmCollectionValue = new EdmCollectionValue(edmCollectionTypeReference, edmDelayedValues);
return(edmCollectionValue);
}
case EdmExpressionKind.Path:
{
EdmUtil.CheckArgumentNull <IEdmStructuredValue>(context, "context");
IEdmPathExpression edmPathExpression = (IEdmPathExpression)expression;
IEdmValue edmValue = context;
foreach (string path in edmPathExpression.Path)
{
edmValue = this.FindProperty(path, edmValue);
if (edmValue != null)
{
continue;
}
throw new InvalidOperationException(Strings.Edm_Evaluator_UnboundPath(path));
}
return(edmValue);
}
case EdmExpressionKind.ParameterReference:
case EdmExpressionKind.FunctionReference:
case EdmExpressionKind.PropertyReference:
case EdmExpressionKind.ValueTermReference:
case EdmExpressionKind.EntitySetReference:
case EdmExpressionKind.EnumMemberReference:
{
throw new InvalidOperationException(string.Concat("Not yet implemented: evaluation of ", expression.ExpressionKind.ToString(), " expressions."));
}
case EdmExpressionKind.If:
{
IEdmIfExpression edmIfExpression = (IEdmIfExpression)expression;
if (!((IEdmBooleanValue)this.Eval(edmIfExpression.TestExpression, context)).Value)
{
return(this.Eval(edmIfExpression.FalseExpression, context));
}
else
{
return(this.Eval(edmIfExpression.TrueExpression, context));
}
}
case EdmExpressionKind.AssertType:
{
IEdmAssertTypeExpression edmAssertTypeExpression = (IEdmAssertTypeExpression)expression;
IEdmValue edmValue1 = this.Eval(edmAssertTypeExpression.Operand, context);
IEdmTypeReference type = edmAssertTypeExpression.Type;
return(EdmExpressionEvaluator.AssertType(type, edmValue1));
}
case EdmExpressionKind.IsType:
{
IEdmIsTypeExpression edmIsTypeExpression = (IEdmIsTypeExpression)expression;
IEdmValue edmValue2 = this.Eval(edmIsTypeExpression.Operand, context);
IEdmTypeReference edmTypeReference = edmIsTypeExpression.Type;
return(new EdmBooleanConstant(EdmExpressionEvaluator.MatchesType(edmTypeReference, edmValue2)));
}
case EdmExpressionKind.FunctionApplication:
{
IEdmApplyExpression edmApplyExpression = (IEdmApplyExpression)expression;
IEdmExpression appliedFunction = edmApplyExpression.AppliedFunction;
IEdmFunctionReferenceExpression edmFunctionReferenceExpression = appliedFunction as IEdmFunctionReferenceExpression;
if (edmFunctionReferenceExpression != null)
{
IList <IEdmExpression> list = edmApplyExpression.Arguments.ToList <IEdmExpression>();
IEdmValue[] edmValueArray = new IEdmValue[list.Count <IEdmExpression>()];
int num = 0;
foreach (IEdmExpression edmExpression in list)
{
int num1 = num;
num = num1 + 1;
edmValueArray[num1] = this.Eval(edmExpression, context);
}
IEdmFunction referencedFunction = edmFunctionReferenceExpression.ReferencedFunction;
if (referencedFunction.IsBad() || !this.builtInFunctions.TryGetValue(referencedFunction, out func))
{
if (this.lastChanceFunctionApplier != null)
{
return(this.lastChanceFunctionApplier(referencedFunction.FullName(), edmValueArray));
}
}
else
{
return(func(edmValueArray));
}
}
if (edmFunctionReferenceExpression != null)
{
traceString = edmFunctionReferenceExpression.ReferencedFunction.ToTraceString();
}
else
{
traceString = string.Empty;
}
throw new InvalidOperationException(Strings.Edm_Evaluator_UnboundFunction(traceString));
}
case EdmExpressionKind.LabeledExpressionReference:
{
return(this.MapLabeledExpressionToDelayedValue(((IEdmLabeledExpressionReferenceExpression)expression).ReferencedLabeledExpression, null, context).Value);
}
case EdmExpressionKind.Labeled:
{
return(this.MapLabeledExpressionToDelayedValue(expression, new EdmExpressionEvaluator.DelayedExpressionContext(this, context), context).Value);
}
}
int expressionKind1 = (int)expression.ExpressionKind;
throw new InvalidOperationException(Strings.Edm_Evaluator_UnrecognizedExpressionKind(expressionKind1.ToString(CultureInfo.InvariantCulture)));
}
public IEdmValue Evaluate(IEdmExpression expression)
{
EdmUtil.CheckArgumentNull <IEdmExpression>(expression, "expression");
return(this.Eval(expression, null));
}
/// <summary>
/// Adds a schema element to this model.
/// </summary>
/// <param name="element">The element to register.</param>
protected void RegisterElement(IEdmSchemaElement element)
{
EdmUtil.CheckArgumentNull(element, "element");
RegistrationHelper.RegisterSchemaElement(element, this.schemaTypeDictionary, this.valueTermDictionary, this.functionDictionary, this.containersDictionary);
}
/// <summary>
/// Adds a model reference to this model.
/// </summary>
/// <param name="model">The model to reference.</param>
protected void AddReferencedModel(IEdmModel model)
{
EdmUtil.CheckArgumentNull(model, "model");
this.referencedEdmModels.Add(model);
}
/// <summary>
/// Gets the preferred prefix mappings for xml namespaces from an IEdmModel
/// </summary>
/// <param name="model">Reference to the calling object.</param>
/// <returns>Namespace prefixes that exist on the model.</returns>
public static IEnumerable <KeyValuePair <string, string> > GetNamespacePrefixMappings(this IEdmModel model)
{
EdmUtil.CheckArgumentNull(model, "model");
return(model.GetAnnotationValue <IEnumerable <KeyValuePair <string, string> > >(model, EdmConstants.InternalUri, CsdlConstants.NamespacePrefixAnnotation));
}
/// <summary>
/// Sets an annotation on the IEdmModel to notify the serializer of preferred prefix mappings for xml namespaces.
/// </summary>
/// <param name="model">Reference to the calling object.</param>
/// <param name="mappings">XmlNamespaceManage containing mappings between namespace prefixes and xml namespaces.</param>
public static void SetNamespacePrefixMappings(this IEdmModel model, IEnumerable <KeyValuePair <string, string> > mappings)
{
EdmUtil.CheckArgumentNull(model, "model");
model.SetAnnotationValue(model, EdmConstants.InternalUri, CsdlConstants.NamespacePrefixAnnotation, mappings);
}
/// <summary>
/// Sets a value of EDMX version attribute of the <paramref name="model"/>.
/// </summary>
/// <param name="model">The model the version should be set for.</param>
/// <param name="version">The version.</param>
public static void SetEdmxVersion(this IEdmModel model, Version version)
{
EdmUtil.CheckArgumentNull(model, "model");
model.SetAnnotationValue(model, EdmConstants.InternalUri, CsdlConstants.EdmxVersionAnnotation, version);
}
/// <summary>
/// Initializes a new instance of the <see cref="EdmEntitySetReferenceExpression"/> class.
/// </summary>
/// <param name="referencedEntitySet">Referenced entity set.</param>
public EdmEntitySetReferenceExpression(IEdmEntitySet referencedEntitySet)
{
EdmUtil.CheckArgumentNull(referencedEntitySet, "referencedEntitySet");
this.referencedEntitySet = referencedEntitySet;
}
public IEdmValue Evaluate(IEdmExpression expression, IEdmStructuredValue context)
{
EdmUtil.CheckArgumentNull <IEdmExpression>(expression, "expression");
return(this.Eval(expression, context));
}
/// <summary>
/// Initializes a new instance of the <see cref="EdmOperationReferenceExpression"/> class.
/// </summary>
/// <param name="referencedOperation">Referenced operation</param>
public EdmOperationReferenceExpression(IEdmOperation referencedOperation)
{
EdmUtil.CheckArgumentNull(referencedOperation, "referencedFunction");
this.referencedOperation = referencedOperation;
}
public IEdmValue Evaluate(IEdmExpression expression, IEdmStructuredValue context, IEdmTypeReference targetType)
{
EdmUtil.CheckArgumentNull <IEdmExpression>(expression, "expression");
EdmUtil.CheckArgumentNull <IEdmTypeReference>(targetType, "targetType");
return(EdmExpressionEvaluator.AssertType(targetType, this.Eval(expression, context)));
}
/// <summary>
/// Initializes a new instance of the <see cref="EdmTypeAnnotation"/> class.
/// </summary>
/// <param name="target">Element the annotation applies to.</param>
/// <param name="term">Term bound by the annotation.</param>
/// <param name="qualifier">Qualifier used to discriminate between multiple bindings of the same property or type.</param>
/// <param name="propertyValueBindings">Value annotations for the properties of the type.</param>
public EdmTypeAnnotation(IEdmVocabularyAnnotatable target, IEdmTerm term, string qualifier, IEnumerable <IEdmPropertyValueBinding> propertyValueBindings)
: base(target, term, qualifier)
{
EdmUtil.CheckArgumentNull(propertyValueBindings, "propertyValueBindings");
this.propertyValueBindings = propertyValueBindings;
}
/// <summary>
/// Initializes a new instance of the <see cref="EdmEnumMemberReferenceExpression"/> class.
/// </summary>
/// <param name="referencedEnumMember">Referenced enum member.</param>
public EdmEnumMemberReferenceExpression(IEdmEnumMember referencedEnumMember)
{
EdmUtil.CheckArgumentNull(referencedEnumMember, "referencedEnumMember");
this.referencedEnumMember = referencedEnumMember;
}
public void AddParameter(IEdmFunctionParameter parameter)
{
EdmUtil.CheckArgumentNull <IEdmFunctionParameter>(parameter, "parameter");
this.parameters.Add(parameter);
}
/// <summary>
/// Initializes a new instance of the <see cref="EdmCollectionType"/> class.
/// </summary>
/// <param name="elementType">The type of the elements in this collection.</param>
public EdmCollectionType(IEdmTypeReference elementType)
{
EdmUtil.CheckArgumentNull(elementType, "elementType");
this.elementType = elementType;
}
/// <summary>
/// Converts <paramref name="edmValue"/> to a <see cref="System.Boolean"/> value.
/// </summary>
/// <param name="edmValue">The EDM value to be converted.</param>
/// <returns>Converted boolean.</returns>
/// <exception cref="InvalidCastException">Exception is thrown if <paramref name="edmValue"/> is not <see cref="IEdmBooleanValue"/>.</exception>
internal static Boolean AsClrBoolean(IEdmValue edmValue)
{
EdmUtil.CheckArgumentNull(edmValue, "edmValue");
return(((IEdmBooleanValue)edmValue).Value);
}
public EdmEntityReferenceType(IEdmEntityType entityType)
{
EdmUtil.CheckArgumentNull <IEdmEntityType>(entityType, "entityType");
this.entityType = entityType;
}
/// <summary>
/// Converts <paramref name="edmValue"/> to a <see cref="System.Double"/> value.
/// </summary>
/// <param name="edmValue">The EDM value to be converted.</param>
/// <returns>Converted double.</returns>
/// <exception cref="InvalidCastException">Exception is thrown if <paramref name="edmValue"/> is not <see cref="IEdmFloatingValue"/>.</exception>
internal static Double AsClrDouble(IEdmValue edmValue)
{
EdmUtil.CheckArgumentNull(edmValue, "edmValue");
return(((IEdmFloatingValue)edmValue).Value);
}
/// <summary>
/// Initializes a new instance of the <see cref="EdmPathExpression"/> class.
/// </summary>
/// <param name="path">Path string containing segments seperated by '/'. For example: "A.B/C/D.E/Func1(NS.T,NS.T2)/P1".</param>
public EdmPathExpression(string path)
: this(EdmUtil.CheckArgumentNull(path, "path").Split('/'))
{
}
/// <summary>
/// Converts <paramref name="edmValue"/> to a <see cref="Microsoft.OData.Edm.Date"/> value.
/// </summary>
/// <param name="edmValue">The EDM value to be converted.</param>
/// <returns>Converted date.</returns>
/// <exception cref="InvalidCastException">Exception is thrown if <paramref name="edmValue"/> is not <see cref="IEdmDateValue"/>.</exception>
internal static Date AsClrDate(IEdmValue edmValue)
{
EdmUtil.CheckArgumentNull(edmValue, "edmValue");
return(((IEdmDateValue)edmValue).Value);
}
/// <summary>
/// Determines if the type of an expression is compatible with the provided type
/// </summary>
/// <param name="expression">The expression to assert the type of.</param>
/// <param name="type">The type to assert the expression as.</param>
/// <param name="context">The context paths are to be evaluated in.</param>
/// <param name="matchExactly">A value indicating whether the expression must match the asserted type exactly, or simply be compatible.</param>
/// <param name="discoveredErrors">Errors produced if the expression does not match the specified type.</param>
/// <returns>A value indicating whether the expression is valid for the given type or not.</returns>
/// <remarks>If the expression has an associated type, this function will check that it matches the expected type and stop looking further.
/// If an expression claims a type, it must be validated that the type is valid for the expression. If the expression does not claim a type
/// this method will attempt to check the validity of the expression itself with the asserted type.</remarks>
public static bool TryCast(this IEdmExpression expression, IEdmTypeReference type, IEdmType context, bool matchExactly, out IEnumerable <EdmError> discoveredErrors)
{
EdmUtil.CheckArgumentNull(expression, "expression");
type = type.AsActualTypeReference();
// If we don't have a type to assert this passes vacuously.
if (type == null || type.TypeKind() == EdmTypeKind.None)
{
discoveredErrors = Enumerable.Empty <EdmError>();
return(true);
}
switch (expression.ExpressionKind)
{
case EdmExpressionKind.IntegerConstant:
case EdmExpressionKind.StringConstant:
case EdmExpressionKind.BinaryConstant:
case EdmExpressionKind.BooleanConstant:
case EdmExpressionKind.DateTimeOffsetConstant:
case EdmExpressionKind.DecimalConstant:
case EdmExpressionKind.FloatingConstant:
case EdmExpressionKind.GuidConstant:
case EdmExpressionKind.DurationConstant:
case EdmExpressionKind.DateConstant:
case EdmExpressionKind.TimeOfDayConstant:
IEdmPrimitiveValue primitiveValue = (IEdmPrimitiveValue)expression;
if (primitiveValue.Type != null)
{
return(TestTypeReferenceMatch(primitiveValue.Type, type, expression.Location(), matchExactly, out discoveredErrors));
}
return(TryCastPrimitiveAsType(primitiveValue, type, out discoveredErrors));
case EdmExpressionKind.Null:
return(TryCastNullAsType((IEdmNullExpression)expression, type, out discoveredErrors));
case EdmExpressionKind.Path:
case EdmExpressionKind.PropertyPath:
case EdmExpressionKind.NavigationPropertyPath:
return(TryCastPathAsType((IEdmPathExpression)expression, type, context, matchExactly, out discoveredErrors));
case EdmExpressionKind.FunctionApplication:
IEdmApplyExpression applyExpression = (IEdmApplyExpression)expression;
if (applyExpression.AppliedFunction != null)
{
IEdmOperation operation = applyExpression.AppliedFunction as IEdmOperation;
if (operation != null)
{
return(TestTypeReferenceMatch(operation.ReturnType, type, expression.Location(), matchExactly, out discoveredErrors));
}
}
// If we don't have the applied function we just assume that it will work.
discoveredErrors = Enumerable.Empty <EdmError>();
return(true);
case EdmExpressionKind.If:
return(TryCastIfAsType((IEdmIfExpression)expression, type, context, matchExactly, out discoveredErrors));
case EdmExpressionKind.IsType:
return(TestTypeReferenceMatch(EdmCoreModel.Instance.GetBoolean(false), type, expression.Location(), matchExactly, out discoveredErrors));
case EdmExpressionKind.Record:
IEdmRecordExpression recordExpression = (IEdmRecordExpression)expression;
if (recordExpression.DeclaredType != null)
{
return(TestTypeReferenceMatch(recordExpression.DeclaredType, type, expression.Location(), matchExactly, out discoveredErrors));
}
return(TryCastRecordAsType(recordExpression, type, context, matchExactly, out discoveredErrors));
case EdmExpressionKind.Collection:
IEdmCollectionExpression collectionExpression = (IEdmCollectionExpression)expression;
if (collectionExpression.DeclaredType != null)
{
return(TestTypeReferenceMatch(collectionExpression.DeclaredType, type, expression.Location(), matchExactly, out discoveredErrors));
}
return(TryCastCollectionAsType(collectionExpression, type, context, matchExactly, out discoveredErrors));
case EdmExpressionKind.Labeled:
return(TryCast(((IEdmLabeledExpression)expression).Expression, type, context, matchExactly, out discoveredErrors));
case EdmExpressionKind.Cast:
return(TestTypeReferenceMatch(((IEdmCastExpression)expression).Type, type, expression.Location(), matchExactly, out discoveredErrors));
case EdmExpressionKind.LabeledExpressionReference:
return(TryCast(((IEdmLabeledExpressionReferenceExpression)expression).ReferencedLabeledExpression, type, out discoveredErrors));
default:
discoveredErrors = new EdmError[] { new EdmError(expression.Location(), EdmErrorCode.ExpressionNotValidForTheAssertedType, Edm.Strings.EdmModel_Validator_Semantic_ExpressionNotValidForTheAssertedType) };
return(false);
}
}
/// <summary>
/// Converts <paramref name="edmValue"/> to a <see cref="System.TimeSpan"/> value.
/// </summary>
/// <param name="edmValue">The EDM value to be converted.</param>
/// <returns>Converted Duration.</returns>
/// <exception cref="InvalidCastException">Exception is thrown if <paramref name="edmValue"/> is not <see cref="IEdmDurationValue"/>.</exception>
internal static TimeSpan AsClrDuration(IEdmValue edmValue)
{
EdmUtil.CheckArgumentNull(edmValue, "edmValue");
return(((IEdmDurationValue)edmValue).Value);
}
/// <summary>
/// Gets the namespaces in all schemas having alias, excluding those without alias.
/// </summary>
/// <param name="model">The IEdmModel.</param>
/// <returns>The namespaces in all schemas having alias.</returns>
internal static VersioningList <string> GetUsedNamespacesHavingAlias(this IEdmModel model)
{
EdmUtil.CheckArgumentNull(model, "model");
return(model.GetAnnotationValue <VersioningList <string> >(model, EdmConstants.InternalUri, CsdlConstants.UsedNamespacesAnnotation));
}