Comment configurer Swashbuckle ignorer propriété sur le modèle

Si vous avez besoin de le faire, mais sans l'aide de JsonIgnore (peut-être que vous avez encore besoin de sérialiser/désérialiser la propriété) puis il suffit de créer un attribut personnalisé.

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

Ensuite un schéma de filtre similaire à Johng de l'

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
}

N'oubliez pas d'enregistrer le filtre

c.SchemaFilter<SwaggerExcludeFilter>();

OriginalL'auteur Richard

Bien, avec un peu de piquer j'ai trouvé un moyen de faire cela à l'aide de 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);
    }
}

puis lors de l'appel de httpConfiguration.EnableSwagger j'ai mis le SwaggerDocsConfig pour utiliser cette SchemaFilter comme suit:

c.SchemaFilter<ApplyCustomSchemaFilters>();

Espère que cela aide quelqu'un. Je serais toujours curieux de savoir s'il est possible d'utiliser la IModelFilter en quelque sorte.

OriginalL'auteur mutex

Le code ci-dessous est très largement basé sur @Richard réponse, mais je suis de l'inclure comme une nouvelle réponse, car elle a trois nouvelles fonctionnalités utiles que j'ai ajouté:

• S'exécute sur .NET de Base sur la dernière version de Swashbuckle (v5)
• Permet à l' SwaggerIgnore attribut pour être appliquée à des champs n'est pas juste pour les propriétés
• Gère le fait que la propriété et les noms de champ peut avoir été substituée à l'aide de la JsonProperty attribut
• EDIT: gère Désormais correctement camelCasing de l'origine TitleCased champs ou propriétés (invité par @mattruma réponse)

De sorte que le code révisé est:

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

et dans Startup.cs:

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

OriginalL'auteur Mike Beaton

(Basé sur la réponse de mutex.)

J'ai ajouté une autre ligne pour ne pas avoir des problèmes avec 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 vous souhaitez supprimer tous les schémas

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

OriginalL'auteur Álvaro Blázquez Sarabia

Basé sur Stef Heyenrath de réponse.

Attribut pour marquer les propriétés d'exclure de l'Arrogance de la documentation.

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

Le filtre pour exclure les propriétés de l'Arrogance de la documentation.

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

La schema.Properties.Keys sont camelCase, tandis que les propriétés se sont PascalCase. Modifié la méthode pour convertir en minuscules et comparer pour voir ce qui doit être exclu.

OriginalL'auteur mattruma