C# Tutorials

Introduction

2030-02-19T10:10:00.000-08:00

Hello, my name is Marc and I will try to teach you the basics of C# (pronounced C Sharp) using Visual Studio 2010 by creating easy-to-understand tutorials and by putting a link to every project's source code at the end of each tutorial's page. For most of the tutorials I will use .NET Framework 2.0, but sometimes I will use other .NET Framework versions to show components such as LINQ.

The reason why I choose C# is because it is easy to learn thanks to the .NET Framework and the integrated development environment (IDE) Visual Studio. I started off with Visual Basic which might look like an easy start, because the language looks more like the English language instead of a cryptic programming language. This turned out badly for me when I had to program in PHP which required the oh-so-fun ; sign. I kept forgetting to use the ; sign in PHP and when I switched back to Visual Basic I kept using the ; sign when it obviously wasn't needed in that programming language and it would only generate errors. To make a long story short, in my opinion it's better to start with a cryptic programming language to avoid problems later.

Your first question will probably be: "Why is your blogspot URL so damn long?". This is because the first thing I learned about C# is that it was greatly influenced by C++ and that it was so good they wanted to call it C++++. The name was too long so they combined the four plusses to the # sign. That's the one thing that has stayed with me for so long that I decided to use it.

The best tutorials are mostly written by the people that recently learned the subject, because they remember exactly where they had trouble with and where they had no trouble with. Unfortunately I didn't know that at the time I started learning C#, so I didn't put any effort in trying to memorise my problems. This is why your help is needed in order to make the tutorials as easy as possible by sending feedback to my email: cplusplusplusplustutorials@hotmail.com.

Hopefully my tutorials will be of any use to you and I wish you good luck!

>> How To Get Started

Polymorphism Interfaces

2012-06-29T12:11:00.000-07:00

Source Code Polymorphism Interfaces Project

Polymorphism is used for converting from the derived class to the base class. The derived class is the class that's inheriting/implementing and the base class is the class that's being inherited/implemented. You can then of course only use the public methods, properties and global variables of the base class.

This doesn't seem very exciting, but you can also convert the derived class to the base interface. When done that, the interface object can all of a sudden be used to call methods and properties. You will be only able to use the methods and properties the interface has, but the actual code being executed will be of the derived class.

Create a new console application called "Polymorphism Tutorial".

I want to show you an example with the interface "ICivilian" and the classes "Man" and "Woman". Add an interface called "ICivilian", then add the following code to the interface:

string Name
{
get;
set;
}
void PayTaxes();

Each civilian has a name and has a method to pay their taxes.

Add a new class called "Woman" and make it implement "ICivilian", then add the following code to "Woman":

private string _name;
public string Name
{
get { return _name; }
set { _name = value; }
}
public void PayTaxes()
{
Console.WriteLine("Paying taxes");
}
public void NurseWound()
{
Console.WriteLine("Nursing wounds");
}

The interface's methods are implemented in the "Woman" class with an extra method called "NurseWounds".

Now add a class called "Man" and make it implement "ICivilian" as well. Add the following code to the class "Man":

private string _name;
public string Name
{
get { return _name; }
set { _name = value; }
}
public void PayTaxes()
{
Console.WriteLine("Paying taxes");
}
public void FixCar()
{
Console.WriteLine("Fixing car");
}

The method and property of the interface "ICivilian" have been implemented with an extra method called "FixCar".

Now to initialize the objects for "Man" and "Woman", and to give them both a name in the "Program" class' "Main" method:

Man man = new Man();
Woman woman = new Woman();
man.Name = "Bob";
woman.Name = "Sarah";

All that's left is polymorphism, so add the following code to your "Main":

ICivilian civilianOne = man;
ICivilian civilianTwo = woman;

Above code converts the "Man" object and "Woman" object to "ICivilian" objects. This can be done, because "Man" and "Woman" implemented "ICivilian".

Now to test the code, so you can see that the content of the properties and methods being called are actually of the derived class and not of the base interface. Not that it would be possible that the content would be of the interface, since interfaces can't have content. Add the following code to your "Main" method:

Console.WriteLine(civilianOne.Name);
Console.WriteLine(civilianTwo.Name);
civilianOne.PayTaxes();
civilianTwo.PayTaxes();
Console.Read();

You can try to call the methods "FixCar" and "NurseWound", but "ICivilian" doesn't know these methods.

Run your application by pressing F5. The names of the "ICivilian" objects should be displayed with twice the text "Paying taxes".

I found it hard to make this tutorial, so it took longer than it normally does. If this tutorial is difficult to understand, then I want input at what part you are having trouble with. You can of course do this with every tutorial, but this is the first time I felt uncertain about a tutorial.

Source Code Polymorphism Interfaces Project

Casting

2012-06-23T11:42:00.000-07:00

Source Code Casting Project

Casting is used for converting between data types. It's used for example when converting from a double to an integer. Doubles are data types that are used for numbers with decimals, like the number 25.5. If you cast this number to an int, then you will lose data, because an integer can't handle decimal numbers. Once you cast the double 25.5 to integer, the integer value will be 25. It will just cut the decimal off.

You can't cast between every data type. It is not possible for example to cast from Random to Button. You can make casting between data types available in the classes you make yourself, but you will have to override something called a cast operator.

There are two different types of casting:

Explicit casting

Data will be lost when converting. For example when going from a decimal number (double) to a non decimal number (int). In that case the decimal number will be lost.

Implicit casting

No data will be lost when converting. If you convert from an integer to a double, then you will not lose any data, because a double is not smaller than an integer.

Create a new console application called "Casting Tutorial".

Add the following method to your Program class:

public static void ShowNumber(int number)
{
Console.WriteLine(number);
}

I know that the public access modifier is unnecessary and that it should be private, but for this example it doesn't really matter. As you can see, this method writes a number on your console application.

Now add the following code to your Main method:

double doubleNumber = 25.5;
ShowNumber(doubleNumber);

If you try to run your application right now, you will receive an error saying that the method ShowNumber only accepts integers and that it can't convert a double to an integer. In order to fix it, you will have to use an explicit cast for converting from a double to an integer.

In order to do so, you will have to replace your Main method's code with the following:

double doubleNumber = 25.5;
int number = (int)doubleNumber;
ShowNumber(number);
Console.Read();

Now your double is converted to an integer using an explicit cast, but of course the decimal number has been lost. Next I want to show you how to use an implicit cast.

For this example you will have to change the ShowNumber method's parameter from double to float and change your Main method so it will look like the following:

static void Main(string[] args)
{
int number = 25;
ShowNumber(number);
Console.Read();
}
public static void ShowNumber(float number)
{
Console.WriteLine(number);
}

It seems like nothing is being cast, but the integer is actually converted to a float using an implicit cast. You can still use an explicit cast, but why would you do that when you have the choice of using an implicit cast with no data being lost.

Knowing the difference between an explicit cast and an implicit cast is nice, but I bet you just want to know how to convert between basic data types. That's why I made you a small list out of the many ways you can convert between certain basic data types:

Code	Converts to	Description	Example
*.ToString()	String	Almost every class in the .NET Framework has a ToString() method.	int number = 25; string message = number.ToString();
bool.Parse()	Boolean	Used to convert from almost every basic data type to boolean.	bool IsOn = bool.Parse("true"); --- bool IsOn = bool.Parse(0); //0 converts to false, 1 converts to true
int.Parse()	Integer	Used to convert from almost every basic data type to integer.	int number = int.Parse("25"); --- int number = int.Parse(true); //false converts to 0, true converts to 1
double.Parse()	Double	Used to convert from almost every basic data type to double.	doublenumber = double.Parse("25"); --- doublenumber = double.Parse(true); //false converts to 0, true converts to 1
int.TryParse()	Integer	This method puts the end result of the conversion in the out parameter and returns a boolean to indicate if the conversion has been successful. If you try to use int.Parse("d"); your application will crash, because "d" is not a valid number. This method will not crash your application.	int number; string message = "Hello"; bool isNumber = int.TryParse(message, out* number);*

A lot of basic types, if not all, have a Parse/TryParse method. Don't think that the Parse/TryParse method only exist for bool, int and double. "char.Parse()" exists as well for example.

Source Code Casting Project

>> Inheritance

Interfaces

2012-06-21T14:39:00.000-07:00

Source Code Interfaces Project

Interfaces are blueprints for classes to implement. With blueprints I mean the following: methods and properties can be declared in interfaces, but they must contain no code. Global variables can't be declared in an interface. When a class implements an interface, it must contain every method and property that exists in the interface. This must sound really useless, because why would you want a blueprint that classes can use when you can just type the methods and properties in the class without a blueprint.

Interfaces are used for the following:

Polymorphism (There will be a tutorial about this later on)
The developer can make "rules" in their software by forcing other developers (or himself/herself) to implement certain methods.

For this tutorial I will only show you the second part of the list shown above, because the concept of polymorphism is a lot to process when you don't know what interfaces are yet. If by the end of this tutorial you are not convinced that interfaces are handy, then you will probably be convinced when you see what you can do with polymorphism. Don't worry, I didn't think much of interfaces at first either.

Create a new console application called "Interfaces Tutorial".

Let's start by adding an interface. Click on "Project" in the menu (Next to File, Edit, View...) (1) and then click "Add New Item" (2).

Select "Interface" (1), give it the name "IAnimal" (2) and then click "Add" (3). The first thing you will notice is that instead of it saying "class IAnimal", it will say "interface IAnimal". The reason why I choose the name "IAnimal" is because every interface within the .NET Framework starts with the I from Interface and I try to keep my code consistent.

Add the following to your interface:

void makeSound();

This method has quite a few differences compared to a method in a class. First of all is that it has no access modifier, so no public, private, protected or internal. Second is that it has no code and no "{ }" signs. A method in a class doesn't end with a ";" sign either. This is what I meant with blueprint. It's just the data type for the return, the method's name and parameters. The code inside the method will be left entirely up to the developer that will implement the interface in a class.

(Honestly stolen from http://www.theverybestcats.blogspot.com/)

Let's say that in a perfect world that every animal can make a sound. The reason why you would want to use an interface is because, for example, a cat makes a different sound than a dog. With an interface you give them the same method, but with different content.

An interface object can not be initialized like a class object. "IAnimal animal = new IAnimal();" will not work.

Create a new class called "Cat".

In order for Cat to implement IAnimal, " : IAnimal" must be typed after "class Cat", so it will look like the following:

class Cat : IAnimal

It looks exactly the same when inheriting a class, but now an interface is used. You can implement and inherit at the same time by using the "," sign. If you have a class called "Creature" it will look like this: "class Cat : IAnimal, Creature". You can implement more than one interface in a class, unlike inheritance where a class can only inherit a maximum of one class.

If you try to run your application now, it will give you an error saying that Cat has not yet implemented the method "makeSound()" from the interface IAnimal.

Add the following code in order to fix the error:

public void makeSound()
{
Console.WriteLine("Meow");
Console.ReadLine();
}

Now the Cat class has implemented the "makeSound()" method and by doing that the error should be gone.

Next I would like to show you that you can implement multiple interfaces at once. Create a new interface called "ICarnivore".

Add the following to your ICarnivore interface:

void eatMeat();

Let's just say that every carnivore eats meat in a different way.

Switch back to your Cat class and add ", ICarnivore" to "class Cat : IAnimal", so it looks like the following:

class Cat : IAnimal, ICarnivore

You still have to make Cat implement the "eatMeat()" method or the compiler will generate an error, so add the following method to Cat:

public void eatMeat()
{
Console.WriteLine("I eat meat like a cat");
}

Now you have implemented two interfaces in the same class. The only thing left to do is to actually use the Cat class.

Add the following code to your Program class' Main method:

Cat cat = new Cat();
cat.eatMeat();
cat.makeSound();

Press F5 to check your application and to test if everything works, then you're done!

Interfaces will play a bigger role the more experience you have, but don't go overboard. I know a lot of programmers that use an interface for every class when it isn't necessary. I hear a lot that interfaces are the new programming. That might be so, but I sometimes have the feeling that only students with no work experience say that. Then again, maybe I just don't understand this new programming.

Source Code Interfaces Project

>> References

Inheritance

2012-06-20T10:56:00.000-07:00

Source Code Inheritance Project

Inheritance is used by a class to inherit another class its methods, properties and global variables. You can then add more methods, properties and global variables to the class that inherited the other class, so it can do the same and more.

If inheritance did not exist, then there would be a lot of duplicate methods. Let's say that guests, members and administrators can post a comment on your website. All those classes would then require a method called "makeComment(string commentText)". If you want to make a change to that method, then you will have to change the method in the guest, member and administrator class.

With inheritance you can make one class called user and let all the other classes inherit the user class. That way you only have to make changes to the makeComment method in the user class. Some people might think: "But if I just change the makeComment method once and copy paste it in the other classes, I won't need inheritance!". My answer to that: programmers should be so incredibly lazy, that even copy pasting code should look like too much trouble.

Let's start already by creating a new console application called "Inheritance Tutorial". Add a new class to the project called "Woman".

Add the following code to the Woman class:

private string _name;
public string Name
{
get { return _name; }
set { _name = value; }
}
private int _age;
public int Age
{
get { return _age; }
set { _age = value; }
}

The Woman class now has two properties called Name and Age.

Add a new class called "Mother" and add the code " : Woman" after the text "class Mother", so it will look like the following:

class Mother : Woman

This makes the Mother class inherit all the global variables, methods and properties from the Woman class. Mother now has the properties Age and Name, even though the properties are not visibly there in the Mother class file.

You can only inherit a maximum of one class.

People in the IT world like to give names to everything, so they named the class that inherits another class the derived class and they named the class that is inherited the base class. Mother is the derived class and Woman is the base class in your software.

Type the following in your Program class' main method to test if the inheritance's a success:

Mother mother = new Mother();
mother.Age = 12;
mother.Name = "Mom";
Console.WriteLine(mother.Age);
Console.WriteLine(mother.Name);
Console.ReadLine();

Press F5 to see it in action. As you can see, Mother now has the properties Age and Name. Next I want to show you that Mother can have the same methods, global variables and properties as Woman and more.

Go back to your Mother class and add the following method:

public void TellBedtimeStory()
{
Console.Write("Once upon a time...");
Console.ReadLine();
}

Now Mother has the methods, properties and global variables it inherited from Woman plus its own method TellBedtimeStory().

Go to your Program class and replace the code in its Main method with the following:

Mother mother = new Mother();
mother.TellBedtimeStory();

Press F5 and you will see that it works like a charm. Last thing I would like to show is that when you initialize a Woman object, that you can't call the "TellBedtimeStory()" method from it.

Add the following code to your Program class' Main method:

Woman woman = new Woman();
woman.TellBedtimeStory();

Press F5 and you will see that it won't work, because Woman does not have that method.

For some people this tutorial must have been a little too detailed. That's because I wanted to show exactly where inheritance starts and ends.

Source Code Inheritance Project

>> Interfaces

Properties

2012-06-19T08:24:00.000-07:00

Source Code Properties Project

Properties are used as an alternative for the Get and Set methods that a lot of classes have. This only involves the Get and Set methods where the Set method only has one parameter, but no data to return and where the Get method has no parameters, but does have data to return. In C# it's common that these Get/Set methods are all replaced by properties.

As usual; start by creating a new console application and call it: Properties Tutorial. Add a class to the project called: Person. First I would like to show you what the application looks like with Get and Set methods and then replace them with a property.

Add the following code to the Person class:

private string _name;
public void SetName(string name)
{
_name = name;
}
public string GetName()
{
return _name;
}

Once you've done that, add the following code to your Main function in your Program class:

Person person = new Person();
person.SetName("Bob");
Console.Write(person.GetName());
Console.Read();

Press F5 and you will see "Bob" on your console application. Next will be replacing the Get and Set methods with a property.

Replace the Get and Set methods with the following code:

public string Name
{
get { return _name; }
set { _name = value; }
}

Now you replaced the Get and Set methods with a property. The get property accessor is used to return the value of the global _name variable, and the set property accessor is used to assign a new value to the global _name variable. Value is a keyword within C# that indicates the value/data when you call the set property accessor. So instead of a parameter, value is used.

As you can see; the get property accessor contains the code of the GetName() method and the set property accessor contains the code of the SetName(string name) method.

You also have to change the code in your Program class.

Replace the code in the Program class file with the following:

Person person = new Person();
person.Name = "Bob";
Console.Write(person.Name);
Console.Read();

Only the way of approaching the data has changed: person.Name = "Bob" accesses the set property accessor and Console.Write(person.Name) accesses the get property accessor of the Name property. You can remove a property accessor if you want to make it read-only or set-only.

Make a global variable public and you can approach it the same way as you approach a public property with a Get and a Set accessor, so why not just use a global variable? That's because it is common to only use global variables within its own class and the same reason why all global variables are private in professional software.

Press F5 to check if the code is correctly implemented.

Source Code Properties Project

References

2012-06-18T16:40:00.004-07:00

Source Code References Project

References are used for using code that are outside the project. The most known example is a .dll file. In Visual Studio you can create a .dll file by creating a Class Library project. It's basically an application without a user interface, so users can't interact with it. I personally use .dll files for code I use a lot for other projects. It is also used for logically separating code.

I will use the words project and library intertwined, because when you develop a library it is a project within Visual Studio. This does not mean that every project is a library. I am implying that every library is a project when developing one in Visual Studio. By calling it a project, I hope you will understand that a library is nothing more than a collection of classes, just like a console application. The only difference is that a console application has a user interface and a library does not.

Create a new console application called Reference Tutorial.

To start off with the tutorial, I would like to point out that you already used references in the "Hello World!" tutorial. In the Solution Explorer (1) you see all the references that are currently made in your current project. For example there is a project (library) called System which has been made a reference to and as you can see many more: System.Core, System.Data, etc... You can compare the project System with your current project. Your current project is called Reference Tutorial and the project that you are using outside your project is called System. The only difference is that you can't change the code that the project System contains, because Microsoft does not like it when other people can see/change their code.

Just referencing it to your project is not enough in order to use the methods System can provide. You also have to point it out in the class its file (2) if you want to use it in that specific class file. Yes, this means that you have to type "using <project name>;" in every class file you plan on using your outside project.

As a summary and the only things you have to do:

You have to create a reference inside your project (1)
You also have to tell the compiler you are using that reference in every class file you are going to use the reference. (2)

References are basically a one sided relation between two projects. With a reference you use an outside project without the outside project knowing that you are using it. It's like me controlling the hand of a paralyzed person. I am the current project and the paralyzed person is the outside project and I'm using that person's hand. The paralyzed person also does not notice me using his hand.

Let's start by creating your own reference. First you will need to add a new project. You can do this by right clicking on your solution in the Solution Explorer (1) -> Add (2) -> New Project (3).

Once you've done that; add a Class Library project by clicking on it (1). Then fill in a name for the project: Reference Library (2). Click OK when you're done (3). It's basically the same when you create a new Console Application. As you see you can also add a new console application to the solution.

A Class Library project will be added to the solution. By default a class will also be added to the library, called Class1.

Start by renaming the Class1 file to Calculator by right clicking Class1 and selecting Rename. Select Yes if it asks if you also want to rename the class itself (1). Once you have done that, add the following code (2):

public int Sum(int a, int b)
{
return a + b;
}

In order to use the Sum method in your Program class, in the Reference Tutorial project, a reference has to be made.

Add a reference by right clicking your Reference Tutorial project in the Solution Explorer (1) and then clicking Add Reference (2).

You can add various kinds of references (1):

.NET

The .NET Framework has a lot of libraries that you can use. System is one of them.

Here you can find the libraries that applications you have installed provide. For example I have VLC media player installed and I can use their libraries to create my own extended VLC media player.

Browse

You can browse for files on your computer and select it if it is a valid library. This does not mean you can select and use a .dll file in the Windows folder. That is because some companies do not want other people to use their code. If you could, they wouldn't be able to make money! If you build the Reference Library project, it creates a .dll file and you can select that file, but then you wouldn't be able to change the code that easily in the Reference Library.

Projects

Here you can select a project in your solution that you wish to create a reference to. You can use almost ANY project type as a reference. This also means console applications.

Click on the tab Projects and select the Reference Library if it is not selected yet (2) and then click OK (3).

You will now see that the reference has been added to your project in the Solution Explorer (1). Go to your Program class (Program.cs) and add the following under "using System.Text;":

using Reference_Library;

Now a reference has been made in your project and in the Program class file.

Now add the following code:

Calculator calculator = new Calculator();
int sumOutcome = calculator.Sum(5, 4);
Console.Write(sumOutcome);
Console.Read();

As you can see, initializing an object and calling its method is the same with a reference.

The problem of using an outside project is that you don't know the classes and methods it contains. Now you do, because you made it yourself. The Object Browser will show the classes and methods the outside projects contain. You can open the Object Browser by going to View -> Object Browser.

As you can see and already know, your outside project Reference Library has a class called Calculator with a method called Sum. This way you can also explore System and of course all the other references you made. Maybe you can find a reference in the COM tab of an application you like and use their library, which you can fiddle around with it. Just remember:

You have to create a reference inside your project
You also have to tell the compiler you are using that reference in every class file you are going to use the reference (using <project name/library name>;).

Source Code References Project

>> Polymorphism Interfaces

Manga Updater

2012-06-18T11:30:00.000-07:00

Source Code MangaUpdater Project
Setup MangaUpdater

This page will only inform you of the functionality of this application. Code will not be discussed on this page. The application will need to be run as admin and .NET Framework 4.0 has to be installed or the application will crash horribly, since I am a very lazy developer. Use this application at your own risk.

A few months ago I started to really like reading manga. I bookmarked every manga I liked and I also bookmarked every new chapter, so I knew where I left off. One month later I had so many bookmarks that I couldn't keep track of them. I also wanted to learn how to use LINQ, so I thought it would be a nice idea to develop an application that could keep track of the manga I followed.

On a lot of websites it is possible to keep track of updates by reading their RSS feed. Explained simply: The RSS feed is a file accessible through a URL, for example: http://mangafox.me/rss/bleach.xml. Mangafox uses XML as data representation. It's also possible to use JSON (and many more), but XML is most common. RSS feeds are usually used for showing updates that have been made on the website. For example if you host a website that shows news, then you could update the RSS feed with every added news. The RSS feed would then contain the title of the news and the link to the webpage of the news.

I figured it would be a good idea to revolve the application around RSS since Mangafox uses RSS and a lot of other manga hosts use RSS as well. When you add an RSS URL (1), it loads the XML and reads the data it needs. For now I only use the title and the chapters of the manga.

When a manga is added, it is shown in a list (2). Every manga is sorted in alphabetical order. If the current chapter of the manga is not the last chapter, then it is colored red and put at the top of the list, else it is colored green and put at the bottom of the list. The selected manga gets a light blue background color and the current chapter is shown.

I also added a feature that makes a screenshot of the current chapter's webpage (3). This is very useful for people that have an awful memory, like me. All those Japanese names don't help with that fact either.

The application looks for updates for each manga in their RSS feed every 15 minutes or when you press the refresh button. A balloon with the manga titles of the manga that have new chapters will appear near your system tray. The application will also look for updates when it has been minimized to the system tray.

Setup MangaUpdater
Source Code MangaUpdater Project

Multiple Processes

2011-03-12T17:02:00.000-08:00

Source Code MultipleProcesses Project

Google Chrome uses a process for each tab. This way the crashed tab won't make the other tabs crash. This example application contains a child application called "ChildApplication.exe". This way you can put multiple child applications in your parent application.

The child application will be split from the parent application when the parent application crashes. Personally I think it would be hard to make the parent crash, because all it does is containing child applications.

I don't know for sure if the parent application is actually waiting for the child application to start first, because under the .NET Framework 2.0 the whole application wouldn't work. Only the child application would start. This is the reason why the application is using the .NET Framework 4.0.

To simulate a crash just create a button and put "throw new Exception();" in the button its click event.

Source Code MultipleProcesses Project

Classes

2011-03-12T15:26:00.000-08:00

Classes are used to split your application into logical parts, so your code is easier to oversee. You can for example split a warship into several parts: weapons, ship, people and etc. In code you will have three classes called: "Weapon", "Ship" and "People". The class ship will then hold an array of weapons and people. You should first write down all the names of the classes with its methods that are logical for your application and then start coding. I bet you won't in the beginning, because coding is way too fun. I thought so too in the beginning, but now I like to predict how my application will look like in the end more.

Enough small talk. Start a new console application called "Classes".

Create a new class by clicking on Project -> Add Class.

Select the template "Class", fill in the name "View" and press Add.

A new file has been created in your project and it's called "View.cs" which can be seen in your solution explorer. The file has been opened and you can see the contents in your text editor.

Add the following code to your "View" class:

public View()
{
Console.Write("I'm alive!");
Console.ReadLine();
}

"public View()" is not a method, it's a constructor. It must have the same name as the class and it mustn't have a return data type. The constructor is called when the class has been instantiated .

Switch back to the "Program.cs" file and create an instance of the class by typing:

View view = new View();

Now the class has been instantiated and the constructor will be called when running your application. Note that the instance "view" of the class "View" could've easily been called anything. The instance "view" doesn't need to be the same name as the class in lowercase. Press F5 on your keyboard to run your application now and "I'm alive!" should be shown on your screen.

Go to your class "View" and add the following method:

public void ShowOutput(string text)
{
Console.Write(text);
Console.Read();
}

The access modifier needs to be "public", because you're going to call the "ShowOutput" method from the class where you instantiated the "View" class.

Back to your "Program" class again. To call the "ShowOutput" method in the "View" class you will have to type the following below "View view = new View();":

view.ShowOutput("Hello World!");

Press F5 on your keyboard and you should see "Hello World!" on your screen after pressing enter once, because your constructor has a "Console.ReadLine();" and your application executes that first.

Use classes to give your application a logical structure. Try to divide classes in how you would do in real life. If you create a game tic tac toe and you want to check if someone made a valid move, then for example create a class called referee.

Source Code Classes Project

>> Properties

Switch Statements

2011-02-28T07:33:00.000-08:00

If statements are great for making choices, but what if you have a lot of choices? A traffic light has three colors: red, orange and green. You'll have to make two if statements and one else statement. For this example it isn't a lot, but what if we want to make choices between all traffic signs? That requires a lot more if statements and that would make your code messy. There is a statement that makes choosing between a lot of options less messy and it's called the switch statement.

Start a new project called "SwitchStatements".

Add the following code to your "Main" method:

string currentStatusTrafficLight = "red";
switch (currentStatusTrafficLight)
{
case "green":
Console.Write("The traffic light is showing green");
break;
case "orange":
Console.Write("The traffic light is showing orange");
break;
case "red":
Console.Write("The traffic light is showing red!");
break;
}
Console.ReadLine();

A switch statement like any other code is read from top to bottom. Your application starts with "switch (currentStatusTrafficLight)". "Red" is used for this example, so it will compare each case with "Red".

First up is the case "green". The string "red" is not equal to the string "green", so it will not execute the code "Console.Write("The traffic light is showing green");break;)".

Next up is the case "orange". The string "red" is not equal to orange and like last time that means that the code "Console.Write("The traffic light is showing orange");break" will not be executed.

Your last case is "red". The string "red" is equal to "red", so the code "Console.Write("The traffic light is showing red!");break;" will get executed.

"break" will make your application jump out your switch statement, because you don't want it to compare "red" with any more cases. Not that it matters in this example, because there aren't any more cases to compare "red" with. The keyword "break" will also make your application jump out of a loop. This is useful for when you want to search a name in an array and when you found the name you can jump out of the loop, so it doesn't continue the loop when it isn't necessary.

Every case is basically an if statement. Take the following example condition in an if statement: "("red" == "green");". The string "red" is what you put in the switch: "switch ("red")". After that you make a case for the string "green": "case "green":". Your application compares "red" and "green" like in the if statement its condition.

Source Code SwitchStatements Project

>> Methods

If Else Statements

2011-02-26T16:48:00.000-08:00

If statements in C# and a lot of other programming languages are used to make choices in your application. Us humans make a lot of choices in life. If you have no ham, then you go to the supermarket to buy ham. You don't want to buy ham if you already have a bunch at home.

Time to show you an example, but first you'll need to create a new console application called "IfStatements".

The following code will be used for the explanation:

//We have a lot of ham, so we don't need more
bool inNeedOfHam = false;

if (inNeedOfHam == true)
{
Console.Write("Buy ham!");
}
Console.Read();

The variable "inNeedOfHam" will decide if you need ham and for this example you don't need any, so it's set to false.

"(inNeedOfHam == true)" is the condition of the if statement and the signs "==" are the comparison. It will compare the variable "inNeedOfHam" that holds the data false with the data true. False is not equal to true, so the code "Console.Write("Buy ham!");" will not be executed. If you're stubborn, then press F5 on your keyboard (See what I did?). Memorise that "==" will compare data and "=" will assign data.

You will use comparisons for every if statement and "==" is one of many:

== - Exactly equal to
> - Greater than
< - Less than
>= - Greater than or equal to
<= - Less than or equal to
!= - Not equal to

Memorising these will prove useful as almost every application will contain one or more comparisons.

For the next example you will turn your "if statement" into an "if else statement", so it will look like the following:

if (inNeedOfHam == true)
{
Console.Write("Buy ham!");
}
else
{
Console.Write("I don't need ham");
}

The else statement will always have the opposite comparison to that of the if statement. In other words: the if statement has the condition "If false is equal to true", so the else statement has the condition "If false is not equal to true". The else statement its condition is true, because false is not equal to true. This means that the code "Console.Write("I don't need ham");" will be executed and "I don't need ham" will be written on your screen. Press F5 on your keyboard to check.

The same can be done for any other data type. An example condition "(5 < 10)" will check if the number 5 is smaller than 10. This condition is true, because 5 is smaller than 10.

Source Code IfStatements Project

>> Arrays And Loops

Arrays And Loops

2011-02-24T12:34:00.001-08:00

Arrays are variables that can hold a list of data, instead of one. After all it would be annoying to create 20 variables to hold a list of numbers.

First create a new project called "ArraysAndLoops".

Start by typing:

int[] listOneOfNumbers = new int[3] {25,31,43};
int[] listTwoOfNumbers = new int[3];
listOneOfNumbers[0] = 25;
listOneOfNumbers[1] = 31;
listOneOfNumbers[2] = 43;

You know that every variable needs a data type. Every array also needs a data type and in this case it will be of the basic data type int. The rule in C# is to put the "[]" signs after the data type to make it an array. The "new int" is to create the array with the basic data type and give it a spot in the memory. "[3]" shows that your array will hold 3 elements of data. Try to assign data to a non-existent fourth element and your application will crash. There are two ways to assign data to each element and both are correct, so just pick one. Arrays begin with element #0 and not with element #1.

"int[] listOneOfNumbers = new int[3] {25,31,43};" will assign data to each element and can only be used when creating an array. The following numbers will be assigned to each a specific element based on the order of the numbers in the array: 25, 31 and 43. The number 25 will be assigned to element #0, 31 to element #1 and 43 to element #2.

int[] listTwoOfNumbers = new int[3];
listOneOfNumbers[0] = 25;
listOneOfNumbers[1] = 31;
listOneOfNumbers[2] = 43;

Above code will first create an array with only 0s as data in its elements. Then you assign data to each element separately. You start with element #0 and end with element #2. In total there are 3 elements to assign data to, just like you typed when you created your array.

You want to read all the elements in the array and want to show them on your screen. This is done by using a loop that goes through every element in the array. Add the following code below "listOneOfNumbers[2] = 43;":

for (int i = 0; i < listOneOfNumbers.Length; i++)
{
Console.Write(listOneOfNumbers[i] + "\n");
}
Console.Read();

A for loop consists out of 3 parts. First you need to initialize a variable. This variable is used to check how many times your code in the loop has been repeated.

The second part is the condition. Your application checks the condition if it still applies every time it loops from the beginning. In the code you just added the condition is "i < 3" (Your array has 3 elements), so your application loops as long as the variable "i" is smaller than 3. This means that the loop will go through the numbers 0, 1 and 2. The third and last part is the step. This part increments your variable "i" every time it loops or else the condition would be useless, because the variable "i" would stay on 0.

The first time your loop its variable "i" will contain the number 0. This is perfect, because you need to read element #0 in your loop. After reading the element and getting the data your application will write the number 25 on your screen. The loop is now done and will increment the variable "i" in the step part of the loop. After that it will check if the condition is still true. The variable "i" now holds the number 1. The loop will continue, because 1 is smaller than 3.

Now your loop's variable "i" holds the number 1 and it will execute the code in the loop again. It will now read element #1 and write the number 31 on your screen. It will increment the variable "i" again and will now check if 2 is smaller than 3. It is, so it will loop again.

Variable "i" now holds the number 2, so it will read element #2 and write the number 43 on your screen. After incrementing the variable "i" again it will check the condition. 3 is not smaller than 3, so the loop stops. This means that "Console.Read();" will be executed and this is where your application ends.

Run your application by pressing F5 on your keyboard and you should see the numbers 25, 31 and 43 on your screen.

Source Code ArraysAndLoops Project

>> Switch Statements

Basic Calculations

2011-02-23T14:10:00.000-08:00

Everyone has a calculator nowadays. There's probably a calculator on your computer right now. If you don't then it won't be hard to make a basic calculator yourself, but before you do that you'll need to know how to add, extract, multiply and divide in C#.

First create a new console application called "BasicCalculations".

Start by typing:

int outcomeByAdding = 5 + 5;
Console.Write(outcomeByAdding);
Console.Read();

The variable "outcomeByAdding" will hold the number 10 after calculating 5 + 5. You put the variable "outcomeByAdding" as the parameter for the "Write" method, so you will see 10 on your screen when running your application by pressing F5 on your keyboard.

You can do the same for subtracting, multiplying and dividing. Add the following to your code below "int outcomeByAdding = 5 + 5;":

int outcomeBySubtracting = 10 - 5;
int outcomeByMultiplying = 5 * 2;
int outcomeByDividing = 10 / 2;

Console.Write(outcomeBySubtracting + "\n");
Console.Write(outcomeByMultiplying + "\n");
Console.Write(outcomeByDividing + "\n");

Putting "outcomeBySubtracting + "\n"" will combine those two. If "\n" was of the basic data type int, then it would add those two numbers. In this case one of the two data is of the basic data type string, so it will combine the two data. "\n" means "new line" and that will make your console application start on a new line. Run your application now and you should see the outcome of all the four calculations.

If you want to add the number 12 to the variable "outcomeByAdding", so it will hold the number 17 won't suffice by typing: "outcomeByAdding + 12;". You will have to type "outcomeByAdding = outcomeByAdding + 12;" below "int outcomeByAdding = 5 + 5;".

Your application will first add the number 10 (the number assigned to your variable) to the number 12 and then assign the number 22 to your variable "outcomeByAdding". You will now see the number 22 instead of the number 10 when you run your application. Instead of typing "outcomeByAdding = outcomeByAdding + 12;" you can also type "outcomeByAdding += 12;". It does the exact same thing, but the full presentation was needed for the explanation. The same can be done with "*", "/" and "-".

Incrementing can be done by putting two "+" signs before or after a variable. For example the variable "outcomeByAdding" will look like "outcomeByAdding++;". Incrementing by typing "outcomeByAdding++;" is the same as "outcomeByAdding = outcomeByAdding + 1;". This will assign the number 23 (22 + 1) to the variable "outcomeByAdding". Decrementing is also a possibility by typing "outcomeByAdding--;" which is the same as "outcomeByAdding = outcomeByAdding - 1;". No, "outcomeByAdding**" or "outcomeByAdding//" won't work.

That's it, basic calculations. You should memorise that calculations are done first and the outcome assigned to the variable.

Source Code BasicCalculations Project

>> If Else Statements

Methods

2011-02-21T17:16:00.000-08:00

Methods are used to make your applications clean or it would be one big code fest. It's also used when you need a piece of code multiple times, so you don't have to copy paste the same piece of code over and over.

Let's begin by creating a new console application called "Methods".

Create the method "private static void ShowHelloWorld(){ }" below your "Main" method. Type in your new method the code "Console.Write("Hello World!");" and "Console.Read();" like you did on your "Hello World" project. This should show the exact same as your old "Hello World" project when you run it by pressing F5 on your keyboard.

A method consists of an access modifier, a modifier (access modifiers are part of modifiers), a return data type and a name (Yes, I did just make "name" bold to give it an extra effect).

An access modifier exists to give your method an access level. There are four access modifiers in C#:

Private : The method can only be called within its own class
Public : The method can always be called
Internal : The method can only be called in its own project
Protected : The method can only be called within its own class and classes that are derived from that class

The fact that you can use the "Write" method from the class "Console" means the "Write" method is public. Your method "ShowHelloWorld" is private, so you won't be able to use it outside your "Program" class, because you don't have to in this case.

There are a lot of modifiers: abstract, const, event, extern, override, readonly, sealed, static, unsafe, virtual and volatile. The only reason the method "ShowHelloWorld" is static is because it's being called from a static method "Main". If the method wasn't static, then calling the method "ShowHelloWorld" would be a bit harder, because of the method "Main" being static. The method "Main" is static, because there should be only one. All the modifiers will be discussed at a certain point, but the modifiers will be too much to explain right now.

Methods can return data and the return data type defines what kind of data will be returned. In your method "ShowHelloWorld" the return data type is void, because the method is for showing something and not for returning something.

Naming a method is very important. You should give it a name that describes its functionality.

Imagine that you work at a computer store and your manager wants to calculate the price of a new computer mouse based on the costs of 5 dollars. Your manager tells you that the price is calculated by multiplying the costs by 2, dividing that by 5, adding that up by 2 and then subtracting 2 of that (Your manager isn't very smart). First you'll need a method:

private static int CalculatePrice(int costs)
{

}

You want the method to return the price by calculating the costs and that's why it has a parameter "int costs" which will be 5 dollars in this example and a return basic data type int (int is the basic data type of "price" which we will return). Parameters have a data type, so that means your method "CalculatePrice" won't accept data of the basic data type string "Hello World!" when it has a basic data type int.

Most methods have parameters. The method "Write" of the class "Console" is one of many. When you type "Console.Write(" you will see "Console.Write(bool value)". This means that you can give the "Write" method data of the basic data type bool (true or false) and it will write that for you on the screen. The method "Write" has the return data type void and that means that the method won't return anything. In total there are 18 methods with the name "Write" in the class "Console", but they all have different parameters. This is called method overloading.

You can for example copy paste your "CalculatePrice" method and give it no parameters, more parameters or different parameters. Don't forget that your "costs" variable might not exist if you change the parameters.

Now back to calculating the price. Add the following to your method "CalculatePrice":

int price = 0;
price = costs * 2;
price = price / 5;
price = price + 2;
price = price - 2;
return price;

"int price = 0;" creates a variable that will hold the price. "price = costs * 2" can be looked at as "10 = 5 * 2" which is the same as "5 * 2 = 10". You have to memorise that first the "5 * 2" will be calculated with the outcome of "10". On the next line you'll see "price = price / 5". It looks like this before it's been calculated: "10 = 10 / 5". After calculating it looks like "2 = 2 / 5", but that doesn't matter anymore, because you have your answer, namely "2" and you don't need anything more from that piece of code. The same happens for the rest: "price = price + 2" -> "4 = 2 + 2" and "price = price - 2" -> "2 = 4 - 2". In the end the variable "price" has the data "2", so the method "CalculatePrice" returns the number "2". The "return" keyword makes your application stop executing your method at that point even if it hasn't reached the end of your method yet.

Now you have a "CalculatePrice" method that calculates the price based on the costs. Make use of that method by typing the following in the "Main" method above the method "ShowHelloWorld":

int computerMouseCosts = 5;
int computerMousePrice = CalculatePrice(computerMouseCosts);
Console.Write(computerMousePrice);

"int computerMouseCosts = 5;" is the 5 dollar costs for the computer mouse your manager wants to determine the price on. "int computerMousePrice = CalculatePrice(computerMouseCosts);" is where the "CalculatePrice" method will calculate the price based on the costs of the computer mouse and the price will be returned by the method "CalculatePrice" to the variable "computerMousePrice". The last step is to write the price on your screen by typing "Console.Write(computerMousePrice);". Run your application by typing F5 on your keyboard and it should show "2Hello World!".

You're a good programmer so you were already going to change "Console.Write(computerMousePrice);" to "Console.Write(computerMousePrice + "\n");". Run your application now and you should see "Hello World!" on a new line.

You would've saved yourself from copy pasting your code by using the "CalculatePrice" method if your manager wanted to calculate more prices that are calculated the same way. Too bad that your manager got fired for trying to steal the fire alarm, but you got promoted to manager by showing the higher ups what you've learned so far.

Source Code Methods Project

>> Classes

Variables

2011-02-21T06:41:00.001-08:00

Variables are words that can hold data. When you have to show the same "Hello World!" on your screen ten times, then it's easier to put that data in a word. This saves you from typing "Hello World!" all the time. Sometimes you will make the variable name longer than the text itself, but that doesn't matter. Visual Studio has a list of all the variables you made and it will give you the option to just type the first few letters and then you can press "Enter" on your keyboard. This will autocomplete your word. It's like when you type something in Google and it will autocomplete what you're searching for, that is if what you're searching for is in Google's list.

Let's start by opening your old "Hello World!" project or make a new one with the exact same code. Replace the text "Hello World!" with a variable.

Start with declaring the variable "helloWorld" by typing "string helloWorld = "Hello World!";" above "Console.Write("Hello World!");" and replace "Console.Write("Hello World!");" with "Console.Write(helloWorld);". If you run your application by pressing F5 on your keyboard now it should show the exact same thing as when you started it the last time.

String is a special data type in C# namely a basic data type. String tells your variable with the name "helloWorld" that it will hold multiple letters and/or signs or in our case "Hello World!". In C# there are in total 15 basic data types and are shown in blue in Visual Studio:

bool : true or false
sbyte: -128 to 127.
byte : 0 to 255
char : One letter or sign
short : -32,768 to 32,767
ushort : 0 to 65,535
int : -2,147,483,648 to 2,147,483,647
uint ; : 0 to 4,294,967,295
long : -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
ulong : 0 to 18,446,744,073,709,551,615
decimal : ±1.0 × 10^−28 to ±7.9 × 10^28 - numbers with comma
float; : ±1.5 × 10^−45 to ±3.4 × 10^38 - numbers with a comma
double : ±5.0 × 10^−324 to ±1.7 × 10^308 - numbers with comma
string : Multiple letters and/or signs
object : This can be anything. It's data without a meaning.

You'll probably think "Why not just always use string?". That's because you'll want to see the difference between data, so you can expect what kind of data it will be. When you will use libraries of the .NET Framework you won't be able to see the code behind it, but you will know what kind of data it will give you thanks to the basic data types. Memorise that "6" is a string (like "Hello World!") and 6 without " signs around it is a number like int, short, long and etc. The same counts for booleans (bool for short): "true" is a string and true without " signs around it is a boolean.

You will probably have to practice a lot in order to memorise all the basic data types and you should, because they're really important. The most used basic data types are: string, object, int and bool, so you should start with those.

Back to the coding part. You can show numbers on your screen by using int. Replace "string helloWorld = "Hello World!";" with "int randomNumber = 25;" and replace "Console.Write(helloWorld);" with "Console.Write(randomNumber);". Run your application and you should see the number "25" on your screen.

You can do the same with booleans (bool for short). Replace "int randomNumber = 25;" with "bool randomBoolean = true;" and replace "Console.Write(randomNumber);" with "Console.Write(randomBoolean);". Run your application and you should see "True" on your screen.

Until now you've only used variables with basic data types, but there are also normal data types which you can add yourself or are available in the .NET Framework. Replace "bool randomBoolean = true;" with "Random myRandomVariable = new Random();" and replace "Console.Write(randomBoolean);" with "Console.Write(myRandomVariable.Next());".

Random is a class in the .NET Framework. "new Random()" returns data with the data type Random (convenient huh?). Your "myRandomVariable" variable now has the information to call the "Next" method of the "Random" class. The "Next" method returns a random number with the basic data type int (point with your cursor on "Next"). You should see a random number on your screen when you start your application.

Note: You should not take it easy on naming your variables. You should give variables a correct description based on the data it will hold in order for you and others to easily understand your (large) projects.

Source Code Variables Project

>> Basic Calculations

Visual Studio Templates

2011-02-20T10:35:00.000-08:00

This page will discuss the templates Visual Studio has in order for you to live a lazy programmer life.

First you will have to start Visual Studio -> click File (upper left corner) -> click New Project. You will see six different templates: Windows Forms Application, Console Application, WPF Application, Class Library, WPF Browser Application and Empty Project. A template in Visual Studio is a pre-programmed application which you can work further on. It saves the trouble from starting with nothing when creating a new project while you want to start at a certain point anyways.

Console Applications don't look flashy at all. They're easy to learn C# with, because you don't get distracted by anything shiny. It's just text and that's what you need to get a slow and easy start. This template is going to be used for all the basic tutorials.

Windows Forms Applications are applications that you see a lot in Windows, like Notepad, Calculator and such. Visual Studio made it so that you can drag programmable buttons, dropdown boxes and many more on your own Windows Form Application.

WPF Applications are like Windows Forms Applications, but WPF makes it easier to make your application look flashy and it uses a language called Extensible Application Markup Language (XAML) to initialize structured values and objects.

Class Libraries are for creating .DLL files. Class Libraries aren't for creating anything visual. They're used for writing code that can be used for many other applications. When you write code for using a database you will probably want to use that same code for other applications that you will write in the near future. In Visual Studio you can make a reference to these .DLL files, so you can make quick use of them. Some of the .DLL files on your computer can also be used as a reference, but most of them will give an error when trying to use them. For example you can use parts of the Microsoft Office Word application in your own application by making a reference to the right .DLL.

WPF Browser Applications are used for Rich Internet Applications. Rich Internet Applications are basically web pages that you open on your browser that look a lot like the applications you open on your computer.

Empty Projects are for hardcore people that want to write everything from scratch. So are you hardcore, then look no further and open your empty project and dive in!

>> Hello World!

How To Get Started

2011-02-19T17:43:00.000-08:00

This is the famous "How To Get Started" page. This page will show what application will be used and the project type that will be used for the basic tutorials.

The easiest application to code C# in must be Visual Studio. Visual Studio uses a framework called the .NET Framework. The .NET Framework is basically a library full of books that you can use. When you program you basically write a book, but sometimes you need help from other books to write your own because you don't know certain things. Of course you can always write your own, but it is way quicker and easier to use a book than to write one all by yourself. There are more frameworks that you can download and use, but the .NET Framework is the only one you will need for the basics.

There are several versions of Visual Studio: Express, Professional, Premium, Ultimate and Test Professional. The Express version is free and is divided in five different editions: C#, Visual Basic, C++, Web Developer and Windows Phone. We will be using the C# version: Visual C# Express. It can be found here: http://www.microsoft.com/visualstudio/en-us/products/2010-editions/visual-csharp-express. You can always get one of the other Visual Studio versions in ways I'd rather not know.

After selecting your language in the dropdown box the download will begin shortly. The file will be small, because that file will only start the actual download of Visual C# Express. Start "vcs_web.exe" (the file you just downloaded) and it will show something that is loading. Go through the setup after it has been loaded. Press "Next", accept the License Terms and press "Next" and then press "Install". It will start downloading the entire application before installing it. After that just press "Exit".

Start Microsoft Visual C# 2010 Express by going to: Start -> All Programs -> Microsoft Visual Studio 2010 Express -> Microsoft Visual C# 2010 Express.

Congratulations, you have installed Visual Studio C# 2010 Express successfully! Don't go crazy and program something brilliant just yet or I won't be able to take the credit. Keep following the tutorials instead.

>> Visual Studio Templates

Hello World!

2011-02-19T11:40:00.000-08:00

The first thing you do when learning a new programming language is showing "Hello World!" on your screen by using the programming language that you're trying to learn. The reason we do this is because it's the simplest way to show something on the screen and to give you that extra motivation to keep going. The second reason is that it's a tradition after it was first introduced in the book "The C Programming Language".

First you have to start Visual Studio -> click File (upper left corner) -> click New Project -> click Console Application -> Fill in "HelloWorld" for the project name -> click OK.

Don't freak out, you don't have to understand everything all at once, except the three parts that are circled by red.

The Debug button (1) is where you click on to test your application. You basically just start the application within Visual Studio and check if your application has errors which will be shown in Visual Studio. If you click on it now you will see something opening and closing.

The Text Editor (2) is where you type your code. Your application starts in "static void Main(string[] args){ }" which is called a method. It's a written rule that your application will start in the method called "Main". Your first code will be written in-between the { } signs of that method.

The Solution Explorer (3) is a list of all the files that exist in your project and the made references to libraries that you are using in your project. You're going to write the code in a text file called "Program.cs" and the contents of that text file is shown in the Text Editor.

Let's get started. Type "Console.Write("Hello World!");" and on the next line type "Console.Read();".

"Console" is a class like "Program" is a class in your application right now. "Write" is the method that is in the class "Console" like "Main" is a method in the class "Program" of your application right now and both the classes and the class their methods are seperated by a dot. The only difference is that you won't be able to see what is inside the class "Console" (except a list of the method names it has) or the method "Write", because they're protected by the .NET Framework. "Hello World" is the parameter that you're giving to the method "Write". Basically you can type "Program.Main(null);" like you just did with "Console.Write("Hello World!");" (null means that you're giving it no data). Putting "Program.Main(null);" in your code is not a good idea though, because that will start your application an infinite times, which will destroy the world.

"Console.Write("Hello World!");" will write "Hello World!" on the console. "Console.Read();" will make the application wait until you press the "Enter" key on your keyboard. The application will close right away if you don't type "Console.Read();", because when a console application reaches the end of its "Main" method, the application closes.

Now click on the Debug button or press F5 on your keyboard to start your application. Your application will be read from top to bottom, so don't think every line of code will be executed at the same time. If your code is exactly like on the previous picture, then there should be no problems and the application should run perfectly. You might've forgotten a ; sign, so make sure you didn't. If everything went perfectly, then congratulations on your first C# console application! Save your project by pressing "Control + Shift + S" on your keyboard, unless you don't need to with your Visual Studio, because Visual Studio saved your project when you created it unlike my Visual Studio.

Source Code HelloWorld Project

>> Variables