Find out how to Study C# Half 1 – Introduction

Final Replace: Dec 31, 2022

This tutorial is a part of a collection. You’ll be able to see the opposite tutorials beneath:

Okay so a couple of months in the past I posted an intro to C# and the .Internet framework and talked a couple of set of tutorials, and right here they’re. I’m going to leap proper into coding and discover a working utility. C# is my favourite language, and after some time of utilizing it you’ll see why.

The earlier article was mainly an intro and reasoning behind why you must use C#, that is extra sensible palms on stuff. We’ll begin with hands-on code and transfer on to how one can use it.

Notice that this tutorial is for absolutely the newbie, in case you’ve had expertise with different Object Oriented Languages you might need to skim this one and transfer on the to the subsequent.

What you have to get began.

To get began you received’t want a lot. All of the instruments we’re utilizing listed below are freed from cost, however when you have a professional copy of Visible Studio that’s nice.

You will have:

All of those downloads are 100% free – no trial or something like that so you may actually take off and run with these items. As you develop into knowledgeable developer or construct industrial merchandise you’ll need the skilled model of Visible Studio, however for now this works nice.

Get Set Up

For these tutorials we’re going to doing it the laborious approach. We’re going to code every part by hand in a textual content editor then compile it. The explanation for that is we need to find out how the code truly works, for skilled improvement you want an IDE, however your basis can be a lot stronger if you understand how every part works intimately.

Step 1 – Create a folder to place your recordsdata in. This may be something you want, akin to C:csharp no matter’s best for you.

Step 2 – Create a path to compiler (or select the Visible Studio Command Immediate). You will have two choices right here, you may both:

Choose Begin->Packages->Microsoft Visible Studio Categorical 2012->Visible Studio Instruments -> Developer Command Immediate (the straightforward away)

Or, you’ll find the trail to CSC, it’s situated in

C:WindowsMicrosoft.NETFramework[version]

So to set your path, you must kind in:

set PATH=%PATH%;C:WindowsMicrosoft.NETFrameworkv4.0.30319

The model could change however that one corresponds to the picture above. It’s best to be capable of kind in “csc” wherever and see one thing like the next:

Now you’re able to get began

Let’s Write Some Code!

I hate to be cliche’ however this actually is the easiest way to start out any programming tutorial, so we’re gonna do a “hey world” app. Create a file referred to as helloworld.cs and kind within the following:

namespace HelloWorldApp
{
	class Program
	{
		static void Important()
		{
			System.Console.WriteLine("Hi there, World!");
		}
	}
}

Now, save the file and kind:

csc helloworld.cs

It’s best to get a message that appears like:

Microsoft (R) Visible C# Compiler model 4.0.30319.17929

for Microsoft (R) .NET Framework 4.5
Copyright (C) Microsoft Company. All rights reserved.

This creates an executable referred to as helloworld.exe that you must output the textual content you’ve specified.

Kind in:

helloworld

and also you’ll see the output. Straightforward proper? Now I’ll clarify slightly extra about what this app is doing.

The way it works

The very first thing you’ll discover this system begins with this:

A namespace is a key phrase that declares the scope of your varieties. Scope is mainly a fenced off space the place your knowledge resides. This associates your variables and different knowledge varieties together with your program and controls entry to them.

HelloWorldApp is your namespace to your program, however the .Internet Framework additionally makes use of namespaces to arrange code as nicely. For instance the System.IO namespace comprises code pertaining to enter and output. Your purposes can make the most of many namespaces, the truth is they are going to all the time make the most of a couple of.

In case you’d wish to learn extra about namespaces see the namespace reference on MSDN. We’ll be speaking about them extra later too.

The following a part of this system is:

This additionally comprises a set of brackets and every part inside them belongs to the category “Program”. A category is a contruct that acts as a template for objects. It defines a set of features and is used for organizing your code in an environment friendly approach.

A category creates an occasion of itself for a given goal. Consider it as a blueprint for knowledge, it specifies what knowledge goes in, what goes out (if something) and what strategies you may carry out on the info. For details about the speculation behind courses take a look at my intro to object oriented programming.

Subsequent we come to this assertion:

This creates an entry level for our program. Important() is the place each program begins, and is required for any C# utility. The key phrase static means it is a variable that’s created statically imply it lives all through the lifetime of this system. Variables which are declared dynamically have a shorter life and are created and destroyed as wanted. Since we’d like this knowledge all through the entire program we wish it to be static. There are different makes use of for static datatypes we’ll get into later.

The phrase “void” signifies no knowledge can be returned by this methodology. Strategies that course of knowledge will return knowledge and this key phrase specifies that format. Since all of our knowledge goes to console output we don’t must return something.

The following line is our precise output.

	System.Console.WriteLine("Hi there, World!");

This makes use of the tactic WriteLine within the System.Console namespace (sound acquainted) to output a string to the console. It really works precisely the way in which you see it, by taking the string “Hi there World” and passing it to the WriteLine operate it shows as output.

I name this methodology explicitly, but it surely’s not the one method to do it. We will embody the System namespace with the “utilizing” key phrase after which name out the Console.WriteLine methodology straight. See the code beneath:

utilizing System;

namespace HelloWorldApp
{
	class Program
	{
		static void Important()
		{
			Console.WriteLine("Hi there, World!");
		}
	}
}

Do you see the distinction? That is often a cleaner method to do it, particularly in case you’re utilizing a number of strategies from the System namespace. On the subject of code, you must all the time optimize for readability.

I hope this was a superb rationalization of our small utility and also you perceive how every part works.

Let’s Change it Up: Ask For Enter

Now we’re going to alter our app slightly to get some person enter. Make a brand new copy of your app or change the prevailing one so it appears to be like like this:

utilizing System;

namespace HelloWorldApp
{
	class Program
	{
		static void Important()
		{
			Console.Write("Please Enter Your Identify: ");
			Console.Write("Hi there there {0}! ", Console.ReadLine());
		}
	}
}

Now as you may see, we now have two strains and the primary one outputs a string asking to your identify. The following line additionally outputs a string however as you may see we now have some new stuff right here. We create a placeholder ({0}) then make a name to the Console.ReadLine() methodology. This does precisely what you’d guess and reads the enter from the console. This system will pause till you enter one thing on the immediate. Kind csc (filename) and check out it out.

Kind the next code into your app:

utilizing System;
utilizing System;

namespace HelloWorldApp
{
	class Program
	{
		static void Important(string[] args)
		{
			Console.WriteLine("You handed {0} as an argument", args[0]);
		}
	}
}

You too can take command line arguments as enter, as this instance does. Discover the distinction in our Important() declaration

static void Important(string[] args)

This tells the compiler that we count on an argument or arguments to be handed to the executable. When the Console.WriteLine methodology executes, it would show what you typed as an argument.

Console.WriteLine("You handed {0} as an argument", args[0]);

Once more we’re utilizing {0} as a placeholder however on the finish you see args[0]. It is because args is a string array, and we wish the primary factor (keep in mind computer systems begin counting at zero) so we declare it there.

Kind in your executable with one thing after it, akin to

helloworld check

and you must see some output like:

You handed check as an argument

It’s that straightforward. You’ll be able to move a number of arguments to the executable and they are going to be numbered args[0], args[1] and so forth.

Conclusion

This was a tutorial to get your toes moist and write slightly code. There’s tons extra to go, however I hope this has no less than coated some fundamentals and given you a tough concept of how one can construct a console utility in C#. There’s tons extra and I’ll be digging deeper within the subsequent tutorial.

My intention for this tutorial and those following are to get individuals began programming, and hopefully construct a basis rapidly so you will get coding. Since most of my viewers is comprised of net builders we can be venturing into ASP.Internet stuff however constructing this core information will certainly assist you to be a greater developer sooner or later.

My finest recommendation is all the time to study the fundamentals. One factor I’ve seen through the years is builders who study simply sufficient to get the duty accomplished they wished and so they begin constructing on that. It’s a high quality method to do it however in case you don’t get a basis of the fundamentals constructed you’ll wrestle the entire approach. In case you study the deep fundamentals after which begin fixing issues, you’ll be much better off.

I hope this has helped, Let me know what you assume, I’ll repsond.

Are you able to beat my SkillIQ Rating in C#??

I believe you may! Take the C# check right here to see the place you stand!