C# Tutorials

1. C# - Introduction & Installation
2. C# - Line by Line Explanations
3. C# - Variables, Constants, Concatenation
4. C# - Data Types & Type Detection
5. C# - User Input & Basic Operations
6. C# - String Operations
7. C# - Math Operations - Max, Min, Abs, Sqrt, Round
8. C# - if..else if..else
9. C# - Switch Statement
10. C# - For Loop
11. C# - While & Do..While Loop
12. C# - Arrays and Foreach Loop
13. C# - Array Operations
14. C# - Break & Continue
15. C# - Methods
16. C# - Method Parameters and Default Params
17. C# - Return Value from Method
18. C# - Change Order of Parameters
19. C# - Method Overloading
20. C# - Exceptions - Try..Catch..Finally
21. C# OO - Namespaces - Internal
22. C# OO - Namespaces - External Files
23. C# OO - DLL Files - How to Create .dll
24. C# OO - Objects and Classes
25. C# OO - Objects and External Classes
26. C# OO - Objects from External Namespaces
27. C# OO - Objects from DLL Files
28. C# OO - Object Modification
29. C# OO - Constructors
30. C# OO - Constructor Parameters
31. C# OO - Private - Access Modifiers
32. C# OO - Getters and Setters
33. C# OO - Automatic Properties - { get; set; }
34. C# OO - Inheritance
35. C# OO - Polymorphism - Virtual and Override
36. C# OO - Abstract Classes & Methods
37. C# OO - Interface
38. C# OO - Multiple Interfaces
39. C# OO - Enum and Switch Statement
40. C# OO - Read From and Write to a Text File

C# OO - Read From and Write to a Text File

Program.cs

using System;
using System.IO;

namespace LearnCS
{
    class Program
    {        
        static void Main(string[] args)
        {
            string toFile = "I will be sent to external file";
            File.WriteAllText("external.txt", toFile);

            string fromFile = File.ReadAllText("external.txt");
            Console.WriteLine(fromFile);

            Console.ReadLine();
        }
    }
}

C# OO - Enum and Switch Statement

Program.cs

using System;

namespace LearnCS
{ 
    class Program
    {
        enum Options
        {
            Audio,
            Video,
            Controls
        }
        static void Main(string[] args)
        {
            Options c1 = Options.Controls;
            //Console.WriteLine(c1);

            switch(c1)
            {
                case Options.Audio:
                    Console.WriteLine("Audio Settings");
                    break;
                case Options.Video:
                    Console.WriteLine("Video Settings");
                    break;
                case Options.Controls:
                    Console.WriteLine("Controls");
                    break;
            }

            Console.ReadLine();
        }
    }
}

C# OO - Multiple Interfaces

Program.cs

using System;

namespace LearnCS
{
    interface IBackupA
    {
        void BackupA();
    }
    interface IBackupB
    {
        void BackupB();
    }

    class Sec : IBackupA, IBackupB
    {
        public void BackupA()
        {
            Console.WriteLine("I Will backup Server A");
        }
        public void BackupB()
        {
            Console.WriteLine("I Will backup Server B");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Sec p1 = new Sec();
            p1.BackupA();
            p1.BackupB();

            Console.ReadLine();
        }
    }
}

C# OO - Interface

Program.cs

using System;

namespace LearnCS
{
    interface IPrim
    {
        void IPrimPrint();        
    }

    class Sec : IPrim
    {
        public void IPrimPrint()
        {
            Console.WriteLine("Body of Method must be in Sec Class");
        }        
    }

    class Program
    {
        static void Main(string[] args)
        {
            Sec p1 = new Sec();
            p1.IPrimPrint();            

            Console.ReadLine();
        }
    }
}

C# OO - Abstract Classes & Methods

using System;

namespace LearnCS
{
    abstract class Prim
    {
        public abstract void PrimPrinter();        
    }

    class Sec : Prim
    {
        public override void PrimPrinter()
        {
            Console.WriteLine("Now I can be used");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {

            Sec p1 = new Sec();
            p1.PrimPrinter();

            Console.ReadLine();
        }
    }
}

C# OO - Polymorphism - Virtual and Override

using System;

namespace LearnCS
{
    class Prim
    {
        public virtual void sameMethod()
        {
            Console.WriteLine("sameMethod, Prim Class, Simple Job");
        }
    }

    class Sec : Prim
    {
        public override void sameMethod()
        {
            Console.WriteLine("sameMethod, Sec Class, Complicated Job");
        }

    }

    class Tert : Prim
    {
        public override void sameMethod()
        {
            Console.WriteLine("sameMethod, Tert Class, Defficult Job");
        }
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            Prim p1 = new Prim(); //Something Basic/Simple
            Prim p2 = new Sec(); //Complicated Job
            Prim p3 = new Tert(); //Difficult Job

            p1.sameMethod();
            p2.sameMethod();
            p3.sameMethod();

            Console.ReadLine();
        }
    }
}

C# OO - Inheritance

Program.cs

using System;

namespace LearnCS
{
    class Prim
    {
        public string primString = "Value From Prim Class";

        public void primPrinter()
        {
            Console.WriteLine("I am result of primPrinter Method");
        }
    }

    class Sec : Prim
    {
        public string secString = "Value from Sec Class";
    }
    class Program
    {
        static void Main(string[] args)
        {
            Sec p1 = new Sec();
            Console.WriteLine(p1.primString);
            p1.primPrinter();

            Console.WriteLine(p1.secString);

            Console.ReadLine();
        }
    }
}

C# OO - Automatic Properties - { get; set; }

using System;

namespace LearnCS
{
    class Storage {
        public string someString
        { get; set; }
       
        public int someNumber 
        { get; set; }
    }
   
    class Program
    {
        static void Main(string[] args)
        {
            Storage p1 = new Storage();

            p1.someString = "New Value";
            Console.WriteLine(p1.someString);

            Storage p2 = new Storage();
            p2.someNumber = 654546;
            Console.WriteLine(p2.someNumber);

            Console.ReadLine();
        }
    }
}

C# OO - Getters and Setters

Program.cs

using System;

namespace LearnCS
{
    class Storage {
        private string someString;   //fields
        public string MitmString    //property
        {
            get { return someString; }  //getter
            set { someString = value; }   //setter
        }

        private int Number;
        public int MitmNumber
        {
            get { return Number; }
            set { Number = value; }
        }
    }
   
    class Program
    {
        static void Main(string[] args)
        {
            //Storage p1 = new Storage();
            //p1.MitmString = "New Value";

            //Console.WriteLine(p1.MitmString);

            Storage p2 = new Storage();
            p2.MitmNumber = 5000;

            Console.WriteLine(p2.MitmNumber);

            Console.ReadLine();
        }
    }
}

C# OO - Private - Access Modifiers

Program.cs

using System;

namespace LearnCS
{
    class Storage {
        private string someString = "Something Simple";
        private int privID = 5;

        public int MultiBy2() {
            return (privID * 2);
        }

        public string DoubleIt() {
            return (someString + " " + someString);
        }
    }
   
    class Program
    {
        static void Main(string[] args)
        {

            Storage p1 = new Storage();
            //Console.WriteLine(p1.someString);

            Console.WriteLine(p1.MultiBy2());
            Console.WriteLine(p1.DoubleIt());

            Console.ReadLine();
        }
    }
}

C# OO - Constructor Parameters

Program.cs

using System;

namespace LearnCS
{
    class Product
    {
        string prodStatus; //activ or obsolete
        int prodID; //individual product number
        char prodWarehouse; //storage, M for Moscow, B for Berlin

        Product(string status, int ID, char warehouse) {
            prodStatus = status;
            prodID = ID;
            prodWarehouse = warehouse;
        }        

        static void Main(string[] args)
        {
            Product p1 = new Product("activ", 123456, 'M');

            Console.WriteLine(p1.prodStatus);
            Console.WriteLine(p1.prodID);
            Console.WriteLine(p1.prodWarehouse);

            Console.ReadLine();
        }
    }
}

C# OO - Constructors

Program.cs

using System;

namespace LearnCS
{
    class Person
    {
        string status;

        Person() {
            status = "activ";
        }

        static void Main(string[] args)
        {

            Person p1 = new Person();
            Console.WriteLine(p1.status);

            Person p2 = new Person();
            Console.WriteLine(p2.status);

            Console.ReadLine();
        }
    }
}

C# OO - Object Modification

Program.cs

using System;

namespace LearnCS
{
    class Person
    {
        string name;
        string lastname;
        int SSN;

        static void Main(string[] args)
        {

            Person p1 = new Person();
            p1.name = "John";
            p1.lastname = "Snow";
            p1.SSN = 456465456;

            Console.WriteLine("P1 Name: " + p1.name);
            Console.WriteLine("P1 LastName: " + p1.lastname);
            Console.WriteLine("P1 SSN: " + p1.SSN);

            p1.SSN = 1111111111;

            Console.WriteLine("P1 Name: " + p1.name);
            Console.WriteLine("P1 LastName: " + p1.lastname);
            Console.WriteLine("P1 SSN: " + p1.SSN);

            Console.ReadLine();
        }
    }
}

C# OO - Objects from DLL Files

ExternalClass.cs

using System;
using System.Collections.Generic;
using System.Text;
using LearnCS;

namespace LearnCS
{
    public class ExternalClass
    {
        public int x = 5;
        public string someString = "Some String";
        public char someChar = 'Z';
    }
}

namespace PrintingMethods
{
    public class Printer
    {
        public static void PrintA()
        {
            ExternalClass genericObject = new ExternalClass();
            Console.WriteLine("----------------------------");
            Console.WriteLine(genericObject.x);
            Console.WriteLine(genericObject.someString);
            Console.WriteLine(genericObject.someChar);
        }
    }
}

namespace MultiMethods { 
    public class Multiplicators
    {
        public static void MultiBy2()
        {
            ExternalClass genericObject = new ExternalClass();
            Console.WriteLine("----------------------------");
            Console.WriteLine("Result from MultiBy2 using Generic Object: ");
            Console.WriteLine(genericObject.x * 2);
        }
    }
}

Program.cs

using System;
usimg PrintingMethods;
using MultiMethods;

namespace LearnCS
{
    class Program
    {
        static void Main(string[] args)
        {
            ExternalClass firstObject = new ExternalClass();
            Console.WriteLine(firstObject.x);
            Console.WriteLine(firstObject.someString);
            Console.WriteLine(firstObject.someChar);

            Printer.PrintA();
            Multiplicator.MultiBy2();
            Console.ReadLine();
        }
    }
}

C# OO - Objects from External Namespaces

 ExternalClass.cs

using System;
using System.Collections.Generic;
using System.Text;
using LearnCS;

namespace LearnCS
{
    public class ExternalClass
    {
        public int x = 5;
        public string someString = "Some String";
        public char someChar = 'Z';
    }
}

namespace PrintingMethods
{
    public class Printer
    {
        public static void PrintA() {
            ExternalClass genericObject = new ExternalClass();
            Console.WriteLine("----------------------------");
            Console.WriteLine(genericObject.x);
            Console.WriteLine(genericObject.someString);
            Console.WriteLine(genericObject.someChar);
        }
    }
}

Program.cs

using System;
using PrintingMethods;

namespace LearnCS
{
    class Program
    {       
        static void Main(string[] args)
        {

            ExternalClass firstobject = new ExternalClass();
            Console.WriteLine(firstobject.x);
            Console.WriteLine(firstobject.someString);
            Console.WriteLine(firstobject.someChar);

            Printer.PrintA();            

            Console.ReadLine();
        }
    }
}

C# OO - Objects and External Classes

ExternalClass.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace LearnCS
{
    public class ExternalClass
    {
        public int x = 5;
        public string someString = "Some String";
        public char someChar = 'Z';
    }
}

Program.cs

using System;

namespace LearnCS
{
    class Program
    {       
        static void Main(string[] args)
        {

            ExternalClass firstobject = new ExternalClass();
            Console.WriteLine(firstobject.x);
            Console.WriteLine(firstobject.someString);
            Console.WriteLine(firstobject.someChar);

            Console.WriteLine("----------------------------------");
            ExternalClass secondobject = new ExternalClass();
            Console.WriteLine(secondobject.x);
            Console.WriteLine(secondobject.someString);
            Console.WriteLine(secondobject.someChar);

            Console.ReadLine();
        }
    }
}

C# OO - Objects and Classes

using System;

namespace LearnCS
{
    class Program
    {
        string x = "Generic Characteristic";

        static void Outsider()
        {
            Program generic = new Program();
            Console.WriteLine(generic.x);
        }

        static void Main(string[] args)
        {

            Program firstObject = new Program();
            Console.WriteLine(firstObject.x);

            Program secondObject = new Program();
            Console.WriteLine(secondObject.x);

            Outsider();

            Console.ReadLine();
        }
    }
}

C# OO - DLL Files - How to Create .dll

DirectPrinter.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DirectPrinter
{
    public class DirectA
    {
        public static void DirectPrintA()
        {
            Console.WriteLine("Line from DirectPrintA Method, from DirectA Class");
        }
    }
    public class DirectB
    {
        public static void DirectPrintB()
        {
            Console.WriteLine("Line from DirectPrintB Method, from DirectB Class");
        }
    }
}

Program.cs

using System;
using DirectPrinter;
//using DDPA = DirectPrinter;

namespace LearnCS
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("I am from Main File");

            ExternalSource.ExternalMethod();
            Console.WriteLine("Variable from External Source: " + ExternalSource.x);

            //Stuff from External Source

            DirectA.DirectPrintA();
            DirectB.DirectPrintB();

            Console.ReadLine();
        }
    }
    class ExternalSource
    {
        public static void ExternalMethod()
        {
            Console.WriteLine("But, I am from External Method");
        }

        public static int x = 100;
    }
}

C# OO - Namespaces - External Files

ExternalSource.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace LearnCS
{
    class ExternalSource
    {
        public static void ExternalMethod() {
            Console.WriteLine("But, I am from External Method");
        }

        public static int x = 100;
    }
}

namespace DirectPrinter
{
    class DirectA
    {
        public static void DirectPrintA() {
            Console.WriteLine("Line from DirectPrintA Method, from DirectA Class");
        }
    }
    class DirectB
    {
        public static void DirectPrintB()
        {
            Console.WriteLine("Line from DirectPrintB Method, from DirectB Class");
        }
    }
}

Program.cs

using System;
using DirectPrinter;
//using DDPA = DirectPrinter;

namespace LearnCS
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("I am from Main File");

            ExternalSource.ExternalMethod();
            Console.WriteLine("Variable from External Source: " + ExternalSource.x);

            //Stuff from External Source

            DirectA.DirectPrintA();
            DirectB.DirectPrintB();

            Console.ReadLine();
        }
    }
}