Dev Tasks

You can write to the console with Console.WriteLine();
Example:

Console.WriteLine("Hello World");

A variable is a container for a value. It allows you to store information for later use.
Before you can use a variable, you must declare it. You can declare the variable using the following format:

[variableType] [variableName] = [variableValue];

int //integer, use for whole numbers.
string //string is used to store text.
double //used to store decimal numbers, like 3.14
bool //used to store TRUE and FALSE.

Declare variables first by typing its type, then its name. Optionally followed by setting its value.

int value;
int value = 10;
int variableName = 100;

Declare the variable:

string variableName = "Hello";

string variableName = "Hello";
Console.WriteLine(variableName);

You can increment a variable in several ways (you can do the same with subtraction)

value = value + 1;  //Adds 1 to value;
		value++; //Adds 1 to value;
		value = value + 10; //Adds 10 to value;
		value += 10; //Adds 10 to value;

int value = 10;
value++;
Console.WriteLine(value);

An IF statement is the most common, widely used and most useful flow control statement in existence. Is tells the program to only do somehitng if a condition is true. This allows your program to act differently based on inputs.
Example:

if(userName = = "Aiden")
{
	Console.WriteLine("Hello Aiden");
}

An else statement is optional and is used in conjunction with an IF statement. It tells the program what to do if the IF statement is NOT true.
Example:

if(userName == "Aiden")
{
	Console.WriteLine("Hello Aiden!");
}
else (This is the ELSE statement.)
{
	Console.WriteLine("Hello Sombody else!");
}

An ELSE-IF statement is optional and is used in conjunction with an IF statement. It tells the program what to do if the original IF statement is NOT true but the next statement IS true.
Example:

if(userName == "Aiden")
{
	Console.WriteLine("Hello Aiden!");
}
else if(userName = = "Cole") (This is the ELSE IF)
{
	Console.WriteLine("Hello Cole!");
}
else
{
	Console.WriteLine("Hello Sombody else!");
}

You will need to use an IF and an ELSE such as in the following example:

int value = 10;

if(value > 5)
{
	Console.WriteLine("BIG");
}
else
{
	Console.WriteLine("SMALL");
}

A function is a collection of code that can be reused and called from various places in code.
For example, the function String.ToString() is a function that you will use alot. It contains all of the code to convert your variable to a string so you dont have to write all that code yourself each time.
A function typically takes parameters and returns a value and typically looks like this pseudo code:

[ReturnType] [FunctionName]([parameters])
{
	[code body....]
	return [return value];
}

int Times10(int value)
{
	return value * 10;
}

Example:

int MyMultiply(int x, int y)
{
	return x * y;
}

void main()
{
	Console.WiteLine(MyMultiply(5, 10));
}

int MyMultiply(int x, int y)
{
	return x * y;
}

while
for
do-while

You can control the flow of a loop with break; and continue;
Break tells the loop to exit now, even if the loop condition is still true.
Continue tells the program to go back to the top of the loop and start over without reaching the end of the loop.

While is like "if", it takes a condition and continues to loop over the scope defined by the curly brackets as long as that condition is true.
Example:

int value = 0;
while(value < 10)
{
	Console.WriteLine(value);
	value++; //This increments the value by one.
}

For this task you will need to use a while loop, Console.ReadLine and Console.WriteLine.
Just like you can write text with Console.WriteLine(), you can get text from the user with the Console.ReadLine() function.
To make a loop infinite, you need to specify a condition that is always true. Such as 1 = = 1 or simply true.
Example:

while(true)
{
	userInput = Console.ReadLine();
	Console.WriteLine(userInput);
}

Again we will be using Console.ReadLine() but will also be using the flow control function BREAK to exit the loop.
Example:

while(true)
{
	string text = Console.ReadLine();
	if(text == "exit")
	{
		break;
	}
}

Example:

Console.WriteLine("What is your name?");
string personName = Console.ReadLine();

while(true)
{
	string text = Console.ReadLine();
	if(text == "hi")
	{
		Console.WriteLine($"Hello {personName}!");
	}
}

A class is a collection of variables and functions that is "packaged up" and reusable. They also support things like inheritence, which we will get into later.
Classes generally have to be instantiated (which means to create an instance of). Just like you can declare a string called firstName and string called lastName, you can create multiple instances of your own classes too.

string
int
double
Console
MessageBox

Class accessibility levels tell the class whether a function, property, or variable can be accessed from outside of the class or project.

public - The function or variable can be access by all code.
private - The function or variable can only be accessed by the class itself.
More advanced protection levels are (more on these later):
protected - The function or variable can only be accessed by the class itself and other classes derived from that class. More on that later.
internal - The function or variable is only accessible to the assembly (think: program),

Just like regular functions, a class function is a collection of C# code that can be reused, in this case that function would belong to a class.

On the most basic level. a class property is like a variable that belongs to a class. Its value can be set and retreived. While it is not a function, you can write code that controls how the property is set and retreived.

Example:

public class Automobile {
	public string Color;
	public int Weight;
}

Before using a class we have to declare a variable of the class type (just like we would declare any other variable), but then we also have to instanciate it. This means we have to create an instance of the class and set it to our variable.
*Example:*

//Declare the variable:
Automobile mycar;

//Instanciate the variable
mycar = new Automobile();

//Set some class instance variables:
mycar.Color = "RED";
mycar.Weight = 1000;

Previously when we looked at classes we saw hoe we have to create an instance of a class in order to use it. This is not always the case. When we declare a class as static, we are staying that there is only one instance and it is already instanciated.

Example:

static class Person {
	public string FirstName;
	public string LastName;
}

As you can see from the example below, we do not have to declare a variable for the Person class or instanciate it because its a STATIC class.
Example:

Person.FirstName = "John";
Person.LastName = "Smith";

Console.WriteLine($"{Person.FirstName} {Person.LastName}")'

A string is just a class, it has properties and one of those properties is the LENGTH property. This allows us yo easily figure out how long a string of text is.
someVariable.Length -or- "".Length
Example:

string text = "Hello Cruel World";
Console.WriteLine(text.Length);

You can isolate parts of a string with the string class method SubString()
In this example you will see that the SubScring fnuction takes two parameters: a starting position and a length. We will pass 6 as the starting position which is the length of "HELLO ". Then we will pass 5 as the length which is the length of the word "Cruel". This will extract that part of the string and return it.
Example:

string text = "Hello Cruel World";
Console.WriteLine(text.SubString(6, 5));

You can see the events exposed to a class (yes, button is a class) by hitting dot (.) after the class instance name.
buttonOk.Clicked +=
In visual studio, the program will auto complete the various components to "wire up" the event when you hit tab.