如何配置swashbuckle以忽略模型上的属性

Question

我正在使用swashbuckle为WebAPI2项目生成Swagger Document \ UI。我们的模型与一些旧接口共享，因此我想在模型上忽略一些属性。我不能使用jsonignore属性，因为旧的接口也需要序列化与JSON序列化，因此我不想在Swashbuckle配置中忽略全球属性。

我找到了在此处记录的方法：

https://github.com/github.com/domaindrivendevendev/swashbuckle/swashbuckle/sissues/sissues/sissues/sissues/issues /73

但这似乎与当前的swashbuckle版本过时。

推荐用于旧版本的Swashbuckle的方法正在使用Imodelfilter实现如下：

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

但是我不确定如何在当前版本中配置Swashbuckle来使用Imodelfilter？我正在使用Swashbuckle 5.5.3。

Answer 1

如果您需要执行此操作，但不使用JSONIGNORE（也许您仍然需要序列化/对属性进行序列化），那么只需创建一个自定义属性即可。

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

然后，一个类似于 johng

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
}

别忘了注册过滤器

c.SchemaFilter<SwaggerExcludeFilter>();

Answer 2

.net Core 3.1 和 .NET标准2.1 的解决方案：

使用 JSONIGNORE 来自 Sytem.text.json.json.serialization 名称空间。

（ jsonignore newtonsoft.json 将无效）

public class Test
{
    [System.Text.Json.Serialization.JsonIgnore]
    public int HiddenProperty { get; set; }
    public int VisibleProperty { get; set; }
}

Answer 3

如果将字段/属性标记为内部或受保护或 private ，则在Swagger Document中会自动忽略它。


更新：显然，这些属性/字段不会在请求/响应中填充。

Answer 4

下面的代码非常基于 @Richard的答案，但我将其作为新答案包括在内，因为它具有三个全新的，有用的功能，我添加了：

• 在最新版本的Swashbuckle（V5）
• 允许的 .NET Core上运行。 swaggerignore 要应用于字段的属性不仅要
• 处理属性和字段名称可能已使用 jsonproperty 属性>属性>属性>
• 属性编辑：现在正确处理最初的摄影作品。基于滴定的字段或属性（由 @mattruma的答案提示），

因此修订的代码为：

[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 // In v5.3.3+ use Type instead
                            .GetFields(bindingFlags).Cast<MemberInfo>()
                            .Concat(schemaFilterContext.SystemType // In v5.3.3+ use Type instead
                            .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);
        }
    }
}

in startup.cs ：

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

Answer 5

aspnetcore 解决方案看起来像：

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

对于像我这样使用 .net core并在 app.useswaggerui3withapiexplorer（）中使用构建的人（

使用 [jsonignore] 使用 newtonsoft.json ;

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

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

它将被排除在您的文档之外。

Answer 7

好吧，有了一点戳戳，我找到了一种使用iSchemafilter进行操作的方法：

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

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

，当调用 httpConfiguration.enableswagger.enableswagger 我设置了 Swagger> Swaggerdocsconfig

c.SchemaFilter<ApplyCustomSchemaFilters>();

然后 帮助某人。我仍然对是否可以以某种方式使用Imodelfilter感到好奇。

Answer 8

我在这里有一个使用Dotnetcore 3和Swashbuckle 5的工作示例。我花了几个小时才能将其置于适当的位置，所以我想回到这个线程，这对我有帮助，但没有解决我的问题。

创建一个虚拟自定义属性：

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

创建一个Swagger将使用它来生成API模型架构，

public class SwaggerExcludeFilter : ISchemaFilter
{
    public void Apply(OpenApiSchema schema, SchemaFilterContext context)
    {
        if (!(context.ApiModel is ApiObject))
        {
            return;
        }

        var model = context.ApiModel as ApiObject;

        if (schema?.Properties == null || model?.ApiProperties == null)
        {
            return;
        }
        var excludedProperties = model.Type
                .GetProperties()
                .Where(
                    t => t.GetCustomAttribute<SwaggerExcludeAttribute>() != null
                );

        var excludedSchemaProperties = model.ApiProperties
               .Where(
                    ap => excludedProperties.Any(
                        pi => pi.Name == ap.MemberInfo.Name
                    )
                );

        foreach (var propertyToExclude in excludedSchemaProperties)
        {
            schema.Properties.Remove(propertyToExclude.ApiName);
        }
    }
}

然后在 startup.cs File中将其添加到Swagger Configuration中，

services.AddSwaggerGen(c =>
{
    c.SwaggerDoc("v1", new OpenApiInfo { Title = "My API", Version = "v1" });
    c.SchemaFilter<SwaggerExcludeFilter>();
});

您现在可以在On On On On On On on swagger配置。您想从API模式中排除的属性

public class MyApiModel
{
    [SwaggerExclude]
    public Guid Token { get; set; }

    public int Id { get; set; }

    public string Name { get; set; }
}

Answer 9

您可以使用 swashbuckle.aspnetcore.annotations 软件包，它允许您标记某些属性仅在输入参数中显示，而有些仅在输出中显示。

例如，如果要在帖子的输入参数中隐藏 alertid ，则只需要通过 [swaggerschema] 来执行此操作

public class Alert
{
    [SwaggerSchema(ReadOnly = true)]
    public string AlertId { get; set; }
    public string Type { get; set; }
}

： 文档

Answer 10

基于Stef Heyenrath的答案。

将属性属于标记属性以将其排除在Swagger文档中。

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

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

schema.properties.keys 是 comelcase ，而属性本身为 pascalcase 。调整了将转换为较低案例转换并比较的方法，以查看应排除的方法。

Answer 11

Swashbuckle现在对Newtonsoft有所支持。
https://github.com/domaindrivendev/Swashbuckle.AspNetCore#systemtextjson-stj -vs-newtonsoft

dotnet add package --version 5.3.1 Swashbuckle.AspNetCore.Newtonsoft

`services.AddSwaggerGenNewtonsoftSupport(); // explicit opt-in - needs tobe placed after AddSwaggerGen();`

Answer 12

这是一个较旧的问题，但此后已经有一个低饮食的中间解决方案可在swashbuckle中使用。

隐藏文档中的遗产属性对阻止这些属性的使用无济于事 - 它只是延迟 Discovery 。毕竟，它们仍然是模型的一部分。实际上，让他们无证件意味着消费者无法知道他们不应该使用它们！

您不应该简单地考虑将它们标记为 [Ompolete] 。

然后，Swashbuckle将在Swagger.json中将它们标记为弃用。在UI中，这将把它们隐藏在示例值部分中，在模式部分中，它们将显示为灰色，并在名称上击中。

如果您仍然希望它们完全隐藏在文档中，则可以在 swaggergeneratoroptions.ignoreobsoleteproperties = true 中设置。

在最初提出这个问题时，这不是可能的解决方案。 弃用标志是OpenAPI V3的功能，直到2017年才发布。

Answer 13

这是我与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 14

参考 https://stackoverflow.com/a/58193046/11748401以下代码：

public class SwaggerExcludeFilter : ISchemaFilter
{
    public void Apply(OpenApiSchema model, SchemaFilterContext context)
    {

        var excludeProperties = context.ApiModel.Type?.GetProperties().Where(prop => Attribute.IsDefined(prop, typeof(SwaggerExcludeAttribute)));
        if (excludeProperties != null)
        {
            foreach (var property in excludeProperties)
            {
                // Because swagger uses camel casing
                var propertyName = $"{ToLowerInvariant(property.Name[0])}{property.Name.Substring(1)}";
                if (model.Properties.ContainsKey(propertyName))
                {
                    model.Properties.Remove(propertyName);
                }
            }
        }
    }

}

Answer 15

(Based on mutex's answer.)

I添加了另一条行以没有 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);        
}

如果您想删除所有模式

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

Answer 16

就我而言，我想保持应用程序层DTOS清洁（没有像JSONINGORE这样的任何注释），但仍然能够在控制器Web API中使用它们。

So, in my Application Layer I have a DTO like this:

public class CreateItemCommand {
     public Guid ContainerId { get; set; }
     public string Name { get; set; }
}

And my API design for creating an item is something like:
POST /containers/{containerId}/items

As the ContainerId is coming from the api route, I don't want the asp.net core trying to bind it into the command DTO and I don't want swashbuckle都没有列出。

So my solution is to inherit the original DTO in the API layer like this:

public class CreateItemCommandMod : CreateItemCommand {
   #pragma warning disable IDE0051
   private new ContainerID { get; }
   #pragma warning restore IDE0051
}

...

[HttpPost("{containerId}/items}")]
public Task Create(
   [FromRoute] Guid containerId,
   [FromBody] CreateItemCommandMod command,
) => useCase.Create(command.Apply(r => r.ContainerId = containerId));

• The useCase.Create from the ApplicationLayer expects the base class CreateItemCommand.
• .Apply只是我所做的一种非常简单的扩展方法，它可以轻松地将路由参数值设置为通讯DTO属性。

Answer 17

非常用户的解决方案@jay Shah，但是如果您使用n'ter架构，则无法从BL获取受保护或私有DAL数据。为了解决这个问题，您可以使用此Prop的ACC修改器作为“受保护的内部”，

public class Test
{
    
    protected internal int HiddenProperty { get; set; }
    
}

您可以从BL但不能访问上述数据，但不能访问PL。或API层。

Answer 18

我受到使用jsonignore忽略控制器动作模型的属性。

我正在使用 .net Core 2.1 和 swashbuckle.aspnetcore 5.3.1 。
下面的代码解决了问题。

添加一个新的过滤器

public class SwaggerJsonIgnoreFilter : IOperationFilter
    {
        public void Apply(OpenApiOperation operation, OperationFilterContext context)
        {
            var ignoredProperties = context.MethodInfo.GetParameters()
                .SelectMany(p => p.ParameterType.GetProperties()
                .Where(prop => prop.GetCustomAttribute<JsonIgnoreAttribute>() != null))
                .ToList();

            if (!ignoredProperties.Any()) return;

            foreach (var property in ignoredProperties)
            {
                operation.Parameters = operation.Parameters
                    .Where(p => (!p.Name.Equals(property.Name, StringComparison.InvariantCulture)))
                    .ToList();
            }
        }
    }

在startup.cs 中使用过滤器

public void ConfigureServices(IServiceCollection services)
{

......

    services.AddSwaggerGen(options =>
    {
        options.SwaggerDoc("v1", new OpenApiInfo { Title = "CustomApi", Version = "v1" });
        options.OperationFilter<SwaggerJsonIgnoreFilter>();
    });

......

}

Answer 19

属性启用属性注释。

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

过滤以排除用属性注释的所有属性。

public class SwaggerExcludeFilter : ISchemaFilter
{
    public void Apply(OpenApiSchema schema, SchemaFilterContext context)
    {
        if (schema.Properties is null)
        {
            return;
        }

        foreach (var property in context.Type.GetProperties().Where(p => p.GetCustomAttribute<SwaggerExcludeAttribute>() is {}))
        {
            var remove = schema.Properties.Keys.SingleOrDefault(p => p == property.Name);

            if (remove is {})
            {
                _ = schema.Properties.Remove(remove);
            }
        }
    }
}

宣传生成服务中的过滤器注册。

_ = services.AddSwaggerGen(options => options.SchemaFilter<SwaggerExcludeFilter>());

应排除属性的注释。

public class Response
{
    public string Message { get; set; }

    [SwaggerExclude]
    public string? StackTrace { get; set; }
}

Answer 20

我需要更多控制权才能删除在其他地方声明的属性，并且无法轻松使用删除属性。

创建的过滤器删除了从我的不包括列表中累积的所有项目：

public class SwaggerExcludeFilter : ISchemaFilter
{
    private static readonly List<string> excludes = new List<string>()
    {
       "StoredProcedureName", "ValidationErrors", "changeTracker",
       "code", "customerId", "IsDebug",
    };

    public void Apply(OpenApiSchema schema, SchemaFilterContext context)
    {
        if (schema?.Properties == null || context == null)
            return;

        // Find all properties by name which need to be removed 
       // and not shown on the swagger spec.
        schema.Properties
              .Where(prp => excludes.Any(exc => string.Equals(exc, prp.Key, StringComparison.OrdinalIgnoreCase)))
              .Select(prExclude => prExclude.Key)
              .ToList()
              .ForEach(key => schema.Properties.Remove(key));    
     }
 }

在启动或program.cs for for for for for for for for for for for for for for for for for you .net 6粉丝。

services.AddSwaggerGen(c =>
                {
                    c.SwaggerDoc("v1", new Info
                    {
                        Version = "2.5",
                        Title = "My Swagger Doc G",
                    });

                    c.SchemaFilter<SwaggerExcludeFilter>();     
                    ...
       

Answer 21

我使用的是dotnet core 3.1和swashbuckle 6.3.1，这里是更新版本，具有类似逻辑的更新版本，用于使用 iSchemafilter 来过滤带有自定义属性的属性 swaggerexcludeattribute

public class SwaggerExcludeFilter : ISchemaFilter
{
    public void Apply(OpenApiSchema schema, SchemaFilterContext context)
    {
        var type = context.Type;
        if (!schema.Properties.Any() || type == null)
        {
            return;
        }

        var excludedPropertyNames = type
                .GetProperties()
                .Where(
                    t => t.GetCustomAttribute<SwaggerExcludeAttribute>() != null
                ).Select(d => d.Name).ToList();

        if (!excludedPropertyNames.Any())
        {
            return;
        }

        var excludedSchemaPropertyKey = schema.Properties
               .Where(
                    ap => excludedPropertyNames.Any(
                        pn => pn.ToLower() == ap.Key
                    )
                ).Select(ap => ap.Key);

        foreach (var propertyToExclude in excludedSchemaPropertyKey)
        {
            schema.Properties.Remove(propertyToExclude);
        }
    }
}

Answer 22

创建的过滤器删除了从我的排除列表中获得的所有项目。

using Microsoft.OpenApi.Models;
using Swashbuckle.AspNetCore.SwaggerGen;
namespace Api.Helpers
{
public class SwaggerExcludeFilter : IOperationFilter
{
    public void Apply(OpenApiOperation operation, OperationFilterContext context)
    {
        if (operation.Parameters.Count == 0)
        {
            return;
        }
        var ignoredProperties = new[] { "CacheKey", "CacheTimeSeconds" };
        foreach (var property in ignoredProperties)
        {
            operation.Parameters = operation.Parameters
                .Where(p => (!p.Name.Equals(property, StringComparison.InvariantCulture)))
                .ToList();
        }
    }
}

}

在启动或program.cs for for for you .net 8.0

 c.OperationFilter<SwaggerExcludeFilter>();

Answer 23

现在，我们从swashbuckle.aspnetcore.annotations nuget软件包中获得了[Swaggerignore]属性。工作完美。

请参阅： https://github.com/domaindrivendevendevendevendevendev/swashbuckle.swashbuckle.aspnetcore/pull/pull/pull/pull/pull/pull/pull/pull/pull/pull/pull/pull/2610 < /a>

Answer 24

最简单的方法：尝试使用要隐藏的字段内部访问操作员。它对我有用。

Answer 25

只需删除 {get; set; }
例如，如果您不希望看到ID
将其用作字段：公共字符串ID;
不是作为属性：公共字符串ID {get;放; }