PHP-Fusion Powered Website

This section of our 1000+ C# multiple choice questions focuses on scope and lifetime of variables in C# Programming Language.

1. Choose the correct type of variable scope for the following C# defined variables.

```
  class ABC
```
```
  {
```
```
      static int m;
```
```
      int n;
```

      void fun (int x , ref int y, out int z, int[] a)

```
      {
```
```
         int j = 10;
```
```
      }
```
```
  }
```

a) m = static variable, n = local variable, x = output parameter, y = reference parameter, j = instance variable, z = output parameter, a[0] = array element
b) m = static variable, n = instance variable, x = value parameter, y = reference parameter, j = local variable, z = output parameter , a[0] = array element
c) m = static variable, n = instance variable, x = reference parameter, y = value parameter, j = local variable, z = output parameter, a[0] = array element
d) m = local variable, n = instance variable, x = reference parameter, y = value parameter, j = static variable, z = output parameter, a[0] = array element

```
class Program
```
```
{
```
```
    static void Main(string[] args)
```
```
    {
```
```
        int  i ;
```
```
        for (i = 0; i < 5; i++)
```
```
        {
```
```
            Console.WriteLine(i);
```
```
        }
```
```
        Console.ReadLine();
```
```
    }
```
```
}
```

Answer: c
Explanation: Scope of ‘i’ is alive within block in which it is declared. So, change in value of i within for loop is reserved until condition of for loop is executing.
Output:

0, 1, 2, 3, 4

```
 class Program
```
```
 {
```
```
     static void Main(string[] args)
```
```
     {
```
```
         int i;
```
```
         for ( i = 0; i < 5; i++)
```
```
         {
```
```
 
```
```
         }
```
```
         Console. WriteLine(i);
```
```
         Console. ReadLine();
```
```
     }
```
```
}
```

```
 class Program
```
```
 {
```
```
     static void Main(string[] args)
```
```
     {
```
```
         int i ;
```
```
         for ( i = 0; i < 5; i++)
```
```
         {
```
```
             int j = 0;
```
```
             j += i; 
```
```
             Console. WriteLine(j);
```
```
         }
```
```
         Console. WriteLine(i);
```
```
         Console. ReadLine();
```
```
     }
```
```
 }
```

```
  static void Main(string[] args)
```
```
  {
```
```
      int i ;
```
```
      for (i = 0; i < 5; i++)
```
```
      {
```
```
          int j = 0;
```
```
          j += i; 
```
```
          Console. WriteLine(j);
```
```
      }
```
```
      Console. WriteLine( i * j);
```
```
      Console. ReadLine();
```
```
  }
```

6. Scope of variable is related to definition of variable as:
i. Region of code within which variable value is valid and hence can be accessed.
ii. No, relation with region where variable is declared its value is valid in entire scope.
a) i
b) ii
c) i, ii
d) None of the mentioned

Answer: a
Explanation: Scope of variable is the area or region within which variable is declared and hence initialized values of different kind. Based, on which operations of different kinds are carried out on that variable declared within that scope. Its value is preserved until and unless scope of that block ({ }) is not expired because as soon as scope gets over. Hence, variable value gets expired. Hence, it’s inaccessible after it.

```
 class Program
```
```
 {
```

     public static void Main(string[] args)

```
     {
```
```
         int i = 100;
```
```
         for (a = 0; a < 5; a++)
```
```
         {
```
```
             int i = 200;
```
```
             Console. WriteLine(a * i);
```
```
         }
```
```
         Console. ReadLine();
```
```
     }
```
```
 }
```

Answer: c
Explanation: The compiler cannot interpret between variable ‘i’ declared as an instance variable outside for loop block and variable ‘i’ declared as a local variable inside the for loop context. The instance variable ‘id’ defined before the for loop is still in scope inside for loop and hence goes out of scope only when main() is finished executing. The local variable ‘i’ declared inside for loop had scope limited within blocks({ }) in which it is declared and hence creates name conflict with instance variable ‘i’ so, compiler is unable to distinguish between both. When instance variable ‘i’ is removed away. The program runs accurately producing the output as “0, 200, 400, 600, 800”, this explains the concept of scope deceleration.

8. Syntax for declaration and initialization of data variable is?
a) <data type><var_name> = <Value>;
b) <data type><var_name>;
c) <var_name><data type>;
d) <var_name> = <value>;

```
 class Program
```
```
 {
```

     public static void Main(string[] args)

```
     {
```
```
         int i, j;
```
```
         i = (j = 5) + 10;
```
```
         Console. WriteLine(i);
```
```
         Console. WriteLine(j);
```
```
         Console. ReadLine();
```
```
     }
```
```
 }
```

Answer: c
Explanation: j=’5′ will return value of 5 stored it in variable ‘j’ but value assigned to variable ‘i’ will be first value of ‘j’ and hence increment a value of ’10’ in that value of ‘j’ i. e 15.
Output:

15, 5

10. Choose effective differences between ‘Boxing’ and ‘Unboxing’.
a) ‘Boxing’ is the process of converting a value type to the reference type and ‘Unboxing’ is the process of converting reference to value type
b) ‘Boxing’ is the process of converting a reference type to value type and ‘Unboxing’ is the process of converting value type to reference type
c) In ‘Boxing’ we need explicit conversion and in ‘Unboxing’ we need implicit conversion
d) Both ‘Boxing’ and ‘Unboxing’ we need implicit conversion

11. Select differences between reference type and value type:
i. Memory allocated to ‘Value type’ is from heap and reference type is from ‘System. ValueType’
ii. Memory allocated to ‘Value type’ is from ‘System. ValueType’ and reference type is from ‘Heap’
iii. Structures, enumerated types derived from ‘System. ValueType’ are created on stack, hence known as ValueType and all ‘classes’ are reference type because values are stored on heap
a) i, iii
b) ii, iii
c) i, ii, iii
d) i

    public static void Main(string[] args)

```
    {
```
```
        int i = 123;
```
```
        object o = i;
```
```
        i = 456;
```

        System. Console. WriteLine("The value-type value = {0}", i);

        System. Console. WriteLine("The object-type value = {0}", o);

```
        Console. ReadLine();
```
```
    }
```

Answer: b
Explanation: The concept of boxing is implemented here. The variable ‘i’ of ‘int’ type is boxed using variable ‘o’ of object type and hence value is stored inside it and is initialized to the object variable ‘o’. Next, variable ‘i’ is again initialized with some value overriding it’s previous stored value.
Output:

456, 123

  public static void Main(string[] args)

```
  {
```
```
      int i = 546;
```
```
      object o = i;
```
```
      int n =(int) o;
```
```
      o = 70;
```

      System. Console. WriteLine("The value-type value = {0}", n);

      System. Console. WriteLine("The object-type value = {0}", o);

```
      Console. ReadLine();
```
```
  }
```

Answer: c
Explanation: The concept of ‘unboxing’ is implemented here. To ‘unbox’ an object back to value type, we have to do it explicitly as “int n = (int) o”.
Output:

546, 70

C# Questions & Answers – Scope and Lifetime of Variables