gRPC [C#] Master Class: Build Modern API & Microservices

Explore protocol buffers as the gRPC cornerstone, defining messages and services and generating code for languages. See how binary protobufs deliver smaller payloads and lower CPU usage for interoperability.

Compare HTTP/2 to HTTP 1.1, showing a single long-lived TCP connection, header compression, multiplexing, and server push, with Gypsy and protocol buffers delivering binary, SSL-secured API calls.

Explore the four types of gRPC APIs—unary, server streaming, client streaming, and bidirectional streaming—enabled by HTTP/2 and protocol buffers. Learn how each type supports updates and multiple requests, guiding implementation.

Explore how gRPC scales on the server with asynchronous processing, enabling parallel requests, and learn when to use asynchronous versus synchronous client responses.

Understand how schema-based serialization contributes to security via binary data, SSL encryption, and TLS connections for gRPC, with interceptors for authentication to APIs.

Compare gRPC and rest, weighing protocol buffers against json. Explore http/2 vs http/1, streaming, and bidirectional communication to guide api design choices for better performance and security.

Define APIs with protocol buffers and let code generation produce client and server code; GRPC adds TLS and authentication interceptors, supports client, service, and bidirectional streaming, and Gypsy defines APIs.

Install Visual Studio Community, set up a .NET console project with client and server, add gRPC and protobuf packages, configure csproj for proto generation, and build succeeds.

Create a dummy.proto using proto three, defining a dummy message and dummy service to enable gRPC code generation in the client and server.

Set up a gRPC server boilerplate on localhost port 50051, start the server, and stop it with a key press, handling io exceptions and ensuring shutdown.

Create a gRPC client boilerplate in C#, connect to the local server at 127.0.0.1:50051, manage channel lifecycle, instantiate a dummy service client, and await a key press before shutting down.

Learn and implement a gRPC unary API call, where the client sends one request and the server returns one response, defined with protocol buffers as grid request and grid response.

Implement a unary rpc client to call the greeting service over a channel, sending a greet request and handling the server response, demonstrating client-server communication and end-to-end testing.

Implement a gRPC calculator service in C# that sums two numbers via a proto-defined rpc, builds a server on port 5052, and verifies a 3 + 10 result of 13.

Explore gRPC's server streaming API enabled by http/2, where the client sends one request and the server streams many responses. Use for big data and live feeds.

Define a server streaming greet many times API in gRPC using protocol buffers, with greet many times request/response and a response stream from the greeting service.

Implement a gRPC server streaming endpoint that returns ten greetings from the greet function. Log the request and write each greeting to the response stream with WriteAsync in a loop.

Implement the client for a server streaming gRPC call in C# and test it against the running server, iterating the response stream with await and printing each greeting.

Implement a gRPC prime number decomposition API in C# by defining a proto with request and streaming response messages, building a server and client, and validating factors on port 5052.

Explore client streaming in gRPC over http/2, sending many messages from client to server and receiving a single, potentially delayed response, ideal for big data uploads and expensive per-message processing.

Implement the server side of a client streaming long read RPC in the greeting service using an asynchronous loop over the request stream to build a multi-line long greet response.

Develop a gRPC C# solution where a client streams numbers to the compute average service, and the server returns the average using a proto definition with AverageRequest and AverageResponse.

Explore bidirectional streaming in gRPC over http/2, where both client and server independently stream messages to each other, enabling asynchronous, long-running data exchange such as a chat protocol.

Implement a bi-directional streaming greet everyone function in the greeting service, iterating the request stream with MoveNext, constructing 'Hello {first} {last}', logging results, and writing them to the response stream.

Implement a bidirectional streaming gRPC C# client that sends multiple greetings through the request stream and reads server responses from the response stream, demonstrating interactive client–server exchange.

Implement a gRPC [C#] bidirectional streaming API that streams numbers and returns the current maximum after each input, with proto definitions and server-client wiring.

Learn advanced gRPC error handling with a compact set of status codes, including cancelled, deadline exceeded, unavailable, unknown, unauthenticated, and internal, and use metadata for extra details in hands-on exercises.

Implement a unary gRPC API that computes the square root, define the proto with request and response messages, and handle invalid argument errors on both server and client sides.

Define and propagate deadlines for every gRPC call to bound RPC latency, cancel long-running work when the deadline expires, and keep microservices efficient across chained calls.

Learn to implement deadlines in gRPC by creating a greet with deadline RPC, building a proto with request and response, implementing server and client, and handling deadline exceeded errors.

Explore how ssl encryption secures grpc calls by default over http2, and how tls, certificate authorities, private keys, and trust roots enable the handshake.

Implement SSL/TLS for a gRPC C# API by creating a certificate authority, issuing server and client certificates, embedding them as resources, and enabling TLS for secure client–server calls.

Explore how gRPC enables language interoperability by using the same protocol buffer files across Go and C#. The demo shows unary and streaming RPCs across languages to prove cross-language communication.

Explore gRPC reflection and the Evans CLI to discover server APIs without a proto file, enabling interactive querying of services, messages, and RPCs.

learn to install Robo 3T (Mongo 3D), connect to a local MongoDB on port 27017, test the connection, and view the system database and collections in a visual GUI.

Set up the blog service by adding the MongoDB driver, creating blog.proto with the Blog message and an empty blog service, then generate C# code and build client and server.

Define and implement the create blog command in the gRPC c# server, using blog.proto, MongoDB to generate an ID, and register the blog service in program.cs.

Build and run a gRPC client to call the create blog command, define author, title, and content, and verify the new blog is stored in the server database.

Implement the read blog rpc in the gRPC [C#] master class, querying MongoDB by blog id (object id) and returning a read blog response or not found error.

Implement the update blog operation by sending an updated blog with id, author id, title, and content, replacing the MongoDB document, and returning the updated blog in the response.

Refine the gRPC client by adding an update blog flow: create a blog, modify its fields, call update blog, handle errors, and verify the updated blog in MongoDB.

Define the delete blog RPC in a gRPC C# server, implement delete by blog ID with MongoDB, and throw an RPC exception when deletion fails.

Implement a delete block client in a C# gRPC app, including a delete function in program.cs, RPC exception handling, and MongoDB deletion confirmation.

Implement a gRPC list blog RPC that streams blog entries from MongoDB using an empty ListBlogRequest and a ListBlogResponse containing a blog property, written asynchronously to the response stream.

Create a C# gRPC client to list blogs from MongoDB by implementing an async listBlog function that streams responses and prints each blog to the console.

Enable gRPC reflection on the server and use the events CLI to perform CRUD operations (create, read, update, list, delete) on a blog service, testing MongoDB-backed data.