Include function names in exception messages

Author: moozzyk

CodeFirstStoreFunctions/FunctionDiscovery.cs

@@ -66,7 +66,8 @@ private FunctionDescriptor CreateFunctionDescriptor(MethodInfo method)
                 if (storeFunctionKind == StoreFunctionKind.ScalarUserDefinedFunction &&
                     (functionAttribute == null || functionAttribute.NamespaceName != "CodeFirstDatabaseSchema"))
                 {
-                    throw new InvalidOperationException("Scalar store functions must be decorated with the 'DbFunction' attribute with the 'CodeFirstDatabaseSchema' namespace.");
+                    throw new InvalidOperationException(
+                        $"Scalar store functions must be decorated with the 'DbFunction' attribute with the 'CodeFirstDatabaseSchema' namespace. Function: '{method.Name}'");
                 }
 
                 var unwrapperReturnType =
@@ -102,9 +103,7 @@ private IEnumerable<ParameterDescriptor> GetParameters(MethodInfo method, StoreF
                 if (parameter.IsOut || parameter.ParameterType.IsByRef)
                 {
                     throw new InvalidOperationException(
-                        string.Format(
-                            "The parameter '{0}' is an out or ref parameter. To map Input/Output database parameters use the 'ObjectParameter' as the parameter type.",
-                            parameter.Name));
+                        $"The parameter '{parameter.Name}' of function '{method.Name}' is an out or ref parameter. To map Input/Output database parameters use the 'ObjectParameter' as the parameter type.");
                 }
 
                 var paramTypeAttribute =
@@ -119,9 +118,7 @@ private IEnumerable<ParameterDescriptor> GetParameters(MethodInfo method, StoreF
                     if (paramTypeAttribute == null)
                     {
                         throw new InvalidOperationException(
-                            string.Format(
-                                "Cannot infer type for parameter '{0}'. All ObjectParameter parameters must be decorated with the ParameterTypeAttribute.",
-                                parameter.Name));
+                            $"Cannot infer type for parameter '{parameter.Name}' of funtion '{method.Name}'. All ObjectParameter parameters must be decorated with the ParameterTypeAttribute.");
                     }
 
                     parameterType = paramTypeAttribute.Type;
@@ -136,20 +133,15 @@ private IEnumerable<ParameterDescriptor> GetParameters(MethodInfo method, StoreF
 
                 if (parameterEdmType == null)
                 {
-                    throw
-                        new InvalidOperationException(
-                            string.Format(
-                                "The type '{0}' of the parameter '{1}' of function '{2}' is invalid. Parameters can only be of a type that can be converted to an Edm scalar type",
-                                unwrappedParameterType.FullName, parameter.Name, method.Name));
+                    throw new InvalidOperationException(
+                        $"The type '{unwrappedParameterType.FullName}' of the parameter '{parameter.Name}' of function '{method.Name}' is invalid. Parameters can only be of a type that can be converted to an Edm scalar type");
                 }
 
                 if (storeFunctionKind == StoreFunctionKind.ScalarUserDefinedFunction &&
                     parameterEdmType.BuiltInTypeKind != BuiltInTypeKind.PrimitiveType)
                 {
                     throw new InvalidOperationException(
-                        string.Format(
-                            "The parameter '{0}' is of the '{1}' type which is not an Edm primitive type. Types of parameters of store scalar functions must be Edm primitive types.",
-                            parameter.Name, parameterEdmType));
+                        $"The parameter '{parameter.Name}' of function '{method.Name}' is of the '{parameterEdmType}' type which is not an Edm primitive type. Types of parameters of store scalar functions must be Edm primitive types.");
                 }
 
                 yield return new ParameterDescriptor(parameter.Name, parameterEdmType,
@@ -162,22 +154,20 @@ private EdmType[] GetReturnTypes(string methodName, Type methodReturnType,
         {
             Debug.Assert(methodReturnType != null, "methodReturnType is null");
 
-            var resultTypes = functionDetailsAttribute != null ? functionDetailsAttribute.ResultTypes : null;
+            var resultTypes = functionDetailsAttribute?.ResultTypes;
 
             if (storeFunctionKind != StoreFunctionKind.StoredProcedure && resultTypes != null)
             {
                 throw new InvalidOperationException(
-                    "The DbFunctionDetailsAttribute.ResultTypes property should be used only for stored procedures returning multiple resultsets and must be null for composable function imports.");
+                    $"The DbFunctionDetailsAttribute.ResultTypes property should be used only for stored procedures returning multiple resultsets and must be null for composable function imports. Function: '{methodName}'");
             }
 
             resultTypes = resultTypes == null || resultTypes.Length == 0 ? null : resultTypes;
 
             if (resultTypes != null && resultTypes[0] != methodReturnType)
             {
                 throw new InvalidOperationException(
-                    string.Format(
-                        "The ObjectResult<T> item type returned by the method '{0}' is '{1}' but the first type specified in the `DbFunctionDetailsAttribute.ResultTypes` is '{2}'. The ObjectResult<T> item type must match the first type from the `DbFunctionDetailsAttribute.ResultTypes` array.",
-                        methodName, methodReturnType.FullName, resultTypes[0].FullName));
+                    $"The ObjectResult<T> item type returned by the function '{methodName}' is '{methodReturnType.FullName}' but the first type specified in the `DbFunctionDetailsAttribute.ResultTypes` is '{resultTypes[0].FullName}'. The ObjectResult<T> item type must match the first type from the `DbFunctionDetailsAttribute.ResultTypes` array.");
             }
 
             var edmResultTypes = (resultTypes ?? new[] {methodReturnType}).Select(GetReturnEdmItemType).ToArray();
@@ -186,9 +176,7 @@ private EdmType[] GetReturnTypes(string methodName, Type methodReturnType,
                 edmResultTypes[0].BuiltInTypeKind != BuiltInTypeKind.PrimitiveType)
             {
                 throw new InvalidOperationException(
-                    string.Format(
-                        "The type '{0}' returned by the method '{1}' cannot be mapped to an Edm primitive type. Scalar user defined functions have to return types that can be mapped to Edm primitive types.",
-                        methodReturnType.FullName, methodName));
+                    $"The type '{methodReturnType.FullName}' returned by the function '{methodName}' cannot be mapped to an Edm primitive type. Scalar user defined functions have to return types that can be mapped to Edm primitive types.");
             }
 
             return edmResultTypes;
@@ -219,7 +207,7 @@ private EdmType GetReturnEdmItemType(Type type)
                 }
             }
 
-            throw new InvalidOperationException(string.Format("No EdmType found for type '{0}'.", type.FullName));
+            throw new InvalidOperationException($"No EdmType found for type '{type.FullName}'.");
         }
 
         private static EdmType GetEdmPrimitiveTypeForClrType(Type clrType)

CodeFirstStoreFunctions/FunctionsConvention.cs

@@ -113,9 +113,7 @@ private static void CreateReturnParameters(DbModel model, FunctionDescriptor fun
                     if (matchingEntitySets.Length == 0)
                     {
                         throw new InvalidOperationException(
-                            string.Format(
-                                "The model does not contain EntitySet for the '{0}' entity type.",
-                                returnType.FullName));
+                            $"The model does not contain EntitySet for the '{returnType.FullName}' entity type.");
                     }
 
                     Debug.Assert(matchingEntitySets.Length == 1, "Invalid model (MEST)");

CodeFirstStoreFunctions/StoreFunctionBuilder.cs

@@ -34,9 +34,7 @@ public EdmFunction Create(FunctionDescriptor functionDescriptor)
             if (_schema == null && functionDescriptor.DatabaseSchema == null)
             {
                 throw new InvalidOperationException(
-                    string.Format(
-                        "Database schema is not defined for function '{0}'. Either set a default database schema or use the DbFunctionEx attribute with non-null DatabaseSchema value.",
-                        functionDescriptor.Name));
+                    $"Database schema is not defined for function '{functionDescriptor.Name}'. Either set a default database schema or use the DbFunctionEx attribute with non-null DatabaseSchema value.");
             }
 
             var functionPayload =
@@ -46,10 +44,10 @@ public EdmFunction Create(FunctionDescriptor functionDescriptor)
                         .Parameters
                         .Select(
                             p => FunctionParameter.Create(
-                                p.Name, 
+                                p.Name,
                                 GetStorePrimitiveType(p),
-                                p.IsOutParam 
-                                    ? ParameterMode.InOut 
+                                p.IsOutParam
+                                    ? ParameterMode.InOut
                                     : ParameterMode.In)).ToArray(),
 
                     ReturnParameters = CreateFunctionReturnParameters(functionDescriptor),
@@ -142,9 +140,9 @@ private Dictionary<EdmProperty, TypeUsage> FindStoreTypeUsages(EntityType entity
             Debug.Assert(entityType != null, "entityType == null");
 
             var propertyToStoreTypeUsage = new Dictionary<EdmProperty, TypeUsage>();
-			
+
             var types = Tools.GetTypeHierarchy(entityType);
-            var entityTypeMappings = 
+            var entityTypeMappings =
                 _model.ConceptualToStoreMapping.EntitySetMappings
                     .SelectMany(s => s.EntityTypeMappings)
                     .Where(t => types.Contains(t.EntityType))
@@ -153,7 +151,7 @@ private Dictionary<EdmProperty, TypeUsage> FindStoreTypeUsages(EntityType entity
             foreach (var property in entityType.Properties)
             {
                 foreach (var entityTypeMapping in entityTypeMappings)
-                { 
+                {
                     var propertyMapping =
                         (ScalarPropertyMapping)entityTypeMapping.Fragments.SelectMany(f => f.PropertyMappings)
                         .FirstOrDefault(p => p.Property == property);
@@ -193,8 +191,8 @@ private EdmType GetStorePrimitiveType(ParameterDescriptor parameterDescriptor)
 
                 if (type == null)
                 {
-                    throw new InvalidOperationException(string.Format(
-                        "No store EdmType with the name '{0}' could be found.", parameterDescriptor.StoreType));
+                    throw new InvalidOperationException(
+                        $"No store EdmType with the name '{parameterDescriptor.StoreType}' could be found.");
                 }
 
                 return type;

CodeFirstStoreFunctionsTests/FunctionDiscoveryTests.cs

@@ -439,6 +439,7 @@ public void FindFunctions_throws_for_TVFs_with_ResultTypes()
                             .ToArray()).Message;
 
                 Assert.Contains("DbFunctionDetailsAttribute.ResultTypes", message);
+                Assert.Contains("TVFWithResultTypes", message);
             }
 
             [Fact]
@@ -621,7 +622,8 @@ public void FindFunctions_throws_if_udf_not_in_CodeFirstDatabaseSchema_namespace
                             .FindFunctions().ToList()).Message;
 
                 Assert.Contains("'DbFunction'", message);
-                Assert.Contains("'CodeFirstDatabaseSchema'", message);                
+                Assert.Contains("'CodeFirstDatabaseSchema'", message);
+                Assert.Contains("'UdfNotInCodeFirstDatabaseSchema'", message);
             }
 
             [Fact]
@@ -641,7 +643,8 @@ public void FindFunctions_throws_for_udfs_with_non_primitive_params()
                             .FindFunctions().ToList()).Message;
 
                 Assert.Contains("'Model.TestEnumType'", message);
-                Assert.Contains("'param'", message);                
+                Assert.Contains("'param'", message);
+                Assert.Contains("'UdfWithNonPrimitiveParam'", message);
             }
 
             [Fact]
@@ -688,6 +691,7 @@ public void FindFunctions_throws_for_ref_params()
                 Assert.Contains("Input/Output", message);
                 Assert.Contains("'param'", message);
                 Assert.Contains("'ObjectParameter'", message);
+                Assert.Contains("'StoredProcWithRefParam'", message);
             }
 
             [Fact]
@@ -758,6 +762,7 @@ public void FindFunctions_throws_if_no_ParameterTypeAttribute_for_ObjectParamete
                 Assert.Contains("ParameterTypeAttribute", message);
                 Assert.Contains("ObjectParameter", message);
                 Assert.Contains("'param'", message);
+                Assert.Contains("'StoredProcWithObjectParamaterAndNoParameterTypeAttribute'", message);
             }
 
             [Fact]