Backend C# .NET Build ( RestAPI & SignalR & gRPC ) MongoDB

Install git, a free, open source distributed version control system for Windows, by following the official installer steps and verifying with git --version and git bash.

Install the .NET SDK 8 from the official site, verify the installation, and confirm the LTS version before proceeding to upgrade to .NET 10.

Install Postman on your machine to test endpoints and services across gRPC, HTTP requests, RPC requests, WebSocket requests, and SignalR.

We start by outlining the project structure, separating the client and backend folders, then build a .NET web API with Swagger and test it via Swagger UI.

Builds the signup user endpoint by configuring controllers, a user service, and MongoDB settings, then exposes a post route to create and encrypt user data via Swagger.

Implement a sign-in endpoint in a C# .NET REST API, validating email and password, decoding the stored password, and returning a token with MongoDB-backed users.

Implement json web tokens (jwt) for user authentication in a dotnet backend, issuing a user-specific token at sign in or sign up, with claims, issuer, audience, and swagger support.

Update Swagger UI to pass JWT tokens via the authorization header, configure a security definition in OpenAPI, and test authorized endpoints using Postman.

toggle following endpoint at patch user/{id}/following; uses token to identify the current user, adds or removes the target from following and updates followers, with error handling.

Implement a delete user endpoint in a C# .NET REST API, including a deleteAsync service, filter-based id matching, authorization checks, and a 200 OK response when deletion succeeds.

Build and wire a post service for a C# .NET REST API with MongoDB, implementing create, update, get by id, delete, and a combined post and user search with pagination.

Define an authorized post endpoint in the post controller at /posts to create posts by validating the body, extracting the user id from the token, and returning the created post.

Create a getPost endpoint that returns a post by id with httpget at route /{id}, including null and not found checks, and test via Swagger UI.

Implement a comment-on-post endpoint in the post controller that accepts a post id and a comment body, validates the post, appends the comment, and updates the post.

Implement a pagination endpoint to retrieve a user's posts and their followings. Query by IDs using the post service, validate input, and return not found or bad request responses.

Build a secure update post endpoint in a C# .NET API using an HTTP patch, validating inputs, authorizing users by token, and updating posts via the post service.

Create chat endpoints and models in a MongoDB-backed backend, defining message and unreaded-messages collections, a message model, a chat interface, and a chat service wired into program.cs.

Build the chat service for the endpoint with MongoDB, creating unreaded messages, messages, and user collections, and implement send message with insert and unread count updates.

Build a chat service that retrieves the last eight messages between two users with number-based pagination, sender/receiver filters, sorting, and unread message retrieval plus mark as read.

Build the send message endpoint in a .NET chat controller, exposing a POST route that validates content, sender, and receiver, and uses mongodb to store messages.

Implement a get messages between two users endpoint in a .NET backend using MongoDB, with retrieval from newest to oldest messages and loading older messages as the user scrolls.

Develop a rest api endpoint to mark messages as read by updating the chat database for the main user and other user, resetting unread counts and returning a boolean success.

Create a notification model in a C# .NET backend using MongoDB, defining a notification class for the notifications collection with id, details, main user id, target id, isRead, createdAt.

Create a notification service as a singleton, wiring it in program.cs, using mongodb to insert, fetch by user id, and mark as read, with real-time gRPC support.

Implement backend-driven notifications by adding a notification service and triggering alerts when users follow, comment, or like, with details including user name, avatar, and ids.

Test the notification creation system by simulating follow, like, and comment events. Introduce endpoints to fetch notifications for a user and to mark them as read.

Build and test notification endpoints in a REST API using ASP.NET Core MVC, including a notification controller with get user notifications and mark as read.

Update version control by creating a new rest api branch in the GitHub repository, add and commit changes, push the branch, and open a pull request to merge with main.

Upgrade the backend app to .NET 10 LTS by installing the latest SDK, using the outdated tool to upgrade dependencies, updating the target framework, and validating the build and run.

Upgrade the backend by enriching comments with commenter details via aggregation, updating comment handling and post relations, and adding user post pagination and notification improvements.

Update models and create a comment model in MongoDB, update the settings, and implement a post response with aggregation that includes a comment with user details.

Update the post service to return a post object with user and comments via a MongoDB aggregation pipeline, enabling create, update, delete, and query operations.

Fix and update the post controller by refactoring to iPostService, handle unauthorized access, create comments on a separate collection, and prepare an endpoint for deleting comments.

Create an http delete endpoint to remove a comment by post id and comment id, authenticate via token, verify post creator, and delete through the post service.

Test and debug rest api endpoints by running the app, authenticating with a token, and creating posts and comments, while validating MongoDB responses and updates.

Update the user service to enable get user by ID and profile data with posts, using i-user-service, virtual methods, and controller wiring, then test the endpoint.

Fix the notification bug by introducing a sender ID, updating the post and user controllers to use sender ID for notifications, and validating updates across Ahmed and ISIL scenarios.

Update the GitHub repository and version control by committing changes, pushing updates, merging pull requests, pulling latest changes, and creating a new branch for signal or gRPC work.

Outline a real-time microservices approach with a notification service and chat service, using signal or WebSocket and gRPC for live updates like follows, likes, and comments.

Build an independent real-time notification service in a .NET web API and create a proto file to enable gRPC communication for notifications.

Implement gRPC with server reflection and a SignalR notification hub to join channels and push real-time notifications. Build a gRPC service to broadcast via WebSockets and test with Postman.

update program.cs to enable real-time notification with gRPC and SignalR, configure endpoints and CORS, map notification hub, and test via websocket on port 8080 and gRPC on 8090.

Install and configure gRPC for a real-time notification client in a .NET API, copy the proto files, add protobuf references, and build the client and server components for notification services.

Implement a gRPC-based real-time notification client in a .NET backend by configuring the service URL, creating the client and interface, and wiring send gRPC notification async with dependency injection.

Leverages gRPC to enable real-time notifications across REST API endpoints, integrating a real-time notification client into post and user controllers to send gRPC notifications on new posts, comments, and follows.

Define a chat proto inside the back-end API to enable real-time chat, making the REST API handle real-time messages and operate as both client and service.

Implement a real-time chat gRPC service that saves messages to the database and retrieves a user's followers and following. Wire up the API and the real-time chat microservice scaffolding.

Test gRPC server methods for a real-time chat service by configuring endpoints, enabling server reflection, and validating message flow from sender to db.

Develop a real-time chat client by implementing gRPC methods to get user IDs and send messages, configuring a real-time chat service and building the project.

Build a chat service for real-time communication, implementing send and save message to database, manage users and rooms, and add and get user rooms for the chat hub.

Extend the chat service by adding methods to list online users, get user rooms, and map user IDs to connection IDs, while integrating SignalR and gRPC in the program setup.

Create a chat hub in a real-time app using SignalR, wire a chat-service, manage user connections and room memberships, and display online users to peers.

Add missing chat hub methods to support private messages, compute unique private group names, manage group joins, broadcast messages, save chats to the database, and wire the hub into program.cs.

Create batch launcher to auto-run all backend microservices, including the API on port 5000, real-time chart on 8000, and real-time notification on 8080, with a tester file for frontend integration.

Test the real-time chat microservice by simulating user connections, verifying online notifications between Ahmed, Aisul, and Mia, and ensuring immediate message delivery and updates.