Fixed issue with type of value from <example> when using IncludeXmlCommentsFromInheritDocs, unchase#34

Author: Patrik-If

src/Unchase.Swashbuckle.AspNetCore.Extensions/Extensions/TypeExtensions.cs

@@ -0,0 +1,35 @@
+using System;
+
+namespace Unchase.Swashbuckle.AspNetCore.Extensions.Extensions
+{
+    /// <summary>
+    /// Extension methods for <see cref=" object"/>.
+    /// </summary>
+    internal static class TypeExtensions
+    {
+        /// <summary>
+        /// Check if an object is a number
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns>True or False</returns>
+        internal static bool IsNumber(this Type type)
+        {
+            return type == typeof(sbyte)
+                   || type == typeof(byte)
+                   || type == typeof(short)
+                   || type == typeof(ushort)
+                   || type == typeof(int)
+                   || type == typeof(uint)
+                   || type == typeof(long)
+                   || type == typeof(ulong)
+                   //|| type == typeof(Int128 - Only in .NET 7, 8, 9)
+                   //|| type == typeof(UInt128  - Only in .NET 7, 8, 9)
+                   //|| type == typeof(nint - Only in .NET 7, 8, 9)
+                   //|| type == typeof(nuint - Only in .NET 7, 8, 9)
+                   //|| type == typeof(Half - Only in .NET 5, 6, 7, 8, 9)
+                   || type == typeof(float)
+                   || type == typeof(double)
+                   || type == typeof(decimal);
+        }
+    }
+}

src/Unchase.Swashbuckle.AspNetCore.Extensions/Extensions/XmlCommentsExtensions.cs

@@ -1,13 +1,13 @@
-using System;
+using Microsoft.OpenApi.Any;
+using Microsoft.OpenApi.Models;
+using Swashbuckle.AspNetCore.SwaggerGen;
+using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using System.Reflection;
 using System.Xml.XPath;
 
-using Microsoft.OpenApi.Any;
-using Microsoft.OpenApi.Models;
-using Swashbuckle.AspNetCore.SwaggerGen;
-
 namespace Unchase.Swashbuckle.AspNetCore.Extensions.Extensions
 {
     internal static class XmlCommentsExtensions
@@ -114,15 +114,11 @@ private static MemberInfo[] GetTargets(MemberInfo memberInfo, string cref)
             }
 
             // Find all matching members in all interfaces and the base class.
-            var targets = type.GetInterfaces()
-                .Append(type.BaseType)
-                .SelectMany(
-                    x => x.FindMembers(
-                        memberInfo.MemberType,
-                        BindingFlags.Instance | BindingFlags.Public,
-                        (info, _) => info.Name == memberInfo.Name,
-                        null))
-                .ToList();
+            var targets = type.GetInterfaces().Append(type.BaseType).SelectMany(x => x.FindMembers(
+                memberInfo.MemberType,
+                BindingFlags.Instance | BindingFlags.Public,
+                (info, _) => info.Name == memberInfo.Name,
+                null)).ToList();
 
             // Try to find the target, if one is declared.
             if (!string.IsNullOrWhiteSpace(cref))
@@ -168,7 +164,7 @@ internal static void ApplyPropertyComments(
             XPathNavigator targetXmlNode;
             if (string.IsNullOrWhiteSpace(cref))
             {
-                var target = memberInfo.GetTargetRecursive(inheritedDocs, cref);
+                var target = GetTargetRecursive(memberInfo, inheritedDocs, cref);
                 if (target == null)
                 {
                     return;
@@ -204,10 +200,95 @@ internal static void ApplyPropertyComments(
             var exampleNode = targetXmlNode.SelectSingleNode(ExampleTag);
             if (exampleNode != null)
             {
-                schema.Example = new OpenApiString(XmlCommentsTextHelper.Humanize(exampleNode.InnerXml));
+                schema.Example = GetExampleValue(memberInfo, exampleNode);
             }
         }
 
+        private static IOpenApiAny GetExampleValue(MemberInfo memberInfo, XPathNavigator exampleNode)
+        {
+            var type = GetUnderlyingType(memberInfo);
+            var exampleValue = exampleNode.InnerXml;
+
+            if (string.IsNullOrEmpty(exampleValue))
+            {
+                return new OpenApiNull();
+            }
+
+            if (!type.IsNumber())
+            {
+                return new OpenApiString(XmlCommentsTextHelper.Humanize(exampleValue));
+            }
+
+
+            if (
+                type == typeof(byte)
+                || type == typeof(sbyte)
+            )
+            {
+                return new OpenApiByte(byte.Parse(XmlCommentsTextHelper.Humanize(exampleValue)));
+            }
+
+            if (
+                type == typeof(short)
+                || type == typeof(ushort)
+                || type == typeof(int)
+                || type == typeof(uint)
+            )
+            {
+                return new OpenApiInteger(int.Parse(XmlCommentsTextHelper.Humanize(exampleValue), CultureInfo.InvariantCulture));
+            }
+
+            if (
+                type == typeof(long)
+                || type == typeof(ulong)
+            )
+            {
+                return new OpenApiLong(long.Parse(XmlCommentsTextHelper.Humanize(exampleValue), CultureInfo.InvariantCulture));
+            }
+
+            if (
+                type == typeof(float)
+                || type == typeof(decimal)
+            )
+            {
+                return new OpenApiFloat(float.Parse(XmlCommentsTextHelper.Humanize(exampleValue), CultureInfo.InvariantCulture));
+            }
+
+            if (type == typeof(double))
+            {
+                return new OpenApiDouble(double.Parse(XmlCommentsTextHelper.Humanize(exampleValue), CultureInfo.InvariantCulture));
+            }
+
+            return new OpenApiString(XmlCommentsTextHelper.Humanize(exampleValue));
+        }
+
+        private static Type GetUnderlyingType(this MemberInfo member)
+        {
+            switch (member.MemberType)
+            {
+                case MemberTypes.Event:
+                    return ((EventInfo)member).EventHandlerType;
+                case MemberTypes.Field:
+                    return ((FieldInfo)member).FieldType;
+                case MemberTypes.Method:
+                    return ((MethodInfo)member).ReturnType;
+                case MemberTypes.Property:
+                    var propType = ((PropertyInfo)member).PropertyType;
+
+                    if (!propType.Name.ToLower().Contains("nullable"))
+                    {
+                        return propType;
+                    }
+
+                    return propType.GenericTypeArguments?.Length > 0 ? propType.GenericTypeArguments[0] : propType;
+
+                default:
+                    throw new ArgumentException
+                    (
+                        "Input MemberInfo must be if type EventInfo, FieldInfo, MethodInfo, or PropertyInfo"
+                    );
+            }
+        }
         internal static XPathNavigator GetMemberXmlNode(string memberName, List<XPathDocument> documents)
         {
             string path = $"/doc/members/member[@name='{memberName}']";

test/Unchase.Swashbuckle.AspNetCore.Extensions.Tests/Models/IInheritDocClass.cs

@@ -1,4 +1,6 @@
-namespace Unchase.Swashbuckle.AspNetCore.Extensions.Tests.Models
+// ReSharper disable CommentTypo
+// ReSharper disable IdentifierTypo
+namespace Unchase.Swashbuckle.AspNetCore.Extensions.Tests.Models
 {
     /// <summary>
     /// InheritDocClass - inheritdoc
@@ -14,6 +16,61 @@ public interface IInheritDocClass : IInheritDocCommon
         /// <remarks>
         /// Name remarks - inheritdoc
         /// </remarks>
+        /// <example>Donald Duck</example>
         string Name { get; set; }
+
+        /// <summary>
+        /// Age - inheritdoc
+        /// </summary>
+        /// <remarks>
+        /// Age remarks - inheritdoc
+        /// </remarks>
+        /// <example>75</example>
+        int? Age { get; set; }
+
+        /// <summary>
+        /// Weight - inheritdoc
+        /// </summary>
+        /// <remarks>
+        /// Weight remarks - inheritdoc
+        /// </remarks>
+        /// <example>0.174</example>
+        float? Weight { get; set; }
+
+        /// <summary>
+        /// NumberOfFeet - inheritdoc
+        /// </summary>
+        /// <remarks>
+        /// NumberOfFeet remarks - inheritdoc
+        /// </remarks>
+        /// <example>2</example>
+        int? NumberOfFeet { get; set; }
+
+        /// <summary>
+        /// AByte - inheritdoc
+        /// </summary>
+        /// <remarks>
+        /// AByte remarks - inheritdoc
+        /// </remarks>
+        /// <example>1</example>
+        byte? AByte { get; set; }
+
+        /// <summary>
+        /// AShort - inheritdoc
+        /// </summary>
+        /// <remarks>
+        /// AShort remarks - inheritdoc
+        /// </remarks>
+        /// <example>1234</example>
+        short? AShort { get; set; }
+
+        /// <summary>
+        /// ALong - inheritdoc
+        /// </summary>
+        /// <remarks>
+        /// ALong remarks - inheritdoc
+        /// </remarks>
+        /// <example>1234</example>
+        long? ALong { get; set; }
     }
 }

test/Unchase.Swashbuckle.AspNetCore.Extensions.Tests/Models/InheritDocClass.cs

@@ -6,6 +6,24 @@ public class InheritDocClass : IInheritDocClass
         /// <inheritdoc/>
         public string Name { get; set; }
 
+        /// <inheritdoc/>
+        public int? Age { get; set; }
+
+        /// <inheritdoc/>
+        public float? Weight { get; set; }
+
+        /// <inheritdoc/>
+        public int? NumberOfFeet { get; set; }
+
+        /// <inheritdoc/>
+        public byte? AByte { get; set; }
+
+        /// <inheritdoc/>
+        public short? AShort { get; set; }
+
+        /// <inheritdoc/>
+        public long? ALong { get; set; }
+
         /// <inheritdoc cref="IInheritDocCommon.Common"/>
         public string Common { get; set; }