c# - net - swashbuckle nuget

Cómo configurar Swashbuckle para ignorar la propiedad en el modelo

Question

Estoy usando Swashbuckle para generar documentación de Swagger / UI para un proyecto webapi2. Nuestros modelos se comparten con algunas interfaces heredadas, por lo que hay un par de propiedades que quiero ignorar en los modelos. No puedo usar el atributo JsonIgnore porque las interfaces heredadas también deben serializarse a JSON, por lo que no quiero ignorar las propiedades globalmente, solo en la configuración de Swashbuckle.

Encontré un método para hacer esto documentado aquí:

https://github.com/domaindrivendev/Swashbuckle/issues/73

Pero esto parece estar desactualizado con la versión actual de Swashbuckle.

El método recomendado para la versión anterior de Swashbuckle es usar una implementación de IModelFilter de la siguiente manera:

public class OmitIgnoredProperties : IModelFilter
{
    public void Apply(DataType model, DataTypeRegistry dataTypeRegistry, Type type)
    {
        var ignoredProperties = … // use reflection to find any properties on 
                                  // type decorated with the ignore attributes

        foreach (var prop in ignoredProperties) 
            model.Properties.Remove(prop.Name);

    }
}

SwaggerSpecConfig.Customize(c => c.ModelFilter<OmitIgnoredProperties>());

¿Pero no estoy seguro de cómo configurar Swashbuckle para usar el IModelFilter en la versión actual? Estoy usando Swashbuckle 5.5.3.

Answer 1

( Basado en la respuesta de mutex .)

Agregué otra línea para no tener problemas con NullReferenceException .

public void Apply(Schema schema, SchemaRegistry schemaRegistry, Type type)
{
  var excludeProperties = new[] { "myProp1", "myProp2, myProp3"};

   foreach (var prop in excludeProperties)
     if(schema.properties != null) // This line
       if (schema.properties.ContainsKey(prop))
        schema.properties.Remove(prop);        
}

Si quieres borrar todos los esquemas

public void Apply(Schema schema, SchemaRegistry schemaRegistry, Type type)
{
  schema.properties = null;       
} 

Answer 2

Bueno, con un poco de empuje encontré una manera de hacer esto usando ISchemaFilter:

public class ApplyCustomSchemaFilters : ISchemaFilter
{
    public void Apply(Schema schema, SchemaRegistry schemaRegistry, Type type)
    {
        var excludeProperties = new[] {"myProp1", "myProp2", "myProp3"};

        foreach(var prop in excludeProperties)
            if (schema.properties.ContainsKey(prop))
                schema.properties.Remove(prop);
    }
}

luego, al llamar a httpConfiguration.EnableSwagger , configuro SwaggerDocsConfig para usar este SchemaFilter de la siguiente manera:

c.SchemaFilter<ApplyCustomSchemaFilters>();

Espero que esto ayude a alguien. Todavía me gustaría saber si es posible usar el IModelFilter de alguna manera.

Answer 3

El código a continuación se basa en gran medida en la respuesta de @ Richard, pero lo estoy incluyendo como una nueva respuesta porque tiene tres características completamente nuevas y útiles que he agregado:

• Se ejecuta en .NET Core en la última versión de Swashbuckle (v5)
• Permite que el atributo SwaggerIgnore se aplique a los campos no solo a las propiedades
• Maneja el hecho de que los nombres de propiedades y campos pueden haber sido anulados usando el atributo JsonProperty
• EDITAR: Ahora maneja correctamente los cambios de camello en los campos o propiedades originalmente del Título (en la pregunta de la respuesta de @ mattruma)

Así que el código revisado es:

[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
public class SwaggerIgnoreAttribute : Attribute
{
}

internal static class StringExtensions
{
    internal static string ToCamelCase(this string value)
    {
        if (string.IsNullOrEmpty(value)) return value;
        return char.ToLowerInvariant(value[0]) + value.Substring(1);
    }
}

public class SwaggerIgnoreFilter : ISchemaFilter
{
    public void Apply(OpenApiSchema schema, SchemaFilterContext schemaFilterContext)
    {
        if (schema.Properties.Count == 0)
            return;

        const BindingFlags bindingFlags = BindingFlags.Public |
                                          BindingFlags.NonPublic |
                                          BindingFlags.Instance;
        var memberList = schemaFilterContext.SystemType
                            .GetFields(bindingFlags).Cast<MemberInfo>()
                            .Concat(schemaFilterContext.SystemType
                            .GetProperties(bindingFlags));

        var excludedList = memberList.Where(m =>
                                            m.GetCustomAttribute<SwaggerIgnoreAttribute>()
                                            != null)
                                     .Select(m =>
                                         (m.GetCustomAttribute<JsonPropertyAttribute>()
                                          ?.PropertyName
                                          ?? m.Name.ToCamelCase()));

        foreach (var excludedName in excludedList)
        {
            if (schema.Properties.ContainsKey(excludedName))
                schema.Properties.Remove(excludedName);
        }
    }
}

y en Startup.cs :

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

Answer 4

Esto es lo que usé con Newtonsoft.Json.JsonIgnoreAttribute:

internal class ApplySchemaVendorExtensions : Swashbuckle.Swagger.ISchemaFilter
{
    public void Apply(Schema schema, SchemaRegistry schemaRegistry, Type type)
    {
        foreach (var prop in type.GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance)
                                 .Where(p => p.GetCustomAttributes(typeof(Newtonsoft.Json.JsonIgnoreAttribute), true)?.Any() == true))
            if (schema?.properties?.ContainsKey(prop.Name) == true)
                schema?.properties?.Remove(prop.Name);
    }
}

Answer 5

La solución AspNetCore se parece a:

public class SwaggerExcludeSchemaFilter : ISchemaFilter
{
    public void Apply(Schema schema, SchemaFilterContext context)
    {
        if (schema?.Properties == null)
        {
            return;
        }

        var excludedProperties = context.SystemType.GetProperties().Where(t => t.GetCustomAttribute<SwaggerExcludeAttribute>() != null);
        foreach (PropertyInfo excludedProperty in excludedProperties)
        {
            if (schema.Properties.ContainsKey(excludedProperty.Name))
            {
                schema.Properties.Remove(excludedProperty.Name);
            }
        }
    }
}

Answer 6

Para las personas como yo que están usando .Net Core y están usando la compilación en la app.UseSwaggerUi3WithApiExplorer()

Use la etiqueta [JsonIgnore] usando Newtonsoft.Json ;

public class Project
{
    [Required]
    public string ProjectName { get; set; }

    [JsonIgnore]
    public string SomeValueYouWantToIgnore { get; set; }
}

Será excluido de su documentación.

Answer 7

Si marca el campo / propiedad como internal o protected o private , Swashbuckle lo ignorará automáticamente en la documentación de Swagger.

Answer 8

Si necesita hacer esto pero sin usar JsonIgnore (tal vez todavía necesite serializar / deserializar la propiedad), simplemente cree un atributo personalizado.

[AttributeUsage(AttributeTargets.Property)]
public class SwaggerExcludeAttribute : Attribute
{
}

Luego un filtro de esquema similar al de Johng''s

public class SwaggerExcludeFilter : ISchemaFilter
{
    #region ISchemaFilter Members

    public void Apply(Schema schema, SchemaRegistry schemaRegistry, Type type)
    {
        if (schema?.Properties == null || type == null)
            return;

        var excludedProperties = type.GetProperties()
                                     .Where(t => 
                                            t.GetCustomAttribute<SwaggerExcludeAttribute>() 
                                            != null);

        foreach (var excludedProperty in excludedProperties)
        {
            if (schema.properties.ContainsKey(excludedProperty.Name))
                schema.properties.Remove(excludedProperty.Name);
        }
    }

    #endregion
}

No olvides registrar el filtro.

c.SchemaFilter<SwaggerExcludeFilter>();

Answer 9

Basado en la respuesta de Stef Heyenrath.

Atributo para marcar las propiedades para excluir de la documentación de Swagger.

[AttributeUsage(AttributeTargets.Property)]
public class SwaggerExcludeAttribute : Attribute
{
}

El filtro para excluir las propiedades de la documentación de Swagger.

public class SwaggerExcludeSchemaFilter : ISchemaFilter
{
    public void Apply(Schema schema, SchemaFilterContext context)
    {
        if (schema?.Properties == null)
        {
            return;
        }

        var excludedProperties = 
            context.SystemType.GetProperties().Where(
                t => t.GetCustomAttribute<SwaggerExcludeAttribute>() != null);

        foreach (var excludedProperty in excludedProperties)
        {
            var propertyToRemove =
                schema.Properties.Keys.SingleOrDefault(
                    x => x.ToLower() == excludedProperty.Name.ToLower());

            if (propertyToRemove != null)
            {
                schema.Properties.Remove(propertyToRemove);
            }
        }
    }
}

Las schema.Properties.Keys son camelCase , mientras que las propiedades en sí son PascalCase . Ajustó el método para convertir ambos a minúsculas y comparar para ver qué debería excluirse.