C# IServiceCollection.AddSwagger方法代码示例

        // This method gets called by a runtime.
        // Use this method to add services to the container
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddTransient<IDataStore<Project>, CommonDataStore<Project>>();
            services.AddTransient<IDataStore<Project, Sprint>, CommonDataStore<Project, Sprint>>();
            services.AddTransient<IDataStore<Project, Sprint, Issue>, CommonDataStore<Project, Sprint, Issue>>();
            services.AddTransient<IDataStore<Project, Sprint, Issue, Comment>, CommonDataStore<Project, Sprint, Issue, Comment>>();
            services.AddTransient<IDataStore<Project, Sprint, Issue, Attachment>, CommonDataStore<Project, Sprint, Issue, Attachment>>();

            services.AddTransient<IDataStore<User>, CommonDataStore<User>>();
            services.AddTransient<IDataStore<UserGroup>, CommonDataStore<UserGroup>>();

            services.AddTransient<ProjectsController>();
            services.AddTransient<SprintsController>();
            services.AddTransient<IssuesController>();
            services.AddTransient<CommentsController>();
            services.AddTransient<AttachmentsController>();
            services.AddTransient<UsersController>();

            services.AddMvc();
            // Uncomment the following line to add Web API services which makes it easier to port Web API 2 controllers.
            // You will also need to add the Microsoft.AspNet.Mvc.WebApiCompatShim package to the 'dependencies' section of project.json.
            // services.AddWebApiConventions();

            services.AddSwagger();
        }

        /// <summary>
        /// This method gets called by a runtime.
        /// Use this method to add services to the container 
        /// </summary>
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc(c =>
            {
                var jsonFormatter = c.OutputFormatters.OfType<JsonOutputFormatter>().First();
                jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
                jsonFormatter.SerializerSettings.Converters.Add(new StringEnumConverter { CamelCaseText = true });
                jsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
            });

            // Uncomment the following line to add Web API services which makes it easier to port Web API 2 controllers.
            // You will also need to add the Microsoft.AspNet.Mvc.WebApiCompatShim package to the 'dependencies' section of project.json.
            //// services.AddWebApiConventions();

            services.AddSwagger();
            services.ConfigureSwaggerDocument(c =>
            {
                c.SingleApiVersion(new Info { Version = "v1", Title = "GreenvilleWiApi" });
                c.OperationFilter<GreenvilleApiFilter>();
                c.OperationFilter<ApplySwaggerOperationFilterAttributes>();
                c.DocumentFilter<GreenvilleApiFilter>();
                c.IgnoreObsoleteActions = true;
            });

            services.ConfigureSwaggerSchema(c =>
            {
                c.DescribeAllEnumsAsStrings = true;
                c.ModelFilter<GreenvilleApiFilter>();
            });
        }

        // This method gets called by a runtime.
        // Use this method to add services to the container
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddOptions();

            services.Configure<AppSettings>(Configuration);

            services.AddMvc();
            // Uncomment the following line to add Web API services which makes it easier to port Web API 2 controllers.
            // You will also need to add the Microsoft.AspNet.Mvc.WebApiCompatShim package to the 'dependencies' section of project.json.
            // services.AddWebApiConventions();

            services.AddSwagger();
            services.ConfigureSwaggerDocument(options =>
            {
                options.SingleApiVersion(new Info
                {
                    Version = "v1",
                    Title = "Gateway API",
                    Description = "The documentation for the Gateway API"
                });
            });
            services.ConfigureSwaggerSchema(options =>
            {
                options.DescribeAllEnumsAsStrings = true;
            });
        }

        // This method gets called by a runtime.
        // Use this method to add services to the container
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc();
            // Uncomment the following line to add Web API services which makes it easier to port Web API 2 controllers.
            // You will also need to add the Microsoft.AspNet.Mvc.WebApiCompatShim package to the 'dependencies' section of project.json.
            // services.AddWebApiConventions();

            services.AddSwagger();
            services.ConfigureSwaggerDocument(options =>
            {
                options.SecurityDefinitions.Add("oauth2", new OAuth2Scheme
                {
                    Type = "oauth2",
                    Flow = "implicit",
                    AuthorizationUrl = "http://petstore.swagger.io/api/oauth/dialog",
                    Scopes = new Dictionary<string, string>
                        {
                            { "read", "read access" },
                            { "write", "write access" }
                        }
                });

                options.OperationFilter<AssignSecurityRequirements>();
            });
        }

        public void ConfigureServices(IServiceCollection services)
        {
            // add Entity Framework
            services.AddEntityFramework()
                .AddSqlServer()
                .AddDbContext<MoviesAppContext>(options =>
                    options.UseSqlServer("Server=(localdb)\\mssqllocaldb;Database=MoviesDatabase;Trusted_Connection=True;MultipleActiveResultSets=true"));

            // add ASP.NET Identity
            services.AddIdentity<ApplicationUser, IdentityRole>() //Configuration)
                .AddEntityFrameworkStores<MoviesAppContext>()
                .AddDefaultTokenProviders();


            // add ASP.NET MVC
            services.AddMvc();

            services.AddSwagger();
            services.ConfigureSwaggerDocument(options =>
            {
                options.SingleApiVersion(new Info
                {
                    Version = "v2",
                    Title = "Swashbuckle Sample API",
                    Description = "A sample API for testing Swashbuckle",
                    TermsOfService = "Some terms ..."
                });

                options.OperationFilter<AssignOperationVendorExtensions>();
            });
            services.ConfigureSwaggerSchema(options =>
            {
                options.DescribeAllEnumsAsStrings = true;
            });
        }

        // This method gets called by a runtime.
        // Use this method to add services to the container
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc();
            // Uncomment the following line to add Web API services which makes it easier to port Web API 2 controllers.
            // You will also need to add the Microsoft.AspNet.Mvc.WebApiCompatShim package to the 'dependencies' section of project.json.
            // services.AddWebApiConventions();

            services.AddSwagger();
            services.ConfigureSwaggerDocument(options =>
            {
                options.SingleApiVersion(new Info
                    {
                        Version = "v1",
                        Title = "Swashbuckle Sample API",
                        Description = "A sample API for testing Swashbuckle",
                        TermsOfService = "Some terms ..."
                    });

                options.OperationFilter<AssignOperationVendorExtensions>();
            });
            services.ConfigureSwaggerSchema(options =>
            {
                options.DescribeAllEnumsAsStrings = true;
            });
        }

        //
        // This method gets called by a runtime.
        // Use this method to add services to the container
        //
        public virtual void ConfigureServices(IServiceCollection services)
        {
#if ENABLE_SWAGGER
            services.AddSwagger();
#endif

            services.AddMvc();
            services.AddSingleton(_ => this.Configuration);

            services.AddLogging();
        }

        /// <summary>
        /// Configures swagger. See https://github.com/domaindrivendev/Swashbuckle
        /// </summary>
        /// <param name="services">The services collection or IoC container.</param>
        /// <param name="configuration">Gets or sets the application configuration, where key value pair settings are 
        /// stored.</param>
        private static void ConfigureSwagger(IServiceCollection services, IConfiguration configuration)
        {
            var configurationSection = configuration.GetSection(nameof(AppSettings));
            AppSettings appSettings = new AppSettings();
            ConfigurationBinder.Bind(configurationSection, appSettings);

            services.AddSwagger(
                x =>
                {
                    // Use strings instead of integers to describe enumerations by default.
                    x.SchemaGeneratorOptions.DescribeAllEnumsAsStrings = true;

                    // If schemes are not explicitly provided in a Swagger 2.0 document, then the scheme used to access
                    // the docs is taken as the default. If your API supports multiple schemes and you want to be 
                    // explicit about them, you can use the "Schemes" option as shown below.
                    x.SwaggerGeneratorOptions.Schemes =
                        new string[]
                        {
                            "http",
                            "https"
                        };

                    // Use "SingleApiVersion" to describe a single version API. Swagger 2.0 includes an "Info" object 
                    // to hold additional metadata for an API.
                    x.SwaggerGeneratorOptions.SingleApiVersion(
                        new Info()
                        {
                            Version = "v1",
                            Title = appSettings.SiteTitle,
                            Description = appSettings.SiteDescription,
                            TermsOfService = appSettings.SiteTermsOfService,
                            Contact = new Swashbuckle.Swagger.Contact()
                            {
                                Name = appSettings.Contact.Name,
                                Email= appSettings.Contact.Email,
                                Url = appSettings.Contact.Url
                            },
                            License = new Swashbuckle.Swagger.License()
                            {
                                Name = appSettings.License.Name,
                                Url = appSettings.License.Url,
                            }
                        });

                    // If your API has multiple versions, use "MultipleApiVersions" instead of "SingleApiVersion".
                    // In this case, you must provide a collection of Info objects for each version of your API and
                    // a lambda that tells Swashbuckle which actions should be included in the docs for a given API 
                    // version.
                    // x.SwaggerGeneratorOptions.MultipleApiVersions(
                    //     GetApiVersions,
                    //     (apiDesc, targetApiVersion) => ResolveVersionSupportByRouteConstraint(apiDesc, targetApiVersion));
                });
        }

        // This method gets called by a runtime.
        // Use this method to add services to the container
        public void ConfigureServices(IServiceCollection services)
        {
            services.Configure<AppSettings>(Configuration.GetSection("AppSettings"));
            services.AddMvc();

            services.AddCors();

            services.AddSwagger();

            services.ConfigureSwaggerSchema(o =>
            {
                o.DescribeAllEnumsAsStrings = true;
            });

            services.ConfigureSwaggerDocument(o =>
            {
                o.SingleApiVersion(new Info
                {
                    Version = "v1",
                    Title = "Film Industry Network API",
                    Description = "Documentation of the API for interfacing with the Film Industry Network",
                    TermsOfService = "Use at your own risk"
                });
            });

            services.AddRouting();

            services.AddSingleton<IContext, NetworkContext>();
            services.AddScoped<IPersonRepository, PersonRepository>();
            services.AddScoped<IMovieRepository, MovieRepository>();
            services.AddScoped<IPersonService, PersonService>();
            services.AddScoped<IMovieService, MovieService>();
            services.AddScoped<IGraphMovieService, GraphMovieService>();
            services.AddScoped<IGraphPersonService, GraphPersonService>();
            services.AddTransient<IDataCollectorFactory, DataCollectorFactory>();

            services.Configure<MvcOptions>(options =>
            {
                var settings = new JsonSerializerSettings
                {
                    TypeNameHandling = TypeNameHandling.Auto
                };
                var jsonFormatter = options.OutputFormatters.Single(o => o.GetType() == typeof(JsonOutputFormatter));
                options.OutputFormatters.Remove(jsonFormatter);
                var outputFormatter = new JsonOutputFormatter { SerializerSettings = settings };
                options.OutputFormatters.Add(outputFormatter);
            });

            //services.AddWebApiConventions();
        }

        // This method gets called by a runtime.
        // Use this method to add services to the container
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc();
            // Uncomment the following line to add Web API services which makes it easier to port Web API 2 controllers.
            // You will also need to add the Microsoft.AspNet.Mvc.WebApiCompatShim package to the 'dependencies' section of project.json.
            // services.AddWebApiConventions();

            services.AddSwagger(s => {
                s.SwaggerGeneratorOptions.Schemes = new[] { "http", "https" };
                s.SwaggerGeneratorOptions.SingleApiVersion(new Info {
                    Version = "v1",
                    Title = "WebAPI with NHibernate"
                });
                //s.SwaggerGeneratorOptions.OperationFilter<AssignOperationVendorExtensions>();
                s.SchemaGeneratorOptions.DescribeAllEnumsAsStrings = true;
            });
        }

 // For more information on how to configure your application, visit http://go.microsoft.com/fwlink/?LinkID=398940
 public void ConfigureServices(IServiceCollection services)
 {
     services.AddCors();
     services.ConfigureCors(options =>
                             options.AddPolicy("AllowAll", p => p.AllowAnyOrigin()
                                                                 .AllowAnyMethod()
                                                                 .AllowAnyHeader()));
     services.AddMvc();
     services.AddSwagger(c =>
     {
         c.SwaggerGeneratorOptions.SingleApiVersion(new Info
         {
             Version = "v1",
             Title = "Huzzah!",
             Description = "An example ASP.NET 5 service",
             TermsOfService = "Unintelligible legalese..."
         });
     });
 }

        public static void ConfigureServices(IServiceCollection services)
        {
            services.AddSwagger(
                config =>
                {
                    config.SwaggerGeneratorOptions.SingleApiVersion(
                        new Info
                        {
                            Version = "v1",
                            Title = "ApiAppAspNet5"
                        });

                    config.SwaggerGeneratorOptions.BasePath = "/";

                    config.SwaggerGeneratorOptions.Schemes = new[] { "https" };

                    config.SwaggerGeneratorOptions.OperationFilter<IncludeParameterNamesOperationFilter>();
                });
        }

        public void ConfigureServices(IServiceCollection services)
        {
            var appEnv = CallContextServiceLocator.Locator.ServiceProvider.GetRequiredService<IApplicationEnvironment>();
            var databaseName = "database.sqlite3";
            var connection = $"Data Source={ appEnv.ApplicationBasePath}/{databaseName}";

            services
                .AddEntityFramework()
                .AddSqlite()

                .AddDbContext<WestWindContext>(options => options.UseSqlite(connection));
            services //no idea want this line can't be added to previous ??
                .AddMvc()
                .AddJsonOptions(options =>
            {
                //elegant handling of circular references
                options.SerializerSettings.PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.All;
            });
            services.AddSwagger();
        }

        public void ConfigureServices(IServiceCollection services)
        {
            var appEnv = CallContextServiceLocator.Locator.ServiceProvider.GetRequiredService<IApplicationEnvironment>();

            // using inmemory database
            services
                .AddEntityFramework()
                .AddInMemoryDatabase()
                .AddDbContext<TaskContext>(options => options.UseInMemoryDatabase(true));

            services
                .AddMvc()
                .AddJsonOptions(options =>
            {
                //handling of circular references
                options.SerializerSettings.PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.All;
            });

            // reading settings from json config
            var configBuilder = new Microsoft.Framework.Configuration.ConfigurationBuilder(appEnv.ApplicationBasePath, null);
            configBuilder.Add(new Microsoft.Framework.Configuration.Json.JsonConfigurationSource(appEnv.ApplicationBasePath + "//appsettings.json"));
            var appsettings = configBuilder.Build();

            // swagger configuration
            string path = string.Format(@"{0}\WebApiSwagger.XML", appEnv.ApplicationBasePath);
            services.AddSwagger(s =>
            {
                s.SwaggerGeneratorOptions.Schemes = new[] { "http", "https" };
                s.SwaggerGeneratorOptions.SingleApiVersion(new Info
                {
                    Version = appsettings["Swagger:Version"],
                    Title = appsettings["Swagger:Title"],
                    Description = appsettings["Swagger:Description"],
                });
                s.IncludeXmlComments(path);
                s.SchemaGeneratorOptions.DescribeAllEnumsAsStrings = true;
                s.SchemaGeneratorOptions.ModelFilters.Add(new ApplyXmlTypeComments(path));
                s.SwaggerGeneratorOptions.OperationFilters.Add(new ApplyXmlActionComments(path));
                s.SwaggerGeneratorOptions.BasePath = appsettings["Swagger:BaseURL"];
            });
        }

        // This method gets called by a runtime.
        // Use this method to add services to the container
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc();
            // Uncomment the following line to add Web API services which makes it easier to port Web API 2 controllers.
            // You will also need to add the Microsoft.AspNet.Mvc.WebApiCompatShim package to the 'dependencies' section of project.json.
            // services.AddWebApiConventions();

            services.AddSwagger();
            services.ConfigureSwaggerDocument(options =>
            {
                options.MultipleApiVersions(
                    new[]
                    {
                        new Info { Version = "v1", Title = "API V1" },
                        new Info { Version = "v2", Title = "API V2" }
                    },
                    ResolveVersionSupportByVersionsConstraint
                );

                options.DocumentFilter<SetVersionInPaths>();
            });
        }