---
title: "C# Syntax"
url: https://weworkworldwide.com/tutorials/c-syntax-2/
description: "C# has many nitty gritty details and throughout this tutorial we will explain them one by one. But before that, we need to get a general sense on how a C#"
date: 2026-05-07T22:32:25+00:00
source: https://weworkworldwide.com/llms.txt
---

# C# Syntax

C# has many nitty gritty details and throughout this tutorial we will explain them one by one. But before that, we need to get a general sense on how a C# program looks like.

So in this section we will give a general view about the syntax of a C# program.

Take a look at the example below:

``` line-numbers
using System;
```

namespace quickExample

``` line-numbers
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
}
}
}
```

If we compile and run this example, we will see the message “Hello World” on the screen.

The first line of this example is `using System;`:

First of all this is called a **statement**. Statements have different forms but they all end with semicolon `;`. If you ignore the semicolon, you’ll get an error and your program won’t compile and run correctly.

Alright, now let’s see what this statement does:

In programming languages like C# we mostly work with prebuilt packages and functionalities. For example if we want to send a message to the console, we can use the `Console.WriteLine` (explained in a moment).

By default these packages and functionalities are not part of the program that we’re working on. Basically we need to manually import any of them that might be needed the program.

This is where the `using` keyword comes in.

In the `using System;` statement, we’re basically telling the C# engine that we need and want to `USE` the `System` package (AKA namespace) in our program.

Inside this namespace there are many prebuilt class and functions that can be used in a program. For example, to send a message to the console we use the `Console.WriteLine`. Now guess where this `Console` class is coming from? Well it is the `System` namespace.

So by invoking the `System` namespace, we’re making this namespace as part of our program and will be able to use its prebuilt members whenever they’re needed.

The next line in our program is:

``` line-numbers
namespace quickExample{…}
```

Starting with the keyword `namespace`:

This keyword is used to create a new namespace in a program.

A program can grow fast and become multiplex. For example part of a program might be in charge of controlling the communication with the data base, another part might be in charge of user interface etc. and we can’t put all these parts in one place! Well, technically we can but then the maintenance can easily become a nightmare! For this reason we use namespaces to separate parts of a program from each other and essentially organize them better.

So here with the help of `namespace` keyword we’ve created a new namespace with the name `quickExample`.

Basically first comes the `namespace` keyword and followed by that is a white space and after that is the name of the namespace that we want to add.

The pair of braces `{}` that comes after the name of the namespace declare the body of that namespace. Anything that we declare in this body belongs to the target namespace.

Now if in the future, this namespace was needed in another program, we can use the `using` keyword and the name of the namespace to invoke it in the target program.

Note: in the *namespace* and *the using keyword* sections we will explain the concept of namespace in greater details.

The next line in our program is:

``` line-numbers
class Program{…}
```

C# is object oriented. This means anything in a C# program is treated as object (There are exceptions to this as well which you’ll see in later sections). But before an object can be created in a program it first needs to have a blueprint or a map (just like real world objects like cars, houses etc. that need to have blueprints before they’re built).

In C# the blueprint of an object is called class! Whenever we want to create an object, first we build (or use a prebuilt) class and create objects from that class.

So here in the ` class Program{…}` we’ve basically created a class with the name `Program`.

The keyword `class` always comes before the name of that class. Also we use a pair of braces `{}` to define the body of the target class. So anything between the open brace `{` and the closing brace `}` of the `Program` class belongs to this class.

The next line in this program is:

``` line-numbers
static void Main(string[] args){…}
```

This is called `method` or sometimes people call it `function` as well.

What is a method and what is does?

Well a method is the place where we define the functionalities of a program. There can be one or many methods in a program and each in charge of doing part of a total work of that program.

For example we might have a calculator program. In this program there might be multiple methods:

-   One in charge of addition process.

-   One in charge of subtraction process.

-   Another one for multiplication and so on…

Again, in short, a method is the place where we define a set of instructions to be executed whenever that method is called.

Methods have name. The name of this particular method is `Main`. There are two keywords behind the name of this method and these are `static` and `void`.

`void`: This keyword declares that the method does not return a value.

`static`: this keyword declares that the method can be invoked directly by the name of the class without creating an object.

Notes:

-   In any C# program, there should be one method with the name  
    `Main` and the same signature that you see here. C# engine always starts  
    from the `Main` method and runs instructions from its body. Basically  
    this is the entry point of our program.

-   Any method has a pair of parentheses `()` after its name. This is  
    part of the signature of methods. (Just so you know, in the parentheses  
    we can put parameters as well. But this is something that you’ll learn  
    about in *the method section*)

-   A method also has its own body and this area is between the open  
    and close braces`{}` that comes after the parentheses of the  
    method.

Inside the body of the `Main` method we have this statement:

``` line-numbers
Console.WriteLine("Hello World!");
```

`Console` is the name of a class and the `WriteLine` is a static method in that class. Basically this statement is telling the C# engine to invoke the `WriteLine` method of the `Console` class.

Note that we used the dot `.` operator between the name of the class and its method.

The `WriteLine()` method is mainly used to send a value to the console. This method is basically representing the programs output.

In the parentheses that come after this method, we put the value that we want to send to the output.

For example if we wanted to send the value 10000 to the output, all we need to do is to put this value in the parentheses of this method:

``` line-numbers
Console.WriteLine(10000);
```

Note: in C# data has different form. For example String values like `"Hi"` is different than an integer value like 12345. You’ll learn these types in *the data type section*.

In the `Main` method there’s only one statement. So when the C# engine runs our program, it only executes this single statement and after that the program will terminate because there’s no other statement in the `Main` method to be executed.

Again, the `Main` method is the entry point to a C# program and as long as there’re instructions in this method, the program will continue to run. But when C# engine reaches to the end of this method (closing brace `}`), it is equal to the end of the program and it will be terminated after that.

At the end of this section, we should mention that C# is case sensitive. This means the name `Main` is different than the name `main` or `MAIN`. Or the keyword `static` is different than the `Static` or `STATIC` keywords etc.

All the stuff you read in this section will be explained in greater details one by one in later sections. The purpose here was to give you a general view of what a simple C# program looks like. So don’t worry if many concepts in this section didn’t click into place right away.

You’ll learn as you go along.