ASP.NET Core 시작하기 - REST API

Creating a REST API in C# typically involves using the ASP.NET Core framework, which provides a robust set of tools and libraries for building web applications and services. Here, I’ll guide you through the steps to create a basic REST API using ASP.NET Core.

Prerequisites

Before you start, make sure you have the following installed:

1. .NET SDK: You can download it from the .NET website.
2. Visual Studio: While you can use any code editor, Visual Studio or Visual Studio Code is recommended for C# development.

Step-by-Step Guide to Creating a REST API

1. Create a New ASP.NET Core Web API Project

You can create a new project using the .NET CLI or Visual Studio.

Using the .NET CLI:

Open a terminal and run the following command:

dotnet new webapi -n MyApi
cd MyApi

This will create a new directory named MyApi with a basic web API project structure.

Using Visual Studio:

1. Open Visual Studio and select Create a new project.
2. Choose ASP.NET Core Web API and click Next.
3. Configure your project settings (name, location) and click Create.
4. Choose the latest .NET version and click Create.

2. Project Structure

The default project structure includes:

• Controllers: A folder for API controllers, which handle HTTP requests.
• Program.cs: Configures the application and starts the web server.
• Startup.cs (if applicable): Configures services and the request pipeline. (Note: In .NET 6 and later, Startup.cs is merged into Program.cs).

3. Create a Model

A model represents the data structure you’ll be working with. For example, a simple Product model:

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}

Add this class to a new Models folder in your project.

4. Create a Controller

Create a controller to handle HTTP requests related to Product. Controllers are typically located in the Controllers folder.

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using System.Linq;

namespace MyApi.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ProductsController : ControllerBase
    {
        private static readonly List<Product> products = new List<Product>
        {
            new Product { Id = 1, Name = "Product1", Price = 10.0m },
            new Product { Id = 2, Name = "Product2", Price = 20.0m }
        };

        // GET: api/products
        [HttpGet]
        public ActionResult<IEnumerable<Product>> GetProducts()
        {
            return Ok(products);
        }

        // GET: api/products/5
        [HttpGet("{id}")]
        public ActionResult<Product> GetProduct(int id)
        {
            var product = products.FirstOrDefault(p => p.Id == id);
            if (product == null)
            {
                return NotFound();
            }
            return Ok(product);
        }

        // POST: api/products
        [HttpPost]
        public ActionResult<Product> CreateProduct([FromBody] Product product)
        {
            product.Id = products.Max(p => p.Id) + 1;
            products.Add(product);
            return CreatedAtAction(nameof(GetProduct), new { id = product.Id }, product);
        }

        // PUT: api/products/5
        [HttpPut("{id}")]
        public IActionResult UpdateProduct(int id, [FromBody] Product updatedProduct)
        {
            var product = products.FirstOrDefault(p => p.Id == id);
            if (product == null)
            {
                return NotFound();
            }

            product.Name = updatedProduct.Name;
            product.Price = updatedProduct.Price;
            return NoContent();
        }

        // DELETE: api/products/5
        [HttpDelete("{id}")]
        public IActionResult DeleteProduct(int id)
        {
            var product = products.FirstOrDefault(p => p.Id == id);
            if (product == null)
            {
                return NotFound();
            }

            products.Remove(product);
            return NoContent();
        }
    }
}

5. Run the API

You can run the API using the .NET CLI or Visual Studio.

Using the .NET CLI:

dotnet run

Using Visual Studio:

1. Press F5 or click on the Start button to run the application.
2. This will launch the API in your default web browser, typically at https://localhost:5001 or http://localhost:5000.

6. Test the API

You can test your API using a tool like Postman or curl.

Using curl:

• Get all products:

  curl -X GET https://localhost:5001/api/products

• Get a product by ID:

  curl -X GET https://localhost:5001/api/products/1

• Create a new product:

  curl -X POST https://localhost:5001/api/products -H "Content-Type: application/json" -d '{"name": "Product3", "price": 30.0}'

• Update a product:

  curl -X PUT https://localhost:5001/api/products/1 -H "Content-Type: application/json" -d '{"name": "Updated Product1", "price": 15.0}'

• Delete a product:

  curl -X DELETE https://localhost:5001/api/products/1

Additional Features

Entity Framework Core

For database operations, you can integrate Entity Framework Core.

1. Install EF Core packages:

   dotnet add package Microsoft.EntityFrameworkCore.SqlServer
   dotnet add package Microsoft.EntityFrameworkCore.Tools

2. Create a DbContext:

   using Microsoft.EntityFrameworkCore;
   
   public class AppDbContext : DbContext
   {
       public AppDbContext(DbContextOptions<AppDbContext> options)
           : base(options)
       {
       }
   
       public DbSet<Product> Products { get; set; }
   }

3. Configure the DbContext in Program.cs:

   builder.Services.AddDbContext<AppDbContext>(options =>
       options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

4. Add a connection string to appsettings.json:

   {
     "ConnectionStrings": {
       "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=MyApiDb;Trusted_Connection=True;"
     }
   }

5. Run EF Core migrations:

   dotnet ef migrations add InitialCreate
   dotnet ef database update

Authentication and Authorization

To secure your API, you can implement authentication and authorization. ASP.NET Core supports JWT and OAuth2, among other authentication mechanisms.

1. Install authentication packages:

   dotnet add package Microsoft.AspNetCore.Authentication.JwtBearer

2. Configure authentication in Program.cs:

   builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
       .AddJwtBearer(options =>
       {
           options.Authority = "https://your-auth-server.com";
           options.Audience = "your-api";
       });

3. Add the [Authorize] attribute to secure endpoints:

   [Authorize]
   [HttpGet]
   public ActionResult<IEnumerable<Product>> GetProducts()
   {
       return Ok(products);
   }

Conclusion

This guide covers the basics of creating a REST API in C# using ASP.NET Core. From setting up the project to implementing CRUD operations and integrating Entity Framework Core, you now have a solid foundation to build upon. Additionally, consider adding features like authentication, logging, and error handling to create a robust and secure API. If you have any specific questions or need further clarification on any part, feel free to ask!