C# Tutorial
Learn C# Fast!
Have you wanted to learn a modern, fast, compiled language that is general-purpose and is used almost everywhere? That's C# for you! It's used in Unity, the web, webassembly, desktop applications, and plays well with C++ and C. There is no reason something can't be accomplished with C#!
After this tutorial, you should have enough C# knowledge to do most things.
Introduction
C# is a multi-paradigm language, it has object-oriented, and functional features. We will be focusing on the object-oriented part, because functions are math, and I didn't like that. Each C# file gets compiled. They either first get linked with other files, or they are compiled on the standalone, like this:
main.cs decl.cs --> main.exe
The compiler is usually called roslyn, or .NET Complier Platform
. Replit uses a compiler similar to it, but it targets mono, which is one way to run .exe
files on linux systems.
Conventions
All classes should LookLikeThis
. Notice the PascalCase.
All methods should AlsoLookLikeThis
, and this is the same for AllProperties
(more on these things later). All local variables should lookLikeThis
. Read more here.
Starting Program
Here is a starting boilerplate.
class MainClass { public static void Main(string[] args) { // code } }
// code
is a comment. Another type of comment is the multiline comment:
/* multi lines */
The entry point is in Main
, and this method must be public and static.
Syntax
If you know some C++, C# is super similar to it. Each program starts with a class. Classes are defined like this:
class Name { // ... more code ... }
Inside the brackets, you can add methods or properties. Methods and properties can either be static or instance methods. Another key feature is accessibility, which we will talk about later.
Methods look like this:
void Method() { // code }
The void
can also be replaced with other types as well. Types will be talked about later.
Instance methods can be used after creating a class, while static classes don't. Here is a short demo:
MyClass instance = new MyClass(); instance.InstanceMethod(); MyClass.StaticMethod();
Methods can be set static using the static
keyword.
Variables can be set using two ways. The first, you specify the type (the class name), and then you set the value. If you don't set a value, you'll get a CS0165
, where you are trying to use an unassigned local variable. Here are all the native types (they are represented by the computer and are not provided as abstractions by C#):
Type | Desc |
---|---|
int | An integer |
uint | An unsigned integer (always positive) |
long | An integer but its BIG (long) |
ulong | A BIG integer, it can be as big as 18,446,744,073,709,551,615 |
float | Represents a decimal, but only to 6-9 digits. |
double | Represents a decimal, but only to 15-17 digits. |
decimal | Represents a decimal, but only to 28-29 digits. |
char | A character, only one letter. |
string | A string represents some text, it contains multiple char s. |
bool | A boolean is either true or false |
You can also define your own custom types, through classes!
int a; a = 5; // good! int b; // bad! int c = 5; // good! var d = 5; // good! var e; // bad! All `var`-created variables must be immediately followed by a value.
You can also make variables constants. They are faster because they don't change, but clearly sometimes change is needed. All things should be set to constant by default, that is good practice.
const int a = 5;
Properties and Methods
Classes have properties and methods. These methods can be public and private. Public properties can be accessed by outside sources, while private properties can only be accessed from inside the class. Here is how you can tell what can access a private property.
class MyClass { private int a = 5; // accessible! } // inaccessible!
All properties and methods are private by default, but its best to be explicit about this.
Remember the static
from before? Now we can combine them!
class MyClass { private static void Method() {} }
The order is like this <private/public> <static> <returntype> <name>
. The accessor must come first.
Methods can also take in some input, like this:
class MyClass { private static void Method(int arg) {} }
They are called arguments.
Now, when you call functions, you call them like this:
Add(1, 2);
More on classes
We have talked syntax, but not how to use classes yet! Classes can be made an instance using something called the constructor.
class MyClass { public int MyProp; public MyClass() { MyProp = 5; } }
don't forget to use the public
keyword, or else it won't be able to be initialized!
As you can see, all the variables by default are exposed to the method scope, but sometimes there are clashes, and they are resolved with the this
keyword:
class MyClass { public int Prop; public MyClass(int Prop) { this.Prop = Prop; } }
The this
keyword refers to this instance.
Namespaces
Many functions, and many standard library functions are put inside namespaces. in replit, there is only one, it's called System
. Namespaces can include namespaces, and they can nest forever.
namespace MyNamespace { class MyClass { public static int a = 5; } } MyNamespace.MyClass.a; // 5
Do note that namespaces must only contain classes, you cannot treat it like a block.
You can also bring namespaces out. Something like this:
namespace A { namespace B { class C {} } }
You can do:
using A.B; C
Now C
is brought out to the global scope!
Enumerables
An easy way to represent things that can only take certain forms are enumerables. They are represented with the keyword enum
:
enum Users { Coder100, Coderbot100, RayhanADev, Others }
They can also have custom integer types, and implicitly they look like this:
enum Users { Coder100 = 0, Coderbot100 = 1, RayhanADev = 2, Others = 3 }
Do note you can not just interchangeably use this with the int
type! You will have to cast it.
Type Conversions
Types can change from one type to another, using two methods, either through methods and functions, or casting. Casting is more interesting and more common than through methods.
They look like this:
(type)(expression)
Remember enums from last time? You can cast them into ints, like this:
enum A { B, C } int val = (int)A.B;
Structs
Sometimes you don't want to use classes, and you want to use sturcts. This is mostly when you just want a data type that stores things. (In js, this is called and object) You can use a struct
for this.
struct MyStruct { public int A = 5; public int B; } MyStruct s = new MyStruct(); s.B = 3; // s.A = 5, s.B = 3
Confused what the difference is between structs and classes? Read this.
Stdlib
The standard library is very very very large. The most commonly used is System.Console
class.
using System; class MainClass { public static void Main(string[] args) { Console.WriteLine("Hi with a newline!"); Console.Write("Hi without a newline!"); } }
You can view the whole System
documentation here
Closing
That's it! C# is a really really big language, and these are the basics to help you get started with coding in C#! Hopefully it was helpful :)
hehe hi twin
||wer
arugula
thanks so much
sure, send repl @Bunnytoes
@Coder100 this is the forked version(no changes and I don't know who made it) https://replit.com/@Bunnytoes/calculator#main.cs
@Coder100 repl I sent was made by @dungeonmaster and I forked it
I'm a bit confused about how to run programs from separate files. How do I do this?

you can export some specific static method that you later call @MrPynap