Gibt es eine Möglichkeit, alle Aufzählungen als Zeichenfolgenwert in swagger anstelle ihres int-Werts anzuzeigen?

Ich möchte in der Lage sein, POST-Aktionen einzureichen und Aufzählungen entsprechend ihrem Zeichenfolgenwert zu setzen, ohne jedes Mal die Aufzählung überprüfen zu müssen.

Ich habe es versucht, DescribeAllEnumsAsStringsaber der Server empfängt dann Zeichenfolgen anstelle des Aufzählungswerts, nach dem wir nicht suchen.

Hat jemand das gelöst?

Bearbeiten:

public class Letter 
{
    [Required]
    public string Content {get; set;}

    [Required]
    [EnumDataType(typeof(Priority))]
    public Priority Priority {get; set;}
}


public class LettersController : ApiController
{
    [HttpPost]
    public IHttpActionResult SendLetter(Letter letter)
    {
        // Validation not passing when using DescribeEnumsAsStrings
        if (!ModelState.IsValid)
            return BadRequest("Not valid")

        ..
    }

    // In the documentation for this request I want to see the string values of the enum before submitting: Low, Medium, High. Instead of 0, 1, 2
    [HttpGet]
    public IHttpActionResult GetByPriority (Priority priority)
    {

    }
}


public enum Priority
{
    Low, 
    Medium,
    High
}

Aus den Dokumenten :

httpConfiguration
    .EnableSwagger(c => 
        {
            c.SingleApiVersion("v1", "A title for your API");

            c.DescribeAllEnumsAsStrings(); // this will do the trick
        });

Wenn Sie dieses Verhalten nur für einen bestimmten Typ und eine bestimmte Eigenschaft wünschen, verwenden Sie den StringEnumConverter:

public class Letter 
{
    [Required]
    public string Content {get; set;}

    [Required]
    [EnumDataType(typeof(Priority))]
    [JsonConverter(typeof(StringEnumConverter))]
    public Priority Priority {get; set;}
}

Für ASP.Net Core 3 mit Newtonsoft JSON-Bibliothek

Swashbuckle.AspNetCore.NewtonsoftPaket installieren .

Dann in Startup.cs / ConfigureServices ():

services
    .AddControllersWithViews(...)
    .AddNewtonsoftJson(options => 
        options.SerializerSettings.Converters.Add(new StringEnumConverter()));
services.AddSwaggerGenNewtonsoftSupport();

Dies erfordert keinen Aufruf von options.DescribeAllEnumsAsStrings()AddSwaggerGen ().

Für ASP.Net Core 3 mit Microsoft JSON-Bibliothek

Siehe @ Bashirs Antwort im Grunde:

services
    .AddControllersWithViews(...)
    .AddJsonOptions(options => 
        options.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter()));

Und wie er beschreibt, erfordert es derzeit options.DescribeAllEnumsAsStrings().

Für ASP.Net Core 2

In Startup.cs / ConfigureServices ():

services
    .AddMvc(...)
    .AddJsonOptions(options => 
        options.SerializerSettings.Converters.Add(new StringEnumConverter()));

Dies erfordert keinen Aufruf von options.DescribeAllEnumsAsStrings()AddSwaggerGen ().

Pre ASP.Net Core

Verwenden Sie den DescribeAllEnumsAsStrings()Ansatz aus der akzeptierten Antwort.

Ich glaube, ich habe ein ähnliches Problem. Ich suche nach Prahlerei, um Enums zusammen mit der int -> String-Zuordnung zu generieren. Die API muss den int akzeptieren. Die Prahlerei-UI ist weniger wichtig. Was ich wirklich will, ist die Codegenerierung mit einer "echten" Aufzählung auf der anderen Seite (in diesem Fall Android-Apps mit Nachrüstung).

Aus meiner Forschung scheint dies letztendlich eine Grenze der OpenAPI-Spezifikation zu sein, die Swagger verwendet. Es ist nicht möglich, Namen und Nummern für Aufzählungen anzugeben.

Das beste Problem, das ich gefunden habe, ist https://github.com/OAI/OpenAPI-Specification/issues/681, das wie "vielleicht bald" aussieht, aber dann müsste Swagger aktualisiert werden, und in meinem Fall Swashbuckle als Gut.

Im Moment bestand meine Problemumgehung darin, einen Dokumentfilter zu implementieren, der nach Aufzählungen sucht und die entsprechende Beschreibung mit dem Inhalt der Aufzählung füllt.

        GlobalConfiguration.Configuration
            .EnableSwagger(c =>
                {
                    c.DocumentFilter<SwaggerAddEnumDescriptions>();

                    //disable this
                    //c.DescribeAllEnumsAsStrings()

SwaggerAddEnumDescriptions.cs:

using System;
using System.Web.Http.Description;
using Swashbuckle.Swagger;
using System.Collections.Generic;

public class SwaggerAddEnumDescriptions : IDocumentFilter
{
    public void Apply(SwaggerDocument swaggerDoc, SchemaRegistry schemaRegistry, IApiExplorer apiExplorer)
    {
        // add enum descriptions to result models
        foreach (KeyValuePair<string, Schema> schemaDictionaryItem in swaggerDoc.definitions)
        {
            Schema schema = schemaDictionaryItem.Value;
            foreach (KeyValuePair<string, Schema> propertyDictionaryItem in schema.properties)
            {
                Schema property = propertyDictionaryItem.Value;
                IList<object> propertyEnums = property.@enum;
                if (propertyEnums != null && propertyEnums.Count > 0)
                {
                    property.description += DescribeEnum(propertyEnums);
                }
            }
        }

        // add enum descriptions to input parameters
        if (swaggerDoc.paths.Count > 0)
        {
            foreach (PathItem pathItem in swaggerDoc.paths.Values)
            {
                DescribeEnumParameters(pathItem.parameters);

                // head, patch, options, delete left out
                List<Operation> possibleParameterisedOperations = new List<Operation> { pathItem.get, pathItem.post, pathItem.put };
                possibleParameterisedOperations.FindAll(x => x != null).ForEach(x => DescribeEnumParameters(x.parameters));
            }
        }
    }

    private void DescribeEnumParameters(IList<Parameter> parameters)
    {
        if (parameters != null)
        {
            foreach (Parameter param in parameters)
            {
                IList<object> paramEnums = param.@enum;
                if (paramEnums != null && paramEnums.Count > 0)
                {
                    param.description += DescribeEnum(paramEnums);
                }
            }
        }
    }

    private string DescribeEnum(IList<object> enums)
    {
        List<string> enumDescriptions = new List<string>();
        foreach (object enumOption in enums)
        {
            enumDescriptions.Add(string.Format("{0} = {1}", (int)enumOption, Enum.GetName(enumOption.GetType(), enumOption)));
        }
        return string.Join(", ", enumDescriptions.ToArray());
    }

}

Dies führt auf Ihrer Swagger-Benutzeroberfläche zu folgenden Ergebnissen, sodass Sie zumindest "sehen können, was Sie tun":

ASP.NET Core 3.1

Um mit Newtonsoft JSON Aufzählungen als Zeichenfolgen zu generieren, müssen Sie die Newtonsoft-Unterstützung explizit hinzufügen, indem Sie AddSwaggerGenNewtonsoftSupport()Folgendes hinzufügen :

services.AddMvc()
    ...
    .AddNewtonsoftJson(opts =>
    {
        opts.SerializerSettings.Converters.Add(new StringEnumConverter());
    });


services.AddSwaggerGen(...);
services.AddSwaggerGenNewtonsoftSupport(); //

Dies ist über ein neues Paket möglich Swashbuckle.AspNetCore.Newtonsoft. Es sieht so aus, als ob alles andere ohne dieses Paket gut funktioniert, abgesehen von der Unterstützung von Enum Converter.

Ich wollte die Antwort von rory_za in einer .NET Core-Anwendung verwenden, musste sie jedoch ein wenig ändern, damit sie funktioniert. Hier ist die Implementierung, die ich für .NET Core entwickelt habe.

Ich habe es auch geändert, damit nicht angenommen wird int, dass es sich um den zugrunde liegenden Typ handelt , und neue Zeilen zwischen den Werten verwendet, um das Lesen zu erleichtern.

/// <summary>
/// Add enum value descriptions to Swagger
/// </summary>
public class EnumDocumentFilter : IDocumentFilter {
    /// <inheritdoc />
    public void Apply(SwaggerDocument swaggerDoc, DocumentFilterContext context) {
        // add enum descriptions to result models
        foreach (var schemaDictionaryItem in swaggerDoc.Definitions) {
            var schema = schemaDictionaryItem.Value;
            foreach (var propertyDictionaryItem in schema.Properties) {
                var property = propertyDictionaryItem.Value;
                var propertyEnums = property.Enum;
                if (propertyEnums != null && propertyEnums.Count > 0) {
                    property.Description += DescribeEnum(propertyEnums);
                }
            }
        }

        if (swaggerDoc.Paths.Count <= 0) return;

        // add enum descriptions to input parameters
        foreach (var pathItem in swaggerDoc.Paths.Values) {
            DescribeEnumParameters(pathItem.Parameters);

            // head, patch, options, delete left out
            var possibleParameterisedOperations = new List<Operation> {pathItem.Get, pathItem.Post, pathItem.Put};
            possibleParameterisedOperations.FindAll(x => x != null)
                .ForEach(x => DescribeEnumParameters(x.Parameters));
        }
    }

    private static void DescribeEnumParameters(IList<IParameter> parameters) {
        if (parameters == null) return;

        foreach (var param in parameters) {
            if (param is NonBodyParameter nbParam && nbParam.Enum?.Any() == true) {
                param.Description += DescribeEnum(nbParam.Enum);
            } else if (param.Extensions.ContainsKey("enum") && param.Extensions["enum"] is IList<object> paramEnums &&
                paramEnums.Count > 0) {
                param.Description += DescribeEnum(paramEnums);
            }
        }
    }

    private static string DescribeEnum(IEnumerable<object> enums) {
        var enumDescriptions = new List<string>();
        Type type = null;
        foreach (var enumOption in enums) {
            if (type == null) type = enumOption.GetType();
            enumDescriptions.Add($"{Convert.ChangeType(enumOption, type.GetEnumUnderlyingType())} = {Enum.GetName(type, enumOption)}");
        }

        return $"{Environment.NewLine}{string.Join(Environment.NewLine, enumDescriptions)}";
    }
}

Fügen Sie dies dann Ihrer ConfigureServicesMethode in Startup.cs hinzu:

c.DocumentFilter<EnumDocumentFilter>();

Mit asp.net Kern 3

using System.Text.Json.Serialization;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
         services.AddControllers().AddJsonOptions(options =>
             options.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter()));

Aber es scheint, dass Swashbuckle Version 5.0.0-rc4 nicht bereit ist, dies zu unterstützen. Daher müssen wir eine Option (veraltet) in der Swashbuckle-Konfigurationsdatei verwenden, bis sie wie die Newtonsoft-Bibliothek unterstützt und wiedergegeben wird.

public void ConfigureServices(IServiceCollection services)
{ 
      services.AddSwaggerGen(c =>
      {
            c.DescribeAllEnumsAsStrings();

Der Unterschied zwischen dieser Antwort und anderen Antworten besteht darin, dass nur die Microsoft JSON-Bibliothek anstelle von Newtonsoft verwendet wird.

.NET CORE 3.1 und SWAGGER 5

Wenn Sie eine einfache Lösung benötigen, um selektiv als Zeichenfolgen übergebene Aufzählungen zu erstellen:

using System.Text.Json.Serialization;


[JsonConverter(typeof(JsonStringEnumConverter))]
public enum MyEnum
{
    A, B
}

Beachten Sie, dass wir den System.Text.Json.SerializationNamespace verwenden, nicht den Newtonsoft.Json!

Wenn jemand interessiert ist, habe ich den Code geändert, um damit zu arbeiten

.NET CORE 3 und Swagger V5

    public class SwaggerAddEnumDescriptions : IDocumentFilter
{
    public void Apply(OpenApiDocument swaggerDoc, DocumentFilterContext context)
    {
        // add enum descriptions to result models
        foreach (var property in swaggerDoc.Components.Schemas.Where(x => x.Value?.Enum?.Count > 0))
        {
            IList<IOpenApiAny> propertyEnums = property.Value.Enum;
            if (propertyEnums != null && propertyEnums.Count > 0)
            {
                property.Value.Description += DescribeEnum(propertyEnums, property.Key);
            }
        }

        // add enum descriptions to input parameters
        foreach (var pathItem in swaggerDoc.Paths.Values)
        {
            DescribeEnumParameters(pathItem.Operations, swaggerDoc);
        }
    }

    private void DescribeEnumParameters(IDictionary<OperationType, OpenApiOperation> operations, OpenApiDocument swaggerDoc)
    {
        if (operations != null)
        {
            foreach (var oper in operations)
            {
                foreach (var param in oper.Value.Parameters)
                {
                    var paramEnum = swaggerDoc.Components.Schemas.FirstOrDefault(x => x.Key == param.Name);
                    if (paramEnum.Value != null)
                    {
                        param.Description += DescribeEnum(paramEnum.Value.Enum, paramEnum.Key);
                    }
                }
            }
        }
    }

    private Type GetEnumTypeByName(string enumTypeName)
    {
        return AppDomain.CurrentDomain
            .GetAssemblies()
            .SelectMany(x => x.GetTypes())
            .FirstOrDefault(x => x.Name == enumTypeName);
    }

    private string DescribeEnum(IList<IOpenApiAny> enums, string proprtyTypeName)
    {
        List<string> enumDescriptions = new List<string>();
        var enumType = GetEnumTypeByName(proprtyTypeName);
        if (enumType == null)
            return null;

        foreach (OpenApiInteger enumOption in enums)
        {
            int enumInt = enumOption.Value;

            enumDescriptions.Add(string.Format("{0} = {1}", enumInt, Enum.GetName(enumType, enumInt)));
        }

        return string.Join(", ", enumDescriptions.ToArray());
    }
}

Ich habe das gerade gemacht und es funktioniert gut!

Startup.cs

services.AddSwaggerGen(c => {
  c.DescribeAllEnumsAsStrings();
});

Model.cs

public enum ColumnType {
  DATE = 0
}

swagger.json

type: {
  enum: ["DATE"],
  type: "string"
}

Ich hoffe das hilft dir wie es mir geholfen hat!

in .net Core 3.1 & Swagger 5.0.0:

using System.Linq;
using Microsoft.OpenApi.Any;
using Microsoft.OpenApi.Models;
using Swashbuckle.AspNetCore.SwaggerGen;

namespace WebFramework.Swagger
{
    public class EnumSchemaFilter : ISchemaFilter
    {
        public void Apply(OpenApiSchema schema, SchemaFilterContext context)
        {
            if (context.Type.IsEnum)
            {
                var enumValues = schema.Enum.ToArray();
                var i = 0;
                schema.Enum.Clear();
                foreach (var n in Enum.GetNames(context.Type).ToList())
                {
                    schema.Enum.Add(new OpenApiString(n + $" = {((OpenApiPrimitive<int>)enumValues[i]).Value}"));
                    i++;
                }
            }
        }
    }

}

und in Startup.cs:

services.AddSwaggerGen(options =>
            {
                #region  EnumDesc
                options.SchemaFilter<EnumSchemaFilter>();
                #endregion
            });

Meine Variante für Enum Stings mit Werten:

Dienste konfigurieren:

services.AddSwaggerGen(c =>
            {
                c.SwaggerDoc("v1", new OpenApiInfo { Title = "web server api", Version = "v1" });
                c.SchemaFilter<EnumSchemaFilter>();
            });

Filter:

public class EnumSchemaFilter : ISchemaFilter
    {
        public void Apply(OpenApiSchema model, SchemaFilterContext context)
        {
            if (context.Type.IsEnum)
            {
                model.Enum.Clear();
                Enum.GetNames(context.Type)
                    .ToList()
                    .ForEach(name => model.Enum.Add(new OpenApiString($"{Convert.ToInt64(Enum.Parse(context.Type, name))} - {name}")));
            }
        }
    }

Schreiben Sie Code in Startup.cs

services.AddSwaggerGen(c => {
      c.DescribeAllEnumsAsStrings();
    });

.Net Core 3.0

   using Newtonsoft.Json.Converters;

 services
    .AddMvc(options =>
    {
     options.EnableEndpointRouting = false;
     })
    .AddNewtonsoftJson(options => options.SerializerSettings.Converters.Add(new StringEnumConverter()))

Ich habe hier eine gute Lösung gefunden:

@PauloVetor - löste es mit ShemaFilter wie folgt:

public class EnumSchemaFilter : ISchemaFilter
{
    public void Apply(OpenApiSchema model, SchemaFilterContext context)
    {
        if (context.Type.IsEnum)
        {
            model.Enum.Clear();
            Enum.GetNames(context.Type)
                .ToList()
                .ForEach(n => model.Enum.Add(new OpenApiString(n)));
            }
        }
    }
}

Und in Startup.cs:

services.AddSwaggerGen(options =>
{
    options.SchemaFilter<EnumSchemaFilter>();
}

Ich habe Hosam Rehanis Antwort geändert, um mit nullbaren Aufzählungen und auch mit der Sammlung von Aufzählungen zu arbeiten. Die vorherige Antwort funktioniert auch nur, wenn eine Eigenschaft genau wie ihr Typ benannt ist. All diese Probleme werden im folgenden Code behandelt.

Es funktioniert mit .net Core 3.x und Swagger 5.x.

Es könnte effizienter sein, wenn in einigen Fällen nicht zweimal nach dem Aufzählungstyp gesucht wird.

class SwaggerAddEnumDescriptions : IDocumentFilter
{
    public void Apply(OpenApiDocument swaggerDoc, DocumentFilterContext context)
    {
        // add enum descriptions to result models
        foreach (var property in swaggerDoc.Components.Schemas.Where(x => x.Value?.Enum?.Count > 0))
        {
            IList<IOpenApiAny> propertyEnums = property.Value.Enum;
            if (propertyEnums != null && propertyEnums.Count > 0)
            {
                property.Value.Description += DescribeEnum(propertyEnums, property.Key);
            }
        }

        // add enum descriptions to input parameters
        foreach (var pathItem in swaggerDoc.Paths)
        {
            DescribeEnumParameters(pathItem.Value.Operations, swaggerDoc, context.ApiDescriptions, pathItem.Key);
        }
    }

    private void DescribeEnumParameters(IDictionary<OperationType, OpenApiOperation> operations, OpenApiDocument swaggerDoc, IEnumerable<ApiDescription> apiDescriptions, string path)
    {
        path = path.Trim('/');
        if (operations != null)
        {
            var pathDescriptions = apiDescriptions.Where(a => a.RelativePath == path);
            foreach (var oper in operations)
            {
                var operationDescription = pathDescriptions.FirstOrDefault(a => a.HttpMethod.Equals(oper.Key.ToString(), StringComparison.InvariantCultureIgnoreCase));
                foreach (var param in oper.Value.Parameters)
                {
                    var parameterDescription = operationDescription.ParameterDescriptions.FirstOrDefault(a => a.Name == param.Name);
                    if (parameterDescription != null && TryGetEnumType(parameterDescription.Type, out Type enumType))
                    {
                        var paramEnum = swaggerDoc.Components.Schemas.FirstOrDefault(x => x.Key == enumType.Name);
                        if (paramEnum.Value != null)
                        {
                            param.Description += DescribeEnum(paramEnum.Value.Enum, paramEnum.Key);
                        }
                    }
                }
            }
        }
    }

    bool TryGetEnumType(Type type, out Type enumType)
    {
        if (type.IsEnum)
        {
            enumType = type;
            return true;
        }
        else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
        {
            var underlyingType = Nullable.GetUnderlyingType(type);
            if (underlyingType != null && underlyingType.IsEnum == true)
            {
                enumType = underlyingType;
                return true;
            }
        }
        else
        {
            Type underlyingType = GetTypeIEnumerableType(type);
            if (underlyingType != null && underlyingType.IsEnum)
            {
                enumType = underlyingType;
                return true;
            }
            else
            {
                var interfaces = type.GetInterfaces();
                foreach (var interfaceType in interfaces)
                {
                    underlyingType = GetTypeIEnumerableType(interfaceType);
                    if (underlyingType != null && underlyingType.IsEnum)
                    {
                        enumType = underlyingType;
                        return true;
                    }
                }
            }
        }

        enumType = null;
        return false;
    }

    Type GetTypeIEnumerableType(Type type)
    {
        if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IEnumerable<>))
        {
            var underlyingType = type.GetGenericArguments()[0];
            if (underlyingType.IsEnum)
            {
                return underlyingType;
            }
        }

        return null;
    }

    private Type GetEnumTypeByName(string enumTypeName)
    {
        return AppDomain.CurrentDomain
            .GetAssemblies()
            .SelectMany(x => x.GetTypes())
            .FirstOrDefault(x => x.Name == enumTypeName);
    }

    private string DescribeEnum(IList<IOpenApiAny> enums, string proprtyTypeName)
    {
        List<string> enumDescriptions = new List<string>();
        var enumType = GetEnumTypeByName(proprtyTypeName);
        if (enumType == null)
            return null;

        foreach (OpenApiInteger enumOption in enums)
        {
            int enumInt = enumOption.Value;

            enumDescriptions.Add(string.Format("{0} = {1}", enumInt, Enum.GetName(enumType, enumInt)));
        }

        return string.Join(", ", enumDescriptions.ToArray());
    }
}

Um den Filter zu verwenden, fügen Sie c.DocumentFilter<SwaggerAddEnumDescriptions>();die Swagger-Konfiguration hinzu Startup.cs.

ASP-NETZLÖSUNG

In meinen API-Dokumenten wurde eine Aufzählung immer noch als int angezeigt, obwohl die Eigenschaft mit markiert ist StringEnumConverter. Wir konnten es uns nicht leisten, die globale Einstellung für alle oben genannten Aufzählungen zu verwenden. Das Hinzufügen dieser Zeile in SwaggerConfig löste das Problem:

c.MapType<ContactInfoType>(() => new Schema { type = "string", @enum = Enum.GetNames(typeof(ContactInfoType))});

Es gab eine Reihe von Mängeln, die ich in den anderen Antworten für das gefunden habe, wonach wir gesucht haben, also dachte ich, ich würde meine eigene Meinung dazu abgeben. Wir verwenden ASP.NET Core 3.1 mit System.Text.Json, aber unser Ansatz funktioniert unabhängig vom verwendeten JSON-Serializer.

Unser Ziel war es, Enum-String-Werte mit niedrigerer Kamelhülle sowohl in der ASP.NET Core-API als auch in Swagger zu dokumentieren. Wir verwenden derzeit [DataContract]und [EnumMember], daher besteht der Ansatz darin, den Wert mit niedrigerer Kamelhülle aus der EnumMember-Werteigenschaft zu übernehmen und auf der ganzen Linie zu verwenden.

Unsere Beispielaufzählung:

[DataContract]
public class enum Colors
{
  [EnumMember(Value="brightPink")]
  BrightPink,
  [EnumMember(Value="blue")]
  Blue
}

Wir werden die EnumMember-Werte in Swashbuckle verwenden, indem wir einen ISchemaFilter wie folgt verwenden:

public class DescribeEnumMemberValues : ISchemaFilter
{
    public void Apply(OpenApiSchema schema, SchemaFilterContext context)
    {
        if (context.Type.IsEnum)
        {
            schema.Enum.Clear();

            //Retrieve each of the values decorated with an EnumMember attribute
            foreach (var member in context.Type.GetMembers())
            {
                var memberAttr = member.GetCustomAttributes(typeof(EnumMemberAttribute), false).FirstOrDefault();
                if (memberAttr != null)
                {
                    var attr = (EnumMemberAttribute) memberAttr;
                    schema.Enum.Add(new OpenApiString(attr.Value));
                }
            }
        }
    }
}

Wir verwenden ein NuGet-Paket eines Drittanbieters (GitHub- Repo ), um sicherzustellen, dass dieses Namensschema auch in ASP.NET Core verwendet wird. Konfigurieren Sie es in Startup.cs in ConfigureServices mit:

services.AddControllers()
  .AddJsonOptions(opt => opt.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverterWithAttributeSupport()));

Schließlich müssen wir unseren ISchemaFilter in Swashbuckle registrieren, also fügen Sie auch in ConfigureServices () Folgendes hinzu:

services.AddSwaggerGen(c => {
  c.SchemaFilter<DescribeEnumMemberValues>();
});

Dies ist mit Standard-OpenAPI nicht möglich. Aufzählungen werden nur mit ihren Zeichenfolgenwerten beschrieben.

Glücklicherweise können Sie dies mit einigen nicht standardmäßigen Erweiterungen tun, die von Ihrem Client-Generator verwendet werden.

NSwag unterstützt x-enumNames

AutoRest unterstützt x-ms-enum.

Openapi-Generator unterstützt x-enum-varnames

Andere Generatoren unterstützen möglicherweise eine dieser Erweiterungen oder haben ihre eigene.

Um x-enumNamesfür NSwag zu generieren, erstellen Sie den folgenden Schemafilter:

public class EnumSchemaFilter : ISchemaFilter
{
    public void Apply(OpenApiSchema schema, SchemaFilterContext context)
    {
        if (context.Type.IsEnum)
        {
            var array = new OpenApiArray();
            array.AddRange(Enum.GetNames(context.Type).Select(n => new OpenApiString(n)));
            // NSwag
            schema.Extensions.Add("x-enumNames", array);
            // Openapi-generator
            schema.Extensions.Add("x-enum-varnames", array);
        }
    }
}

Und registrieren Sie es als:

services.AddSwaggerGen(options =>
{
    options.SchemaFilter<EnumSchemaFilter>();
});

Wenn die Version der Prahlerei 5.5.x war, müssen Sie:

1. install: Install-Package Swashbuckle.AspNetCore.Newtonsoft -Version 5.5.0

2. services.AddSwaggerGenNewtonsoftSupport ();

Referenz: https://github.com/domaindrivendev/Swashbuckle.AspNetCore#systemtextjson-stj-vs-newtonsoft