Added [ExcelReturnConversion] for custom return types.

Sergey-Vlasov · govert · commit d128f4df7cf5 · 2025-07-14T23:06:06.000+02:00
diff --git a/Source/ExcelDna.Integration/AssemblyLoader.cs b/Source/ExcelDna.Integration/AssemblyLoader.cs
@@ -28,6 +28,7 @@ public static void ProcessAssemblies(
                     List<ExportedAssembly> assemblies,
                     List<MethodInfo> methods,
                     List<ExtendedRegistration.ExcelParameterConversion> excelParameterConversions,
+                    List<ExtendedRegistration.ExcelReturnConversion> excelReturnConversions,
                     List<ExtendedRegistration.ExcelFunctionProcessor> excelFunctionProcessors,
                     List<Registration.ExcelFunctionRegistration> excelFunctionsExtendedRegistration,
                     List<Registration.FunctionExecutionHandlerSelector> excelFunctionExecutionHandlerSelectors,
@@ -41,6 +42,7 @@ public static void ProcessAssemblies(
             {
                 int initialObjectsCount = methods.Count +
                     excelParameterConversions.Count +
+                    excelReturnConversions.Count +
                     excelFunctionProcessors.Count +
                     excelFunctionsExtendedRegistration.Count +
                     excelFunctionExecutionHandlerSelectors.Count +
@@ -85,6 +87,7 @@ public static void ProcessAssemblies(
                         if (!explicitRegistration)
                         {
                             GetExcelParameterConversions(type, excelParameterConversions);
+                            GetExcelReturnConversions(type, excelReturnConversions);
                             GetExcelFunctionProcessors(type, excelFunctionProcessors);
                             GetExcelMethods(type, explicitExports, methods, excelFunctionsExtendedRegistration);
                             GetExcelFunctionExecutionHandlerSelectors(type, excelFunctionExecutionHandlerSelectors);
@@ -101,6 +104,7 @@ public static void ProcessAssemblies(
 
                 if (methods.Count +
                     excelParameterConversions.Count +
+                    excelReturnConversions.Count +
                     excelFunctionProcessors.Count +
                     excelFunctionsExtendedRegistration.Count +
                     excelFunctionExecutionHandlerSelectors.Count +
@@ -127,6 +131,18 @@ static void GetExcelParameterConversions(Type t, List<ExtendedRegistration.Excel
             }
         }
 
+        static void GetExcelReturnConversions(Type t, List<ExtendedRegistration.ExcelReturnConversion> excelReturnConversions)
+        {
+            MethodInfo[] mis = t.GetMethods(BindingFlags.Public | BindingFlags.Static);
+            foreach (MethodInfo mi in mis)
+            {
+                if (IsReturnConversion(mi))
+                {
+                    excelReturnConversions.Add(new ExtendedRegistration.ExcelReturnConversion(mi));
+                }
+            }
+        }
+
         static void GetExcelFunctionProcessors(Type t, List<ExtendedRegistration.ExcelFunctionProcessor> excelFunctionProcessors)
         {
             MethodInfo[] mis = t.GetMethods(BindingFlags.Public | BindingFlags.Static);
@@ -434,6 +450,11 @@ private static bool IsParameterConversion(MethodInfo methodInfo)
             return HasCustomAttribute(methodInfo, "ExcelDna.Integration.ExcelParameterConversionAttribute");
         }
 
+        private static bool IsReturnConversion(MethodInfo methodInfo)
+        {
+            return HasCustomAttribute(methodInfo, "ExcelDna.Integration.ExcelReturnConversionAttribute");
+        }
+
         private static bool IsFunctionProcessor(MethodInfo methodInfo)
         {
             return HasCustomAttribute(methodInfo, "ExcelDna.Integration.ExcelFunctionProcessorAttribute");
diff --git a/Source/ExcelDna.Integration/DnaLibrary.cs b/Source/ExcelDna.Integration/DnaLibrary.cs
@@ -259,6 +259,8 @@ internal List<ExportedAssembly> GetAssemblies(string pathResolveRoot)
         [XmlIgnore]
         List<ExtendedRegistration.ExcelParameterConversion> _excelParameterConversions = new List<ExtendedRegistration.ExcelParameterConversion>();
         [XmlIgnore]
+        List<ExtendedRegistration.ExcelReturnConversion> _excelReturnConversions = new List<ExtendedRegistration.ExcelReturnConversion>();
+        [XmlIgnore]
         private List<Registration.ExcelFunctionRegistration> _excelFunctionsExtendedRegistration = new List<Registration.ExcelFunctionRegistration>();
         [XmlIgnore]
         private List<Registration.FunctionExecutionHandlerSelector> _excelFunctionExecutionHandlerSelectors = new List<Registration.FunctionExecutionHandlerSelector>();
@@ -281,7 +283,7 @@ internal void Initialize()
 
             // Recursively get assemblies down .dna tree.
             _exportedAssemblies = GetAssemblies(dnaResolveRoot);
-            AssemblyLoader.ProcessAssemblies(_exportedAssemblies, _methods, _excelParameterConversions, _excelFunctionProcessors, _excelFunctionsExtendedRegistration, _excelFunctionExecutionHandlerSelectors, _addIns, rtdServerTypes, comClassTypes);
+            AssemblyLoader.ProcessAssemblies(_exportedAssemblies, _methods, _excelParameterConversions, _excelReturnConversions, _excelFunctionProcessors, _excelFunctionsExtendedRegistration, _excelFunctionExecutionHandlerSelectors, _addIns, rtdServerTypes, comClassTypes);
 
             // Register RTD Server Types (i.e. remember that these types are available as RTD servers, with relevant ProgId etc.)
             RtdRegistration.RegisterRtdServerTypes(rtdServerTypes);
@@ -328,7 +330,7 @@ internal void AutoOpen()
             else
                 ExtendedRegistration.Registration.RegisterStandard(_methods.Select(i => new ExcelDna.Registration.ExcelFunctionRegistration(i)), _excelFunctionExecutionHandlerSelectors);
 
-            ExtendedRegistration.Registration.RegisterExtended(_excelFunctionsExtendedRegistration, _excelParameterConversions, _excelFunctionProcessors, _excelFunctionExecutionHandlerSelectors);
+            ExtendedRegistration.Registration.RegisterExtended(_excelFunctionsExtendedRegistration, _excelParameterConversions, _excelReturnConversions, _excelFunctionProcessors, _excelFunctionExecutionHandlerSelectors);
 
             // Invoke AutoOpen in all assemblies
             foreach (AssemblyLoader.ExcelAddInInfo addIn in _addIns)
diff --git a/Source/ExcelDna.Integration/ExcelAttributes.cs b/Source/ExcelDna.Integration/ExcelAttributes.cs
@@ -128,6 +128,15 @@ public class ExcelParameterConversionAttribute : Attribute
     {
     }
 
+    /// <summary>
+    /// For user-defined return conversions.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
+    [MeansImplicitUse]
+    public class ExcelReturnConversionAttribute : Attribute
+    {
+    }
+
     /// <summary>
     /// For user-defined function execution handlers.
     /// </summary>
diff --git a/Source/ExcelDna.Integration/ExtendedRegistration/ExcelReturnConversion.cs b/Source/ExcelDna.Integration/ExtendedRegistration/ExcelReturnConversion.cs
@@ -0,0 +1,35 @@
+﻿using System;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace ExcelDna.Integration.ExtendedRegistration
+{
+    internal class ExcelReturnConversion
+    {
+        public MethodInfo MethodInfo { get; private set; }
+
+        public ExcelReturnConversion(MethodInfo methodInfo)
+        {
+            this.MethodInfo = methodInfo;
+        }
+
+        public Func<Type, IExcelFunctionReturn, LambdaExpression> GetConversion()
+        {
+            return (type, returnReg) => CreateConversion(type, returnReg);
+        }
+
+        private LambdaExpression CreateConversion(Type type, IExcelFunctionReturn returnReg)
+        {
+            ParameterInfo[] parameters = MethodInfo.GetParameters();
+
+            if (parameters.Length != 1 || type != parameters[0].ParameterType)
+                return null;
+
+            var paramExprs = parameters
+                             .Select(pi => Expression.Parameter(pi.ParameterType, pi.Name))
+                             .ToList();
+            return Expression.Lambda(Expression.Call(MethodInfo, paramExprs), MethodInfo.Name, paramExprs);
+        }
+    }
+}
diff --git a/Source/ExcelDna.Integration/ExtendedRegistration/Registration.cs b/Source/ExcelDna.Integration/ExtendedRegistration/Registration.cs
@@ -10,11 +10,11 @@ namespace ExcelDna.Integration.ExtendedRegistration
 {
     internal class Registration
     {
-        public static void RegisterExtended(IEnumerable<ExcelDna.Registration.ExcelFunctionRegistration> functions, IEnumerable<ExcelParameterConversion> parameterConversions, IEnumerable<ExcelFunctionProcessor> excelFunctionProcessors, IEnumerable<FunctionExecutionHandlerSelector> excelFunctionExecutionHandlerSelectors)
+        public static void RegisterExtended(IEnumerable<ExcelDna.Registration.ExcelFunctionRegistration> functions, IEnumerable<ExcelParameterConversion> parameterConversions, IEnumerable<ExcelReturnConversion> returnConversions, IEnumerable<ExcelFunctionProcessor> excelFunctionProcessors, IEnumerable<FunctionExecutionHandlerSelector> excelFunctionExecutionHandlerSelectors)
         {
             // Set the Parameter Conversions before they are applied by the ProcessParameterConversions call below.
             // CONSIDER: We might change the registration to be an object...?
-            var conversionConfig = GetParameterConversionConfig(parameterConversions);
+            var conversionConfig = GetParameterConversionConfig(parameterConversions, returnConversions);
 
             var functionHandlerConfig = GetFunctionExecutionHandlerConfig(excelFunctionExecutionHandlerSelectors);
 
@@ -47,7 +47,7 @@ internal static void Register(IEnumerable<ExcelDna.Registration.ExcelFunctionReg
             ExcelIntegration.RegisterLambdaExpressions(lambdas, attribs, argAttribs);
         }
 
-        static ParameterConversionConfiguration GetParameterConversionConfig(IEnumerable<ExcelParameterConversion> parameterConversions)
+        static ParameterConversionConfiguration GetParameterConversionConfig(IEnumerable<ExcelParameterConversion> parameterConversions, IEnumerable<ExcelReturnConversion> returnConversions)
         {
             // NOTE: The parameter conversion list is processed once per parameter.
             //       Parameter conversions will apply from most inside, to most outside.
@@ -79,7 +79,8 @@ static ParameterConversionConfiguration GetParameterConversionConfig(IEnumerable
                 .AddParameterConversion(ParameterConversions.GetOptionalConversion(treatEmptyAsMissing: true))
                 .AddParameterConversion(RangeConversion.GetRangeParameterConversion, null)
 
-                .AddParameterConversions(ParameterConversions.GetUserConversions(parameterConversions))
+                .AddParameterConversions(ParameterConversions.GetUserParameterConversions(parameterConversions))
+                .AddReturnConversions(ParameterConversions.GetUserReturnConversions(returnConversions))
 
                 // This is a conversion applied to the return value of the function
                 .AddReturnConversion((Complex value) => new double[2] { value.Real, value.Imaginary })
diff --git a/Source/ExcelDna.Integration/Registration/ParameterConversionConfiguration.cs b/Source/ExcelDna.Integration/Registration/ParameterConversionConfiguration.cs
@@ -155,6 +155,14 @@ public ParameterConversionConfiguration AddReturnConversion<TFrom, TTo>(Expressi
             AddReturnConversion<TFrom>((unusedReturnType, unusedAttributes) => convert, null, handleSubTypes);
             return this;
         }
+
+        public ParameterConversionConfiguration AddReturnConversions(IEnumerable<Func<Type, IExcelFunctionReturn, LambdaExpression>> returnConversions)
+        {
+            foreach (var i in returnConversions)
+                AddReturnConversion(i);
+
+            return this;
+        }
         #endregion
 
         Func<Type, ExcelParameterRegistration, LambdaExpression> GetNullableConversion(bool treatEmptyAsMissing, bool treatNAErrorAsMissing)
diff --git a/Source/ExcelDna.Integration/Registration/ParameterConversions.cs b/Source/ExcelDna.Integration/Registration/ParameterConversions.cs
@@ -39,11 +39,16 @@ public static Func<Type, ExcelParameterRegistration, LambdaExpression> GetEnumSt
             return (type, paramReg) => EnumStringConversion(type, paramReg);
         }
 
-        internal static IEnumerable<Func<Type, ExcelParameterRegistration, LambdaExpression>> GetUserConversions(IEnumerable<Integration.ExtendedRegistration.ExcelParameterConversion> parameterConversions)
+        internal static IEnumerable<Func<Type, ExcelParameterRegistration, LambdaExpression>> GetUserParameterConversions(IEnumerable<Integration.ExtendedRegistration.ExcelParameterConversion> parameterConversions)
         {
             return parameterConversions.OrderBy(i => i.MethodInfo.Name).Select(i => i.GetConversion());
         }
 
+        internal static IEnumerable<Func<Type, IExcelFunctionReturn, LambdaExpression>> GetUserReturnConversions(IEnumerable<Integration.ExtendedRegistration.ExcelReturnConversion> returnConversions)
+        {
+            return returnConversions.OrderBy(i => i.MethodInfo.Name).Select(i => i.GetConversion());
+        }
+
         internal static LambdaExpression NullableConversion(
             ParameterConversionConfiguration config, Type type,
             ExcelParameterRegistration paramReg, bool treatEmptyAsMissing,
diff --git a/Source/Tests/ExcelDna.AddIn.RuntimeTests/Conversions.cs b/Source/Tests/ExcelDna.AddIn.RuntimeTests/Conversions.cs
@@ -27,5 +27,11 @@ public static Version ToVersion(string s)
         {
             return new Version(s);
         }
+
+        [ExcelReturnConversion]
+        public static string Order1FromTestType1(TestType1 value)
+        {
+            return value.Value;
+        }
     }
 }
diff --git a/Source/Tests/ExcelDna.AddIn.RuntimeTests/MyFunctions.cs b/Source/Tests/ExcelDna.AddIn.RuntimeTests/MyFunctions.cs
@@ -141,6 +141,12 @@ public static string MyVersion2(Version v)
             return "The Version value with field count 2 is " + v.ToString(2);
         }
 
+        [ExcelFunction]
+        public static TestType1 MyReturnTestType1(string s)
+        {
+            return new TestType1("The TestType1 return value is " + s);
+        }
+
         [ExcelFunction]
         public static string MyFunctionExecutionLog()
         {
diff --git a/Source/Tests/ExcelDna.RuntimeTests/Registration.cs b/Source/Tests/ExcelDna.RuntimeTests/Registration.cs
@@ -223,7 +223,16 @@ public void UserDefinedParameterConversions()
             Assert.Equal("The TestType2 value is From TestType1 world2", functionRange.Value.ToString());
         }
 
-        [ExcelFact(Workbook = "", AddIn = @"..\..\..\..\ExcelDna.AddIn.RuntimeTests\bin\Debug\net6.0-windows\ExcelDna.AddIn.RuntimeTests-AddIn")]
+        [ExcelFact(Workbook = "", AddIn = AddInPath.RuntimeTests)]
+        public void UserDefinedReturnConversions()
+        {
+            Range functionRange = ((Worksheet)ExcelDna.Testing.Util.Workbook.Sheets[1]).Range["B1:B1"];
+
+            functionRange.Formula = "=MyReturnTestType1(\"world\")";
+            Assert.Equal("The TestType1 return value is world", functionRange.Value.ToString());
+        }
+
+        [ExcelFact(Workbook = "", AddIn = AddInPath.RuntimeTests)]
         public void FunctionExecutionHandlerExtended()
         {
             Range functionRange = ((Worksheet)ExcelDna.Testing.Util.Workbook.Sheets[1]).Range["B1"];

Original file line number	Diff line number	Diff line change
`@@ -10,11 +10,11 @@ namespace ExcelDna.Integration.ExtendedRegistration`
`10`	`10`	`{`
`11`	`11`	`internal class Registration`
`12`	`12`	`{`
`13`		`- public static void RegisterExtended(IEnumerable<ExcelDna.Registration.ExcelFunctionRegistration> functions, IEnumerable<ExcelParameterConversion> parameterConversions, IEnumerable<ExcelFunctionProcessor> excelFunctionProcessors, IEnumerable<FunctionExecutionHandlerSelector> excelFunctionExecutionHandlerSelectors)`
	`13`	`+ public static void RegisterExtended(IEnumerable<ExcelDna.Registration.ExcelFunctionRegistration> functions, IEnumerable<ExcelParameterConversion> parameterConversions, IEnumerable<ExcelReturnConversion> returnConversions, IEnumerable<ExcelFunctionProcessor> excelFunctionProcessors, IEnumerable<FunctionExecutionHandlerSelector> excelFunctionExecutionHandlerSelectors)`
`14`	`14`	`{`
`15`	`15`	`// Set the Parameter Conversions before they are applied by the ProcessParameterConversions call below.`
`16`	`16`	`// CONSIDER: We might change the registration to be an object...?`
`17`		`- var conversionConfig = GetParameterConversionConfig(parameterConversions);`
	`17`	`+ var conversionConfig = GetParameterConversionConfig(parameterConversions, returnConversions);`
`18`	`18`
`19`	`19`	`var functionHandlerConfig = GetFunctionExecutionHandlerConfig(excelFunctionExecutionHandlerSelectors);`
`20`	`20`
`@@ -47,7 +47,7 @@ internal static void Register(IEnumerable<ExcelDna.Registration.ExcelFunctionReg`
`47`	`47`	`ExcelIntegration.RegisterLambdaExpressions(lambdas, attribs, argAttribs);`
`48`	`48`	`}`
`49`	`49`
`50`		`- static ParameterConversionConfiguration GetParameterConversionConfig(IEnumerable<ExcelParameterConversion> parameterConversions)`
	`50`	`+ static ParameterConversionConfiguration GetParameterConversionConfig(IEnumerable<ExcelParameterConversion> parameterConversions, IEnumerable<ExcelReturnConversion> returnConversions)`
`51`	`51`	`{`
`52`	`52`	`// NOTE: The parameter conversion list is processed once per parameter.`
`53`	`53`	`// Parameter conversions will apply from most inside, to most outside.`
`@@ -79,7 +79,8 @@ static ParameterConversionConfiguration GetParameterConversionConfig(IEnumerable`
`79`	`79`	`.AddParameterConversion(ParameterConversions.GetOptionalConversion(treatEmptyAsMissing: true))`
`80`	`80`	`.AddParameterConversion(RangeConversion.GetRangeParameterConversion, null)`
`81`	`81`
`82`		`- .AddParameterConversions(ParameterConversions.GetUserConversions(parameterConversions))`
	`82`	`+ .AddParameterConversions(ParameterConversions.GetUserParameterConversions(parameterConversions))`
	`83`	`+ .AddReturnConversions(ParameterConversions.GetUserReturnConversions(returnConversions))`
`83`	`84`
`84`	`85`	`// This is a conversion applied to the return value of the function`
`85`	`86`	`.AddReturnConversion((Complex value) => new double[2] { value.Real, value.Imaginary })`
Original file line number	Diff line number	Diff line change
`@@ -39,11 +39,16 @@ public static Func<Type, ExcelParameterRegistration, LambdaExpression> GetEnumSt`
`39`	`39`	`return (type, paramReg) => EnumStringConversion(type, paramReg);`
`40`	`40`	`}`
`41`	`41`
`42`		`- internal static IEnumerable<Func<Type, ExcelParameterRegistration, LambdaExpression>> GetUserConversions(IEnumerable<Integration.ExtendedRegistration.ExcelParameterConversion> parameterConversions)`
	`42`	`+ internal static IEnumerable<Func<Type, ExcelParameterRegistration, LambdaExpression>> GetUserParameterConversions(IEnumerable<Integration.ExtendedRegistration.ExcelParameterConversion> parameterConversions)`
`43`	`43`	`{`
`44`	`44`	`return parameterConversions.OrderBy(i => i.MethodInfo.Name).Select(i => i.GetConversion());`
`45`	`45`	`}`
`46`	`46`
	`47`	`+ internal static IEnumerable<Func<Type, IExcelFunctionReturn, LambdaExpression>> GetUserReturnConversions(IEnumerable<Integration.ExtendedRegistration.ExcelReturnConversion> returnConversions)`
	`48`	`+ {`
	`49`	`+ return returnConversions.OrderBy(i => i.MethodInfo.Name).Select(i => i.GetConversion());`
	`50`	`+ }`
	`51`	`+`
`47`	`52`	`internal static LambdaExpression NullableConversion(`
`48`	`53`	`ParameterConversionConfiguration config, Type type,`
`49`	`54`	`ExcelParameterRegistration paramReg, bool treatEmptyAsMissing,`
Original file line number	Diff line number	Diff line change
`@@ -27,5 +27,11 @@ public static Version ToVersion(string s)`
`27`	`27`	`{`
`28`	`28`	`return new Version(s);`
`29`	`29`	`}`
	`30`	`+`
	`31`	`+ [ExcelReturnConversion]`
	`32`	`+ public static string Order1FromTestType1(TestType1 value)`
	`33`	`+ {`
	`34`	`+ return value.Value;`
	`35`	`+ }`
`30`	`36`	`}`
`31`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -141,6 +141,12 @@ public static string MyVersion2(Version v)`
`141`	`141`	`return "The Version value with field count 2 is " + v.ToString(2);`
`142`	`142`	`}`
`143`	`143`
	`144`	`+ [ExcelFunction]`
	`145`	`+ public static TestType1 MyReturnTestType1(string s)`
	`146`	`+ {`
	`147`	`+ return new TestType1("The TestType1 return value is " + s);`
	`148`	`+ }`
	`149`	`+`
`144`	`150`	`[ExcelFunction]`
`145`	`151`	`public static string MyFunctionExecutionLog()`
`146`	`152`	`{`