Swashbuckle still not showing OData Controllers with Swashbuckle.OData
<p>I've installed Swashbuckle v5.3.2, Swashbuckle.OData v2.18.3 but Swagger docs still won't show my OData Controllers. My API Controllers appear just fine. What am I doing wrong?</p>

<p>This is my controller class:</p>

<pre><code>[LogActionFilter, LogExceptionFilter]
    public class UsuarioODataController : ODataController { 

        private static FluentValidation.AbstractValidator&lt;UsuarioMobile&gt; Validator = new UsuarioMobileValidator();
        private IUsuarioMobileService _service;

        public UsuarioODataController(IUsuarioMobileService service)
        {
            _service = service;
        }

        [EnableQuery]
        public async Task&lt;IQueryable&lt;UsuarioMobile&gt;&gt; Get()
        {
            var result = _service.Queryable();
            return result;
        }

        [EnableQuery]
        public async Task&lt;SingleResult&lt;UsuarioMobile&gt;&gt; Get([FromODataUri] int key)
        {
            IQueryable&lt;UsuarioMobile&gt; result = _service.Queryable().Where(x =&gt; x.Id == key);
            return SingleResult.Create(result);
        }

        public async Task&lt;IHttpActionResult&gt; Put([FromODataUri] int key, UsuarioMobile model)
        {
            try
            {
                model.Id = key;
                var validationResult = Validator.Validate(model);
                if (validationResult.IsValid)
                {
                    return Ok(await _service.Update(model));
                }

                return BadRequest(validationResult.Errors.ToJson());
            }
            catch (Exception ex)
            {
                return BadRequest(ex.Message);
            }
        }

        public async Task&lt;IHttpActionResult&gt; Post(UsuarioMobile model)
        {
            try
            {
                var validationResult = Validator.Validate(model);
                if (validationResult.IsValid)
                {
                    return Ok(await _service.Add(model));
                }

                return BadRequest(validationResult.Errors.ToJson());
            }
            catch (Exception ex)
            {
                return BadRequest(ex.Message);
            }

        }

        public async Task&lt;IHttpActionResult&gt; Delete([FromODataUri] int key)
        {
            try
            {
                return Ok(await _service.DeleteAsync(key));
            }
            catch (Exception ex)
            {
                return BadRequest(ex.Message);
            }
        }
    }
</code></pre>

<p>Startup class:</p>

<pre><code>public partial class Startup
    {
        public void Configuration(IAppBuilder app)
        {
            var container = InjectorConfig.InjectorInitialize();
            ConfigureAuth(app);
            ConfigurationApp(app, container);
        }

        private void ConfigurationApp(IAppBuilder app, Container container)
        {
            var config = new HttpConfiguration
            {
                DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container),
                IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always
            };

            //Swagger
            config
                .EnableSwagger(c =&gt;
                {
                    c.SingleApiVersion("v1", "MTM.MeuEinstein.IntegratorHIAE");
                    c.IncludeXmlComments(SwaggerConfig.GetXmlCommentsPath());
                    c.IncludeXmlComments(SwaggerConfig.GetXmlCommentsPathForModels());
                    c.CustomProvider(defaultProvider =&gt; new ODataSwaggerProvider(defaultProvider, c, config));
                })
                .EnableSwaggerUi(c =&gt;
                { });

            config.MapHttpAttributeRoutes();
            WebApiConfig.Register(config);
            RouteConfig.RegisterRoutes(RouteTable.Routes);

            var jsonFormatter = config.Formatters.JsonFormatter;
            var jSettings = new JsonSerializerSettings
            {
                Formatting = Formatting.None,
                DateTimeZoneHandling = DateTimeZoneHandling.Utc,
                DateFormatString = "dd/MM/yyyy HH:mm:ss",
                //TODO: Necessário importar
                //Culture = CultureInfo.GetCultureInfo(SplCulture.GetCurrentCulture()),
                NullValueHandling = NullValueHandling.Ignore,
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
                ContractResolver = new CamelCasePropertyNamesContractResolver()
            };
            //config.MessageHandlers.Add(new WebApiHandler());
            //config.MessageHandlers.Add(new SplCookieHandler());
            jsonFormatter.SerializerSettings = jSettings;
            config.Formatters.Clear();
            config.Formatters.Insert(0, jsonFormatter);
            app.UseCors(CorsOptions.AllowAll);
            app.UseWebApi(config);
        }
    }
</code></pre>

<p>WebApiConfig.cs</p>

<pre><code>public static class WebApiConfig
    {
        public static void Register(HttpConfiguration config)
        {
            // Web API configuration and services
            // Configure Web API to use only bearer token authentication.
            //config.SuppressDefaultHostAuthentication();
            //config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));

            // Web API routes
            //config.MapHttpAttributeRoutes();

            // OData routes
            ODataModelBuilder builder = new ODataConventionModelBuilder();
            builder.EntitySet&lt;UsuarioMobile&gt;("UsuarioOData");
            config.Routes.MapODataServiceRoute("ODataApi", "api", builder.GetEdmModel());

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );
        }
    }
</code></pre>