Exemplo n.º 1
0
        /// <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>
 /// Initializes a new instance of the <see cref="EdmLabeledExpressionReferenceExpression"/> class.
 /// This constructor will not allow changing <see cref="ReferencedLabeledExpression"/> property after the EdmLabeledExpressionReferenceExpression instance has been constructed.
 /// </summary>
 /// <param name="referencedLabeledExpression">Referenced labeled element.</param>
 public EdmLabeledExpressionReferenceExpression(IEdmLabeledExpression referencedLabeledExpression)
 {
     EdmUtil.CheckArgumentNull(referencedLabeledExpression, "referencedLabeledExpression");
     this.referencedLabeledExpression = referencedLabeledExpression;
 }
 /// <summary>
 /// Sets the schema an annotation should appear in.
 /// </summary>
 /// <param name="annotation">The annotation the schema should be set for.</param>
 /// <param name="model">Model containing the annotation.</param>
 /// <param name="schemaNamespace">The schema the annotation belongs in.</param>
 public static void SetSchemaNamespace(this IEdmVocabularyAnnotation annotation, IEdmModel model, string schemaNamespace)
 {
     EdmUtil.CheckArgumentNull(annotation, "annotation");
     EdmUtil.CheckArgumentNull(model, "model");
     model.SetAnnotationValue(annotation, EdmConstants.InternalUri, CsdlConstants.SchemaNamespaceAnnotation, schemaNamespace);
 }
Exemplo n.º 4
0
 /// <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);
 }
Exemplo n.º 5
0
 private static string PathAsXml(IEnumerable <string> path)
 {
     return(EdmUtil.JoinInternal("/", path));
 }
Exemplo n.º 6
0
 // This internal method exists so we can get a consistent view of the mappings through the entire serialization process.
 // Otherwise, changes to the dictionary durring serialization would result in an invalid or inconsistent output.
 internal static VersioningDictionary <string, string> GetNamespaceAliases(this IEdmModel model)
 {
     EdmUtil.CheckArgumentNull(model, "model");
     return(model.GetAnnotationValue <VersioningDictionary <string, string> >(model, EdmConstants.InternalUri, CsdlConstants.NamespaceAliasAnnotation));
 }
Exemplo n.º 7
0
 /// <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));
 }
Exemplo n.º 8
0
        /// <summary>
        /// Initializes a new instance of the <see cref="EdmToClrConverter"/> class.
        /// </summary>
        /// <param name="tryCreateObjectInstanceDelegate">The delegate customizing conversion of structured values.</param>
        public EdmToClrConverter(TryCreateObjectInstance tryCreateObjectInstanceDelegate)
        {
            EdmUtil.CheckArgumentNull(tryCreateObjectInstanceDelegate, "tryCreateObjectInstanceDelegate");

            this.tryCreateObjectInstanceDelegate = tryCreateObjectInstanceDelegate;
        }
Exemplo n.º 9
0
        private object AsClrObject(IEdmValue edmValue, Type clrObjectType)
        {
            EdmUtil.CheckArgumentNull(edmValue, "edmValue");
            EdmUtil.CheckArgumentNull(clrObjectType, "clrObjectType");

            if (edmValue is IEdmNullValue)
            {
                return(null);
            }

            IEdmStructuredValue edmStructuredValue = edmValue as IEdmStructuredValue;

            if (edmStructuredValue == null)
            {
                if (edmValue is IEdmCollectionValue)
                {
                    throw new InvalidCastException(Strings.EdmToClr_CannotConvertEdmCollectionValueToClrType(clrObjectType.FullName));
                }
                else
                {
                    throw new InvalidCastException(Strings.EdmToClr_CannotConvertEdmValueToClrType(GetEdmValueInterfaceName(edmValue), clrObjectType.FullName));
                }
            }

            object clrObject;

            if (this.convertedObjects.TryGetValue(edmStructuredValue, out clrObject))
            {
                return(clrObject);
            }

            // By convention we only support mapping structured values to a CLR class.
            if (!clrObjectType.IsClass())
            {
                throw new InvalidCastException(Strings.EdmToClr_StructuredValueMappedToNonClass);
            }

            // Try user-defined logic before the default logic.
            bool clrObjectInitialized;

            if (this.tryCreateObjectInstanceDelegate != null && this.tryCreateObjectInstanceDelegate(edmStructuredValue, clrObjectType, this, out clrObject, out clrObjectInitialized))
            {
                // The user-defined logic might have produced null, which is Ok, but we need to null the type in to keep them in sync.
                if (clrObject != null)
                {
                    Type newClrObjectType = clrObject.GetType();
                    if (!clrObjectType.IsAssignableFrom(newClrObjectType))
                    {
                        throw new InvalidCastException(Strings.EdmToClr_TryCreateObjectInstanceReturnedWrongObject(newClrObjectType.FullName, clrObjectType.FullName));
                    }

                    clrObjectType = newClrObjectType;
                }
            }
            else
            {
                // Default instance creation logic: use Activator to create the new CLR object from the type.
                clrObject            = Activator.CreateInstance(clrObjectType);
                clrObjectInitialized = false;
            }

            // Cache the object before populating its properties as their values might refer to the object.
            this.convertedObjects[edmStructuredValue] = clrObject;

            if (!clrObjectInitialized && clrObject != null)
            {
                this.PopulateObjectProperties(edmStructuredValue, clrObject, clrObjectType);
            }

            return(clrObject);
        }
Exemplo n.º 10
0
        /// <summary>
        /// Converts <paramref name="edmValue"/> to a <see cref="System.Guid"/> value.
        /// </summary>
        /// <param name="edmValue">The EDM value to be converted.</param>
        /// <returns>Converted Guid.</returns>
        /// <exception cref="InvalidCastException">Exception is thrown if <paramref name="edmValue"/> is not <see cref="IEdmGuidValue"/>.</exception>
        internal static Guid AsClrGuid(IEdmValue edmValue)
        {
            EdmUtil.CheckArgumentNull(edmValue, "edmValue");

            return(((IEdmGuidValue)edmValue).Value);
        }
Exemplo n.º 11
0
        /// <summary>
        /// Converts <paramref name="edmValue"/> to a <see cref="System.DateTimeOffset"/> value.
        /// </summary>
        /// <param name="edmValue">The EDM value to be converted.</param>
        /// <returns>Converted DateTimeOffset.</returns>
        /// <exception cref="InvalidCastException">Exception is thrown if <paramref name="edmValue"/> is not <see cref="IEdmDateTimeOffsetValue"/>.</exception>
        internal static DateTimeOffset AsClrDateTimeOffset(IEdmValue edmValue)
        {
            EdmUtil.CheckArgumentNull(edmValue, "edmValue");

            return(((IEdmDateTimeOffsetValue)edmValue).Value);
        }
Exemplo n.º 12
0
        /// <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);
        }
Exemplo n.º 13
0
        /// <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);
        }
Exemplo n.º 14
0
        /// <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);
        }
Exemplo n.º 15
0
 /// <summary>
 /// Gets an annotation indicating whether the value of an enum member should be explicitly serialized.
 /// </summary>
 /// <param name="member">The member the annotation is on.</param>
 /// <param name="model">Model containing the member.</param>
 /// <returns>Whether the member should have its value serialized.</returns>
 public static bool?IsValueExplicit(this IEdmEnumMember member, IEdmModel model)
 {
     EdmUtil.CheckArgumentNull(member, "member");
     EdmUtil.CheckArgumentNull(model, "model");
     return(model.GetAnnotationValue(member, EdmConstants.InternalUri, CsdlConstants.IsEnumMemberValueExplicitAnnotation) as bool?);
 }
Exemplo n.º 16
0
 /// <summary>
 /// Returns true if this element contains errors returned by the <see cref="Errors"/> method.
 /// </summary>
 /// <param name="element">Reference to the calling object.</param>
 /// <returns>This element is an invalid element.</returns>
 public static bool IsBad(this IEdmElement element)
 {
     EdmUtil.CheckArgumentNull(element, "element");
     return(element.Errors().FirstOrDefault() != null);
 }
Exemplo n.º 17
0
 /// <summary>
 /// Gets an annotation indicating if the value should be serialized as an element.
 /// </summary>
 /// <param name="value">Value the annotation is on.</param>
 /// <param name="model">Model containing the value.</param>
 /// <returns>Value indicating if the string should be serialized as an element.</returns>
 public static bool IsSerializedAsElement(this IEdmValue value, IEdmModel model)
 {
     EdmUtil.CheckArgumentNull(value, "value");
     EdmUtil.CheckArgumentNull(model, "model");
     return((model.GetAnnotationValue(value, EdmConstants.InternalUri, CsdlConstants.IsSerializedAsElementAnnotation) as bool?) ?? false);
 }
Exemplo n.º 18
0
 /// <summary>
 /// Gets the errors, if any, that belong to this element or elements that this element contains. For example errors for a structural type include the errors of the type itself and errors of its declared properties.
 /// The method does not analyze elements referenced by this element. For example errors of a property do not include errors from its type.
 /// </summary>
 /// <param name="element">Reference to the calling object.</param>
 /// <returns>Any errors that belong to this element or elements that element contains.</returns>
 public static IEnumerable <EdmError> Errors(this IEdmElement element)
 {
     EdmUtil.CheckArgumentNull(element, "element");
     return(InterfaceValidator.GetStructuralErrors(element));
 }
Exemplo n.º 19
0
 internal static string TargetString(this IEdmVocabularyAnnotation annotation)
 {
     return(EdmUtil.FullyQualifiedName(annotation.Target));
 }
Exemplo n.º 20
0
 /// <summary>
 /// Gets the errors, if any, that belong to this type reference or its definition.
 /// </summary>
 /// <param name="type">The type reference.</param>
 /// <returns>Any errors that belong to this type reference or its definition.</returns>
 public static IEnumerable <EdmError> TypeErrors(this IEdmTypeReference type)
 {
     EdmUtil.CheckArgumentNull(type, "type");
     return(InterfaceValidator.GetStructuralErrors(type).Concat(InterfaceValidator.GetStructuralErrors(type.Definition)));
 }
Exemplo n.º 21
0
 /// <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);
 }
Exemplo n.º 22
0
 /// <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));
 }
Exemplo n.º 23
0
        private void AddSchema(CsdlSchema schema, bool addAnnotations)
        {
            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;
                            }

                            // TODO: REF referenced derived types
                            derivedTypes.Add(structuredType);
                        }
                    }
                }

                RegisterElement(type);
            }

            foreach (IEdmOperation function in schemaWrapper.Operations)
            {
                RegisterElement(function);
            }

            foreach (IEdmTerm valueTerm in schemaWrapper.Terms)
            {
                RegisterElement(valueTerm);
            }

            foreach (IEdmEntityContainer container in schemaWrapper.EntityContainers)
            {
                RegisterElement(container);
            }

            if (!string.IsNullOrEmpty(schema.Alias))
            {
                this.SetNamespaceAlias(schema.Namespace, schema.Alias);
            }

            if (addAnnotations)
            {
                foreach (CsdlAnnotations schemaOutOfLineAnnotations in schema.OutOfLineAnnotations)
                {
                    string target   = schemaOutOfLineAnnotations.Target;
                    string replaced = this.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));
                }
            }

            var edmVersion = this.GetEdmVersion();

            if (edmVersion == null || edmVersion < schema.Version)
            {
                this.SetEdmVersion(schema.Version);
            }
        }
Exemplo n.º 24
0
 /// <summary>
 /// Sets a value for the MaxDataServiceVersion attribute in an EDMX artifact.
 /// </summary>
 /// <param name="model">The model the attribute should be set for.</param>
 /// <param name="version">The value of the attribute.</param>
 public static void SetMaxDataServiceVersion(this IEdmModel model, Version version)
 {
     EdmUtil.CheckArgumentNull(model, "model");
     model.SetAnnotationValue(model, EdmConstants.InternalUri, EdmConstants.MaxDataServiceVersion, version);
 }
Exemplo n.º 25
0
 /// <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")))
 {
 }
Exemplo n.º 26
0
 /// <summary>
 /// Gets the value for the MaxDataServiceVersion attribute used during EDMX serialization.
 /// </summary>
 /// <param name="model">Model the attribute has been set for</param>
 /// <returns>Value of the attribute.</returns>
 public static Version GetMaxDataServiceVersion(this IEdmModel model)
 {
     EdmUtil.CheckArgumentNull(model, "model");
     return(model.GetAnnotationValue <Version>(model, EdmConstants.InternalUri, EdmConstants.MaxDataServiceVersion));
 }
Exemplo n.º 27
0
        /// <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 TryAssertType(this IEdmExpression expression, IEdmTypeReference type, IEdmType context, bool matchExactly, out IEnumerable <EdmError> discoveredErrors)
        {
            EdmUtil.CheckArgumentNull(expression, "expression");

            // 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.DateTimeConstant:
            case EdmExpressionKind.DateTimeOffsetConstant:
            case EdmExpressionKind.DecimalConstant:
            case EdmExpressionKind.FloatingConstant:
            case EdmExpressionKind.GuidConstant:
            case EdmExpressionKind.TimeConstant:
                IEdmPrimitiveValue primitiveValue = (IEdmPrimitiveValue)expression;
                if (primitiveValue.Type != null)
                {
                    return(TestTypeReferenceMatch(primitiveValue.Type, type, expression.Location(), matchExactly, out discoveredErrors));
                }

                return(TryAssertPrimitiveAsType(primitiveValue, type, out discoveredErrors));

            case EdmExpressionKind.Null:
                return(TryAssertNullAsType((IEdmNullExpression)expression, type, out discoveredErrors));

            case EdmExpressionKind.Path:
                return(TryAssertPathAsType((IEdmPathExpression)expression, type, context, matchExactly, out discoveredErrors));

            case EdmExpressionKind.FunctionApplication:
                IEdmApplyExpression applyExpression = (IEdmApplyExpression)expression;
                if (applyExpression.AppliedFunction != null)
                {
                    IEdmFunctionBase function = applyExpression.AppliedFunction as IEdmFunctionBase;
                    if (function != null)
                    {
                        return(TestTypeReferenceMatch(function.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(TryAssertIfAsType((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(TryAssertRecordAsType(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(TryAssertCollectionAsType(collectionExpression, type, context, matchExactly, out discoveredErrors));

            case EdmExpressionKind.Labeled:
                return(TryAssertType(((IEdmLabeledExpression)expression).Expression, type, context, matchExactly, out discoveredErrors));

            case EdmExpressionKind.AssertType:
                return(TestTypeReferenceMatch(((IEdmAssertTypeExpression)expression).Type, type, expression.Location(), matchExactly, out discoveredErrors));

            case EdmExpressionKind.LabeledExpressionReference:
                return(TryAssertType(((IEdmLabeledExpressionReferenceExpression)expression).ReferencedLabeledExpression, type, out discoveredErrors));

            default:
                discoveredErrors = new EdmError[] { new EdmError(expression.Location(), EdmErrorCode.ExpressionNotValidForTheAssertedType, Edm.Strings.EdmModel_Validator_Semantic_ExpressionNotValidForTheAssertedType) };
                return(false);
            }
        }
Exemplo n.º 28
0
 /// <summary>
 /// Sets an annotation indicating whether the value of an enum member should be explicitly serialized.
 /// </summary>
 /// <param name="member">Member to set the annotation on.</param>
 /// <param name="model">Model containing the member.</param>
 /// <param name="isExplicit">If the value of the enum member should be explicitly serialized</param>
 public static void SetIsValueExplicit(this IEdmEnumMember member, IEdmModel model, bool?isExplicit)
 {
     EdmUtil.CheckArgumentNull(member, "member");
     EdmUtil.CheckArgumentNull(model, "model");
     model.SetAnnotationValue(member, EdmConstants.InternalUri, CsdlConstants.IsEnumMemberValueExplicitAnnotation, (object)isExplicit);
 }
 /// <summary>
 /// Gets the schema an annotation should be serialized in.
 /// </summary>
 /// <param name="annotation">Reference to the calling annotation.</param>
 /// <param name="model">Model containing the annotation.</param>
 /// <returns>Name of the schema the annotation belongs to.</returns>
 public static string GetSchemaNamespace(this IEdmVocabularyAnnotation annotation, IEdmModel model)
 {
     EdmUtil.CheckArgumentNull(annotation, "annotation");
     EdmUtil.CheckArgumentNull(model, "model");
     return(model.GetAnnotationValue <string>(annotation, EdmConstants.InternalUri, CsdlConstants.SchemaNamespaceAnnotation));
 }
Exemplo n.º 30
0
        /// <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);
        }