Fix infinite loop with IFormCollection

Author: Oleksandr Liakhevych

GenerateAspNetCoreClient.Command/ClientModelBuilder.cs

@@ -22,32 +22,26 @@ public class ClientModelBuilder
     {
         private readonly ApiDescriptionGroupCollection apiExplorer;
         private readonly GenerateClientOptions options;
-        private readonly string[] additionalNamespaces;
         private readonly Assembly webProjectAssembly;
 
         public ClientModelBuilder(
             ApiDescriptionGroupCollection apiExplorer,
             GenerateClientOptions options,
-            string[] additionalNamespaces,
             Assembly webProjectAssembly)
         {
             this.apiExplorer = apiExplorer;
             this.options = options;
-            this.additionalNamespaces = additionalNamespaces;
             this.webProjectAssembly = webProjectAssembly;
         }
 
-        public ClientCollection GetClientCollection()
+        public List<Client> GetClientCollection()
         {
             var apiDescriptions = apiExplorer.Items
                 .SelectMany(i => i.Items)
                 .ToList();
 
             FilterDescriptions(apiDescriptions);
 
-            var allNamespaces = GetNamespaces(apiDescriptions);
-            var ambiguousTypes = GetAmbiguousTypes(allNamespaces);
-
             var assemblyName = webProjectAssembly.GetName().Name;
             var apiGroupsDescriptions = apiDescriptions.GroupBy(i => GroupInfo.From(i, assemblyName));
 
@@ -56,13 +50,11 @@ public ClientCollection GetClientCollection()
             var clients = apiGroupsDescriptions.Select(apis =>
                 GetClientModel(
                     commonControllerNamespace: commonControllerNamespacePart,
-                    additionalNamespaces: additionalNamespaces,
                     controllerInfo: apis.Key,
-                    apiDescriptions: apis.ToList(),
-                    ambiguousTypes: ambiguousTypes)
+                    apiDescriptions: apis.ToList())
                 ).ToList();
 
-            return new ClientCollection(clients, ambiguousTypes);
+            return clients;
         }
 
         private void FilterDescriptions(List<ApiDescription> apiDescriptions)
@@ -92,10 +84,8 @@ private void FilterDescriptions(List<ApiDescription> apiDescriptions)
 
         internal Client GetClientModel(
             string commonControllerNamespace,
-            string[] additionalNamespaces,
             GroupInfo controllerInfo,
-            List<ApiDescription> apiDescriptions,
-            HashSet<Type> ambiguousTypes)
+            List<ApiDescription> apiDescriptions)
         {
             apiDescriptions = HandleDuplicates(apiDescriptions);
 
@@ -108,22 +98,11 @@ internal Client GetClientModel(
 
             var clientNamespace = string.Join(".", new[] { options.Namespace }.Concat(subPath));
 
-            var namespaces = GetNamespaces(apiDescriptions, ambiguousTypes)
-                .Concat(additionalNamespaces);
-
-            if (options.AddCancellationTokenParameters)
-                namespaces = namespaces.Append("System.Threading");
-
-            namespaces = namespaces
-                .OrderByDescending(ns => ns.StartsWith("System"))
-                .ThenBy(ns => ns);
-
             var methods = apiDescriptions.Select(GetEndpointMethod).ToList();
 
             return new Client
             (
                 location: Path.Combine(subPath),
-                importedNamespaces: namespaces.ToList(),
                 @namespace: clientNamespace,
                 accessModifier: options.AccessModifier,
                 name: name,
@@ -182,7 +161,7 @@ private List<Parameter> GetParameters(ApiDescription apiDescription)
 
                     parametersList.Add(new Parameter(
                         source: ParameterSource.File,
-                        type: typeof(IFormFile),
+                        type: typeof(Stream),
                         name: parameterDescription.Name,
                         parameterName: name.ToCamelCase(),
                         defaultValueLiteral: null));
@@ -205,24 +184,39 @@ private List<Parameter> GetParameters(ApiDescription apiDescription)
                     var name = parameterDescription.ParameterDescriptor?.Name ?? "form";
                     var formType = parameterDescription.ParameterDescriptor?.ParameterType ?? typeof(object);
 
-                    var sameFormParameters = apiDescription.ParameterDescriptions.Skip(i - 1)
-                        .TakeWhile(d => d.ParameterDescriptor?.ParameterType == formType && d.ParameterDescriptor?.Name == name)
-                        .ToArray();
-
-                    // If form model has file parameters - we have to put it as separate parameters.
-                    if (!sameFormParameters.Any(p => p.Source.Id == "FormFile"))
+                    if (formType == typeof(IFormCollection))
                     {
                         parametersList.Add(new Parameter(
                             source: ParameterSource.Form,
-                            type: formType,
+                            type: typeof(Dictionary<string, string>),
                             name: parameterDescription.Name,
                             parameterName: name.ToCamelCase(),
-                            defaultValueLiteral: "null"));
-
-                        i += sameFormParameters.Length - 1;
+                            defaultValueLiteral: null));
 
                         continue;
                     }
+                    else
+                    {
+                        var sameFormParameters = apiDescription.ParameterDescriptions.Skip(i - 1)
+                            .TakeWhile(d => d.ParameterDescriptor?.ParameterType == formType && d.ParameterDescriptor?.Name == name)
+                            .ToArray();
+
+                        // If form model has file parameters - we have to put it as separate parameters.
+                        if (!sameFormParameters.Any(p => p.Source.Id == "FormFile"))
+                        {
+                            parametersList.Add(new Parameter(
+                                source: ParameterSource.Form,
+                                type: formType,
+                                name: parameterDescription.Name,
+                                parameterName: name.ToCamelCase(),
+                                defaultValueLiteral: "null"));
+
+                            if (sameFormParameters.Length > 0)
+                                i += sameFormParameters.Length - 1;
+
+                            continue;
+                        }
+                    }
                 }
 
                 if (options.UseQueryModels
@@ -282,7 +276,9 @@ private List<Parameter> GetParameters(ApiDescription apiDescription)
 
                 parameterName = new string(parameterName.Where(c => char.IsLetterOrDigit(c)).ToArray());
 
-                var type = parameterDescription.ModelMetadata?.ModelType ?? parameterDescription.Type ?? typeof(string);
+                var type = parameterDescription.Source == BindingSource.FormFile
+                    ? typeof(Stream)
+                    : parameterDescription.ModelMetadata?.ModelType ?? parameterDescription.Type ?? typeof(string);
 
                 var defaultValue = GetDefaultValueLiteral(parameterDescription, type);
 
@@ -313,30 +309,6 @@ private List<Parameter> GetParameters(ApiDescription apiDescription)
             return parametersList;
         }
 
-        private static HashSet<Type> GetAmbiguousTypes(IEnumerable<string> namespaces)
-        {
-            var namespacesSet = namespaces.ToHashSet();
-
-            return AppDomain.CurrentDomain.GetAssemblies()
-                .Where(a => !a.IsDynamic)
-                .SelectMany(a =>
-                {
-                    try
-                    {
-                        return a.ExportedTypes;
-                    }
-                    catch
-                    {
-                        return Array.Empty<Type>();
-                    }
-                })
-                .Where(t => t.DeclaringType == null && namespacesSet.Contains(t.Namespace!))
-                .GroupBy(t => t.Name)
-                .Where(g => g.Select(t => t.Namespace).Distinct().Count() > 1)
-                .SelectMany(g => g)
-                .ToHashSet();
-        }
-
         private static string? GetXmlDoc(ApiDescription apiDescription)
         {
             var xmlElement = (apiDescription.ActionDescriptor as ControllerActionDescriptor)?.MethodInfo.GetXmlDocsElement();
@@ -385,59 +357,6 @@ private static string GetCommonNamespacesPart(IEnumerable<IGrouping<GroupInfo, A
             return namespaces.GetCommonPart(".");
         }
 
-        private List<string> GetNamespaces(IEnumerable<ApiDescription> apiDescriptions, HashSet<Type>? ambiguousTypes = null)
-        {
-            var namespaces = new HashSet<string>();
-
-            foreach (var apiDescription in apiDescriptions)
-            {
-                var responseType = GetResponseType(apiDescription);
-                AddForType(responseType);
-
-                foreach (var parameterDescription in apiDescription.ParameterDescriptions)
-                {
-                    switch (parameterDescription.Source.Id)
-                    {
-                        case "FormFile":
-                            // Skip FormFile, as it won't be present in result file 
-                            // (not needed for 3.1+)
-                            break;
-                        case "Form":
-                            var hasFile = apiDescription.ParameterDescriptions
-                                .Any(d => d.ParameterDescriptor == parameterDescription.ParameterDescriptor && d.Source.Id == "FormFile");
-
-                            if (!hasFile)
-                                AddForType(parameterDescription.ParameterDescriptor.ParameterType);
-
-                            break;
-                        case "Query" when options.UseQueryModels && parameterDescription.ModelMetadata?.ContainerType != null:
-                            AddForType(parameterDescription.ModelMetadata.ContainerType);
-                            break;
-                        default:
-                            AddForType(parameterDescription.ModelMetadata?.ModelType ?? parameterDescription.Type);
-                            break;
-                    }
-                }
-            }
-
-            return namespaces.ToList();
-
-            void AddForType(Type? type)
-            {
-                if (type != null && !type.IsBuiltInType() && ambiguousTypes?.Contains(type) != true)
-                {
-                    if (type.Namespace != null)
-                        namespaces.Add(type.Namespace);
-
-                    if (type.IsGenericType)
-                    {
-                        foreach (var typeArg in type.GetGenericArguments())
-                            AddForType(typeArg);
-                    }
-                }
-            }
-        }
-
         private static string? GetDefaultValueLiteral(ApiParameterDescription parameter, Type parameterType)
         {
             var defaultValue = parameter.DefaultValue;

GenerateAspNetCoreClient.Command/GenerateClientCommand.cs

@@ -16,15 +16,16 @@ public class GenerateClientCommand
     {
         public static void Invoke(Assembly assembly, GenerateClientOptions options)
         {
+            options.AdditionalNamespaces = ["System.Threading.Tasks", "Refit"];
             var apiExplorer = GetApiExplorer(assembly, options.Environment);
-
-            var clientModelBuilder = new ClientModelBuilder(apiExplorer, options,
-                additionalNamespaces: new[] { "System.Threading.Tasks", "Refit" }, assembly);
+            var clientModelBuilder = new ClientModelBuilder(apiExplorer, options, assembly);
             var clientCollection = clientModelBuilder.GetClientCollection();
 
+            var ambiguousTypes = GetAmbiguousTypes(clientCollection);
+
             foreach (var clientModel in clientCollection)
             {
-                var clientText = CreateClient(clientModel, clientCollection.AmbiguousTypes, options);
+                var clientText = CreateClient(clientModel, ambiguousTypes, options);
 
                 var path = Path.Combine(options.OutPath, clientModel.Location);
                 Directory.CreateDirectory(path);
@@ -48,6 +49,7 @@ private static string CreateClient(Client clientModel, HashSet<Type> ambiguousTy
             IEnumerable<EndpointMethod> endpointMethods = clientModel.EndpointMethods;
             endpointMethods = HandleEndpointDuplicates(endpointMethods, ambiguousTypes);
             endpointMethods = HandleSignatureDuplicates(endpointMethods, ambiguousTypes);
+            var namespaces = GetImportedNamespaces(clientModel, ambiguousTypes, options);
 
             var methodDescriptions = endpointMethods.Select(endpointMethod =>
             {
@@ -98,7 +100,7 @@ private static string CreateClient(Client clientModel, HashSet<Type> ambiguousTy
             return
     $@"//<auto-generated />
 
-{string.Join(Environment.NewLine, clientModel.ImportedNamespaces.Select(n => $"using {n};"))}
+{string.Join(Environment.NewLine, namespaces.Select(n => $"using {n};"))}
 
 namespace {clientModel.Namespace}
 {{
@@ -109,6 +111,21 @@ namespace {clientModel.Namespace}
 }}";
         }
 
+        private static IEnumerable<string> GetImportedNamespaces(Client clientModel, HashSet<Type> ambiguousTypes, GenerateClientOptions options)
+        {
+            var namespaces = GetNamespaces(clientModel.EndpointMethods, ambiguousTypes)
+                .Concat(options.AdditionalNamespaces);
+
+            if (options.AddCancellationTokenParameters)
+                namespaces = namespaces.Append("System.Threading");
+
+            namespaces = namespaces
+                .OrderByDescending(ns => ns.StartsWith("System"))
+                .ThenBy(ns => ns);
+
+            return namespaces;
+        }
+
         private static string GetResponseTypeName(Type responseType, HashSet<Type> ambiguousTypes, GenerateClientOptions options)
         {
             if (options.UseApiResponses)
@@ -174,6 +191,62 @@ private static string GetQueryAttribute(Parameter parameter)
             return "";
         }
 
+        private static HashSet<Type> GetAmbiguousTypes(IEnumerable<Client> clients)
+        {
+            var allNamespaces = GetNamespaces(clients.SelectMany(c => c.EndpointMethods));
+
+            return AppDomain.CurrentDomain.GetAssemblies()
+                .Where(a => !a.IsDynamic)
+                .SelectMany(a =>
+                {
+                    try
+                    {
+                        return a.ExportedTypes;
+                    }
+                    catch
+                    {
+                        return [];
+                    }
+                })
+                .Where(t => t.DeclaringType == null && allNamespaces.Contains(t.Namespace!))
+                .GroupBy(t => t.Name)
+                .Where(g => g.Select(t => t.Namespace).Distinct().Count() > 1)
+                .SelectMany(g => g)
+                .ToHashSet();
+        }
+
+        private static HashSet<string> GetNamespaces(IEnumerable<EndpointMethod> apiDescriptions, HashSet<Type>? ambiguousTypes = null)
+        {
+            var namespaces = new HashSet<string>();
+
+            foreach (var apiDescription in apiDescriptions)
+            {
+                AddForType(apiDescription.ResponseType);
+
+                foreach (var parameterDescription in apiDescription.Parameters)
+                {
+                    AddForType(parameterDescription.Type);
+                }
+            }
+
+            return namespaces;
+
+            void AddForType(Type? type)
+            {
+                if (type != null && !type.IsBuiltInType() && ambiguousTypes?.Contains(type) != true)
+                {
+                    if (type.Namespace != null)
+                        namespaces.Add(type.Namespace);
+
+                    if (type.IsGenericType)
+                    {
+                        foreach (var typeArg in type.GetGenericArguments())
+                            AddForType(typeArg);
+                    }
+                }
+            }
+        }
+
         private class RunSettings : IDisposable
         {
             private readonly string? environment;

GenerateAspNetCoreClient.Command/Model/Client.cs

@@ -8,27 +8,22 @@ public class Client
         /// Relative location from target folder.
         /// </summary>
         public string Location { get; }
-
-        public IReadOnlyList<string> ImportedNamespaces { get; }
         public string Namespace { get; }
         public string AccessModifier { get; }
         public string Name { get; }
         public IReadOnlyList<EndpointMethod> EndpointMethods { get; }
 
         public Client(
             string location,
-            IReadOnlyList<string> importedNamespaces,
             string @namespace, string accessModifier,
             string name,
             IReadOnlyList<EndpointMethod> endpointMethods)
         {
             Location = location;
-            ImportedNamespaces = importedNamespaces;
             Namespace = @namespace;
             AccessModifier = accessModifier;
             Name = name;
             EndpointMethods = endpointMethods;
         }
-
     }
 }