Create Database yourDb
USE [yourDb]
CREATE TABLE [dbo].[products]
  (
     [productrowid] [INT] IDENTITY(1, 1) NOT NULL,
     [productid]    [VARCHAR](20) NOT NULL,
     [productname]  [VARCHAR](200) NOT NULL,
     [categoryname] [VARCHAR](200) NOT NULL,
     [manufacturer] [VARCHAR](200) NOT NULL,
     [price]        [INT] NOT NULL,
     PRIMARY KEY CLUSTERED ( [productrowid] ASC )WITH (pad_index = OFF,
     statistics_norecompute = OFF, ignore_dup_key = OFF, allow_row_locks = on,
     allow_page_locks = on, optimize_for_sequential_key = OFF) ON [PRIMARY],
     UNIQUE NONCLUSTERED ( [productid] ASC )WITH (pad_index = OFF,
     statistics_norecompute = OFF, ignore_dup_key = OFF, allow_row_locks = on,
     allow_page_locks = on, optimize_for_sequential_key = OFF) ON [PRIMARY]
  )
ON [PRIMARY]
go

package products;
service ProductsService {
    rpc GetAll(Empty) returns(Products);
    rpc GetById(ProductRowIdFilter) returns(Product);
    rpc Post(Product) returns(Product);
    rpc Put(Product) returns(Product);
    rpc Delete(ProductRowIdFilter) returns(Empty);
}
message Empty {}
message Product {
    int32 ProductRowId = 1;
    string ProductId = 2;
    string ProductName = 3;
    string CategoryName = 4;
    string Manufacturer = 5;
    int32 Price = 6;
}
message ProductRowIdFilter {
    int32 productRowId = 1;
}
message Products {
    repeated Product items = 1;
}

using Grpc.Core;
using GrpcService;
using GrpcService.Models;
using System.Linq;
using System.Threading.Tasks;
using static GrpcService.ProductsService;
namespace GrpcService.Services {
    public class ProductsAppService: ProductsServiceBase {
        public BlazorContext dbContext;
        public ProductsAppService(BlazorContext DBContext) {
            dbContext = DBContext;
        }
        #region GetAll
        public override Task < Products > GetAll(Empty request, ServerCallContext context) {
            Products response = new Products();
            var products = from prd in dbContext.Products
            select new Product() {
                ProductRowId = prd.ProductRowId,
                    ProductId = prd.ProductId,
                    ProductName = prd.ProductName,
                    CategoryName = prd.CategoryName,
                    Manufacturer = prd.Manufacturer,
                    Price = prd.Price
            };
            response.Items.AddRange(products.ToArray());
            return Task.FromResult(response);
        }
        #endregion
        #region GetById
        public override Task < Product > GetById(ProductRowIdFilter request, ServerCallContext context) {
            var product = dbContext.Products.Find(request.ProductRowId);
            var searchedProduct = new Product() {
                ProductRowId = product.ProductRowId,
                    ProductId = product.ProductId,
                    ProductName = product.ProductName,
                    CategoryName = product.CategoryName,
                    Manufacturer = product.Manufacturer,
                    Price = product.Price
            };
            return Task.FromResult(searchedProduct);
        }
        #endregion
        #region PostInsert
        public override Task < Product > Post(Product request, ServerCallContext context) {
            var prdAdded = new Models.Product() {
                ProductId = request.ProductId,
                    ProductName = request.ProductName,
                    CategoryName = request.CategoryName,
                    Manufacturer = request.Manufacturer,
                    Price = request.Price
            };
            var res = dbContext.Products.Add(prdAdded);
            dbContext.SaveChanges();
            var response = new Product() {
                ProductRowId = res.Entity.ProductRowId,
                    ProductId = res.Entity.ProductId,
                    ProductName = res.Entity.ProductName,
                    CategoryName = res.Entity.CategoryName,
                    Manufacturer = res.Entity.Manufacturer,
                    Price = res.Entity.Price
            };
            return Task.FromResult < Product > (response);
        }
        #endregion
        #region PUTUPDATE
        public override Task < Product > Put(Product request, ServerCallContext context) {
            Models.Product prd = dbContext.Products.Find(request.ProductRowId);
            if (prd == null) {
                return Task.FromResult < Product > (null);
            }
            prd.ProductRowId = request.ProductRowId;
            prd.ProductId = request.ProductId;
            prd.ProductName = request.ProductName;
            prd.CategoryName = request.CategoryName;
            prd.Manufacturer = request.Manufacturer;
            prd.Price = request.Price;
            dbContext.Products.Update(prd);
            dbContext.SaveChanges();
            return Task.FromResult < Product > (new Product() {
                ProductRowId = prd.ProductRowId,
                    ProductId = prd.ProductId,
                    ProductName = prd.ProductName,
                    CategoryName = prd.CategoryName,
                    Manufacturer = prd.Manufacturer,
                    Price = prd.Price
            });
        }
        #endregion
        #region DELETE
        public override Task < Empty > Delete(ProductRowIdFilter request, ServerCallContext context) {
            Models.Product prd = dbContext.Products.Find(request.ProductRowId);
            if (prd == null) {
                return Task.FromResult < Empty > (null);
            }
            dbContext.Products.Remove(prd);
            dbContext.SaveChanges();
            return Task.FromResult < Empty > (new Empty());
        }
        #endregion
    }
}

using GrpcService.Models;
using GrpcService.Services;
using Microsoft.EntityFrameworkCore;
using System;
var builder = WebApplication.CreateBuilder(args);
// Additional configuration is required to successfully run gRPC on macOS.
// For instructions on how to configure Kestrel and gRPC clients on macOS, visit https://go.microsoft.com/fwlink/?linkid=2099682
// Add services to the container.
builder.Services.AddGrpc();
builder.Services.AddDbContext < BlazorContext > (item => item.UseSqlServer(builder.Configuration.GetConnectionString("AppDbContext")));
builder.Services.AddCors(options => {
    options.AddPolicy("cors", policy => {
        policy.AllowAnyMethod().AllowAnyHeader().AllowAnyOrigin().WithExposedHeaders("Grpc-Status", "Grpc-Message", "Grpc-Encoding", "Grpc-Accept-Encoding");
    });
});
var app = builder.Build();
// Configure the HTTP request pipeline.
app.MapGrpcService < GreeterService > ();
app.MapGrpcService < ProductsAppService > ();
app.MapGet("/", () => "Communication with gRPC endpoints must be made through a gRPC client. To learn how to create a client, visit: https://go.microsoft.com/fwlink/?linkid=2086909");
app.Run();