How you can Be taught C# Half 3 – Coding Fundamentals

Final Replace: Dec 31, 2022

This tutorial is a part of a sequence. You possibly can see the opposite tutorials under:

On this third installment of my C# .NET tutorial sequence I’m going to speak concerning the fundamentals. We’ve slung a bit code and lined namespaces fairly good, and now we’re going to have a look at some stuff you’ll must know to put in writing code successfully in C#. I received’t dig too deep into these ideas, however offer you a very good overview of the fundamentals.

In the event you’ve already completed some C# or have expertise with one other programming language you possibly can most likely simply skim this tutorial and go to the subsequent one.

How you can compile the examples

I’m working off some suggestions right here, and I didn’t give sufficient element within the first chapter about working your packages. There are two methods to do it.

Choice 1: Compiling from the immediate

That is the way in which you need to be doing these workouts so that you may be extra conversant in coding by hand. When compiling from the command immediate you utilize csc.exe to compile the information. You possible received’t be doing it this fashion as you progress however for studying it’s a good way to be taught the fundamentals. Right here is the way it works.

You sort all of your code right into a textual content file (on this instance helloworld.cs) after which compile it with csc.exe by typing “csc helloworld.cs”. This creates an executable file referred to as helloworld.exe which you’ll run by typing in “helloworld” and urgent return.

You have to to create a folder in your exhausting drive for these information, and you’ll have to add csc to your path which I outlined in Chapter 1. Or you should utilize the Visible Studio Command Immediate which can have CSC in its path:

In the event you’re not too conversant in working from the command immediate, take a look at this Information to the Command Immediate to be taught the fundamentals.

Choice 2: Compiling from Visible Studio

Compiling in Visible Studio is even simpler, yow will discover the inexperienced “begin debugging” button on the prime:

You simply press the button or F5 to compile and run this system.

One factor you would possibly discover for those who’re constructing a console app resembling our hiya world app: it flashes on the display and dissapears. It’s because Visible Studio opens up a window, runs the packages after which exits.

There are two methods you possibly can clear up this, one is to drive your program to attend for enter, by placing the next in your code:

It will wait to your enter earlier than closing the window. An excellent higher and simpler possibility is to easily press CTRL+F5 to run this system, it should compile and run, then ask the consumer to press a key return. It would seem like this:

TIP: Be taught the hotkeys. In practically each business the place you see individuals working with growth environments whether or not it’s Visible Studio, Eclipse, Photoshop, Illustrator, and so forth you’ll discover the professionals rely closely on sizzling keys of their every day work. There’s a studying curve to realizing all of the totally different key combos and it takes time to get used to them, however when you do you’ll take pleasure in years of higher productiveness. I extremely advocate stepping into the behavior now so you possibly can work higher later.

So now that you realize the fundamentals of methods to compile your program, let’s get began on some extra fundamentals of utility building.

Primary Construction of a Program

Let’s take one other take a look at our hiya world app:

utilizing System;

namespace HelloWorldApp
{
	class Program
	{
		static void Principal()
		{
			Console.WriteLine("Howdy, World!");
		}
	}
}

Here’s what we will see in our program:

As you possibly can see the curly braces set up the elements of this system for you. The namespace is contained within the topmost and backside brace. The “Program” class is within the set of braces previous that, and the Principal() methodology is contained in yet one more set of braces. These are right here so you possibly can set up your program and the compiler can work out what you’re attempting to do.

Utilizing Directive – This lets you declare the kinds in that namespace for use with out qualifying them. I clarify this in additional element in half 2 of this sequence overlaying namespaces.

namespace – this defines your namespace, one thing we additionally lined in Chapter 2. This declares your code lives within the HelloWorldApp namespace.

class – courses are constructs to create a set of customized varieties and grouping them collectively in an object. On this case our class identify is “Program”. A category is a blueprint or template for knowledge, which is generally varieties, strategies and occasions. I’ll go over this extra intimately later, additionally to be taught extra about courses take a look at my Intro to Object Oriented Programming.

static void Principal() – This can be a perform named Principal(), which is a reserved identify for the entry level of this system. You outline this so the compiler is aware of the place to begin. The phrase “void” declares what sort of information this may return, on this case nothing. “Static” means this class member may be referred to as with out creating an occasion of the category, one thing I’ll clarify in future tutorials.

That is the hiya world app defined, however it doesn’t do a lot. Let’s make it do one thing.

Getting Enter

Make a replica of the helloworld.cs or create a brand new file named myname.cs, with the next code:

utilizing System;

namespace NameApp
{
	class Program
	{
		static void Principal()
		{
			Console.WriteLine("What's your identify?");

			string identify = Console.ReadLine();

			Console.WriteLine("Howdy {0}, good to satisfy you!", identify);
		}
	}
}

Kind in “csc identify.cs” and run it.

As you possibly can see, this utility has some new code to it. Listed below are the steps:

Show textual content asking for a reputation
Create a variable referred to as string, and get its enter from Console.ReadLine()
Write a brand new string with the variable inside and output it to the console.

This can be a very fundamental instance of enter and output (I/O) with a console utility.

The tactic Console.ReadLine() reads a line of textual content from the console. Whenever you press return it lets the strategy know to seize what was simply typed.

The information that you simply entered was then entered right into a variable which is an area to place knowledge. The identify of the variable is “identify” and earlier than that you simply see the phrase “string” which lets the compiler know to anticipate a string as the kind of knowledge to be saved in identify.

There are just a few methods we might initialize, or create the string variable:

Technique 1: Initialize it as clean and assign later

string identify;

identify = "Jeremy";

Technique 2: Initialize it and populate it:

Technique 3: Populate it with an expression

string identify = Console.ReadLine();

There are different methods we will populate variables, and we’ll get to all of them quickly.

In Console.WriteLine() we used an emblem – {0} as a placeholder to be populated with knowledge later. After the string was output, the 2nd parameter was specified as “identify” to let the WriteLine methodology know to switch {0} with the information from the string variable.

You possibly can mess around with this little, the truth is lets make some modifications. Create the next:

utilizing System;

namespace NameApp
{
	class Program
	{
		static void Principal(String[] args)
		{
			Console.WriteLine("Howdy {0}, good to satisfy you!", args[0]);
		}
	}
}

Kind in csc identify.cs after which run it by typing in identify.exe.

Did you get the next error?

Don’t fret, it’s no massive deal, the explanation you bought that error was as a result of the applying tried to make use of the args[0] variable however there was nothing there. I tricked you! You could put one thing after the executable identify, that’s what an “argument” is. In the event you seen the distinction within the Principal() methodology,

static void Principal(String[] args)

we ask for arguments to be handed right into a string array referred to as args. Then every argument is positioned into that string array so you should utilize it. Strive working it together with your identify as an argument.

identify.exe Jeremy

Now, you see the output you anticipated, proper? The WriteLine methodology nonetheless builds a string with {0} as a placeholder however then depends on args[0] for the information it wants. The [0] means its the primary factor within the record (computer systems begin numbering at 0) or the primary argument after the executable identify. A string array is just a listing of strings. Let’s modify our program a bit extra. Change line 9 to seem like this:

Console.WriteLine("Howdy {0} {1}, good to satisfy you!", args[0],args[1]);

As you possibly can see we now have two placeholders, {0} and {1} to cope with within the string. After the string output is asserted we see args[0] and args[1] that are the strings we use. Compile it and sort in your full identify this time.

identify Jeremy Morgan

See the output? That is how you are taking arguments from a command line.

Right here’s a cool little trick. Change your program with the next code:

utilizing System;

namespace NameApp
{
	class Program
	{
		static void Principal(String[] args)
		{
			foreach (string s in args)
			{
				Console.WriteLine(s);
			}
		}
	}
}

On this instance we’ll loop by means of our string array, and show every part that’s in it. The foreach assertion loops every time there’s a new factor in a string and creates the “s” variable to place it in. Inside the curly braces of that loop the WriteLine methodology will output the contents of the “s” variable.

To run it, sort in

identify John Jacob Jingleheimer Schmidt

and also you’ll see that it outputs each phrase within the record. Whether or not it’s one argument or many, it should cease as soon as there is no such thing as a extra knowledge within the args variable.

Two types of enter

Let’s make some modifications to our app. Let’s say we wish to mix it so we will both put in our identify as an argument, or by means of console enter. Right here’s the code:

utilizing System;
utilizing System.Collections.Generic;

namespace NameApp
{
	class Program
	{
		static void Principal(String[] args)
		{
			string identify;

			if (args.Size > 0)
			{
				identify = args[0];
			}
			else
			{
				Console.WriteLine("Please Enter Your Identify");
				identify = Console.ReadLine();
			}

			Console.WriteLine("Howdy {0} good to satisfy you!", identify);
		}
	}
}

Right here I’m introducing some new stuff, right here’s the essential circulate of this system

Run this system with or with out an argument
If an argument is entered, populate right into a string
If no argument is entered, ask for identify by way of console enter
Output the string with the identify included

Fairly easy stuff proper? However we had so as to add just a few issues to perform that.

Create a variable for our identify

We create a string variable referred to as identify, however we don’t put something in it but.

Aspect Word: if we attempt to use this variable earlier than placing something in it, the compiler will spit again an error. It’s okay to create a variable with nothing in it so long as you populate it later.

Verify for arguments

On this line we use an if assertion that checks the size of the args variable to see if there’s something in it. If there have been no arguments entered this quantity shall be zero, so we’re saying “if the variety of arguments is greater than zero do that stuff”.

Every thing that’s within the following braces shall be executed if that assertion is true, beginning with { and ending with }.

If we now have an argument, retailer it

Then this system exits this code block and continues.

If we dont have an argument..

}else {
	Console.WriteLine("Please Enter Your Identify");
	identify = Console.ReadLine();
}

If there aren’t any arguments (args.Size is zero) then every part inside these curly braces (code block) shall be executed.

Inside these braces we write some output to ask your identify, then within the subsequent line we use the ReadLine() methodology to populate identify, after which escape of the code block.

In order you seen we created the identify variable and gave two pathways to populating it. At this level within the code we all know the variable is populated by means of considered one of these strategies, so we output it:

Console.WriteLine("Howdy {0} good to satisfy you!", identify);

After this, we escape of the loop and exit the Principal() methodology and exit this system. Do not forget that error we obtained earlier? That was as a result of we put in no arguments so we ended up attempting to make use of a variable that wasn’t populated with knowledge. With this system we simply wrote we corrected that downside by ensuring the variables would comprise knowledge earlier than we used them.

That is the sort of considering it’s a must to begin getting used to as a result of C# is a statically typed program, which means it’s a must to outline all of your varieties earlier than this system will compile and for those who attempt to use variables with no knowledge in them this system will break. That is totally different from dynamically typed languages resembling JavaScript or PHP.

*Word: My opinion on static typing in C#: I adore it. It might appear inflexible and harsh to make you declare all of your variables as a kind and guarantee they’re populated for it to work correctly, however it makes debugging a lot simpler down the street. I don’t like unfastened typing as a result of that “free for all” can result in some actually unhealthy code, and simply because it really works doesn’t imply the job is completed. You’ll spend extra time debugging code than writing it so something that saves you time and makes it clearer is an efficient factor. I’ll get off my cleaning soap field now.

Abstract

Okay so this was a protracted one, however no less than we obtained to sling some code. We went over the 2 methods to compile and run your program, checked out our hiya world app a bit nearer and we labored with some enter on the command line. I hope that is serving to you construct a greater understanding of how programming in C# works. We nonetheless have a protracted methods to go however I believe at this level you need to be snug with modifying the code and enjoying round a bit.

Within the subsequent chapter we’re going to cowl some extra fundamental coding stuff and dig in a bit deeper. I hope you’ll test it out and provides some suggestions on these tutorials. I’m relying heavy on this suggestions as a result of I need this to be as useful as potential for years to come back. Be happy to attain out and let me know the way I’m doing.