public void Init() { this._address = new Address { Street = "123 fake st" }; this._entity = new Customer { Id = 1, Address = this._address, Emails = new List <string> { "*****@*****.**" } }; var model = new ClientEdmModel(ODataProtocolVersion.V4); var entityType = model.GetOrCreateEdmType(typeof(Customer)); var complexType = model.GetOrCreateEdmType(typeof(Address)); this._complexValue = new ClientEdmStructuredValue(this._address, model, model.GetClientTypeAnnotation(complexType)); this._entityValue = new ClientEdmStructuredValue(this._entity, model, model.GetClientTypeAnnotation(entityType)); }
/// <summary> /// Evaluate IEdmVocabularyAnnotation to an CLR object /// </summary> /// <typeparam name="TResult">The CLR type of the annotation to be returned.</typeparam> /// <param name="context">The data service context.</param> /// <param name="edmValueAnnotation">IEdmVocabularyAnnotation to be evaluated.</param> /// <param name="clientEdmValue">Value to use as context in evaluating the expression.</param> /// <param name="annotationValue">Value of the term evaluated.</param> /// <returns>True if the annotation value can be evaluated, else false.</returns> private static bool TryEvaluateMetadataAnnotation <TResult>(DataServiceContext context, IEdmVocabularyAnnotation edmValueAnnotation, ClientEdmStructuredValue clientEdmValue, out TResult annotationValue) { if (edmValueAnnotation == null) { annotationValue = default(TResult); return(false); } EdmToClrEvaluator evaluator = CreateEdmToClrEvaluator(context); try { annotationValue = evaluator.EvaluateToClrValue <TResult>(edmValueAnnotation.Value, clientEdmValue); } catch (InvalidOperationException) { // When expression contains Path. if the clientEdmValue is null, or the related property is not valid property of the clientEdmValue. // TheEvaluateToClrValue might throw InvalidOperationException; annotationValue = default(TResult); return(false); } return(true); }
/// <summary> /// Gets the CLR value of a term that has been applied to the specified object /// </summary> /// <typeparam name="TResult">The CLR type of the annotation to be returned.</typeparam> /// <param name="context">The data service context.</param> /// <param name="source">The specified annotated object instance.</param> /// <param name="term">The term name.</param> /// <param name="qualifier">The qualifier name.</param> /// <param name="annotationValue">Value of the term evaluated.</param> /// <returns>True if the annotation value can be evaluated, else false.</returns> internal static bool TryGetMetadataAnnotation <TResult>(DataServiceContext context, object source, string term, string qualifier, out TResult annotationValue) { IEdmVocabularyAnnotation edmValueAnnotation = null; ClientEdmStructuredValue clientEdmValue = null; PropertyInfo propertyInfo = null; MethodInfo methodInfo = null; var keyValue = source as Tuple <object, MemberInfo>; if (keyValue != null) { // Get metadata annotation defined on property or Navigation property or Operation or OperationImport var instance = keyValue.Item1; var memberInfo = keyValue.Item2; propertyInfo = memberInfo as PropertyInfo; methodInfo = memberInfo as MethodInfo; if (instance != null) { IEdmType edmType = context.Model.GetOrCreateEdmType(instance.GetType()); if (edmType is IEdmStructuredType) { ClientTypeAnnotation clientTypeAnnotation = context.Model.GetClientTypeAnnotation(edmType); clientEdmValue = new ClientEdmStructuredValue(instance, context.Model, clientTypeAnnotation); } } } else { if (propertyInfo == null) { propertyInfo = source as PropertyInfo; } if (methodInfo == null) { methodInfo = source as MethodInfo; } } if (propertyInfo != null) { edmValueAnnotation = GetOrInsertCachedMetadataAnnotationForPropertyInfo(context, propertyInfo, term, qualifier); return(TryEvaluateMetadataAnnotation(context, edmValueAnnotation, clientEdmValue, out annotationValue)); } if (methodInfo != null) { edmValueAnnotation = GetOrInsertCachedMetadataAnnotationForMethodInfo(context, methodInfo, term, qualifier); return(TryEvaluateMetadataAnnotation(context, edmValueAnnotation, clientEdmValue, out annotationValue)); } var type = source as Type; Type underlyingType = type; if (type == null) { type = source.GetType(); underlyingType = Nullable.GetUnderlyingType(type) ?? type; // For complex type or entity type instance, try to convert the instance to ClientEdmStructuredValue for further evaluation. IEdmType edmType = context.Model.GetOrCreateEdmType(underlyingType); if (edmType is IEdmStructuredType) { ClientTypeAnnotation clientTypeAnnotation = context.Model.GetClientTypeAnnotation(edmType); clientEdmValue = new ClientEdmStructuredValue(source, context.Model, clientTypeAnnotation); } } edmValueAnnotation = GetOrInsertCachedMetadataAnnotationForType(context, underlyingType, term, qualifier); return(TryEvaluateMetadataAnnotation(context, edmValueAnnotation, clientEdmValue, out annotationValue)); }