Learn C# in One Day

Mini Bytes: You would be surprised, how i am going to teach C# language in one day. But it is possible, you can learn C# in one day, only if you know the basic of C/C++ language. If you don’t know basic of C/C++ then it would be difficult for you to learn C# language.

C# is a object oriented programming language. It was developed by Microsoft which is mostly based on C and C++ programming language.

In order to learn C# in one day, you need to do some required software’s for compiling the programs. You can download visual studio 2017 community edition and install it in your computer. This software was developed by Microsoft and it was free to use for education purpose.

Note: In this article i am not going to use any of the technical words which was used in C#. I going to use only normal keywords which you can understand so that you can learn C# in one day. Some of the keywords may seem technical but trust me those are program keywords.

Lets see some advantages of C# languages.

  1. Automatic garbage collections.
  2. Standard library.
  3. Assembly versioning.
  4. Events and properties.
  5. Indexers.
  6. Linq and Lambda expressions.
  7. Windows integration.
  8. Easy generics.
  9. Multi-threading.
  10. Events and delegates management.

Lets go to the topic. Below are the topics which i am going to discuss with examples.

  1. Syntax.
  3. Data Types.
  4. Variables.
  5. Type Conversions.
  6. Constants.
  7. Operators.
  8. Loops.
  9. Switch.
  10. Arrays.
  11. Namespace.
  12. Methods.
  13. String Manipulation.
  14. Class.
  15. Struct.
  16. Enums.
  17. Inheritance.
  18. Polymorphism.
  19. Overloading operator.
  20. Interface
  21. Try.
  22. Catch.
  23. Multiple Catch.
  24. Final.
  25. File I/O.

C# – Syntax:

You can easily learn c# in one day, if you know the basic syntax of the C# language. Like the common object oriented languages, C# language has simple an common syntax which looks much like the C and C++ language.

public class HelloWorld                    //creating a class (public: access the class throughout the program)
   {                                       //starting a class
      static void Main(string[] args)      //function or method
      {                                    //creating a function
         Console.WriteLine("Hello World"); //displays a value in console
         Console.ReadLine();               //holds the command prompt from closing 
      }                                    //ending a function
   }                                       //ending a class

Above code will open a command prompt and displays “Hello World”. Class was declared as public so you can access any of the methods created inside throughout the program.

C# – Comments:

  1.  // -> one line comment.
  2. /* Your comments here*/ -> Multiple line comments.
public class HelloWorld                   //One line comment
/* Multiple line comment
line 1
line 2 */
      static void Main(string[] args)     
         Console.WriteLine("Hello World");

Tip: /// -> This syntax can be used to trigger a comment summary in your Visual Studio 2017.

C# – Data Types:

Data types can be categorized into 3 types.

  1. Value types
  2. Pointer types
  3. Reference types

Please refer the data types in detail to learn C# data types.

Values Types:

Below are the value data types you can use in your C# program.

Type Represents Range Default Value
bool Boolean value True or False False
byte 8-bit unsigned integer 0 to 255 0
char 16-bit Unicode character U +0000 to U +ffff ‘\0’
decimal 128-bit precise decimal values with 28-29 significant digits (-7.9 x 1028 to 7.9 x 1028) / 100 to 28 0.0M
double 64-bit double-precision floating point type (+/-)5.0 x 10-324 to (+/-)1.7 x 10308 0.0D
float 32-bit single-precision floating point type -3.4 x 1038 to + 3.4 x 1038 0.0F
int 32-bit signed integer type -2,147,483,648 to 2,147,483,647 0
long 64-bit signed integer type -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 0L
sbyte 8-bit signed integer type -128 to 127 0
short 16-bit signed integer type -32,768 to 32,767 0
uint 32-bit unsigned integer type 0 to 4,294,967,295 0
ulong 64-bit unsigned integer type 0 to 18,446,744,073,709,551,615 0
ushort 16-bit unsigned integer type 0 to 65,535 0

Pointer type:

You can use these type of variables to store the pointers. i.e. it was used to store the memory address of another data type.


int* iptr;

char* cptr;

Reference type:

Reference type is used to store the references to their data objects. Below are some of the reference type examples.

The following keywords are used to declare reference types:

C# also provides the following built-in reference types:

C# – Variables:

Variables are nothing but a name that you assign to the storage location. Variables can be of different types such as integer, float, decimal, string etc…You need to assign a name which can be understandable by the coders.



<data_type> <variable_name> = value;


int i, j, k;
char c, ch;
float f, salary;
double d;

Above are declared variables, but if you want to initialize a variable, then you need to assign values to the variable, like you fill the storage area with necessary content which you need to store.

C# – Type Conversions:

Type conversions are used to convert one data type to another data type. Thought you cant able to convert all the available data type to necessary data, below are some of the data type conversion methods you can use.


Sr.No. Methods & Description
1 ToBoolean

Converts a type to a Boolean value, where possible.

2 ToByte

Converts a type to a byte.

3 ToChar

Converts a type to a single Unicode character, where possible.

4 ToDateTime

Converts a type (integer or string type) to date-time structures.

5 ToDecimal

Converts a floating point or integer type to a decimal type.

6 ToDouble

Converts a type to a double type.

7 ToInt16

Converts a type to a 16-bit integer.

8 ToInt32

Converts a type to a 32-bit integer.

9 ToInt64

Converts a type to a 64-bit integer.

10 ToSbyte

Converts a type to a signed byte type.

11 ToSingle

Converts a type to a small floating point number.

12 ToString

Converts a type to a string.

13 ToType

Converts a type to a specified type.

14 ToUInt16

Converts a type to an unsigned int type.

15 ToUInt32

Converts a type to an unsigned long type.

16 ToUInt64

Converts a type to an unsigned big integer.


int x = 10;
//Displays the integer as string in message box.

Type conversions completely depend on the type of data which you are going to convert. There are certain methods available which do throw error if the type conversions doesn’t work much like we want.

C# – Constant:

If you assign a constant variable , then this variable cannot be modified at the time of execution.

Constant can be of any type like integer, floating or character. Below are some of the literals which we can use


Character constants should always be enclosed inside single quotes and it can be assigned to a variable.

Escape sequence Meaning
\\ \ character
\’ ‘ character
\” ” character
\? ? character
\a Alert or bell
\b Backspace
\f Form feed
\n Newline
\r Carriage return
\t Horizontal tab
\v Vertical tab
\xhh . . . Hexadecimal number of one or more digits


const <data_type> <constant_name> = value;


const int value = 10;

C# – Operator:

Operators are the symbols which was used by the compiler to do the arithmetic operations such as addition, multiplication, subtraction etc…There are 6 different kinds of operator.

  • Arithmetic Operators (+, -, *, ++, –, /, % etc…)
  • Relational Operators (=, !=, >=, <=, >, < etc…)
  • Logical Operators (&&, ||, !)
  • Bitwise Operators( &, |, ^ etc…)
  • Assignment Operators (=, += , -=, *=, !=, >>=, <<= etc…)
  • Misc Operators (sizeof(), typeof(), *,&,is,as etc…)



int a = 10;
int b = 10;
int c;
c = a + b;

C# – Loops:

In C# loops are used to execute the code several times. I.e you can run the code whenever the condition is satisfied or not, or you can run the code for specific number of times. Different kinds of loops which are using in C# are as follows


While Loop:

while (<condition>)
//do your stuff

For Loop:

for (int i = 0; i < length; i++)


Do While Loop:

do while (<condition>)
//do calculations

Nested Loops:

for ( initialize; condition; increment ) {
   for ( initialize; condition; increment ) {


using System;

namespace Loops {
   class Program {
      static void Main(string[] args) {
         /* local variable definition */
         int i, j;
         for (i = 2; i < 100; i++) {
            for (j = 2; j <= (i / j); j++)
            if ((i % j) == 0) break; // if factor found, not prime
            if (j > (i / j)) Console.WriteLine("{0} is prime", i);

C# – Switch:

Switch can be used to execute a list of statements that matches the expression. There are various usage for switch statement and it was one of my favorite in C#.


using System;

public class Example
   public static void Main()
      int caseSwitch = 1;
      switch (caseSwitch)
          case 1:
              Console.WriteLine("Case 1");
          case 2:
              Console.WriteLine("Case 2");
              Console.WriteLine("Default case");

C# – Array:

In C# Array is nothing but a sequential collection of data. In latest C# we are using list in most cases instead of array because of its simplicity and robust feature.

An array can be declared, initialized and cleared and than same can also be done in List. To learn C# in one day, then you need to know basic of arrays concept. Because while coding you will face challenges in handling arrays.


datatype[] arrayName;


double[] balance = { 2340.0, 4523.69, 3421.0};
int [] marks = new int[5]  { 99,  98, 92, 97, 95};
int [] marks = new int[]  { 99,  98, 92, 97, 95};

An array can be accessed with the help of its sequence number which start from 0.


double salary = balance[9];

C# – Namespace:

Namespace is used to keep the names separately to avoid avoid conflicts between different classes. Once a namespace is given to a class then specific class in C# can be called with the help of the namespace. It will not conflict with the other classes.

using System;
namespace first_space {
   class namespace_name {
      public void function() {
         Console.WriteLine("It wirks");


C# – Methods:

In C# Methods are called as a group of statements that produces output. This output can also be used by another method. This is the basic for learning C#, because if you want to learn any kind of language, then you need to know how to create and call methods. below is the syntax for the methods.

To learn C# in one day, then you need to know basic of how methods can be created.

<Access Specifier> <Return Type> <Method Name>(Parameter List) {
   Method Body

In many cases method was also called as functions. Here access specifiers are

  1. public.
  2. private.
  3. protected.
  4. internal


Return type can be of any data type which you are going to return such as string, list, integer etc. You need to give a name for the method and you can also pass the parameters if you need. In order to learn C# in one day, you need to know how to create methods.

public int FindMax(int num1, int num2) {     
      int result;
      if (num1 > num2)
         result = num1;
         result = num2;
      return result;

C# – Class:

Class consists of operations that need to be performed during execution. It will enclose declared variables, group of methods which can be used by another classes i.e like a library which contains all the available operations predefined. To learn C# in one day, then you need to know basic of how class can be created.

Below is the syntax for creating class.

<access specifier> class  class_name {
   // member variables
   <access specifier> <data type> variable1;
   <access specifier> <data type> variable2;
   <access specifier> <data type> variableN;
   // member methods
   <access specifier> <return type> method1(parameter_list) {
      // method body
   <access specifier> <return type> method2(parameter_list) {
      // method body
   <access specifier> <return type> methodN(parameter_list) {
      // method body


public class Person
    // Field
    public string name;

    // Constructor that takes no arguments.
    public Person()
        name = "unknown";

    // Constructor that takes one argument.
    public Person(string nm)
        name = nm;

    // Method
    public void SetName(string newName)
        name = newName;
class TestPerson
    static void Main()
        // Call the constructor that has no parameters.
        Person person1 = new Person();

        person1.SetName("John Smith");

        // Call the constructor that has one parameter.
        Person person2 = new Person("Sarah Jones");

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
// Output:
// unknown
// John Smith
// Sarah Jones

C# – String Manipulation:

Strings are one of the important part of the program. Without it you cant output a result and most of the results cannot be determined. So in-order to use strings in different ways, there are manipulation techniques available in C# such as string concatenation, finding sub-string, searching string, joining string, splitting string etc…


string s3 = "Visual C# Express";
System.Console.WriteLine(s3.Substring(7, 2));
// Output: "C#"

System.Console.WriteLine(s3.Replace("C#", "Basic"));
// Output: "Visual Basic Express"

// Index values are zero-based
int index = s3.IndexOf("C");
// index = 7

Below are some escape sequence which you can use in the string manipulations.

Escape sequence Character name Unicode encoding
\’ Single quote 0x0027
\” Double quote 0x0022
\\ Backslash 0x005C
\0 Null 0x0000
\a Alert 0x0007
\b Backspace 0x0008
\f Form feed 0x000C
\n New line 0x000A
\r Carriage return 0x000D
\t Horizontal tab 0x0009
\U Unicode escape sequence for surrogate pairs. \Unnnnnnnn
\u Unicode escape sequence \u0041 = “A”
\v Vertical tab 0x000B
\x Unicode escape sequence similar to “\u” except with variable length. \x0041 = “A”

C# – Structs:

Struct is use to hold related value of various data types. It was used to hold small group of related data. Keyword used for struct is “Struct”. Below example shows how to declare struct in C#.

public struct Book  
    public decimal price;  
    public string title;  
    public string author;  

C# – Enum:

Enum is used to declare the named constants which is called as the enumerator list.

enum Day {Sat, Sun, Mon, Tue, Wed, Thu, Fri};

We can also use initializers in enum to override default values.

C# – Inheritance:

In C# Inheritance is an important concept. You can write C# code without inheritance but it will take more time to complete the code because without inheritance you need to create and declare the variables and methods again and again.

To learn C# in one day, then you need to know basic of inheritance concept.

Inheritance is used to create a base class that gives us specific functionality and in another class the base class functionality can be inherited ( like importing and using) or it can be overridden.

Below is a simple example which can be used to know more about inheritance.

using System;

public class A 
   private int value = 10;

   public class B : A
       public int GetValue()
           return this.value;

public class C : A
//    public int GetValue()
//    {
//        return this.value;
//    }

public class Example
    public static void Main(string[] args)
        var b = new A.B();
// The example displays the following output:
//       10

C# – Polymorphism & Overloading Operator:

Polymorphism means having many shapes. It has two types

  1. Static Polymorphism.
  2. Dynamic Polymorphism.

Static Polymorphism:

Links a function with an object during run-time. It was differentiated into two different types.

Function Overloading:

Multiple functions having same function name is called function overloading.

Operator Overloading:

Redefining or overloading the builtin operator again and again is called operator overloading.

Dynamic Polymorphism:

It was used to create abstract class. Abstract class contains abstract methods.

using System;
using System.Collections.Generic;

public class Shape
    // A few example members
    public int X { get; private set; }
    public int Y { get; private set; }
    public int Height { get; set; }
    public int Width { get; set; }
    // Virtual method
    public virtual void Draw()
        Console.WriteLine("Performing base class drawing tasks");

class Circle : Shape
    public override void Draw()
        // Code to draw a circle...
        Console.WriteLine("Drawing a circle");
class Rectangle : Shape
    public override void Draw()
        // Code to draw a rectangle...
        Console.WriteLine("Drawing a rectangle");
class Triangle : Shape
    public override void Draw()
        // Code to draw a triangle...
        Console.WriteLine("Drawing a triangle");

class Program
    static void Main(string[] args)
        // Polymorphism at work #1: a Rectangle, Triangle and Circle
        // can all be used whereever a Shape is expected. No cast is
        // required because an implicit conversion exists from a derived 
        // class to its base class.
        var shapes = new List<Shape>
            new Rectangle(),
            new Triangle(),
            new Circle()

        // Polymorphism at work #2: the virtual method Draw is
        // invoked on each of the derived classes, not the base class.
        foreach (var shape in shapes)

        // Keep the console open in debug mode.
        Console.WriteLine("Press any key to exit.");


/* Output:
    Drawing a rectangle
    Performing base class drawing tasks
    Drawing a triangle
    Performing base class drawing tasks
    Drawing a circle
    Performing base class drawing tasks

C# – Interface:

Interface contains definitions and declarations for the class and struct. Interface may also contain related functions related to the class and struct.


You can simple implement the interface which contains the predefined function declarations.

interface IEquatable<T>
    bool Equals(T obj);

public class Car : IEquatable<Car>
    public string Make {get; set;}
    public string Model { get; set; }
    public string Year { get; set; }

    // Implementation of IEquatable<T> interface
    public bool Equals(Car car)
        if (this.Make == car.Make &&
            this.Model == car.Model &&
            this.Year == car.Year)
            return true;
            return false;

C# – Try & Catch:

Try Catch statement is used to execute the statements which was given inside the try block and throw the exception to the catch block. It was most widely used to debug the program. Each and every developers will use the try-catch statement and find out the error occurred while executing the statements.

To learn C# in one day, then you need to know basic of try-catch statement for debugging.



//catch and display the errors or exceptions.


static void Main()   
    int n;  
        // Do not initialize this variable here.  
        n = 123;  
    // Error: Use of unassigned local variable 'n'.  

C# – Multiple Catch:

Multiple catch contains multiple catch block in the try-catch statement to catch manual or specific exceptions. But if you use “Exceptions” then it will catch all the exceptions which was thrown from try block.

static void Main()   
    int n;  
        // Do not initialize this variable here.  
        n = 123;  
    // Error: Use of unassigned local variable 'n'.  

C# – Final:

In try-catch block, the last block which we can use is final block. Whether or not whenever try-catch block runs, final block was always executed. This helps you to catch the database exceptions and dispose it in the final block even after throwing errors.

      //logic or database operations
      // catch exceptions
      //this block is always executed.

C# – File I/O:

It was called File Input and Output operations. In Windows whenever you are reading the files or writing the files, it was always done like a stream. So the input steam is used for reading the file and output stream is used for writing the file.

To learn C# in one day, then you need to know basic of handling file i/o operations.

There are different file stream classes which can be used to read and write files in different formats.

Sr.No. I/O Class & Description
1 BinaryReader

Reads primitive data from a binary stream.

2 BinaryWriter

Writes primitive data in binary format.

3 BufferedStream

A temporary storage for a stream of bytes.

4 Directory

Helps in manipulating a directory structure.

5 DirectoryInfo

Used for performing operations on directories.

6 DriveInfo

Provides information for the drives.

7 File

Helps in manipulating files.

8 FileInfo

Used for performing operations on files.

9 FileStream

Used to read from and write to any location in a file.

10 MemoryStream

Used for random access to streamed data stored in memory.

11 Path

Performs operations on path information.

12 StreamReader

Used for reading characters from a byte stream.

13 StreamWriter

Is used for writing characters to a stream.

14 StringReader

Is used for reading from a string buffer.

15 StringWriter

Is used for writing into a string buffer.


public partial class MainWindow : Window
        public MainWindow()

        private async void Button_Click(object sender, RoutedEventArgs e)
            UnicodeEncoding uniencoding = new UnicodeEncoding();
            string filename = @"c:\Users\exampleuser\Documents\userinputlog.txt";

            byte[] result = uniencoding.GetBytes(UserInput.Text);

            using (FileStream SourceStream = File.Open(filename, FileMode.OpenOrCreate))
                SourceStream.Seek(0, SeekOrigin.End);
                await SourceStream.WriteAsync(result, 0, result.Length);

From the above contents, you can learn c# in one day if and only you know the concepts clearly. I have only specified basic details about the concepts which was used in C# language. If you want to learn more in details, then you need to approach professionals to get in-depth knowledge about C#. Here is is the link from Microsoft where can get documentation for C#

Above post was created base on the content from tutorialspoint

You may also like...

Leave a Reply

Your email address will not be published. Required fields are marked *