Sign in Subscribe

Bikin API pake ASP.NET Core itu gampang! Yuk, kita langsung praktek.

Halo CSharp

Halo CSharp

— 7 min read
Share

Pernah kebayang nggak sih, bikin API itu ribet dan makan waktu? Stop deh mikir gitu, karena di ASP.NET Core, bikin API itu super gampang dan asik banget! Kita bisa langsung praktek sekarang juga dan lihat sendiri betapa powerful serta efisiennya framework ini. Siap-siap aja, karena sebentar lagi kita bakal punya API keren buatan sendiri.

Kenapa Sih Harus Pake ASP.NET Core Buat Bikin API?

Mungkin banyak di antara kita yang masih nanya-nanya, kenapa harus ASP.NET Core? Kan ada banyak pilihan lain di luar sana. Nah, dengerin baik-baik ya. ASP.NET Core itu modern, cross-platform jadi bisa jalan di Windows, macOS, atau Linux, punya performa yang juara, dan didukung sama ekosistem yang luas banget dari Microsoft. Artinya, kalau kita ngoding pakai ASP.NET Core, kita itu lagi investasi ke skill yang relevan dan masa depan banget.

Buat bikin RESTful API, ASP.NET Core menyediakan berbagai fitur bawaan yang memudahkan developer. Mulai dari routing yang intuitif, dependency injection yang sudah terintegrasi, sampai support untuk asynchronous programming yang bikin API kita responsif banget. Belum lagi komunitasnya yang aktif, jadi kalau ada apa-apa kita nggak sendirian deh. Pokoknya, bikin API pakai ASP.NET Core itu pilihan cerdas yang bikin proses development jadi lebih menyenangkan dan efektif.

Persiapan Kita Sebelum Tempur

Sebelum kita terjun langsung ke kode, ada beberapa peralatan perang yang perlu kita siapkan. Anggap aja ini pemanasan sebelum kita lari marathon bikin API. Nggak banyak kok, cuma beberapa tools esensial yang wajib kita punya.

.NET SDK Itu Wajib Punya

Yang pertama dan paling penting adalah .NET SDK. Ini semacam kit pengembangan yang berisi semua yang kita butuhkan buat ngembangin aplikasi .NET, termasuk compiler, runtime, dan berbagai tool command-line. Kita bisa download versi terbaru dari website resmi Microsoft. Pastikan kita pilih versi yang stabil ya. Setelah terinstal, kita bisa cek dengan membuka Command Prompt atau Terminal dan ketik dotnet --version. Kalau muncul nomor versi, berarti instalasi kita sukses dan kita siap lanjut.

Pilih Editor Kesayangan Visual Studio Code atau Visual Studio

Selanjutnya, kita butuh editor kode. Ada dua rekomendasi utama yang sering dipakai developer .NET. Pertama, Visual Studio Code. Ini editor yang ringan, cepat, dan cross-platform. Banyak banget extension yang bisa kita pakai buat meningkatkan produktivitas, misalnya C# extension dari Microsoft. Instalasi Visual Studio Code juga gampang banget. Kedua, Visual Studio. Ini IDE (Integrated Development Environment) yang lebih lengkap dan powerful, terutama kalau kita pakai Windows. Visual Studio punya banyak fitur canggih buat debugging, testing, dan project management. Pilih mana yang lebih nyaman buat kita ya, keduanya sama-sama asik kok buat ngoding ASP.NET Core.

Yuk Kita Mulai Project Baru Dengan ASP.NET Core

Oke, semua persiapan sudah beres. Sekarang waktunya kita mulai project API pertama kita. Nggak perlu ribet, cuma pakai satu perintah saja di terminal kita.

Buka Command Prompt atau Terminal di folder mana pun yang kita mau jadikan workspace. Lalu ketik perintah ini.

bash
dotnet new webapi -n MyAwesomeAPI

Perintah dotnet new webapi itu akan membuat template project API ASP.NET Core baru. Sedangkan -n MyAwesomeAPI itu untuk memberikan nama project kita, "MyAwesomeAPI". Kita bisa ganti namanya sesuka hati kita ya. Setelah itu, akan ada folder baru dengan nama MyAwesomeAPI. Masuk ke folder tersebut dengan cd MyAwesomeAPI.

Sekarang, kita bisa coba jalankan project yang baru kita buat tadi. Ketik perintah ini.

bash
dotnet run

Voila! Project kita akan di-build dan dijalankan. Kita akan melihat output di terminal yang menunjukkan alamat lokal tempat API kita berjalan, biasanya https://localhost:5001 atau http://localhost:5000. Coba buka alamat tersebut di browser kita. Kita mungkin akan melihat halaman default Swagger UI atau sebuah pesan "Hello World" kalau kita pakai template minimal. Itu tandanya API kita sudah hidup! Asik kan?

Mengenal Struktur Project API Kita

Setelah project kita jadi, yuk kita intip sedikit struktur foldernya. Biar kita paham apa fungsi dari setiap bagiannya. Memahami struktur project itu penting banget biar kita nggak nyasar pas ngoding nanti.

Di dalam folder MyAwesomeAPI, kita akan menemukan beberapa file dan folder penting.

  • Controllers folder ini tempat kita akan menaruh semua logic untuk endpoint API kita. Setiap file controller akan menangani request HTTP tertentu.
  • Models (opsional, tapi bagusnya ada) folder ini biasa kita gunakan untuk mendefinisikan struktur data yang akan kita kirim atau terima lewat API kita. Misalnya, kalau kita bikin API untuk daftar produk, di sinilah kita definisikan class Product.
  • Program.cs ini adalah entry point aplikasi kita. Di sini konfigurasi dasar aplikasi kita diatur, seperti build web host, konfigurasi layanan, dan lain-lain.
  • appsettings.json file ini untuk menyimpan konfigurasi aplikasi, misalnya connection string database atau pengaturan lainnya yang bisa berbeda di lingkungan development, staging, atau production.

Dengan template webapi, kita juga akan melihat contoh WeatherForecastController.cs dan WeatherForecast.cs. Ini adalah contoh bawaan dari ASP.NET Core yang bisa kita pelajari atau kita hapus saja kalau kita ingin membuat dari nol.

Bikin Model Data Sederhana Buat API Kita

Kita akan bikin API CRUD (Create, Read, Update, Delete) untuk sebuah daftar tugas sederhana. Jadi, kita butuh model data untuk representasi tugas tersebut.

Yuk, kita buat file baru di dalam folder MyAwesomeAPI (atau kalau kita mau rapi, buat folder Models di root project, lalu simpan di sana) dengan nama TodoItem.cs.

Isi filenya kira-kira begini.

csharp
namespace MyAwesomeAPI.Models
{
    public class TodoItem
    {
        public int Id { get; set; }
        public string Title { get; set; } = string.Empty;
        public bool IsComplete { get; set; }
    }
}

Simpel banget kan? Kita punya tiga properti. Id buat identifikasi unik setiap tugas, Title untuk judul tugasnya, dan IsComplete buat menandakan apakah tugasnya sudah selesai atau belum. Sekarang kita punya struktur data yang bisa kita pakai di API kita.

Bikin Controller Pertama Kita Untuk API

Ini dia bagian yang paling seru. Kita bakal bikin controller yang akan menghandle permintaan dari client. Controller ini yang bakal jadi jembatan antara permintaan HTTP dengan logic aplikasi kita.

Buat file baru di folder Controllers dengan nama TodoItemsController.cs.

csharp
using Microsoft.AspNetCore.Mvc;
using MyAwesomeAPI.Models;
using System.Collections.Generic;
using System.Linq;namespace MyAwesomeAPI.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class TodoItemsController : ControllerBase
    {
        private static List _todoItems = new List
        {
            new TodoItem { Id = 1, Title = "Belajar ASP.NET Core", IsComplete = false },
            new TodoItem { Id = 2, Title = "Bikin API Pertama", IsComplete = true }
        };
        private static int _nextId = 3;[HttpGet]
        public ActionResult> GetTodoItems()
        {
            return Ok(_todoItems);
        }[HttpGet("{id}")]
        public ActionResult GetTodoItem(int id)
        {
            var todoItem = _todoItems.FirstOrDefault(item => item.Id == id);
            if (todoItem == null)
            {
                return NotFound();
            }
            return Ok(todoItem);
        }[HttpPost]
        public ActionResult PostTodoItem(TodoItem todoItem)
        {
            todoItem.Id = _nextId++;
            _todoItems.Add(todoItem);
            return CreatedAtAction(nameof(GetTodoItem), new { id = todoItem.Id }, todoItem);
        }[HttpPut("{id}")]
        public IActionResult PutTodoItem(int id, TodoItem todoItem)
        {
            if (id != todoItem.Id)
            {
                return BadRequest();
            }var existingItem = _todoItems.FirstOrDefault(item => item.Id == id);
            if (existingItem == null)
            {
                return NotFound();
            }existingItem.Title = todoItem.Title;
            existingItem.IsComplete = todoItem.IsComplete;return NoContent();
        }[HttpDelete("{id}")]
        public IActionResult DeleteTodoItem(int id)
        {
            var todoItem = _todoItems.FirstOrDefault(item => item.Id == id);
            if (todoItem == null)
            {
                return NotFound();
            }

Oke, mari kita bedah kode ini sedikit.

  • [ApiController] dan [Route("api/[controller]")] ini adalah attribute yang penting. [ApiController] itu memberikan berbagai fitur kenyamanan untuk pengembangan API, seperti automatic HTTP 400 responses. [Route("api/[controller]")] itu mendefinisikan routing untuk controller ini. [controller] akan diganti dengan nama controller kita tanpa akhiran "Controller", jadi rutenya akan jadi api/TodoItems.
  • Kita menggunakan private static List _todoItems sebagai "database" sementara kita. Ini cuma buat contoh ya, di project sungguhan kita bakal pakai database sungguhan.
  • Metode GetTodoItems dengan attribute [HttpGet] akan menangani permintaan GET ke api/TodoItems dan mengembalikan semua daftar tugas.
  • Metode GetTodoItem dengan attribute [HttpGet("{id}")] akan menangani permintaan GET ke api/TodoItems/{id} (misalnya api/TodoItems/1) dan mengembalikan satu tugas berdasarkan ID.
  • Metode PostTodoItem dengan attribute [HttpPost] akan menangani permintaan POST ke api/TodoItems untuk membuat tugas baru.
  • Metode PutTodoItem dengan attribute [HttpPut("{id}")] akan menangani permintaan PUT ke api/TodoItems/{id} untuk memperbarui tugas yang sudah ada.
  • Metode DeleteTodoItem dengan attribute [HttpDelete("{id}")] akan menangani permintaan DELETE ke api/TodoItems/{id} untuk menghapus tugas.

Setiap metode HTTP ini mengembalikan ActionResult atau IActionResult yang memungkinkan kita mengembalikan status kode HTTP yang sesuai, seperti Ok (200), NotFound (404), BadRequest (400), atau NoContent (204).

Tes API Kita Pakai Swagger UI

Setelah controller kita jadi, sekarang waktunya kita tes. Cara termudah untuk mengetes API ASP.NET Core adalah menggunakan Swagger UI, yang sudah otomatis terintegrasi kalau kita pakai template webapi.

Jalankan lagi project kita dengan dotnet run. Buka browser dan pergi ke alamat API kita, misalnya https://localhost:5001/swagger. Kita akan melihat halaman Swagger UI yang menampilkan semua endpoint yang ada di API kita, termasuk yang baru saja kita buat di TodoItemsController.

Dari Swagger UI, kita bisa.

  • Klik pada endpoint GET /api/TodoItems untuk melihat semua daftar tugas. Lalu klik Try it out dan Execute.
  • Klik pada endpoint POST /api/TodoItems, klik Try it out, lalu masukkan JSON body untuk tugas baru. Misalnya { "title": "Beli kopi", "isComplete": false }. Klik Execute.
  • Coba endpoint GET /api/TodoItems/{id} dengan ID yang baru dibuat.
  • Coba PUT dan DELETE juga.

Lihat, kita bisa berinteraksi langsung dengan API kita. Keren banget kan? Swagger UI ini alat yang sangat berguna buat dokumentasi dan testing API kita secara interaktif.

Sedikit Enhancements Biar API Makin Keren

API kita sudah berfungsi dengan baik, tapi ada beberapa hal yang bisa kita tambahkan biar makin mantap dan siap untuk project yang lebih besar.

Dependency Injection Itu Teman Baik Kita

Di ASP.NET Core, Dependency Injection (DI) itu fitur inti yang sudah terintegrasi. Kalau di contoh tadi kita pakai static List buat data, di aplikasi nyata kita akan pakai database. Untuk mengakses database, kita akan punya sebuah service atau repository. Nah, service ini bisa kita suntikkan (inject) ke controller kita menggunakan DI.

Misalnya, kita punya ITodoRepository dan implementasinya TodoRepository yang bertugas berinteraksi dengan database. Kita bisa daftarkan di Program.cs seperti ini.

csharp
// Di Program.cs
builder.Services.AddSingleton(); // Atau AddScoped/AddTransient

Lalu di controller kita tinggal minta saja di constructor.

csharp
public class TodoItemsController : ControllerBase
{
    private readonly ITodoRepository _repository;

Dengan begitu, controller kita jadi lebih bersih dan mudah diuji.

Error Handling yang Elegan

Saat mengembangkan API, pasti ada kalanya terjadi kesalahan, baik itu kesalahan di sisi client (misalnya input yang tidak valid) atau di sisi server. Kita bisa menangani error ini dengan lebih elegan.

ASP.NET Core sudah punya fitur bawaan seperti middleware untuk menangani exception secara global. Kita bisa tambahkan middleware UseExceptionHandler di Program.cs untuk menangkap semua exception yang tidak tertangani dan mengembalikan respons error yang konsisten.

csharp
// Di Program.cs
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}
else
{
    app.UseExceptionHandler("/Error"); // Bisa diarahkan ke halaman error atau custom error handling
    app.UseHsts();
}

Ini membuat API kita lebih tangguh dan memberikan pengalaman yang lebih baik bagi pengguna API kita.

Kesimpulan Bikin API Pake ASP.NET Core Itu Gampang Kan

Nah, gimana? Bikin API pake ASP.NET Core itu beneran gampang banget kan? Dari mulai setup project, bikin model data, sampai nulis controller dengan berbagai method HTTP, semuanya bisa kita lakukan dengan cepat dan efisien. Kita sudah berhasil membuat sebuah RESTful API sederhana yang lengkap dengan fungsi CRUD.

Kita juga sudah melihat bagaimana Swagger UI bisa membantu kita mengetes dan mendokumentasikan API kita secara interaktif. Dengan fondasi yang kuat ini, kita bisa lanjut mengembangkan API kita jadi lebih kompleks, terhubung ke database sungguhan, atau bahkan menambahkan fitur otentikasi dan otorisasi.

Jangan berhenti sampai di sini ya. Terus eksplorasi, terus belajar, dan terus bikin project-project asik lainnya. Dunia backend development dengan ASP.NET Core ini luas banget dan banyak hal menarik yang bisa kita gali. Selamat ngoding dan sampai jumpa di project selanjutnya!

Read more