সোয়াগার ইউআই ওয়েব এপি ডকুমেন্টেশন স্ট্রিং হিসাবে এনামগুলিকে উপস্থাপন করেন?

Question 1

সমস্ত এনামগুলিকে তাদের মান মানের পরিবর্তে সোয়াগারে তার স্ট্রিং মান হিসাবে প্রদর্শন করার কোনও উপায় আছে?

আমি পোষ্ট ক্রিয়া জমা দিতে এবং এনামগুলিকে প্রতিবার এনামের দিকে না তাকিয়ে তাদের স্ট্রিংয়ের মান অনুযায়ী রাখতে সক্ষম হতে চাই।

আমি চেষ্টা করেছিলাম DescribeAllEnumsAsStringsতবে সার্ভারটি এনাম মানের পরিবর্তে স্ট্রিংগুলি পেয়ে থাকে যা আমরা যা খুঁজছি তা নয়।

কেউ কি এর সমাধান করেছেন?

সম্পাদনা করুন:

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
}

Question 2

ডক্স থেকে :

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

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

এছাড়াও, আপনি যদি কেবল কোনও নির্দিষ্ট ধরণের এবং সম্পত্তিতেই এই আচরণটি চান তবে স্ট্রিংইনম কনভার্টারটি ব্যবহার করুন:

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

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

Question 3

মাইক্রোসফ্ট জেএসওএন লাইব্রেরি (সিস্টেম.টেক্সট.জসন) সহ এএসপি.নেট কোর 3 এর জন্য

স্টার্টআপ.সি / কনফিগার সার্ভিসগুলিতে ():

services
    .AddControllersWithViews(...) // or AddControllers() in a Web API
    .AddJsonOptions(options => 
        options.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter()));

জেএসন.এনইটি (নিউটনসফট.জেসন) লাইব্রেরির সাথে এএসপি.নেট কোর 3 এর জন্য

Swashbuckle.AspNetCore.Newtonsoftপ্যাকেজ ইনস্টল করুন ।

স্টার্টআপ.সি / কনফিগার সার্ভিসগুলিতে ():

services
    .AddControllersWithViews(...)
    .AddNewtonsoftJson(options => 
        options.SerializerSettings.Converters.Add(new StringEnumConverter()));
// order is vital, this *must* be called *after* AddNewtonsoftJson()
services.AddSwaggerGenNewtonsoftSupport();

এএসপি.নেট কোর 2 এর জন্য

স্টার্টআপ.সি / কনফিগার সার্ভিসগুলিতে ():

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

প্রাক- ASSP.NET কোর

httpConfiguration
    .EnableSwagger(c => 
        {
            c.DescribeAllEnumsAsStrings();
        });

Question 4

সুতরাং আমার মনে হয় আমারও একই সমস্যা রয়েছে। আমি ইনট -> স্ট্রিং ম্যাপিংয়ের সাথে এনামগুলি তৈরি করতে সোয়াগার খুঁজছি। এপিআই অবশ্যই অন্তর্ভুক্ত গ্রহণ করতে হবে। সোয়াগার-ইউআই কম গুরুত্ব দেয়, আমি যা চাই তা হল অন্যদিকে "রিয়েল" এনাম সহ কোড জেনারেশন (এই ক্ষেত্রে retrofit ব্যবহার করে অ্যান্ড্রয়েড অ্যাপ্লিকেশন)।

সুতরাং আমার গবেষণা থেকে শেষ পর্যন্ত এটিকে ওপেনপিআই স্পেসিফিকেশনের সীমা হিসাবে মনে হয় যা সোয়াগার ব্যবহার করে। এনামগুলির জন্য নাম এবং সংখ্যা নির্দিষ্ট করা সম্ভব নয়।

আমি যে সেরা ইস্যুটি অনুসরণ করতে পেরেছি তা হ'ল https://github.com/OAI/OpenAPI-Specifications/issues/681 যা "সম্ভবত শীঘ্রই" মনে হচ্ছে তবে স্ব্যাগার আপডেট হতে হবে, এবং আমার ক্ষেত্রে Swashbuckle হিসাবে আমরা হব.

আপাতত আমার কাজটি হ'ল একটি ডকুমেন্ট ফিল্টার প্রয়োগ করা হয়েছে যা এনামগুলির জন্য অনুসন্ধান করে এবং এনামের বিষয়বস্তু সহ প্রাসঙ্গিক বিবরণকে জনপ্রিয় করে তোলে।

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

                    //disable this
                    //c.DescribeAllEnumsAsStrings()

SwaggerAddEnumDesifications.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());
    }

}

এটি আপনার স্ব্যাগার-ইউআইতে নিম্নলিখিতগুলির মতো কিছুতে ফলাফল দেয় যাতে অন্তত আপনি "আপনি কী করছেন তা" দেখতে পারেন:

Question 5

এএসপি.নেট কোর 3.1

নিউটোনসফট জেএসওএন ব্যবহার করে স্ট্রিং হিসাবে এনামগুলি তৈরি করতে আপনাকে অবশ্যই AddSwaggerGenNewtonsoftSupport()নিম্নলিখিতগুলি যোগ করে স্পষ্টভাবে নিউটনসফট সমর্থন যুক্ত করতে হবে :

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


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

এটি একটি নতুন প্যাকেজের মাধ্যমে উপলব্ধ Swashbuckle.AspNetCore.Newtonsoft। দেখে মনে হচ্ছে এনাম কনভার্টার সমর্থন ব্যতীত এই প্যাকেজটি ছাড়া অন্য সমস্ত কিছুই সূক্ষ্মভাবে কাজ করে।

Question 6

আমি .NET কোর অ্যাপ্লিকেশনটিতে ররি_জার উত্তরটি ব্যবহার করতে চেয়েছিলাম, তবে এটি কার্যকর করতে আমাকে এটিকে কিছুটা পরিবর্তন করতে হয়েছিল। এনট কোরের জন্য আমি এখানে এসেছি বাস্তবায়ন।

আমি এটিও পরিবর্তন করেছি যাতে এটি অন্তর্নিহিত ধরণটি ধরে না নেয় intএবং সহজ পাঠের জন্য মানগুলির মধ্যে নতুন লাইন ব্যবহার করে।

/// <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)}";
    }
}

তারপরে এটি আপনার ConfigureServicesস্টার্টআপ.সিগুলিতে যুক্ত করুন:

c.DocumentFilter<EnumDocumentFilter>();

Question 7

.NET CORE 3.1 এবং সোয়াগার 5

আপনার যদি এনামগুলিকে নির্বাচন করে স্ট্রিং হিসাবে পাস করার জন্য একটি সহজ সমাধানের প্রয়োজন হয় :

using System.Text.Json.Serialization;


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

দ্রষ্টব্য, আমরা System.Text.Json.Serializationনেমস্পেস ব্যবহার করি , না Newtonsoft.Json!

Question 8

যদি কেউ আগ্রহী হয় আমি কোডটি সাথে কাজ করার জন্য পরিবর্তন করেছি

.NET CORE 3 এবং সোয়াগার ভি 5

    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());
    }
}

Question 9

এসপ নেট কোর 3 সহ

using System.Text.Json.Serialization;

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

তবে মনে হচ্ছে স্বশবাকল সংস্করণ 5.0.0-আরসি 4 এটি সমর্থন করার জন্য প্রস্তুত নয়। সুতরাং নিউটোনসফ্ট লাইব্রেরির মতো এটি সমর্থন ও প্রতিবিম্বিত না হওয়া পর্যন্ত আমাদের স্বশবাকল কনফিগারেশনের ফাইলটিতে একটি বিকল্প (অবমূল্যায়িত) ব্যবহার করা দরকার।

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

এই উত্তর এবং অন্যান্য উত্তরের মধ্যে পার্থক্যটি হল নিউটনসফটের পরিবর্তে কেবল মাইক্রোসফ্ট জেএসএন লাইব্রেরি ব্যবহার করা using

Question 10

মানগুলির সাথে এনাম স্টিংগুলির জন্য আমার বৈকল্পিক:

পরিষেবাদি কনফিগার করুন:

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

ছাঁকনি:

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}")));
            }
        }
    }

Question 11

আমি ঠিক এটি করেছি এবং এটি কাজ করে!

স্টার্টআপ.সি

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

Model.cs

public enum ColumnType {
  DATE = 0
}

swagger.json

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

আমি আশা করি এটি আপনাকে কীভাবে সহায়তা করেছিল তা আপনাকে সহায়তা করে!

Question 12

নেট কোর 3.1 এ এবং সোয়াগার 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++;
                }
            }
        }
    }

}

এবং স্টার্টআপের মধ্যে:

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

Question 13

আমি হজম রেহানীর জবাবটি পরিবর্তনযোগ্য করেছি এনাল সংগ্রহের সাথে এবং এনাম সংগ্রহের সাথেও to পূর্ববর্তী উত্তরগুলি কেবলমাত্র কোনও সম্পত্তির টাইপের মতো ঠিক নামকরণ করা হলে কাজ করে। এই সমস্ত সমস্যা নীচের কোডে সম্বোধন করা হয়।

এটি। নেট কোর 3.x এবং সোয়াগার 5.x এর সাথে কাজ করে

কিছু ক্ষেত্রে এনাম টাইপের জন্য দু'বার অনুসন্ধান না করে এটি আরও কার্যকর হতে পারে।

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());
    }
}

ফিল্টারটি c.DocumentFilter<SwaggerAddEnumDescriptions>();swagger কনফিগারেশন এ যুক্ত করতে ব্যবহার করুন Startup.cs।

Question 14

মানক ওপেনপিআইআই দিয়ে এটি সম্ভব নয়। এনামগুলি কেবল তাদের স্ট্রিংয়ের মান সহ বর্ণিত হয়।

ভাগ্যক্রমে আপনি এটি কিছু অ-মানক এক্সটেনশানগুলি দিয়ে করতে পারেন যা আপনার ক্লায়েন্ট জেনারেটর দ্বারা ব্যবহৃত হয়।

এনএসওয়াগ সমর্থন করে x-enumNames

অটোরেস্ট সমর্থন করে x-ms-enum।

ওপেনপি-জেনারেটর সমর্থন করে x-enum-varnames

অন্যান্য জেনারেটরগুলি এই এক্সটেনশনের একটিটিকে সমর্থন করতে পারে বা তাদের নিজস্ব থাকতে পারে।

x-enumNamesএনএসওয়াগের জন্য উত্পন্ন করতে নিম্নলিখিত স্কিমা ফিল্টারটি তৈরি করুন:

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);
        }
    }
}

এবং এটি হিসাবে নিবন্ধন করুন:

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

Question 15

স্টার্টআপ.এস এর ভিতরে কোড লিখুন

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

Question 16

আমি এখানে সুন্দর কাজ পেয়েছি:

@ পাওলোভিটার - এটি শেমা ফিল্টার ব্যবহার করে এটি সমাধান করুন:

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)));
            }
        }
    }
}

এবং স্টার্টআপের মধ্যে:

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

Question 17

আপনি যদি newtonsof.json ব্যবহার করছেন তবে এটি ব্যবহার করুন

using Newtonsoft.Json.Converters;


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

আপনি যদি System.Text.Json.Serialization ব্যবহার করছেন

using System.Text.Json.Serialization;


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

Question 18

। নেট কোর 3.0

   using Newtonsoft.Json.Converters;

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

Question 19

যদি সোয়াগারের সংস্করণটি 5.5.x হয়, তবে আপনার প্রয়োজন:

ইনস্টল করুন: ইনস্টল করুন-প্যাকেজ Swashbuckle.AspNetCore.Newtonsoft-সংস্করণ 5.5.0
পরিষেবাদি.এডসস্বাগারজেন নিউটোনসফটসপোর্ট ();

তথ্যসূত্র: https://github.com/domaindrivendev/Swashbuckle.AspNetCore#systemtextjson-stj-vs-newtonsoft

Question 20

এএসপি নেট সলিউশন

আমার এপিআই ডক্সে সম্পত্তিটি চিহ্নিত করা সত্ত্বেও একটি এনাম এখনও ইন্ট হিসাবে দেখানো হয়েছিল StringEnumConverter। উপরে উল্লিখিত সমস্ত এনামের জন্য আমরা বিশ্বব্যাপী সেটিংস ব্যবহার করতে পারিনি। সোয়াগারকনফাইগে এই লাইনটি যুক্ত করা সমস্যার সমাধান করেছে:

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

Question 21

আমরা যা খুঁজছিলাম তার জন্য অন্যান্য উত্তরে আমি বেশ কয়েকটি ত্রুটিগুলি পেয়েছি, তাই আমি ভেবেছিলাম যে আমি এটি আমার নিজের সরবরাহ করব। আমরা System.Text.Json এর সাথে এএসপি.নেট কোর 3.1 ব্যবহার করছি, তবে আমাদের ব্যবহারটি JSON সিরিয়ালাইজড নির্বিশেষে কাজ করে।

আমাদের লক্ষ্য ছিল এএসপি.নেট কোর এপিআই উভয়টিতে নিম্ন-উট-কেসড এনাম স্ট্রিং মানগুলি গ্রহণ করার পাশাপাশি সোয়াগার-তে একই নথির। আমরা বর্তমানে ব্যবহার করছেন [DataContract]এবং [EnumMember], তাই পদ্ধতির যে জুড়ে বোর্ড EnumMember মান সম্পত্তি এবং ব্যবহার থেকে ছোট হাতের উট-cased মান নিতে হয়।

আমাদের নমুনা এনাম:

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

আমরা স্বশবাকলে এনামমেম্বার মানগুলি নীচের মত একটি ইস্কেমা ফিল্টার ব্যবহার করে ব্যবহার করব:

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));
                }
            }
        }
    }
}

এই নামকরণ প্রকল্পটি এএসপি.নেট কোর-এও ব্যবহৃত হয়েছে তা নিশ্চিত করতে আমরা একটি তৃতীয় পক্ষের নুগেট প্যাকেজ (গিটহাব রেপো ) ব্যবহার করছি। এটির সাথে কনফিগার সার্ভিসগুলির মধ্যে স্টার্টআপ.সিগুলিতে কনফিগার করুন:

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

অবশেষে, আমাদের স্বশবাকলিতে আমাদের ইসকেমা ফিল্টারটি নিবন্ধিত করতে হবে, সুতরাং কনফিগার সার্ভিসগুলিতে নিম্নলিখিতগুলিও যুক্ত করুন ():

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