Make a Simple Command Line Music Player With C# #2

The difference between an instance and a static object is subtle however very useful and important.
  
When a class is created if it has instance variables new ones will be created and associated to that new class object with their default values. Theise variables are seperate from all other instances of the class so changing their values will NOT affect the values on another instance of the class. However when a static variable is used this variable is not recreated each time a new instance of the class is created. So changing their values WILL affect all other instances of the class.
  
An example of this is shown below

public class Foo
{
    public static int staticInt;
    public int instancedInt;

    public int GetStaticInt()
    {
        return staticInt;
    }
}

public class Example
{
    void Bar()
    {
        var var1 = new Foo();
        var var2 = new Foo();

        var1.instancedInt = 2;
        var2.instancedInt = 5;

        var1.staticInt = 3; //Error
        Foo.staticInt = 3; //works

        Console.WriteLine(var1.instancedInt); //returns 2
        Console.WriteLine(var2.instancedInt); //returns 5
        Console.WriteLine(var1.GetStaticInt()); //returns 3
        Console.WriteLine(var2.GetStaticInt()); //returns 3
    }
}



Here is also another explanation of instanced and static variables: Programming Interview.com - What’s the difference between a class variable and an instance variable?
And another from Dot Net Perls: Dot Net Perls - C# Static Method, Class, and Constructor
  

A static method works in the same way to the static variable. However appart from the arguments passed into the function and the variables defined in the function the only other outside variables it may use are the static variables in the containing class. However, unlike a static variable a static method can be called from an instance of the class.

An instance method can access non-static or instanced variables in the class and will reference the variable values from the instance that it is called from. However, this method must be called from an instance of the class.

An example and explanation from Dot Net Perls: Dot Net Perls - C# Static Method, Class, and Constructor

A return type is the type of data that the method will give back.
So if you don't want a method to return anything you can say that the return type is void. However, if you want to return some data you can return any type of data, for example you can return a class just as easily as an int.
  
To return some data from a method all you need to do is use the return before the data you want to return. An example is shown below

public int Foo()
{
  return 1; 
}

This is because when searching through the files we will not know how many music files there actually are. As an array requires a length when initialized this would either cause us to set a size to large or too small, this is not ideal so instead we use a List
  

There is no set rule as to when to and when not to use an array as opposed to List<> so I can only suggest when to use them and tell you when I would use one as opposed to the other. I would use a List<> when the ammout of data is ambiguous so there is no way to tell the length the array should be. Situations like this arise when users input is requred that changes the ammout of elements in the List<>. All other times I would most likely use an array. There are also a few cases when the C# Linq library will only work with a List<> so when a Linq's function has the possibility of being required I will also use a List<>.

A for says that something should be performed N number of times and it does not have to iterate over a IEnumerable. You can just say to go between 2 numbers adding each inturn. However a foreach loop goes over each item in an IEnumerable object in turn. Or in other words perform this code on each item in this list/array.

You should use a foreach loop when you have a list of things that will all need to have the same thing done to them and the index of the item is not important then you should use a foreach loop, due to the fact that it is safer (cannot try to acces an index outside of the arrays bounds). Otherwise if the index is important, you must skip evey other element, etc you should use a for loop.

An enum or Enumeration type is a special value they allows you to specify a group of named numeric constants.

They can be defined like so:
public enum Foo {ENUMONE, ENUMTWO, ENUMTHREE}

public enum Foo {ENUMONE = 0.5, ENUMTWO, ENUMTHREE}

var example = Foo.EUMONE;

decimal example2 = (decimal)example;

Method overloading allows 2 methods to be defined with the same name in the same class however with a different number of arguments or different input types (have a unique method signature). Each of these different methods may have different logic.

Example:
public void Foo(int x) {...}
public void Foo(float x) {...}
public void Foo(int x, int y) {...}


All of these methods can coexist in the same class as they each have different signatures (the number and types of data passed into a method).

If you tried this:
public void Foo(int x) {...}
public void Foo(int y) {...}

This would not work as the argument name does not affect the signature of the method.

Overloaded methods also cannot return different types and the params keyword do not cout as part of the method signature an example of the params usage is seen below:
public void Foo(int x) {...}
public void Foo(params int x) {...}


The above would cause an error.

Method overloading is very useful and you should play around with it when you get a chance.

If you only have one line of code and one branch to an if C# will allow you to just not use {} it also reduces the size of the code on the website so I will use that feature whenever I can. You dont have to it is personal preference as it does not affect performance in any way.

The var type is a type that can be assigned any data type. It is effectively short had for a variable decleration. However there can be no ambiguity in the data type it is short hand for so the variable must be assigned value during its creation if useing the var keyword. In the above code it is assigned a types of string as Directory.GetFiles() returns a type of string[].

The continue is a keyword that is mainly used in loops and it is used to ignore this iteration and move onto the next an example is shown below:

for (int i = 0; i < 3; i++)
{
  if (i == 1)
    continue; // ignore all other code below this and move onto the next iteration of the loop 

  Console.WriteLine(i);
}

This will output: 0, 2. As you can see 1 is ignored as all code below continue was ignored for that iteration of the loop.

Whilst they can both be used to exit a piece of code the the amount they exit differs. So a break statement will exit the current loop and a return statement will exit the current method or return to the next iteration of the loop.
    
Example of a break and return in a while loop:

void Foo()
{
  int x = -1;
  while(true)
  {
    if(x == 0)
      break;         // escape while() and jump to execute code after the the loop
    else if(x == 1)
      return;        // will end the function Foo() immediately,
            // no further code inside this method will be executed

    //do stuff eventually setting variable x to either 0 or 1
  }

  //code that will be executed on break (but not with return)
}



So as you can see the break will exit the while loop and return will exit the method Foo()

They also work the same in a foor loop as can be seen below:


void Foo()
{
  for(int i = 0; i < 10; i++)
  {
    if(i == 0)
      break;         // exit the loop and go to the code after the loop
    else if(i == 5)
      return;        // will end the function Foo() immediately,
            // no further code inside this method will be executed
  }

  //code that will be executed on break
}



return can also be uesd to give data out of a function by putting some data after the statement as shown:

int Foo()
{
  return 1; 
}

This is to bring to attention the different numerical types that C# has a few different commonly used numeric types and then a few less common. The common types are as follows: 
int
float
double
decimal
Bar int each of the types may hold real numbers (numbers with a decimal part). Each of these is also a signed value meaning it can hold negative numbers.

The unsigned value types are show below in order of acending max value: 
byte
ushort
uint
ulong
All of these types can only hold integers (a whole number) so as you can see only integral types can become unsigned. All of these types can become signed values by removeing the preceding u, except in the case of the btye where we add a preceding s resulting in sbyte.

When to use each of the different types is mostly personal preference hoewver some differences are that int cannot divide by 0 and will result in an error where as a float will instead not produce an error. By default when typeing a number like 0.5 its type will be a double in C# to convert this to a float we must write 0.5f and to convert to an int we can type:

int x = (int)0.5

Resulting in an int value of 0 as decimal to intreger conversion truncates the decimal part.