3500 Final Cheat Sheet (DRAFT) by _allisonwalker

Databases
Networking (e.g., client­/server architecture)
Multi-­thr­eading
GUI
Logging

What is it?
Why should it be effective?
What can prevent it from being effective?

Read all docume­ntation
Assignment Specif­ica­tions
Microsoft Developer Documentation
etc.
Understand protocols and APIs
Networking object
Agario “Commands”
Develop toy programs to help you understand

Dec 1969
4 nodes in utah

DOMAIN NAME SYSTEM
DNS 🡪 Domain Name System Provides “IP Address”

“MAIL BOXES” ASSOCIATED WITH SPECIFIC PROGRAMS

For Query/­Res­ponse programs (e.g., a web server):
the server will use a specific low port that is “known” so anyone can make an initial connection
i.e., 80
Ongoing connec­tions will be moved to a different (high) port number
So that new clients can talk to server at the same time

Who decides number?
Some programs have official ports
Other programs have “taken” over ports
Some ports screen­ed/­blocked by firewalls!
Especially low ports under 1000

Client asks the Server for connec­tion.
A Socket is defined!

Agreed order and format of data for commun­ication

Runs on top of IP (Internet Protocol)
One to One Reliable Communication
Data will arrive
Verified Ordering
Verified Uncorr­upted
Does not verify when data arrives or how much arrives at a given time!
C# libraries do all the work for you

Happen at the BYTE level!!!!
Your program must
Translate useful data into bytes and
Translate bytes into useful data (e.g., strings, objects, etc)
TCP does not guarantee
When Inform­ation Goes Out
When Inform­ation Arrives
How much inform­ation is sent at any one time…
TCP does guarantee
order and validity

A SERVER DOES TWO THINGS:
“NETWORK STUFF” (E.G., HANDLE MULTIPLE CLIENT REQUESTS AND CONNECTIONS)
“APPLI­CATION STUFF” (E.G., MANAGES A GAME)

What I call an Event Loop
Server Process
Thread 1 : // Purpose 🡪 Await Connection
Start up code:
Build TCP listener
Wait for Connec­tion( event_­handler )
Function event_­han­dler()
Build new socket identi­fying client
Build new Thread to handle client
Wait for Connec­tion( event_­handler )

Async - tells the system that the code may “pause” and “return” later
Allows other threads to execute

Async methods should do “somet­hing” that may take a long time
E.g., DB lookup, network connec­tion, big comput­ation

Two Threads:
Client Accepting
Message Sending
All Shared Data (e.g., Client array) must be protected
E.g., Removing items from the list
Lock (this.client_array)
{
this.client_array.Remove(x)
}

Callbacks
This is how the network code commun­icates state to the “user” program
TcpClient/TcpListener objects
The main object you will be using
See Simple­Cha­t[C­lie­nt/­Ser­ver­]Tc­pClient code
ID
A unique identifier for the connection Settable (default → socket)

Working with another developer
Versioning, e.g., git usage
Iterating
Asking questions & Discussing

Rule 1: Don’t optimize until necessary
Rule 2: Optimize algorithm
Rule 3: Optimize the code that is being run the most
Use Profiling to define this code.

Proper Naming
variables/methods/classes/namespaces/etc.
Less is better­/Sm­aller is better
Divide and conquer
Don’t repeat code!
Delete code instead of add new code
Separate functionality
Code does one thing well (a SOLID principle)

Document
Describe high level intera­ctions of functi­ons­/cl­ass­es/etc in “header” comments
Describe tricky coding details using inline comments

Model View Contro­ller?
Why separate out these “parts”?
The smaller the code, the “closer” you are to it, the less likely there will be defects

Consistent Styles
I_Dont­_Ca­re_­If_­You­_Us­e_u­nde­rsc­ore­s_B­ut_­DoN­otM­ixW­ith­Cam­elCase
Also, keep consistent with capitalization
What tools do we have to assist us?

Requir­ement Gathering
Design­/Ar­chi­tecting
Implementation
Verification/Testing
Maintenance
Note: Nonlinear, increm­ental, “circular”

Apply computer programs to Analyze and Improve computer programming
Code Analysis Tools
Complexity Analysis - e.g., how many lines of code
Duplicate Code Analysis - e.g., could be refactored into methods
Style Guides - e.g., put spaces around parameters
Code Cleanup - e.g., remove unused using statements

Well understood and beneficial ways to effect­ively solve recurring problems
Two Examples:
Iterator
Null Object

In C#, we don’t have much control
Optimization is done by the runtime (JIT)
And partly by the CIL compiler
This is fine for most purposes
C# is not the language of choice for (super) high perfor­mance…

You could craft your own solution to save and retrieve data…
Or you could take advantage of decades of research
Performance
Availa­bility
Stability
Concurrent access
Backups
Interface
Shared/Remote Service
Don’t reinvent the wheel

Operations leave database in consistent state
E.g., cannot assign a “user” into a Roll (table) if the user does not exist

Results will not be lost
E.g., if the “building loses power” any committed data will be accurate upon restart. (Data saved to disk.)

SQL takes care of managing and EFFICI­ENTLY traver­sin­g/m­erging relationships!
SELECT Title
FROM Patrons
JOIN CheckedOut ON Patron­s.C­ardNum = Checke­dOu­t.C­ardNum
JOIN Inventory ON Checke­dOu­t.S­erial = Invent­ory.Serial
JOIN Titles ON Titles.ISBN = Invent­ory.ISBN
WHERE Patron­s.c­ardNum = 7

Interface for accessing a relational database
Get data
Set data
Change data

For our purposes this means:
The URL tells the server everything it needs to know in order to take an action.
Often this is specified as an API

C# is simple, readable and easy to use
C# is all about developer productivity
C# is very flexible and allows you to develop a big variety of systems.
Console applic­ations Desktop applic­ations (Windows Forms, WPF) Windows Services Web Services and Web applic­ations (ASP.NET Core, Blazor) Native Mobile Applic­ations (.NET MAUI) AI Applic­ations (ML.NET) Distri­buted and Cloud Applic­ations (Azure) Games (Unity) IoT applic­ations Reusable libraries
C# runs on a solid well-e­ngi­neered .NET runtime
C# has built-in design patterns and best practices

Your compiled code
Let’s take a look at the GUI Chat Client release folder
Logging dll
Communications dll
File Logger Dll
Etc., etc., etc.

When Deploying:
Almost always the DLL should be built in
RELEASE mode
More efficient - removes debug symbols
When Developing
Almost always the DLL should be built in
DEBUG mode
Allows debugger to interact with running program
In rare “why does it work on my machine but not when deployed” situat­ions, you can deploy DEBUG code and ATTACH to it!

Objects that need other objects to help do their job
Want to be able to use different objects without modifying source code:
Define functi­onality as an interface
Pass object in at constr­uction time (and save in class field)
Important: only works for classes that the “system” builds for you
E.g., you MAUI program MainPage!

Logs can be sent to one _or more_ of the following:
Console
Debug Display in Visual Studio
GUI
Files
Databases
Windows Event Log
Etc.

every little detail.. way too much inform­ati­on... turn this off most of the time
Stakeholder: Developer - Something really odd is going on…
Show me all the mouse X,Y values as the mouse traverses the screen

high level inform­ati­on... for example "when a client connec­ts"... use this to understand "­met­a-l­eve­l" of applic­ation
Stakeholder: Develo­per­/Site Admini­strator
Show me who logged into the system.

something has gone wrong and we didn't know how to (or didn't want to spend the time) to handle it
Stakeh­olders: Site Admini­str­ators, Project Lead, (Devel­oper)
Bank software cannot transfer to another bank

turn off messaging.
Reasons to do:
My code is perfect.
Disk space is very expensive.
(Note: neither of these are a reason to do this, nor are they true)

Position of mouse
_logge­r.L­ogT­race($ “{Mous­ePo­sit­ion}” );
Partial messages coming over internet
_logge­r.L­ogD­ebug( $”Data Receive: {data}” );
Information (or maybe just warning)
New Chat Client Connected
_logge­r.L­ogI­nfo­rma­tion( $” {name} connected from {ip_ad­dress}” );

Network commun­ica­tions come in “Async”
Handled on DIFFERENT threads
GUI work MUST BE DONE on the GUI thread
Solution:
Dispatcher.Dispatch( ( ) => { Messag­esA­ndS­tat­us.Text = $"Server Shutdo­wn!­" + Enviro­nme­nt.N­ew­Line; }

The Clients list is “shared” by all threads, thus becoming a Race Condition
How do we fix this?
Answer: locking!
Warning for Server: Don’t “hold on to” client list while doing lots of work (e.g., sending messages to all clients)
Copy client list (while locked)
Then iterate over the copied list!

GUI Server
Everything to do with storing multiple clients should be “abstr­acted” (i.e., put into a model class)
Everything to do with Networking should be put into the Networking class
Everything to do with the GUI should stay in the GUI class

What constr­uctor is used BEFORE data put in:
Default constr­uctor
What is serial­ized? Public properties
What is not serialized?
Fields, private properties
How do we change that?
Attributes (Metadata Tags)

[JsonConstructor]
Specify the specific constr­uctor to use
Constructor parameters must match names of Json Fields
[JsonInclude]
Force property to be part of the serial­ization
[JsonIgnore]
For property to not be part of the serialization
[JsonR­equire]
If field _not_ there then error

Point browser to a web server, e.g.,
http:/­/ww­w.w­ebp­age.com
Browser opens socket to address
Server accepts socket
Browser sends text:
“GET / HTTP/1.1” + stuff
Server replies with text:
“HTTP/1.1 200 OK …” + “<h­tml­>…<­/ht­ml>”
Server closes socket – every HTTP request uses a new connection

Just a string that follows the protocol, e.g.,
Header
[New Line]
Body

<!D­OCTYPE html>
<ht­ml>
<bo­dy>
<h1­>My First Headin­g</­h1>
<p>My first paragr­aph.</­p>
</body>
</h­tml>

CSS
Cascading Style Sheets
Send type: “text/css”
Makes things look nice