ASP.NET Web API File Upload and Download via Web API: A Step-by-Step Guide for Beginners

Welcome to the guide on handling file upload and download operations using ASP.NET Web API. ASP.NET Web API is a versatile platform for building RESTful web services, and one common requirement in web applications is the ability to handle file uploads and downloads. In this guide, we will walk through the process of setting up an ASP.NET Web API project to handle these operations, starting from scratch and ending with a fully functional application.

Prerequisites

Before we begin, make sure you have the following tools installed:

• Visual Studio 2019 or later: The IDE we'll use for developing the Web API.
• .NET 6 SDK: The framework to build the Web API.
• REST Client: Such as Postman or Swagger, to test the API endpoints.

Setting up an ASP.NET Web API Project

1. Create a new ASP.NET Web API project:

   • Open Visual Studio and select "Create a new project".
   • Choose "ASP.NET Core Web API" and click "Next".
   • Configure your project by specifying the name and location, then click "Create".
   • Select the .NET 6 (Long-term support) framework and click "Create". This will create a basic Web API project with a couple of default controllers.

2. Understanding the Default Project Structure:

   • The created Web API project contains a Controllers folder which will hold all our endpoint definitions.
   • A Program.cs file which is the entry point of the application.
   • A appsettings.json file for application configuration.

Implementing File Upload via Web API

1. Create a new Controller for File Upload:

   • Right click on the Controllers folder in the Solution Explorer and select Add > New Item.
   • Choose API Controller - Empty and name it FileUploadController.
   • Open the newly created controller and add the following code snippet:

   using Microsoft.AspNetCore.Http;
   using Microsoft.AspNetCore.Mvc;
   using System.IO;
   using System.Threading.Tasks;
   
   namespace WebApi.Controllers
   {
       [Route("api/[controller]")]
       [ApiController]
       public class FileUploadController : ControllerBase
       {
           [HttpPost("upload")]
           public async Task<IActionResult> UploadFile(IFormFile file)
           {
               if (file == null || file.Length == 0)
               {
                   return BadRequest("No file uploaded.");
               }
   
               var uploadsFolder = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "uploads");
               Directory.CreateDirectory(uploadsFolder);
               var filePath = Path.Combine(uploadsFolder, file.FileName);
   
               using (var stream = new FileStream(filePath, FileMode.Create))
               {
                   await file.CopyToAsync(stream);
               }
   
               return Ok(new { filePath });
           }
       }
   }
   

2. Configure Static Files Middleware (if required):

   • Open Program.cs. If you want to serve the uploaded files via URL, you need to configure static files middleware.

   using Microsoft.AspNetCore.Builder;
   using Microsoft.Extensions.DependencyInjection;
   using Microsoft.Extensions.Hosting;
   
   var builder = WebApplication.CreateBuilder(args);
   
   builder.Services.AddControllers()
       .AddJsonOptions(options =>
           options.JsonSerializerOptions.PropertyNamingPolicy = null);
   
   // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
   builder.Services.AddEndpointsApiExplorer();
   builder.Services.AddSwaggerGen();
   
   var app = builder.Build();
   
   // Configure the HTTP request pipeline.
   if (app.Environment.IsDevelopment())
   {
       app.UseSwagger();
       app.UseSwaggerUI();
   }
   
   app.UseHttpsRedirection();
   app.UseStaticFiles(); // For serving static files
   
   app.UseAuthorization();
   
   app.MapControllers();
   
   app.Run();
   

3. Test File Upload Endpoint:

   • Press F5 to run the application.
   • Use Postman or any other REST client and create a POST request to https://localhost:5001/api/fileupload/upload (the port may vary).
   • Set the request body type to "form-data".
   • Add a key file with the type "File" to upload a file from your local disk.
   • Send the request and verify whether the file is uploaded to the designated folder.

Implementing File Download via Web API

1. Create a new Controller for File Download:

   • In Solution Explorer, right-click on the Controllers folder and select Add > New Item.
   • Choose API Controller - Empty and name it FileDownloadController.
   • Open the newly created controller and add the following code snippet:

   using Microsoft.AspNetCore.Mvc;
   using System.IO;
   using System.Net.Http.Headers;
   
   namespace WebApi.Controllers
   {
       [Route("api/[controller]")]
       [ApiController]
       public class FileDownloadController : ControllerBase
       {
           [HttpGet("download/{fileName}")]
           public IActionResult DownloadFile(string fileName)
           {
               var uploadsFolder = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "uploads");
               var filePath = Path.Combine(uploadsFolder, fileName);
   
               if (!System.IO.File.Exists(filePath))
               {
                   return NotFound("File not found.");
               }
   
               var memory = new MemoryStream();
               using (var stream = new FileStream(filePath, FileMode.Open))
               {
                   stream.CopyTo(memory);
               }
               memory.Position = 0;
   
               return File(memory, new MediaTypeHeaderValue("application/octet-stream").ToString(), fileName);
           }
       }
   }
   

2. Test File Download Endpoint:

   • Press F5 to ensure the application is running.
   • Use Postman or another REST client and create a GET request to https://localhost:5001/api/filedownload/download/your-file.txt (replace your-file.txt with the actual filename).
   • Set the request method to "GET" and send the request.
   • The file should download to your local disk.

Additional Considerations

• Error Handling: Implement error handling to manage cases such as invalid file types, large file sizes, file not found, etc.
• Security: Ensure security by validating file contents and using HTTPS to protect data in transit.
• Configuration: Use appsettings.json to store paths and settings related to file storage.
• Scalability: For large files, consider using streaming or temporary storage strategies.

Summary

In this guide, we walked through the process of creating a simple yet functional ASP.NET Web API that can handle file upload and download operations. Starting with creating a new Web API project, setting up file upload and download endpoints, and finally testing these endpoints thoroughly, we covered the essential steps to implement file handling in a Web API application. With this knowledge, you can adapt and extend these examples to handle more complex requirements in your own web applications. Happy coding!

If you have any questions or need further assistance, feel free to ask. Happy building with ASP.NET Web API!