Tuesday, 29 March 2016

Method parameters

In  this system we will discuss on
Different types of method parameters
Method Parameters Vs Method Arguments
Types of method parameters:
1.value parameters:
creates a copy of paramter passed,so modification does not affect each other.


   i  ------------------------------------->  10
   j   -------------------------------------->10


i and j pointing to different memory locations.Operations one variable will not effect on other variable value.
Example:
 using System;
namespace arrays {
 class Program {
  static void Main(string[] args) {
   int a = 0;
   Add(a);
   Console.WriteLine(a);
  }
  public static void Add(int a) {
   a = 100;
  }
 }
}
2.reference parameters:
The ref method parameter keyword on a method parameter causes a method to refer to the same variable that was passed into the method .Any change made to the parameter in the method will be reflected in that variable when control passes back to the calling method.
                              
I and j are pointing to the same memory location.Operations one variable will  effect on other variable value.

 Example :
using System;
namespace arrays {
 class Program {
  static void Main(string[] args) {
   int a = 0;
   Add(ref a);
   Console.WriteLine(a);
   Console.ReadLine();

   }
  public static void Add(ref int a) {
   a = 100;

   }
 }
}

3.out parameters:
use when you want a method to returns more than one value.

Example :     
  using System;
  namespace arrays {
   class Program {
    static void Main(string[] args) {
     int sum = 0, product = 0;

      Add(10, 20, out sum, out product);

      Console.WriteLine("sum {0},product {1}", sum, product);
    }
    public static void Add(int a, int b, out int sum, out int product) {
     sum = a + b;
     product = a * b;
    }
   }
  }
4.parameter arrays:
The params kewyord lets you spwcify a method parameter that takes a variable parameter arraysnumber of arguments.You can send a comma separated list of arguments,or an array,or no arguments.
params keyword should be the last one in a method declaration and only one params keyword is permitted in a method declaration.

Example:
using System;
namespace arrays {
 class Program {
  static void Main(string[] args) {
   int[] array = new int[3];
   array[0] = 1;
   array[1] = 2;
   array[2] = 3;
   Add(4, 5, 6);
  }
  public static void Add(params int[] array) {

    foreach(int i in array) {
    Console.WriteLine(i);
   }

   }
 }
}
Method parameters Vs Method arguments:

A parameter represents a value that the procedure expects you to pass when you call it.
An argument represents the value that you pass to a procedure parameter when you call the procedure.
Example:
using System;
namespace arrays
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] array = new int[3];
            array[0] = 1;
            array[1] = 2;
            array[2] = 3;
            Add(4,5,6);  // these are arguments
           }
        public static void Add(params int[] array){  //these are parameters

             foreach (int i in array)
            {
                Console.WriteLine(i);
            }
            
           
        }
    }
}



Methods

In this post we will discuss on
Structure of  a method
Difference between static and instance methods
why methods
Methods are also called as functions.these terms are used interchangeably.
Methods are extremely useful because they allow you to define your logic once,  and use it, at many  places.
Methods make the maintenance of your application easier.
Structure of a method
[attributes]
access-modifiers return-type methodname (parameters)
{
method-body
}
NOTE : Return type can be any valid datatype or void.
Method name can be any meaningful name.
Parameters are  optional.


Access modifiers are an integral part of object-oriented programming. They support the concept of encapsulation, which promotes the idea of hiding functionality. Access modifiers allow you to define who does or doesn't have access to certain features.


In C# there are 5 different types of Access Modifiers


Modifier
Description
public
There are no restrictions on accessing public members.
private
Access is limited to within the class definition. This is the default access modifier type if none is formally specified
protected
Access is limited to within the class definition and any class that inherits from the class
internal
Access is limited exclusively to classes defined within the current project assembly
protected internal
Access is limited to the current assembly and types derived from the containing class. All members in current project and all members in derived class can access the variables.

public
The public keyword is an access modifier for types and type members. Public access is the most permissive access level.
There are no restrictions on accessing public members.
Accessibility:

  • Can be accessed by objects of the class
  • Can be accessed by derived classes


private
Private access is the least permissive access level.
Private members are accessible only within the body of the class or the struct in which they are declared.
Accessibility:

  • Cannot be accessed by object
  • Cannot be accessed by derived classes


protected
A protected member is accessible from within the class in which it is declared, and from within any class derived from the class that declared this member.
A protected member of a base class is accessible in a derived class only if the access takes place through the derived class type.
Accessibility:

  • Cannot be accessed by object
  • By derived classes


internal
The internal keyword is an access modifier for types and type members. We can declare a class as internal or its member as internal. Internal members are accessible only within files in the same assembly (.dll).
In other words, access is limited exclusively to classes defined within the current project assembly.
Accessibility:
In same assembly (public)
  • Can be accessed by objects of the class
  • Can be accessed by derived classes
In other assembly (internal)
  • Cannot be accessed by object
  • Cannot be accessed by derived classes


protected internal
The protected internal accessibility means protected OR internal, not protected AND internal.
In other words, a protected internal member is accessible from any class in the same assembly, including derived classes.
The protected internal access modifier seems to be a confusing but is a union of protected and internal in terms of providing access but not restricting. It allows:  
  • Inherited types, even though they belong to a different assembly, have access to the protected internal members.
  • Types that reside in the same assembly, even if they are not derived from the type, also have access to the protected internal members.

Default access

A default access level is used if no access modifier is specified in a member declaration. The following list defines the default access modifier for certain C# types:
enum: The default and only access modifier supported is public.
class: The default access for a class is private. It may be explicitly defined using any of the access modifiers.
interface: The default and only access modifier supported is public.
struct: The default access is private with public and internal supported as well.
The default access may suffice for a given situation, but you should specify the access modifier you want to use to ensure proper application behavior.
Note: Interface and enumeration members are always public and no access modifiers are allowed.


static vs instance methods:
when a method declaration includes static modifier that method is said to be static method.
when no static modifier is present ,the  method is said to be an instance method.
static method is involved using the class name ,where as an  instance method is involved using an instance of the class.
The difference between instance methods and static methods is that multiple instances of a class can be created and each instance has its own separate method.however, when a method is static ,there are no instances of that method and you can involve only that one definition of the static method.

Eg : with static keyword
using System;

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

   int result = Program.Add(10, 20); //we use class name to call the method 
   Console.WriteLine(result);
   Console.ReadLine();
  }
  public static int Add(int a, int b) { //return type is int
   return a + b;

  }
 }
}
Eg : without static keyword
using System;

namespace arrays {
 class Program {
  static void Main(string[] args) {
   Program p = new Program(); //we create instance 
   int result = p.Add(10, 20);
   Console.WriteLine(result);
   Console.ReadLine();
  }
  public int Add(int a, int b) { //we can alse use void if we dont want to 
   return a + b; //re turn the value


  }
 }
}

Monday, 7 March 2016

Loops

In this post we will discuss on loops

   A loop statement allows us to execute a statement or group of statements multiple times.c# provides different types of loops.

If and Else statement :

One of the single most important statements in every programming language is the if statement.With an if-statement, we make a logical decision based on it. In an if-statement, we test expressions. These evaluate to true or false.


Syntax :

if(condition)     //  if condition satisfies loop executes
{
   //something
}
else
{
  //do something   // if condition fails else loop executes
}

Example

using System;

namespace ConsoleApplication1 {
 class Program {
  static void Main(string[] args) {
   int number;

   Console.WriteLine("Please enter a number between 0 and 10:");
   number = int.Parse(Console.ReadLine());

   if (number > 10)
    Console.WriteLine("Hey! The number should be 10 or less!");
   else
   if (number < 0)
    Console.WriteLine("Hey! The number should be 0 or more!");
   else
    Console.WriteLine("Good job!");

   Console.ReadLine();
  }
 }
}
Switch Statement :

Multiple if else can be replaced by switch .

It is used when there is multiple if condition in a program. It also includes a default value in Default statements. If no any case matches then Default statements executes and run the code.

Example:

 using System;

 namespace arrays {
  class Program {
   static void Main(string[] args) {
    int Number = int.Parse(Console.ReadLine());

    switch (Number) {
     case 10:

      Console.WriteLine("Number is 10");
      break; //will break the switch statement
     case 9:

      Console.WriteLine("Number is 9");
      break;
     case 8:

      Console.WriteLine("Number is 8");
      break;
     default:
      Console.WriteLine("Number is {0}", Number);
      break;
    }


   }
  }
 }
Program with single case for multiple values using switch

Example

using System;

namespace arrays {
 class Program {
  static void Main(string[] args) {
   int Number = int.Parse(Console.ReadLine());

   switch (Number) {
    case 10: //creates a single case for multiple values
    case 9:
    case 8:

     Console.WriteLine("Number is {0}", Number);
     break;
    default:
     Console.WriteLine("Number is not 10,9,8", Number);
     break;
   }

   Console.ReadLine();


  }
 }
}

Goto :

      Goto used in switch case will goto particular label or to the particular case statement.You create label at anywhere in program then can pass the execution control via the goto statements.

It can help us understand branches and control flow.

Example

using System;

namespace goto_statement {
 class Program {
  static void Main(string[] args) {
   string name;

   label: //creating label with colon(:)

    Console.WriteLine("Enter your name:");
   name = Console.ReadLine();

   Console.WriteLine("Welcome {0}", name);

   goto label; //jump to label statement           
  }
 }
}

While:

    The while loop simply executes a block of code as long as the condition you give it is true.

It checks the condition first and there should be increment variable.

Example:

using System;

namespace While_Loop {
 class Program {
  static void Main(string[] args) {
   int num1, res, i;

   Console.WriteLine("Enter a number");
   num1 = Convert.ToInt32(Console.ReadLine());

   i = 1; //Initialization
   //Check whether condition matches or not
   while (i <= 10) {
    res = num1 * i;
    Console.WriteLine("{0} x {1} = {2}", num1, i, res);
    i++; //Increment by one
   }
   Console.ReadLine();
  }
 }
}

Do...While Loop.:

       Unlike  while loops, which test the loop condition at the start of the loop, the do...while loop checks its condition at the end of the loop. A do...while loop is similar to a while loop, except that a do...while loop is guaranteed to execute at least one time.
Example:

using System;
namespace Loops {
 class Program {
  static void Main(string[] args) {
   /* local variable definition */
   int a = 10;

   /* do loop execution */
   do {
    Console.WriteLine("value of a: {0}", a);
    a = a + 1;
   }
   while (a < 20);
   Console.ReadLine();
  }
 }
}

foreach

A typical foreach loop that displays the contents of an array of integers
It doesn’t includes initialization, termination and increment/decrement characteristics. It uses collection to take value one by one and then processes them.

Syntax:
foreach(string name in arr) {
}
Example
using System;

class Program {
 static void Main() {
  int[] Numbers = new int[3];
  Numbers[0] = 1;
  Numbers[1] = 2;
  Numbers[2] = 3;
  // ... Loop with the foreach keyword.
  foreach(int i in Numbers) {
   Console.WriteLine(i);
  }
 }
}