How To Convert Console Project To Web API Project

Figure-Adding Startup. cs class

Now, enter the name of the class as Startup. cs and click on Add button.

Figure-Adding Startup class

Step 7

Now we see that our error is solved. Now we need to enable Routing and use EndPoints in the Startup.cs file. So first, we must create a method with the name public void ConfigureServices(IServiceCollection services) in order to configure the services. This method uses IServiceCollection as a parameter, which is presented in the namespace Microsoft.Extensions.DependencyInjection. We also need a method with the name public void Configure(IApplicationBuilder app, IWebHostEnvironment env), which uses IapplicationBuilder and IwebHostEnvironmentas a parameter.

Here IapplicationBuilder is used to enable routing using UseRouting();. This is a method that is located in the namespace Microsoft.AspNetCore.Builder and in static class EndpointRoutingApplicationBuilderExtensions. IwebHostEnvironment is used to set an environment to run the web API, as it is an Interface. Now let's implement these methods.

public void Configure(IApplicationBuilder app, IWebHostEnvironment env) {
    app.UseRouting();
    app.UseEndpoints(endpoints => {
        endpoints.MapGet("/", async context => {
            await context.Response.WriteAsync("Hello from new web Api");
        });
    });
}

This method used a UseRouting() method that enabled the routing in our application. Another method is called the app.UseEndpoints, and it is used to configure endpoints. Endpoints are selected by the URLs and executed by the delegates. In this section:

endpoints.MapGet("/", async context => {
    await context.Response.WriteAsync("Hello from new web Api");
});

We have used the endpoints.mapGet(), which is used to define endpoints. Under this mapGet method, we have defined the URL "/", which means this will be loaded when our application runs. Under this section, we have an async keyword that is used to execute code ssynchronously. Next, if we use the async keyword, then we have to use the await keyword. Await is used to return the operation that is performed by the async task. Next, we can write a hello message in context.Response.WriteAsync("Hello from new web API");. Now if we run our application, the code output will be:

Figur-Empty API out-put

At the beginning of the article when we executed the application, the output window was a console window with a hello world message. Now we can see that the output window is a web browser.

Step 8

Now we need to add API services to our controller. Let’s open our second method, which is ConfigureServices(IServiceCollection services). In API we don't need to add a view part, so here we add a controller using:

   services.AddControllers();

in our ConfigureServices(IServiceCollection services) method by adding this line, we have the support of controllers. Now, we don't need this section:

MapGet("/", async context => {
    await context.Response.WriteAsync("Hello from new web Api");
});

because now output will come from the Controller. Simply we use the app.MapControllers() method that helps in generating output from the controller.

Step 9

Now we need to add a folder in our project with the name Controllers. We can simply add a folder by right-clicking on project name, then add, then new folder. The name of the folder would be Controller.

Figure-Add controller Folder

Step 10

Now we need to add the Controller in the controller folder. So, right-click on the controller folder, then click on add, then choose controller, or we can choose a class. If we choose the controller, then some basic functionality will be added automatically. If we add the class, what will be added will be a simple class. Here, I've chosen class, then entered the class name NewController. Choose any name that you want, but use Controller as a suffix. This means that we must add "Controller" to the name of the controller.

Figure-Adding Controller

Now we have to inherit the class with ControllerBase, which is located at Microsoft.AspNetCore.MVC namespace. Next, we need to add [ApiController] that indicates that a type. All derived types will be used to serve HTTP API responses. Second, we must add the [Route()] attribute, where we can pass a custom route to our API.

using Microsoft.AspNetCore.Mvc;
namespace ConsoleAppToWebAPI.Controllers {
    [ApiController]
    [Route("NewApi/[action]")]
    public class NewController: ControllerBase {
        public string SayHii() {
            return "Hii Learners";
        }
    }
}

  [Route("NewApi/[action]")]

Now we can call our API with the Defined Route like here. To call an API, we need to pass /NewApi/sayHii. Here sayhii is an action you can create. Any other one or multiple actions can be invoked by their name. Now if I run this project, the output will be:

Figure-API Output

Now our API is ready with controllers, so we can add many more things to this API, like swigger UI and many more features.

Conclusion

In this article, we began with a console application with a console output, and now we have an API. We have made a lot of changes in our application. Still, we can make many more changes in our project.