Ejemplo n.º 1
0
        /// <summary>
        /// Returns true if function signatures are semantically equivalent.
        /// Signature includes function name (<see cref="IEdmNamedElement"/>) and its parameter types.
        /// </summary>
        /// <param name="thisFunction">Reference to the calling object.</param>
        /// <param name="otherFunction">Function being compared to.</param>
        /// <returns>Equivalence of signatures of the two functions.</returns>
        internal static bool IsFunctionSignatureEquivalentTo(this IEdmFunctionBase thisFunction, IEdmFunctionBase otherFunction)
        {
            if (thisFunction == otherFunction)
            {
                return(true);
            }

            if (thisFunction.Name != otherFunction.Name)
            {
                return(false);
            }

            if (!thisFunction.ReturnType.IsEquivalentTo(otherFunction.ReturnType))
            {
                return(false);
            }

            IEnumerator <IEdmFunctionParameter> otherFunctionParameterEnumerator = otherFunction.Parameters.GetEnumerator();

            foreach (IEdmFunctionParameter parameter in thisFunction.Parameters)
            {
                otherFunctionParameterEnumerator.MoveNext();
                if (!parameter.IsEquivalentTo(otherFunctionParameterEnumerator.Current))
                {
                    return(false);
                }
            }

            return(true);
        }
Ejemplo n.º 2
0
 protected virtual void ProcessFunctionBase(IEdmFunctionBase functionBase)
 {
     if (functionBase.ReturnType != null)
     {
         this.VisitTypeReference(functionBase.ReturnType);
     }
     this.VisitFunctionParameters(functionBase.Parameters);
 }
Ejemplo n.º 3
0
 public EdmFunctionParameter(IEdmFunctionBase declaringFunction, string name, IEdmTypeReference type, EdmFunctionParameterMode mode) : base(name)
 {
     EdmUtil.CheckArgumentNull <IEdmFunctionBase>(declaringFunction, "declaringFunction");
     EdmUtil.CheckArgumentNull <string>(name, "name");
     EdmUtil.CheckArgumentNull <IEdmTypeReference>(type, "type");
     this.type = type;
     this.mode = mode;
     this.declaringFunction = declaringFunction;
 }
Ejemplo n.º 4
0
		public EdmFunctionParameter(IEdmFunctionBase declaringFunction, string name, IEdmTypeReference type, EdmFunctionParameterMode mode) : base(name)
		{
			EdmUtil.CheckArgumentNull<IEdmFunctionBase>(declaringFunction, "declaringFunction");
			EdmUtil.CheckArgumentNull<string>(name, "name");
			EdmUtil.CheckArgumentNull<IEdmTypeReference>(type, "type");
			this.type = type;
			this.mode = mode;
			this.declaringFunction = declaringFunction;
		}
Ejemplo n.º 5
0
        /// <summary>
        /// Initializes a new instance of <see cref="EdmFunctionParameterFacade"/> class.
        /// </summary>
        /// <param name="serverFunctionParameter">The function parameter from the server-side model to wrap.</param>
        /// <param name="declaringFunctionFacade">The function import facade which this parameter belongs to.</param>
        /// <param name="modelFacade">The edm model facade this function import belongs to.</param>
        public EdmFunctionParameterFacade(IEdmFunctionParameter serverFunctionParameter, EdmFunctionImportFacade declaringFunctionFacade, EdmModelFacade modelFacade)
        {
            Debug.Assert(serverFunctionParameter != null, "serverFunctionParameter != null");
            Debug.Assert(declaringFunctionFacade != null, "declaringFunctionFacade != null");
            Debug.Assert(modelFacade != null, "modelFacade != null");

            this.serverFunctionParameter = serverFunctionParameter;
            this.declaringFunction       = declaringFunctionFacade;
            this.type = modelFacade.GetOrCreateEntityTypeFacadeOrReturnNonEntityServerType(serverFunctionParameter.Type.Definition).ToEdmTypeReference(serverFunctionParameter.Type.IsNullable);
        }
        /// <summary>
        /// Initializes a new instance of <see cref="EdmFunctionParameterFacade"/> class.
        /// </summary>
        /// <param name="serverFunctionParameter">The function parameter from the server-side model to wrap.</param>
        /// <param name="declaringFunctionFacade">The function import facade which this parameter belongs to.</param>
        /// <param name="modelFacade">The edm model facade this function import belongs to.</param>
        public EdmFunctionParameterFacade(IEdmFunctionParameter serverFunctionParameter, EdmFunctionImportFacade declaringFunctionFacade, EdmModelFacade modelFacade)
        {
            Debug.Assert(serverFunctionParameter != null, "serverFunctionParameter != null");
            Debug.Assert(declaringFunctionFacade != null, "declaringFunctionFacade != null");
            Debug.Assert(modelFacade != null, "modelFacade != null");

            this.serverFunctionParameter = serverFunctionParameter;
            this.declaringFunction = declaringFunctionFacade;
            this.type = modelFacade.GetOrCreateEntityTypeFacadeOrReturnNonEntityServerType(serverFunctionParameter.Type.Definition).ToEdmTypeReference(serverFunctionParameter.Type.IsNullable);
        }
Ejemplo n.º 7
0
        protected virtual void ProcessFunctionBase(IEdmFunctionBase functionBase)
        {
            if (functionBase.ReturnType != null)
            {
                this.VisitTypeReference(functionBase.ReturnType);
            }

            // Do not visit vocabularyAnnotatable because functions and function imports are always going to be either a schema element or a container element and will be visited through those paths.
            this.VisitFunctionParameters(functionBase.Parameters);
        }
Ejemplo n.º 8
0
        public static string ParameterizedName(IEdmFunctionBase function)
        {
            int           index          = 0;
            int           parameterCount = function.Parameters.Count();
            StringBuilder sb             = new StringBuilder();

            UnresolvedFunction unresolvedFunctionImport = function as UnresolvedFunction;

            if (unresolvedFunctionImport != null)
            {
                sb.Append(unresolvedFunctionImport.Namespace);
                sb.Append("/");
                sb.Append(unresolvedFunctionImport.Name);
                return(sb.ToString());
            }

            // If we have a function (rather than a function import), we want the parameterized name to include the namespace
            IEdmSchemaElement schemaFunction = function as IEdmSchemaElement;

            if (schemaFunction != null)
            {
                sb.Append(schemaFunction.Namespace);
                sb.Append(".");
            }

            sb.Append(function.Name);
            sb.Append("(");
            foreach (IEdmFunctionParameter parameter in function.Parameters)
            {
                string typeName = "";
                if (parameter.Type.IsCollection())
                {
                    typeName = CsdlConstants.Value_Collection + "(" + parameter.Type.AsCollection().ElementType().FullName() + ")";
                }
                else if (parameter.Type.IsEntityReference())
                {
                    typeName = CsdlConstants.Value_Ref + "(" + parameter.Type.AsEntityReference().EntityType().FullName() + ")";
                }
                else
                {
                    typeName = parameter.Type.FullName();
                }

                sb.Append(typeName);
                index++;
                if (index < parameterCount)
                {
                    sb.Append(", ");
                }
            }

            sb.Append(")");
            return(sb.ToString());
        }
Ejemplo n.º 9
0
		public UnresolvedParameter(IEdmFunctionBase declaringFunction, string name, EdmLocation location)
			: base(new EdmError[] { new EdmError(location, EdmErrorCode.BadUnresolvedParameter, Strings.Bad_UnresolvedParameter(name)) })
		{
			this.type = new Cache<UnresolvedParameter, IEdmTypeReference>();
			string str = name;
			string empty = str;
			if (str == null)
			{
				empty = string.Empty;
			}
			this.name = empty;
			this.declaringFunction = declaringFunction;
		}
Ejemplo n.º 10
0
        public UnresolvedParameter(IEdmFunctionBase declaringFunction, string name, EdmLocation location)
            : base(new EdmError[] { new EdmError(location, EdmErrorCode.BadUnresolvedParameter, Strings.Bad_UnresolvedParameter(name)) })
        {
            this.type = new Cache <UnresolvedParameter, IEdmTypeReference>();
            string str   = name;
            string empty = str;

            if (str == null)
            {
                empty = string.Empty;
            }
            this.name = empty;
            this.declaringFunction = declaringFunction;
        }
Ejemplo n.º 11
0
        internal static bool IsFunctionSignatureEquivalentTo(this IEdmFunctionBase thisFunction, IEdmFunctionBase otherFunction)
        {
            bool flag;

            if (thisFunction != otherFunction)
            {
                if (thisFunction.Name == otherFunction.Name)
                {
                    if (thisFunction.ReturnType.IsEquivalentTo(otherFunction.ReturnType))
                    {
                        IEnumerator <IEdmFunctionParameter> enumerator  = otherFunction.Parameters.GetEnumerator();
                        IEnumerator <IEdmFunctionParameter> enumerator1 = thisFunction.Parameters.GetEnumerator();
                        using (enumerator1)
                        {
                            while (enumerator1.MoveNext())
                            {
                                IEdmFunctionParameter current = enumerator1.Current;
                                enumerator.MoveNext();
                                if (current.IsEquivalentTo(enumerator.Current))
                                {
                                    continue;
                                }
                                flag = false;
                                return(flag);
                            }
                            return(true);
                        }
                        return(flag);
                    }
                    else
                    {
                        return(false);
                    }
                }
                else
                {
                    return(false);
                }
            }
            else
            {
                return(true);
            }
        }
Ejemplo n.º 12
0
        public static string ParameterizedName(IEdmFunctionBase function)
        {
            string            str;
            int               num              = 0;
            int               num1             = function.Parameters.Count <IEdmFunctionParameter>();
            StringBuilder     stringBuilder    = new StringBuilder();
            IEdmSchemaElement edmSchemaElement = function as IEdmSchemaElement;

            if (edmSchemaElement != null)
            {
                stringBuilder.Append(edmSchemaElement.Namespace);
                stringBuilder.Append(".");
            }
            stringBuilder.Append(function.Name);
            stringBuilder.Append("(");
            foreach (IEdmFunctionParameter parameter in function.Parameters)
            {
                if (!parameter.Type.IsCollection())
                {
                    if (!parameter.Type.IsEntityReference())
                    {
                        str = parameter.Type.FullName();
                    }
                    else
                    {
                        str = string.Concat("Ref(", parameter.Type.AsEntityReference().EntityType().FullName(), ")");
                    }
                }
                else
                {
                    str = string.Concat("Collection(", parameter.Type.AsCollection().ElementType().FullName(), ")");
                }
                stringBuilder.Append(str);
                num++;
                if (num >= num1)
                {
                    continue;
                }
                stringBuilder.Append(", ");
            }
            stringBuilder.Append(")");
            return(stringBuilder.ToString());
        }
Ejemplo n.º 13
0
        public static bool TryAssertType(this IEdmExpression expression, IEdmTypeReference type, out IEnumerable <EdmError> discoveredErrors)
        {
            EdmError[] edmError;
            EdmUtil.CheckArgumentNull <IEdmExpression>(expression, "expression");
            if (type == null || type.TypeKind() == EdmTypeKind.None)
            {
                discoveredErrors = Enumerable.Empty <EdmError>();
                return(true);
            }
            else
            {
                EdmExpressionKind expressionKind = expression.ExpressionKind;
                switch (expressionKind)
                {
                case EdmExpressionKind.BinaryConstant:
                case EdmExpressionKind.BooleanConstant:
                case EdmExpressionKind.DateTimeConstant:
                case EdmExpressionKind.DateTimeOffsetConstant:
                case EdmExpressionKind.DecimalConstant:
                case EdmExpressionKind.FloatingConstant:
                case EdmExpressionKind.GuidConstant:
                case EdmExpressionKind.IntegerConstant:
                case EdmExpressionKind.StringConstant:
                case EdmExpressionKind.TimeConstant:
                {
                    IEdmPrimitiveValue edmPrimitiveValue = (IEdmPrimitiveValue)expression;
                    if (edmPrimitiveValue.Type == null)
                    {
                        return(edmPrimitiveValue.TryAssertPrimitiveAsType(type, out discoveredErrors));
                    }
                    else
                    {
                        return(edmPrimitiveValue.Type.TestTypeMatch(type, expression.Location(), out discoveredErrors));
                    }
                }

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

                case EdmExpressionKind.Record:
                {
                    IEdmRecordExpression edmRecordExpression = (IEdmRecordExpression)expression;
                    if (edmRecordExpression.DeclaredType == null)
                    {
                        return(edmRecordExpression.TryAssertRecordAsType(type, out discoveredErrors));
                    }
                    else
                    {
                        return(edmRecordExpression.DeclaredType.TestTypeMatch(type, expression.Location(), out discoveredErrors));
                    }
                }

                case EdmExpressionKind.Collection:
                {
                    IEdmCollectionExpression edmCollectionExpression = (IEdmCollectionExpression)expression;
                    if (edmCollectionExpression.DeclaredType == null)
                    {
                        return(edmCollectionExpression.TryAssertCollectionAsType(type, out discoveredErrors));
                    }
                    else
                    {
                        return(edmCollectionExpression.DeclaredType.TestTypeMatch(type, expression.Location(), out discoveredErrors));
                    }
                }

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

                case EdmExpressionKind.ParameterReference:
                case EdmExpressionKind.FunctionReference:
                case EdmExpressionKind.PropertyReference:
                case EdmExpressionKind.ValueTermReference:
                case EdmExpressionKind.EntitySetReference:
                case EdmExpressionKind.EnumMemberReference:
                {
                    edmError         = new EdmError[1];
                    edmError[0]      = new EdmError(expression.Location(), EdmErrorCode.ExpressionNotValidForTheAssertedType, Strings.EdmModel_Validator_Semantic_ExpressionNotValidForTheAssertedType);
                    discoveredErrors = edmError;
                    return(false);
                }

                case EdmExpressionKind.If:
                {
                    return(((IEdmIfExpression)expression).TryAssertIfAsType(type, out discoveredErrors));
                }

                case EdmExpressionKind.AssertType:
                {
                    return(((IEdmAssertTypeExpression)expression).Type.TestTypeMatch(type, expression.Location(), out discoveredErrors));
                }

                case EdmExpressionKind.IsType:
                {
                    return(EdmCoreModel.Instance.GetBoolean(false).TestTypeMatch(type, expression.Location(), out discoveredErrors));
                }

                case EdmExpressionKind.FunctionApplication:
                {
                    IEdmApplyExpression edmApplyExpression = (IEdmApplyExpression)expression;
                    if (edmApplyExpression.AppliedFunction != null)
                    {
                        IEdmFunctionBase appliedFunction = edmApplyExpression.AppliedFunction as IEdmFunctionBase;
                        if (appliedFunction != null)
                        {
                            return(appliedFunction.ReturnType.TestTypeMatch(type, expression.Location(), out discoveredErrors));
                        }
                    }
                    discoveredErrors = Enumerable.Empty <EdmError>();
                    return(true);
                }

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

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

                default:
                {
                    edmError         = new EdmError[1];
                    edmError[0]      = new EdmError(expression.Location(), EdmErrorCode.ExpressionNotValidForTheAssertedType, Strings.EdmModel_Validator_Semantic_ExpressionNotValidForTheAssertedType);
                    discoveredErrors = edmError;
                    return(false);
                }
                }
            }
        }
Ejemplo n.º 14
0
 public UnresolvedParameter(IEdmFunctionBase declaringFunction, string name, EdmLocation location)
     : base(new EdmError[] { new EdmError(location, EdmErrorCode.BadUnresolvedParameter, Edm.Strings.Bad_UnresolvedParameter(name)) })
 {
     this.name = name ?? string.Empty;
     this.declaringFunction = declaringFunction;
 }
Ejemplo n.º 15
0
        /// <summary>
        /// Returns true if function signatures are semantically equivalent.
        /// Signature includes function name (<see cref="IEdmNamedElement"/>) and its parameter types.
        /// </summary>
        /// <param name="thisFunction">Reference to the calling object.</param>
        /// <param name="otherFunction">Function being compared to.</param>
        /// <returns>Equivalence of signatures of the two functions.</returns>
        internal static bool IsFunctionSignatureEquivalentTo(this IEdmFunctionBase thisFunction, IEdmFunctionBase otherFunction)
        {
            if (thisFunction == otherFunction)
            {
                return true;
            }
            
            if (thisFunction.Name != otherFunction.Name)
            {
                return false;
            }
            
            if (!thisFunction.ReturnType.IsEquivalentTo(otherFunction.ReturnType))
            {
                return false;
            }

            IEnumerator<IEdmFunctionParameter> otherFunctionParameterEnumerator = otherFunction.Parameters.GetEnumerator();
            foreach (IEdmFunctionParameter parameter in thisFunction.Parameters)
            {
                otherFunctionParameterEnumerator.MoveNext();
                if (!parameter.IsEquivalentTo(otherFunctionParameterEnumerator.Current))
                {
                    return false;
                }
            }

            return true;
        }
Ejemplo n.º 16
0
		public EdmFunctionParameter(IEdmFunctionBase declaringFunction, string name, IEdmTypeReference type) : this(declaringFunction, name, type, (EdmFunctionParameterMode)1)
		{
		}
Ejemplo n.º 17
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);
            }
        }
Ejemplo n.º 18
0
		internal static bool IsFunctionSignatureEquivalentTo(this IEdmFunctionBase thisFunction, IEdmFunctionBase otherFunction)
		{
			bool flag;
			if (thisFunction != otherFunction)
			{
				if (thisFunction.Name == otherFunction.Name)
				{
					if (thisFunction.ReturnType.IsEquivalentTo(otherFunction.ReturnType))
					{
						IEnumerator<IEdmFunctionParameter> enumerator = otherFunction.Parameters.GetEnumerator();
						IEnumerator<IEdmFunctionParameter> enumerator1 = thisFunction.Parameters.GetEnumerator();
						using (enumerator1)
						{
							while (enumerator1.MoveNext())
							{
								IEdmFunctionParameter current = enumerator1.Current;
								enumerator.MoveNext();
								if (current.IsEquivalentTo(enumerator.Current))
								{
									continue;
								}
								flag = false;
								return flag;
							}
							return true;
						}
						return flag;
					}
					else
					{
						return false;
					}
				}
				else
				{
					return false;
				}
			}
			else
			{
				return true;
			}
		}
Ejemplo n.º 19
0
 public EdmFunctionParameter(IEdmFunctionBase declaringFunction, string name, IEdmTypeReference type) : this(declaringFunction, name, type, (EdmFunctionParameterMode)1)
 {
 }
Ejemplo n.º 20
0
        /// <summary>
        /// Generates an action link following the OData URL conventions for the action <paramref name="action"/> and bound to the entity
        /// represented by <paramref name="entityContext"/>.
        /// </summary>
        /// <param name="entityContext">The <see cref="EntityInstanceContext"/> representing the entity for which the action link needs to be generated.</param>
        /// <param name="action">The action for which the action link needs to be generated.</param>
        /// <returns>The generated action link following OData URL conventions.</returns>
        public static Uri GenerateActionLink(this EntityInstanceContext entityContext, IEdmFunctionBase action)
        {
            if (entityContext == null)
            {
                throw Error.ArgumentNull("entityContext");
            }
            if (action == null)
            {
                throw Error.ArgumentNull("action");
            }

            IEdmFunctionParameter bindingParameter = action.Parameters.FirstOrDefault();

            if (bindingParameter == null || !bindingParameter.Type.IsEntity())
            {
                throw Error.Argument("action", SRResources.ActionNotBoundToEntity, action.Name);
            }

            return(GenerateActionLink(entityContext, bindingParameter.Type.FullName(), action.Name));
        }
        /// <summary>
        /// Generates an action link following the OData URL conventions for the action <paramref name="action"/> and bound to the entity
        /// represented by <paramref name="entityContext"/>.
        /// </summary>
        /// <param name="entityContext">The <see cref="EntityInstanceContext"/> representing the entity for which the action link needs to be generated.</param>
        /// <param name="action">The action for which the action link needs to be generated.</param>
        /// <returns>The generated action link following OData URL conventions.</returns>
        public static Uri GenerateActionLink(this EntityInstanceContext entityContext, IEdmFunctionBase action)
        {
            if (entityContext == null)
            {
                throw Error.ArgumentNull("entityContext");
            }
            if (action == null)
            {
                throw Error.ArgumentNull("action");
            }

            IEdmFunctionParameter bindingParameter = action.Parameters.FirstOrDefault();
            if (bindingParameter == null || !bindingParameter.Type.IsEntity())
            {
                throw Error.Argument("action", SRResources.ActionNotBoundToEntity, action.Name);
            }

            return GenerateActionLink(entityContext, bindingParameter.Type.FullName(), action.Name);
        }
Ejemplo n.º 22
0
 public UnresolvedParameter(IEdmFunctionBase declaringFunction, string name, EdmLocation location)
     : base(new EdmError[] { new EdmError(location, EdmErrorCode.BadUnresolvedParameter, Edm.Strings.Bad_UnresolvedParameter(name)) })
 {
     this.name = name ?? string.Empty;
     this.declaringFunction = declaringFunction;
 }