Client-server architecture in Unity - Step-by-Step Execution

Concept Flow - Client-server architecture

Client sends request

↓

Server receives request

↓

Server processes request

↓

Server sends response

↓

Client receives response

↓

Client uses data

The client sends a request to the server, the server processes it and sends back a response, which the client then uses.

Execution Sample

Unity

using UnityEngine;
using System.Net.Sockets;

// Client sends message to server
TcpClient client = new TcpClient("127.0.0.1", 5500);
NetworkStream stream = client.GetStream();
byte[] data = System.Text.Encoding.ASCII.GetBytes("Hello Server");
stream.Write(data, 0, data.Length);

// Remember to close the stream and client after use
stream.Close();
client.Close();

This code shows a Unity client connecting to a server and sending a message.

Execution Table

Step	Action	Details	Result
1	Client creates TcpClient	Connects to 127.0.0.1:5500	Connection established
2	Client gets NetworkStream	Prepares to send data	Stream ready
3	Client encodes message	"Hello Server" to bytes	Byte array created
4	Client writes to stream	Sends bytes to server	Message sent
5	Server receives message	Reads bytes from stream	Message received
6	Server processes message	Interprets "Hello Server"	Ready to respond
7	Server sends response	Sends reply bytes	Response sent
8	Client reads response	Reads from stream	Response received
9	Client uses response	Displays or processes data	Interaction complete
10	Connection closed	Client or server closes connection	Communication ended

💡 Communication ends after client and server exchange messages and close connection.

Variable Tracker

Variable	Start	After Step 1	After Step 4	After Step 8	Final
client	null	TcpClient connected	TcpClient connected	TcpClient connected	Closed or disposed
stream	null	NetworkStream ready	NetworkStream ready	NetworkStream ready	Closed
data	null	null	Byte array with message	null	null
response	null	null	null	Byte array with server reply	Used or stored

Key Moments - 3 Insights

Why do we convert the message string to bytes before sending?

Network communication sends bytes, not strings. See execution_table step 3 where the string is encoded to bytes before sending.

What happens if the server is not running when the client tries to connect?

The client cannot establish a connection (step 1 fails). This stops communication early, so no stream or data is sent.

Why do we need to close the connection after communication?

To free resources and avoid hanging connections. See execution_table step 10 where connection is closed to end communication.

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of 'client' after step 1?

A Connection closed

B TcpClient connected

C null

D Byte array created

💡 Hint

Check variable_tracker row for 'client' after Step 1.

At which step does the client send the message bytes to the server?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at execution_table action descriptions for sending data.

If the client never closes the connection, what happens according to the flow?

A Resources remain used, connection hangs

B Server closes connection automatically

C Communication ends normally

D Client reconnects automatically

💡 Hint

Refer to key_moments about closing connection and execution_table step 10.

Concept Snapshot

Client-server architecture:
- Client sends requests to server
- Server processes and replies
- Communication uses network streams
- Messages sent as bytes
- Connections must be closed after use

Full Transcript

Client-server architecture means one program (client) asks another (server) for data or service. The client opens a connection to the server's address and port. It sends a message by converting text to bytes and writing to the network stream. The server reads the bytes, processes the request, and sends back a response. The client reads the response bytes and uses the data. Finally, both close the connection to free resources. This flow ensures clear communication between two programs over a network.

Practice

1. In Unity's client-server architecture, what is the main role of the client?

easy

A. Send requests to the server and receive responses

B. Store all game data permanently

C. Control the server hardware

D. Manage other clients directly

Solution

1. Step 1: Understand client role in client-server

   The client initiates communication by sending requests to the server.

2. Step 2: Understand server response

   The server processes requests and sends back responses to the client.

3. Final Answer:

   Send requests to the server and receive responses -> Option A

4. Quick Check:

   Client = Request sender [OK]

Hint: Clients always ask; servers always answer [OK]

Common Mistakes:

• Thinking client stores all data permanently
• Confusing client with server hardware control
• Assuming clients manage other clients

2. Which of the following is the correct way to create a TcpClient in Unity C#?

easy

A. TcpClient client = TcpClient("127.0.0.1", 8080);

B. TcpClient client = new TcpClient.connectTo("127.0.0.1", 8080);

C. TcpClient client = new TcpClient.connect("127.0.0.1", 8080);

D. TcpClient client = new TcpClient("127.0.0.1", 8080);

Solution

1. Step 1: Recall TcpClient constructor syntax

   In C#, creating a new TcpClient requires the 'new' keyword and constructor with IP and port.

2. Step 2: Check each option's syntax

   Only TcpClient client = new TcpClient("127.0.0.1", 8080); uses 'new TcpClient("127.0.0.1", 8080);' correctly.

3. Final Answer:

   TcpClient client = new TcpClient("127.0.0.1", 8080); -> Option D

4. Quick Check:

   Use 'new' keyword with constructor [OK]

Hint: Always use 'new' to create objects in C# [OK]

Common Mistakes:

• Omitting 'new' keyword
• Using incorrect method names like connect or connectTo
• Wrong constructor call syntax

3. What will the following Unity C# code output if the server sends back the string "Hello Client"?

using System;
using System.Net.Sockets;
using System.Text;

TcpClient client = new TcpClient("127.0.0.1", 9000);
NetworkStream stream = client.GetStream();
byte[] data = new byte[256];
int bytes = stream.Read(data, 0, data.Length);
string response = Encoding.ASCII.GetString(data, 0, bytes);
Console.WriteLine(response);

medium

A. System.Byte[]

B. Hello Client

C. null

D. Exception thrown

Solution

1. Step 1: Understand data reading from NetworkStream

   The code reads bytes from the stream into a byte array and counts bytes read.

2. Step 2: Convert bytes to string

   It converts the bytes read to a string using ASCII encoding, which matches the server's sent string.

3. Final Answer:

   Hello Client -> Option B

4. Quick Check:

   Read bytes + decode = server message [OK]

Hint: Decode bytes read from stream to get server message [OK]

Common Mistakes:

• Printing byte array directly instead of decoding
• Ignoring number of bytes read
• Assuming null if no data

4. Identify the error in this Unity C# client code snippet:

TcpClient client = new TcpClient();
client.Connect("192.168.1.10", 7000);
NetworkStream stream = client.GetStream();
byte[] message = Encoding.ASCII.GetBytes("Ping");
stream.Write(message, 0, message.Length);
stream.Close();
client.Close();

medium

A. Missing try-catch block for network exceptions

B. Calling stream.Close() before client.Close() causes error

C. TcpClient must be created with IP and port in constructor

D. No error; code is correct

Solution

1. Step 1: Review TcpClient creation and connection

   Creating TcpClient with default constructor and then calling Connect is valid.

2. Step 2: Check for error handling

   Network operations can fail; missing try-catch means exceptions are unhandled.

3. Final Answer:

   Missing try-catch block for network exceptions -> Option A

4. Quick Check:

   Always handle network exceptions [OK]

Hint: Always wrap network calls in try-catch [OK]

Common Mistakes:

• Assuming stream.Close() before client.Close() is wrong
• Thinking TcpClient must have IP in constructor
• Ignoring exception handling

5. You want to build a Unity client that connects to a server and sends a player's score only if it is above 1000. Which code snippet correctly implements this logic using TcpClient and NetworkStream?

hard

A. if(score > 1000) {
TcpClient client = new TcpClient("server.com");
NetworkStream stream = client.GetStream();
byte[] data = Encoding.ASCII.GetBytes(score.ToString());
stream.Write(data, 0, data.Length);
stream.Close();
client.Close();
}

B. TcpClient client = new TcpClient("server.com", 5000);
NetworkStream stream = client.GetStream();
if(score > 1000) {
byte[] data = Encoding.ASCII.GetBytes(score.ToString());
stream.Write(data, 0, data.Length);
}
stream.Close();
client.Close();

C. TcpClient client = new TcpClient();
if(score > 1000) {
client.Connect("server.com", 5000);
NetworkStream stream = client.GetStream();
byte[] data = Encoding.ASCII.GetBytes(score.ToString());
stream.Write(data, 0, data.Length);
stream.Close();
client.Close();
}

D. if(score > 1000) {
TcpClient client = new TcpClient();
client.Connect("server.com", 5000);
NetworkStream stream = client.GetStream();
byte[] data = Encoding.ASCII.GetBytes(score);
stream.Write(data, 0, data.Length);
stream.Close();
client.Close();
}

Solution

1. Step 1: Check conditional connection and sending

   TcpClient client = new TcpClient(); if(score > 1000) { client.Connect("server.com", 5000); NetworkStream stream = client.GetStream(); byte[] data = Encoding.ASCII.GetBytes(score.ToString()); stream.Write(data, 0, data.Length); stream.Close(); client.Close(); } creates TcpClient without parameters, connects only if score > 1000, then sends data.

2. Step 2: Verify data conversion and method calls

   Converts score to string before encoding to bytes, uses correct Connect() and stream methods.

3. Final Answer:

   new TcpClient(); client.Connect() inside if(score > 1000) -> Option C

4. Quick Check:

   Connect and send inside if condition [OK]

Hint: Connect and send only inside the if block [OK]

Common Mistakes:

• Sending data without converting score to string
• Connecting outside the if condition
• Using score directly as bytes without encoding