The AMD Ryzen 5 7600X is a 6-core, 12-thread processor based on the Zen 4 architecture, with a base clock of 4.7 GHz and a boost clock up to 5.3 GHz. It has a TDP of 105W, supports DDR5 memory, and offers PCIe 5.0 compatibility, making it a strong mid-range option for gaming and productivity in modern systems.

So now on I needed a budget cooler to handle my 7600X which is offically 105W TDP. Done research and decided to have AK400 Which was 45USD in my country. AK620 and AG620 had price of 50–55USD which was normally a better choice but it was out of stock in my country… AIO’s were at good price but I didnt wanted to have Liquid Cooler because of problems happening with Pump (Noises, Malfunctions…) Even some China 240mm AIO’s were almost same price with AK400…

The DeepCool AK400 comes well-packaged, with a clean, minimalistic box design that reflects its aesthetic. Inside, you’ll find the cooler, mounting hardware for both Intel and AMD sockets, a user manual, and a single 120mm PWM fan. The all-black design with subtle branding makes it suitable for various build themes, whether you’re going for stealth or a pop of color with RGB elsewhere in your setup.

• Four heat pipes for efficient heat transfer.
• Compatibility with most modern sockets, including Intel LGA1700 and AMD AM5.
• 220W Official TDP Rate

AK400 Zero Dark Plus comes with extra fan. But it is only for airflow, you may not notice extra cooling at temperatures. AG400 is for users who doesnt want to pay extra for aestethics…

AK400 And R5 7600X : BENCHMARKS

First of all, I want to show the airflow confugiration. As Case for my system, I have Darkflash DK431 Case, with standard of 3 fans in front and 1 exhaust fan at exit… But I added 2 extra inputs from bottom, and 2 extra exhaust fan at top.

R5 7600X have performed well in Cinebench R23 All Core Cpu Benchmark, result varying from 14500 to 15100…

Within Default Bios settings of R5 7600X (With Asus TUF B650M-PLUS Wifi Motherboard). R23 Performed about 14573 points in Multicore, with tepmerature of 92C… (Amd Officially announced that Ryzen 7000’s have operating temperature up to 95C). AK400 Have let 7600x to work at TDP Rate of 119watts which means even it can handle standart boost frequency of 7600X… Normally 7600X Has TDP Of 105Watt…

So now let’s optimize our 7600X settings at BIOS, to decrease the temperature and have better results at Benchmark…

Let’s have curve optimizer at negative 13… You can go through until your system crash. In this test I made this value -13. My system performed well for 3 months with value -19. Increase value when you have BSOD…

And thermal throttle limit at 88C. (You can enter your value from 80 to 90C)…

Now the cpu curve voltage decreased -13mv and thermal limit is set to 88C which make system to have thermal throttle at lower level of temperature.

PBO Curve Tune is recommended for users who even prefer High Range 360mm AIO or even custom loop cooling… You will have better performance with less voltage, shortly you are tweaking your cpu for better performance without any cost…

Now System has achieved 15113 points at Cinebench R23 With temperature of 88C max…

AK400 Has about 30–32C in idle operations… And 40–42C in package temp of CPU…

Test System:

Here is my complete System I used at this benchmark…

CPU: Amd Ryzen 5 7600X

Motherboard: Asus TUF B650M-Plus Wifi

Ram: Gskill Flare X5 32GB DDR5 6000Mhz (2x16GB) 32CL Ram

GPU: Zotac Twin Edge RTX 3060Ti OC 8GB GDDR5

Cooler: DeepCool AK400

NVME SSD: Crucial P3 1TB Nvme 3500mb/s RW

SATA SSD: Kioxia Exceria 960GB

HDD: WDC WD20EZRX-00D8PB0 : 2000,3 GB

Case: DK431 DarkFlash E-ATX Case

PSU: FSP Hyper S 700W Silver 85+ Single Rail

AK400 And R5 7600X : Game Temperatures

Here are my videos of R5 7600X with AK400, Game Temperatures:

Conclusion:

The DeepCool AK400 is a standout budget air cooler that delivers a compelling mix of performance, simplicity, and affordability. It excels in providing efficient cooling for mid-range CPUs while maintaining a compact footprint and quiet operation. The minimalist design, with variants like the Zero Dark and WH models, ensures it fits seamlessly into various build aesthetics, whether you’re going for a stealthy blackout or a bright white theme.

While it lacks premium features like RGB lighting or extensive overclocking support, its performance-to-price ratio makes it an excellent choice for budget-conscious users or those looking to upgrade from stock coolers. The AK400 proves you don’t need to overspend to keep your system cool and reliable. For its price point, it punches well above its weight, making it a top contender in the budget air cooling market.

Shortly, the DeepCool AK400 performed completely fine in Amd Ryzen 5 7600x Cpu… It will also handle other mid to high range AMD Ryzen 7000 and 9000 Cpu’s like R7 7700,R7 7700x… Also you can look for this budget cooler for Amd Ryzen 5000 AM4 Processors, and similar Intel LGA 1200/1700 Core Cpu’s which will not exceed 120–130Watts TDP…

Alternative Coolers:

First of all, if you have a few bucks more budget, you can go through the dual-tower AK620 Cooler with dual fan… It may handle more TDP Within a few bucks more, with similar looking…

Noctua NH-U12S Redux

• Compact single-tower design.
• Reliable cooling and quiet operation.
• Great for smaller cases.

be quiet! Dark Rock 4

• Stylish, high-performance cooler with minimal noise.
• Compact enough for most builds.

Cooler Master Hyper 212 Black Edition

• Budget-friendly option with solid performance.
• Sleek black design and easy installation.

And other Quality 240 or 360mm AIO’S…

Before Start:

Set up your NodeJs Backend and make sure it is accessible from your local-host... Here is the link for NodeJs Sample Backend project ready.

• React Backend SQL Tutorial
• GitHub - ardasenbaklavaci/React-SQL-Tutorial-Backend: React SQL Tutorial Backend Side

Step 1: Set Up Retrofit in Your Android Project

1.1 Add Retrofit Dependencies

In your Android project, add Retrofit and Gson dependencies to your build.gradle (app-level):

dependencies {
    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
}

Sync your project to ensure the dependencies are downloaded and available.

1.2 Create the Retrofit Client

Next, create a Kotlin class called RetrofitClient. This class will help us create a singleton instance of Retrofit and provide access to the backend API.

object RetrofitClient {
    private const val BASE_URL = "http://10.0.2.2:3001/" // 10.0.2.2 for localhost access in Android Emulator

    val instance: Retrofit by lazy {
        Retrofit.Builder()
            .baseUrl(BASE_URL)
            .addConverterFactory(GsonConverterFactory.create())
            .build()
    }
}

Here, BASE_URL is the URL of your backend. If you’re running a local backend, use 10.0.2.2 to route requests from your Android emulator to your localhost.

Step 2: Define API Endpoints Using Retrofit

In this step, you will create an interface that defines the backend API endpoints.

2.1 Create ApiService Interface

In your ApiService interface, define methods to interact with the API. These methods correspond to the GET and POST endpoints of your Node.js API.

data class User(
    @SerializedName("Id") val id: Int,
    @SerializedName("Name") val name: String,
    @SerializedName("Email") val email: String
)

interface ApiService {
    @GET("users")
    fun getUsers(): Call<List<User>>

    @POST("users")
    @FormUrlEncoded
    fun addUser(
        @Field("Id") id: Int,
        @Field("Name") name: String,
        @Field("Email") email: String
    ): Call<User>
}

The @SerializedName annotations ensure the JSON fields match the model names in Kotlin.

Step 3: Fetch Data Using Retrofit in MainActivity

Now, we’ll implement the logic in MainActivity.kt to make the API calls and display the results.

3.1 Set Up MainActivity

In MainActivity.kt, we will fetch and display the list of users from the API. Later, we can add functionality to post new users.

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        fetchUsers() // Fetch users on activity start
    }

    private fun fetchUsers() {
        val api = RetrofitClient.instance.create(ApiService::class.java)

        api.getUsers().enqueue(object : Callback<List<User>> {
            override fun onResponse(call: Call<List<User>>, response: Response<List<User>>) {
                if (response.isSuccessful) {
                    val userList = response.body()
                    userList?.let { displayUsers(it) }
                }
            }

            override fun onFailure(call: Call<List<User>>, t: Throwable) {
                Log.e("MainActivity", "Error fetching users", t)
            }
        })
    }

    private fun displayUsers(users: List<User>) {
        // Code to display users in a RecyclerView goes here
    }
}

The fetchUsers() function makes a call to getUsers() from the ApiService. On success, we display the list of users in the UI.

3.2 Handle Network Security Config

To allow communication with your local backend, add a network_security_config.xml file in res/xml/.

<?xml version="1.0" encoding="utf-8"?>
<network-security-config>
    <domain-config cleartextTrafficPermitted="true">
        <domain includeSubdomains="true">localhost</domain>
    </domain-config>
</network-security-config>

Reference this in the AndroidManifest.xml:

<application
    android:networkSecurityConfig="@xml/network_security_config"
    ... >
</application>

This allows the Android emulator to communicate with your backend using HTTP.

Step 4: Display Data in RecyclerView

Now, we will display the fetched users using a RecyclerView. In activity_main.xml, set up a simple layout:

<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <RecyclerView
        android:id="@+id/recyclerView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_margin="16dp"/>
</LinearLayout>

In MainActivity, add the logic to bind the data to a RecyclerView. Create an Adapter to display the list of users.

class UserAdapter(private val userList: List<User>) : RecyclerView.Adapter<UserAdapter.UserViewHolder>() {

    class UserViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
        val nameTextView: TextView = itemView.findViewById(R.id.nameTextView)
        val emailTextView: TextView = itemView.findViewById(R.id.emailTextView)
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): UserViewHolder {
        val view = LayoutInflater.from(parent.context).inflate(R.layout.user_item, parent, false)
        return UserViewHolder(view)
    }

    override fun onBindViewHolder(holder: UserViewHolder, position: Int) {
        val user = userList[position]
        holder.nameTextView.text = user.name
        holder.emailTextView.text = user.email
    }

    override fun getItemCount(): Int = userList.size
}

In MainActivity, bind the RecyclerView with the UserAdapter:

private fun displayUsers(users: List<User>) {
    val recyclerView = findViewById<RecyclerView>(R.id.recyclerView)
    recyclerView.layoutManager = LinearLayoutManager(this)
    recyclerView.adapter = UserAdapter(users)
}

Now, when you run the app, you should be able to see the user data fetched from the backend displayed in a RecyclerView!

Running App:

First of all, run your Node Js Backend as at the ending of tutorial and make sure it is listening at your localhost:3001 . Go to http://localhost:3001/users in browser to make sure you recieve response from backend.

Now run the kotlin app and you will see:

So, the app recieved data from NodeJs Backend…

By following these steps, you’ve created a simple yet powerful Android application that communicates with an external API. You can extend this by adding more functionality such as creating, updating, or deleting users.

Github:

GitHub - ardasenbaklavaci/Android-NodeJs-Api-Tutorial-Retrofit: Tutorial to consume NodeJs backend api in Android Kotlin

This tutorial is perfect for developers looking to bridge the gap between frontend and backend technologies, while also learning how to connect to relational databases like MySQL.

• Setting up a MySQL database and table.
• Building the backend API using Node.js and Express.
• Connecting the backend to a React frontend.
• Making HTTP requests with Axios to interact with the MySQL database.
• Handling both GET and POST requests for fetching and adding data.

So lets start…

First of all, lets create our sample database for this project in MySQL and insert sample data… MySQL suits best for this project because you will not have to mess with TCP/IP Settings (as you need to do in MSSQL)…

create database demo;

CREATE TABLE Users (
    Id INT AUTO_INCREMENT PRIMARY KEY,
    Name NVARCHAR(100) NOT NULL,
    Email NVARCHAR(100) NOT NULL
);
INSERT INTO Users (Name, Email) VALUES ('John Doe', 'john.doe@example.com');
INSERT INTO Users (Name, Email) VALUES ('Jane Smith', 'jane.smith@example.com');
INSERT INTO Users (Name, Email) VALUES ('Alice Johnson', 'alice.johnson@example.com');

Prerequisites

1. Node.js and npm: Install from Node.js official website. Node js is required for backend side…
2. SQL Database: Install MySQL, PostgreSQL, or any SQL database of your choice. We will use MySQL in this tutorial…
3. Basic understanding: Familiarity with JavaScript, React, SQL, and basic backend development.

1:Set Up Backend

1. Create a new backend project:

mkdir react-sql-backend
cd react-sql-backend
npm init -y

2. Install necessary packages:

npm install express mysql2 cors body-parser

• express: A web framework for Node.js.
• mysql2: A MySQL client for Node.js.
• cors: Middleware to enable Cross-Origin Resource Sharing.
• body-parser: Middleware to parse incoming request bodies.

3. Create an index.js file for the backend:

const express = require('express');
const mysql = require('mysql2');
const cors = require('cors');
const bodyParser = require('body-parser');

const app = express();
app.use(cors());
app.use(bodyParser.json());

// MySQL Database Connection
const db = mysql.createConnection({
  host: 'localhost',
  user: 'root',
  password: 'password',
  database: 'your_database_name'
});

db.connect((err) => {
  if (err) {
    console.error('Database connection failed:', err.stack);
    return;
  }
  console.log('Connected to MySQL database.');
});

// API Endpoint Example: Fetch Users
app.get('/users', (req, res) => {
  db.query('SELECT * FROM users', (err, results) => {
    if (err) {
      res.status(500).send(err);
    } else {
      res.json(results);
    }
  });
});

// API Endpoint Example: Add a New User
app.post('/users', (req, res) => {
  const { name, email } = req.body;
  db.query('INSERT INTO users (name, email) VALUES (?, ?)', [name, email], (err, results) => {
    if (err) {
      res.status(500).send(err);
    } else {
      res.json({ id: results.insertId, name, email });
    }
  });
});

const PORT = 3001;
app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

Dont forget to change user, password and database for your project…

4. Run the backend server:

node index.js

When you recieved the log ‘Connected to MySQL database.’ at Terminal Console, this means your backend is working… Also you can debug your errors here…

So now backend pipe is streaming at http://localhost:3001 . Do not turn off this terminal since it streams backend to your localhost…

Step 2: Set Up the React Frontend

1. Create a new React project:

npx create-react-app react-sql-frontend
cd react-sql-frontend

2. Install Axios for making HTTP requests:

npm install axios

3. Create a component to fetch and display data:

Create a new file Users.js in the src folder:

import React, { useEffect, useState } from 'react';
import axios from 'axios';

const Users = () => {
  const [users, setUsers] = useState([]);

  useEffect(() => {
    axios.get('http://localhost:3001/users')
      .then(response => {
        setUsers(response.data);
      })
      .catch(error => {
        console.error('There was an error fetching the users!', error);
      });
  }, []);

  return (
    <div>
      <h1>Users List</h1>
      <ul>
        {users.map(user => (
          <li key={user.id}>{user.name} - {user.email}</li>
        ))}
      </ul>
    </div>
  );
};

export default Users;

4. Use the Users component in App.js:

import React from 'react';
import Users from './Users';

function App() {
  return (
    <div className="App">
      <Users />
    </div>
  );
}

export default App;

5. Run the React application:

npm start

Step 3: Testing the Application

• Open your browser and navigate to http://localhost:3000.
• You should see a list of users fetched from your SQL database.

Step 4: Adding New Users

To add a form to insert new users:

1. Update the Users.js component:

import React, { useEffect, useState } from 'react';
import axios from 'axios';

const Users = () => {
  const [users, setUsers] = useState([]);
  const [name, setName] = useState('');
  const [email, setEmail] = useState('');

  useEffect(() => {
    fetchUsers();
  }, []);

  const fetchUsers = () => {
    axios.get('http://localhost:3001/users')
      .then(response => {
        setUsers(response.data);
      })
      .catch(error => {
        console.error('There was an error fetching the users!', error);
      });
  };

  const handleAddUser = () => {
    axios.post('http://localhost:3001/users', { name, email })
      .then(response => {
        setUsers([...users, response.data]);
        setName('');
        setEmail('');
      })
      .catch(error => {
        console.error('There was an error adding the user!', error);
      });
  };

  return (
    <div>
      <h1>Users List</h1>
      <ul>
        {users.map(user => (
          <li key={user.id}>{user.name} - {user.email}</li>
        ))}
      </ul>

      <h2>Add New User</h2>
      <input
        type="text"
        placeholder="Name"
        value={name}
        onChange={e => setName(e.target.value)}
      />
      <input
        type="email"
        placeholder="Email"
        value={email}
        onChange={e => setEmail(e.target.value)}
      />
      <button onClick={handleAddUser}>Add User</button>
    </div>
  );
};

export default Users;

Enhancements

• Validation: Add client-side and server-side validation for better data handling.
• Error Handling: Improve error handling for network errors or database issues.
• State Management: Consider using a state management library like Redux for larger applications.

After starting the app (frontend side), you will see the names and email adresses returned from SQL (Backend) which is GET Method.

Also you can post new name and email couple with POST Method called from Backend…

Github Links:

Backend:

GitHub - ardasenbaklavaci/React-SQL-Tutorial-Backend: React SQL Tutorial Backend Side

Frontend:

GitHub - ardasenbaklavaci/React-SQL-Tutorial-Frontend: React SQL Tutorial Frontend Side

Shortly, EfCorePowerTools let you implement API directly from SQL Server and consume it from .NET Core…

To successfully reverse engineer a .NET Core API from an SQL database using EF Core Power Tools, you’ll need to install several NuGet packages. These packages facilitate the development of the API and enable smooth interactions with your SQL database.

Required NuGet Packages:

1. Microsoft.EntityFrameworkCore

Purpose: This is the core package for EF Core, providing the essential functionalities for ORM (Object-Relational Mapping).

dotnet add package Microsoft.EntityFrameworkCore

2. Microsoft.EntityFrameworkCore.SqlServer

Purpose: This package is required to use SQL Server as your database provider with EF Core.

dotnet add package Microsoft.EntityFrameworkCore.SqlServer

Note: If you’re using a different database, you should install the corresponding provider package, such as:

• Microsoft.EntityFrameworkCore.Sqlite for SQLite
• Npgsql.EntityFrameworkCore.PostgreSQL for PostgreSQL
• Pomelo.EntityFrameworkCore.MySql for MySQL

3. Microsoft.EntityFrameworkCore.Design

Purpose: This package provides tools for EF Core design-time services like scaffolding and migrations. It is essential for reverse engineering and generating EF Core models from an existing database.

dotnet add package Microsoft.EntityFrameworkCore.Design

4. Microsoft.EntityFrameworkCore.Tools

Purpose: Provides command-line tools for EF Core operations, such as database migrations and reverse engineering. These tools can be used in Visual Studio’s Package Manager Console or via the .NET CLI.

dotnet add package Microsoft.EntityFrameworkCore.Tools

5. Microsoft.Extensions.Logging.Console

Purpose: This package enables console logging for EF Core operations, which is helpful for debugging and monitoring SQL queries and other activities.

dotnet add package Microsoft.Extensions.Logging.Console

Summary of Installation Commands

For convenience, here’s a summary of the CLI commands to install the necessary packages:

dotnet add package Microsoft.EntityFrameworkCore dotnet add package Microsoft.EntityFrameworkCore.SqlServer dotnet add package Microsoft.EntityFrameworkCore.Design dotnet add package Microsoft.EntityFrameworkCore.Tools dotnet add package Microsoft.Extensions.Logging.Console

Start:

After opening the project, we will have this project solution explorer hierarchy… We will have our sample class for this project, WeatherForecast.cs class. And a sample Controller WeatherForecastController.cs, lets keep theese for reference…

When we launch this project, we will have the sample WeatherForecast API Implemented… Running at Swagger UI Interface.

And lets execute this…

We can see our GET operation returned all data… With status of 200 (Succesfull). This number indicates the result status for debugging.

After making sure Swagger UI is working with sample data of project, now Lets create our sample database table and insert sample data’s… Here is query for our sample database, we will use MSSQL…

-- Create the Books table
CREATE TABLE Books (
    Id INT PRIMARY KEY IDENTITY(1,1),
    Title VARCHAR(255) NOT NULL,
    Author VARCHAR(255) NOT NULL,
    PublishedYear INT NOT NULL,
    Genre VARCHAR(100),
    Price DECIMAL(10, 2)
);

-- Insert sample data into the Books table
INSERT INTO Books (Title, Author, PublishedYear, Genre, Price) VALUES
('The Great Gatsby', 'F. Scott Fitzgerald', 1925, 'Classic', 10.99),
('To Kill a Mockingbird', 'Harper Lee', 1960, 'Classic', 7.99),
('1984', 'George Orwell', 1949, 'Dystopian', 8.99),
('Pride and Prejudice', 'Jane Austen', 1813, 'Romance', 5.99),
('The Catcher in the Rye', 'J.D. Salinger', 1951, 'Classic', 6.99),
('Moby Dick', 'Herman Melville', 1851, 'Adventure', 12.50),
('War and Peace', 'Leo Tolstoy', 1869, 'Historical', 14.99),
('The Hobbit', 'J.R.R. Tolkien', 1937, 'Fantasy', 11.99),
('The Road', 'Cormac McCarthy', 2006, 'Post-Apocalyptic', 9.99),
('The Da Vinci Code', 'Dan Brown', 2003, 'Thriller', 7.50);

Now go to your appsettings.json… Add your connection string:

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=your_server_name;Database=your_database_name;User Id=your_username;Password=your_password;"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}

Now right click on your project (Not Solution!!!) and extend EF Core Power Tools…

And select Reverse Engineer…

Now lets make connection with SQL Server to scaffold.

Click on Add… and select Add Database Connection…

Here you can gather your Machine’s SQL Servers… Right now my EfCore can not sniff local MS SQL Servers (have a look at TCP Connections etc…) so lets have custom connection with connection string…

From VS SQL Server Object Explorer, select your database and get your Connection String. My Connection String worked with EFCore by getting theese parts:

Data Source=DESKTOP-2ED7HUR;Initial Catalog=apiProj;Integrated Security=True;Encrypt=False;Trust Server Certificate=False;

Name your SQL Server Connection String and hit OK.

Now select your Connection String and EF Core Version, and hit OK.

Now you can see your database entities sniffed from your SQL Server… You can reverse engineer Tables, Stored Procedures (if available) to consume.

Now you will create your DataContext to consume database… First of all it will create models from your database and then it will generate DataContext to consume your data, stored procedures…

So we generated our Book Model from database directly, and apiProjContext (Datacontext class) to consume the database.

// <auto-generated> This file has been auto generated by EF Core Power Tools. </auto-generated>
#nullable disable
using System;
using System.Collections.Generic;

namespace WebApplication6.Models;

public partial class Book
{
    public int Id { get; set; }

    public string Title { get; set; }

    public string Author { get; set; }

    public int PublishedYear { get; set; }

    public string Genre { get; set; }

    public decimal? Price { get; set; }
}

EFCore generated Book class from database…

// <auto-generated> This file has been auto generated by EF Core Power Tools. </auto-generated>
#nullable disable
using System;
using System.Collections.Generic;
using Microsoft.EntityFrameworkCore;

namespace WebApplication6.Models;

public partial class apiProjContext : DbContext
{
    public apiProjContext(DbContextOptions<apiProjContext> options)
        : base(options)
    {
    }

    public virtual DbSet<Book> Books { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Book>(entity =>
        {
            entity.HasKey(e => e.Id).HasName("PK__Books__3214EC075694FD1D");

            entity.Property(e => e.Author)
                .IsRequired()
                .HasMaxLength(255)
                .IsUnicode(false);
            entity.Property(e => e.Genre)
                .HasMaxLength(100)
                .IsUnicode(false);
            entity.Property(e => e.Price).HasColumnType("decimal(10, 2)");
            entity.Property(e => e.Title)
                .IsRequired()
                .HasMaxLength(255)
                .IsUnicode(false);
        });

        OnModelCreatingPartial(modelBuilder);
    }

    partial void OnModelCreatingPartial(ModelBuilder modelBuilder);
}

And our DataContext…

Now lets create our Controller class to directly consume our API from Swagger UI and Postman (Later…)

Click on Add -> Controller…

Select API insted of MVC…

And API Controller-Empty… Name it BookController.cs

So it created our Controller with ControllerBase…

using WebApplication6.Models;

Import your DbContext directory and type your DataContext…

public class BookController : ControllerBase
{
    apiProjContext dbContext;
}

Make your constructor…

[Route("api/[controller]")]
[ApiController]
public class BookController : ControllerBase
{
    apiProjContext dbContext;

    BookController(apiProjContext _dbContext)
    {
        this.dbContext = _dbContext;
    }
}

Now lets make our Get All books implementation.

  // GET: api/Book
  [HttpGet]
  public async Task<ActionResult<IEnumerable<Book>>> GetBooks()
  {
      return await _context.Books.ToListAsync();
  }

This will return List of all Books… By adding list’s where attribute, we can have get book by id Implementation…

[HttpGet("{id}")]
public async Task<ActionResult<Book>> GetBook(int id)
{
    var book = await _context.Books
                             .Where(b => b.Id == id)
                             .FirstOrDefaultAsync();

    if (book == null)
    {
        return NotFound();
    }

    return book;
}

Also you can do this with:

    [HttpGet("{id}")]
    public async Task<ActionResult<Book>> GetBook(int id)
    {
      var book = await _context.Books.FindAsync(id);

      if (book == null)
      {
        return NotFound();
      }

      return book;
    }

Final code of the controller:

using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using WebApplication6.Models;

namespace WebApplication6.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class BookController : ControllerBase
    {
        private readonly apiProjContext _context;

        // Constructor with the required DbContext parameter
        public BookController(apiProjContext context)
        {
            _context = context;
        }

        // GET: api/Book
        [HttpGet]
        public async Task<ActionResult<IEnumerable<Book>>> GetBooks()
        {
            return await _context.Books.ToListAsync();
        }

        // GET: api/Book/5
        [HttpGet("{id}")]
        public async Task<ActionResult<Book>> GetBook(int id)
        {
            var book = await _context.Books
                                     .Where(b => b.Id == id)
                                     .FirstOrDefaultAsync();

            if (book == null)
            {
                return NotFound();
            }

            return book;
        }
    }
}

You can directly FindAsync with id…

If you get ModelBuilder error, Install: If this error exist…

Finally, in program.cs , add :

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.

// Configure the database context with SQL Server.
// Replace "YourConnectionString" with your actual connection string.
builder.Services.AddDbContext<apiProjContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

// Add controllers service
builder.Services.AddControllers();

To connect your SQL Connection String and DataContext to API.

Now launch the app:

We got the API’s implemented at Controller.

And all books have returned to Interface…