Editing an IOpenApiSchema

[rwb196884]

I was doing this sort of thing

public class SchemaFilter : ISchemaFilter
{
        public void Apply(IOpenApiSchema schema, SchemaFilterContext context)
        {
            List<PropertyInfo> properties = context.Type.GetProperties().ToList();

            foreach (KeyValuePair<string, OpenApiSchema> p in schema.Properties ?? new Dictionary<string, IOpenApiSchema>())
            {
                PropertyInfo pi = properties.Single(z => string.Equals(z.Name, p.Key, StringComparison.InvariantCultureIgnoreCase));
                StringLengthAttribute? asl = pi.GetCustomAttribute<StringLengthAttribute>();
                if (asl != null)
                {
                    pv.MaxLength = asl.MaximumLength;
                }
        }
    }
}

However this has been broken in version 10 because OpenApiSchema has been replaced by IOpenApiSchema which is not editable.

I couldn't find anything about this in the upgrade notes, and I haven't been able to find a workaround.

Can it work or do I need to stay on version 9?

[Youssef Fahmy (Youssef1313)]

Vincent Biret (@baywet) Was it considered to keep the property setters in the interfaces?

rwb196884 You can achieve that today by doing a type check. In all common cases, the instance will be of type OpenApiSchema.

[Vincent Biret (baywet)]

here is essentially the solution

public class SchemaFilter : ISchemaFilter
{
        public void Apply(IOpenApiSchema schema, SchemaFilterContext context)
        {
            List<PropertyInfo> properties = context.Type.GetProperties().ToList();

-            foreach (KeyValuePair<string, OpenApiSchema> pv in schema.Properties ?? new Dictionary<string, IOpenApiSchema>())
+            foreach (var pv in schema.Properties ?? new Dictionary<string, IOpenApiSchema>())
            {
+               if (pv.Value is not OpenApiSchema targetSchema) continue;
                PropertyInfo pi = properties.Single(z => string.Equals(z.Name, p.Key, StringComparison.InvariantCultureIgnoreCase));
                StringLengthAttribute? asl = pi.GetCustomAttribute<StringLengthAttribute>();
                if (asl != null)
                {
_                    pv.Value.MaxLength = asl.MaximumLength;
+                    targetSchema.MaxLength = asl.MaximumLength;
                }
        }
    }
}

Youssef Fahmy (@Youssef1313) we coudln't. That's an intentional change if you compare with how references are handed in v1. A lot of people ended up mutating the target value when they didn't intend to. This requirement of making a type assertion is here so that consumers evaluate whether they want to change inline schemas, the reference target, or both.

[RKS (rksharma-owg)]

You don’t need to stay on v9 🙂 OpenApiSchema is still editable; the setters just aren’t exposed through IOpenApiSchema. As baywet mentioned, you can check the concrete type and update it:

foreach (var property in schema.Properties
    ?? new Dictionary<string, IOpenApiSchema>())
{
    if (property.Value is not OpenApiSchema targetSchema)
        continue;

    var propertyInfo = context.Type.GetProperties()
        .SingleOrDefault(p => string.Equals(
            p.Name, property.Key,
            StringComparison.InvariantCultureIgnoreCase));

    var attribute = propertyInfo?
        .GetCustomAttribute<StringLengthAttribute>();

    if (attribute is not null)
        targetSchema.MaxLength = attribute.MaximumLength;
}

The catch is that this skips reference schemas. That’s intentional: changing a referenced schema could affect other properties that share it. The type check makes you choose whether you want to edit an inline schema or the shared reference target, which is why the interface no longer exposes setters. Maintainer’s explanation.