コード例 #1
0
        private static IList <FunctionParameter> GetStoreReturnParameters(DbModel model, MethodInfo methodInfo, FunctionAttribute functionAttribute)
        {
            if (methodInfo.ReturnParameter == null || (methodInfo.ReturnParameter.ParameterType == typeof(void) && functionAttribute.Type != FunctionType.StoredProcedure))
            {
                throw new NotSupportedException(string.Format("The return type of {0} is not supported.", methodInfo.Name));
            }

            var returnParameterAttribute = methodInfo.ReturnParameter.GetCustomAttribute <ParameterAttribute>();

            //var returnTypeAttributes = methodInfo.GetCustomAttributes<ResultTypeAttribute>();

            if (functionAttribute.Type == FunctionType.StoredProcedure || functionAttribute.Type == FunctionType.TableValuedFunction)
            {
                if (returnParameterAttribute != null)
                {
                    throw new NotSupportedException(string.Format("ParameterAttribute for return value of method {0} is not supported.", methodInfo.Name));
                }
            }

            if (functionAttribute.Type == FunctionType.StoredProcedure || methodInfo.ReturnType == typeof(void))
            {
                //Stored Procedure
                return(new FunctionParameter[0]);
                //return new[]
                //{
                //	FunctionParameter.Create("ReturnType", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), ParameterMode.ReturnValue)
                //};
            }

            //if (returnTypeAttributes.Length > 0)
            //	throw new NotSupportedException(string.Format("ResultTypeAttribute for method {0} is not supported.", methodInfo.Name));

            if (functionAttribute.Type == FunctionType.TableValuedFunction)
            {
                //if (returnParameterAttribute != null)
                //	throw new NotSupportedException(string.Format("ParameterAttribute for return value of method {0} is not supported.", methodInfo.Name));

                /*
                 * <CollectionType>
                 * <RowType>
                 *      <Property Name="PersonID" Type="int" Nullable="false" />
                 *      <Property Name="FirstName" Type="nvarchar" MaxLength="50" />
                 *      <Property Name="LastName" Type="nvarchar" MaxLength="50" />
                 *      <Property Name="JobTitle" Type="nvarchar" MaxLength="50" />
                 *      <Property Name="BusinessEntityType" Type="nvarchar" MaxLength="50" />
                 * </RowType>
                 * </CollectionType>
                 */

                // returnParameterInfo.ParameterType is IQueryable<T>.
                var storeReturnParameterClrType        = methodInfo.ReturnParameter.ParameterType.GetGenericArguments().Single();
                var modelReturnParameterStructuralType = GetModelStructualType(model, storeReturnParameterClrType, methodInfo);
                var modelReturnParameterComplexType    = modelReturnParameterStructuralType as ComplexType;

                RowType storeReturnParameterRowType = null;
                if (modelReturnParameterComplexType != null)
                {
                    storeReturnParameterRowType = RowType.Create(
                        modelReturnParameterComplexType.Properties.Select(property =>
                                                                          EdmProperty.Create(property.Name, model.ProviderManifest.GetStoreType(property.TypeUsage))), null);
                }
                else
                {
                    var modelReturnParameterEntityType = modelReturnParameterStructuralType as EntityType;
                    if (modelReturnParameterEntityType != null)
                    {
                        storeReturnParameterRowType = RowType.Create(
                            modelReturnParameterEntityType.Properties.Select(property => CloneEdmProperty(property)), null);
                    }
                    else
                    {
                        throw new NotSupportedException(string.Format("Structural type {0} of method {1} cannot be converted to RowType.", modelReturnParameterStructuralType.FullName, methodInfo.Name));
                    }
                }

                return(new[]
                {
                    FunctionParameter.Create(
                        "ReturnType",
                        storeReturnParameterRowType.GetCollectionType(), // Collection of RowType.
                        ParameterMode.ReturnValue)
                });
            }

            //if (functionAttribute.Type == FunctionType.NonComposableScalarValuedFunction)
            //{
            //	// Non-composable scalar-valued function.
            //	return new FunctionParameter[0];
            //}

            // Composable scalar-valued/Aggregate/Built in/Niladic function.
            // <Function Name="ufnGetProductListPrice" Aggregate="false" BuiltIn="false" NiladicFunction="false" IsComposable="true" ParameterTypeSemantics="AllowImplicitConversion" Schema="dbo"
            //    ReturnType ="money">
            var storeReturnParameterPrimitiveType = GetStoreParameterPrimitiveType(model, methodInfo, methodInfo.ReturnParameter, functionAttribute);

            return(new[]
            {
                FunctionParameter.Create("ReturnType", storeReturnParameterPrimitiveType, ParameterMode.ReturnValue)
            });
        }
コード例 #2
0
        private static IList <FunctionParameter> GetStoreParameters(DbModel model, MethodInfo methodInfo, FunctionAttribute functionAttribute)
        {
            var parameters = GetDataParameters(methodInfo);

            if (parameters.Length > 0 && functionAttribute.Type == FunctionType.NiladicFunction)
            {
                throw new NotSupportedException(string.Format("The Niladic Function can not have parameter.", methodInfo.Name));
            }

            var result = new List <FunctionParameter>();

            for (int i = 0; i < parameters.Length; i++)
            {
                var parameterInfo   = parameters[i];
                var parameterAttrib = parameterInfo.GetCustomAttribute <ParameterAttribute>();
                var parameterName   = (parameterAttrib != null ? parameterAttrib.Name : null);
                if (string.IsNullOrWhiteSpace(parameterName))
                {
                    parameterName = parameterInfo.Name;
                }

                result.Add(
                    FunctionParameter.Create(
                        parameterName,
                        GetStoreParameterPrimitiveType(model, methodInfo, parameterInfo, functionAttribute),
                        (parameterInfo.IsOut || parameterInfo.ParameterType.IsByRef ? ParameterMode.InOut : ParameterMode.In)));
            }
            return(result.ToArray());
        }
コード例 #3
0
        private static IList <FunctionParameter> GetModelReturnParameters(DbModel model, MethodInfo methodInfo, FunctionAttribute functionAttribute)
        {
            var returnParameterInfo = methodInfo.ReturnParameter;

            if (returnParameterInfo == null || (returnParameterInfo.ParameterType == typeof(void) && functionAttribute.Type != FunctionType.StoredProcedure))
            {
                throw new NotSupportedException(string.Format("The return parameter type of {0} is not supported.", methodInfo.Name));
            }

            var returnParameterAttribute = returnParameterInfo.GetCustomAttribute <ParameterAttribute>();
            //var returnTypeAttributes = methodInfo.GetCustomAttributes<ResultTypeAttribute>();
            IEnumerable <EdmType> modelReturnParameterEdmTypes;

            if (functionAttribute.Type == FunctionType.StoredProcedure)
            {
                if (returnParameterAttribute != null)
                {
                    throw new NotSupportedException(string.Format("ParameterAttribute for method {0} is not supported.", methodInfo.Name));
                }

                modelReturnParameterEdmTypes =
                    GetStoredProcedureReturnTypes(methodInfo)
                    .Select(clrType => GetModelStructualType(model, clrType, methodInfo));
            }
            else
            {
                //if (returnTypeAttributes.Length > 0)
                //{
                //	throw new NotSupportedException(
                //		string.Format("ResultTypeAttribute for method {0} is not supported.", methodInfo.Name));
                //}

                if (functionAttribute.Type == FunctionType.TableValuedFunction)
                {
                    // returnParameterInfo.ParameterType is IQueryable<T>.
                    Type           returnParameterClrType             = returnParameterInfo.ParameterType.GetGenericArguments().Single();
                    StructuralType modelReturnParameterStructuralType = GetModelStructualType(model, returnParameterClrType, methodInfo);
                    modelReturnParameterEdmTypes = Enumerable.Repeat(modelReturnParameterStructuralType, 1);
                }
                else
                {
                    Type returnParameterClrType          = returnParameterInfo.ParameterType;
                    Type returnParameterAttributeClrType = (returnParameterAttribute != null ? returnParameterAttribute.ClrType : null);
                    if (returnParameterAttributeClrType != null && returnParameterAttributeClrType != returnParameterClrType)
                    {
                        throw new NotSupportedException(
                                  string.Format("Return parameter of method {0} is of {1}, but its ParameterAttribute.ClrType has a different type {2}",
                                                methodInfo.Name, returnParameterClrType.FullName, returnParameterAttributeClrType.FullName));
                    }

                    PrimitiveType returnParameterPrimitiveType = GetModelPrimitiveType(model, returnParameterClrType, methodInfo);
                    modelReturnParameterEdmTypes = Enumerable.Repeat(returnParameterPrimitiveType, 1);
                }
            }

            return(modelReturnParameterEdmTypes
                   .Select((edmType, index) => FunctionParameter.Create(
                               string.Format("ReturnType{0}", index),
                               edmType.GetCollectionType(),
                               ParameterMode.ReturnValue))
                   .ToArray());
        }
コード例 #4
0
        private static PrimitiveType GetStoreParameterPrimitiveType(DbModel model, MethodInfo methodInfo, ParameterInfo parameterInfo, FunctionAttribute functionAttribute)
        {
            var parameterClrType = parameterInfo.ParameterType;

            if (parameterClrType.IsByRef)
            {
                parameterClrType = parameterClrType.GetElementType();
            }
            var parameterAttribute = parameterInfo.GetCustomAttribute <ParameterAttribute>();

            //var parameterAttributeClrType = (parameterAttribute != null ? parameterAttribute.ClrType : null);
            if (parameterAttribute != null && parameterAttribute.ClrType != null)
            {
                parameterClrType = parameterAttribute.ClrType;
            }

            //if (parameterClrType.IsGenericType)
            //{
            //	var parameterClrTypeDefinition = parameterClrType.GetGenericTypeDefinition();
            //	if (parameterClrTypeDefinition == typeof(IEnumerable<>) || parameterClrTypeDefinition == typeof(IQueryable<>))
            //	{
            //		//if (functionAttribute.Type == FunctionType.AggregateFunction)
            //		//	parameterClrType = parameterClrType.GetGenericArguments().Single();
            //		//else
            //		throw new NotSupportedException(
            //			string.Format("Parameter {0} of method {1} is not supported. {2} parameter must be used for FunctionType.AggregateFunction method.",
            //				parameterInfo.Name, methodInfo.Name, typeof(IEnumerable<>).FullName));
            //	}
            //}

            //if (parameterClrType == typeof(ObjectParameter))
            //{
            //	// ObjectParameter must be used for stored procedure parameter.
            //	if (functionAttribute.Type != FunctionType.StoredProcedure)
            //	{
            //		throw new NotSupportedException(
            //			string.Format("Parameter {0} of method {1} is not supported. ObjectParameter parameter must be used for FunctionType.StoredProcedure method.",
            //				parameterInfo.Name, methodInfo.Name));
            //	}

            //	// ObjectParameter.Type is available only when methodInfo is called.
            //	// When building model, its store type/clr type must be provided by ParameterAttribute.
            //	if (parameterAttributeClrType == null)
            //	{
            //		throw new NotSupportedException(
            //			string.Format("Parameter {0} of method {1} is not supported. ObjectParameter parameter must have ParameterAttribute with ClrType specified, with optional DbType.",
            //				parameterInfo.Name, methodInfo.Name));
            //	}

            //	parameterClrType = parameterAttributeClrType;
            //}
            //else
            //{
            //	// When parameter is not ObjectParameter, ParameterAttribute.ClrType should be either not specified, or the same as parameterClrType.
            //	if (parameterAttributeClrType != null && parameterAttributeClrType != parameterClrType)
            //	{
            //		throw new NotSupportedException(
            //			string.Format("Parameter {0} of method {1} is not supported. It is of {2} type, but its ParameterAttribute.ClrType has a different type {3}",
            //				parameterInfo.Name, methodInfo.Name, parameterClrType.FullName, parameterAttributeClrType.FullName));
            //	}
            //}


            var storePrimitiveTypeName = (parameterAttribute != null ? parameterAttribute.DbType : null);

            return(!string.IsNullOrEmpty(storePrimitiveTypeName)
                                ? GetStorePrimitiveType(model, storePrimitiveTypeName, methodInfo, parameterInfo)
                                : GetStorePrimitiveType(model, parameterClrType, methodInfo, parameterInfo));
        }
コード例 #5
0
        private static IList <EntitySet> GetModelEntitySets(DbModel model, MethodInfo methodInfo, FunctionAttribute functionAttribute)
        {
            ParameterInfo returnParameterInfo = methodInfo.ReturnParameter;

            if (returnParameterInfo == null || (returnParameterInfo.ParameterType == typeof(void) && functionAttribute.Type != FunctionType.StoredProcedure))
            {
                throw new NotSupportedException(string.Format("The return parameter type of {0} is not supported.", methodInfo.Name));
            }

            if (returnParameterInfo.ParameterType == typeof(void))
            {
                return(new EntitySet[0]);
            }
            else if (functionAttribute.Type == FunctionType.StoredProcedure && returnParameterInfo.ParameterType != typeof(void))
            {
                //// returnParameterInfo.ParameterType is ObjectResult<T>.
                //var returnParameterClrTypes = GetStoredProcedureReturnTypes(methodInfo).ToArray();
                //if (returnParameterClrTypes.Length > 1)
                //{
                //	// Stored procedure has more than one result.
                //	// EdmFunctionPayload.EntitySets must be provided. Otherwise, an ArgumentException will be thrown:
                //	// The EntitySets parameter must not be null for functions that return multiple result sets.
                //	return returnParameterClrTypes.Select(clrType =>
                //	{
                //		var modelEntitySet = model
                //			.ConceptualModel
                //			.Container
                //			.EntitySets
                //			.FirstOrDefault(entitySet => entitySet.ElementType == GetModelEntityType(model, clrType, methodInfo)); // TODO: bug.

                //		//if (modelEntitySet == null)
                //		//	throw new NotSupportedException(
                //		//		string.Format("{0} for method {1} is not supported in conceptual model as entity set.", clrType.FullName, methodInfo.Name));

                //		return modelEntitySet;

                //	}).Where(s=>s!=null).ToArray();
                //}
            }
            else if (functionAttribute.Type == FunctionType.TableValuedFunction)
            {
                // returnParameterInfo.ParameterType is IQueryable<T>.
                var returnParameterClrType    = returnParameterInfo.ParameterType.GetGenericArguments().Single();
                var returnParameterEntityType = GetModelEntityType(model, returnParameterClrType, methodInfo);
                if (returnParameterEntityType != null)
                {
                    var modelEntitySet = model
                                         .ConceptualModel
                                         .Container
                                         .EntitySets
                                         .FirstOrDefault(entitySet => entitySet.ElementType == returnParameterEntityType);
                    if (modelEntitySet == null)
                    {
                        throw new NotSupportedException(
                                  string.Format("{0} for method {1} is not supported in conceptual model as entity set.",
                                                returnParameterInfo.ParameterType.FullName, methodInfo.Name));
                    }

                    return(new[] { modelEntitySet });
                }
            }

            // Do not return new EntitySet[0], which causes a ArgumentException:
            // The number of entity sets should match the number of return parameters.
            return(null);
        }