Search This Blog

Wednesday, June 20, 2018

Oops Interview Question - 1

1. What is C#?
C# is an object oriented, type safe and managed language that is compiled by .Net framework to generate Microsoft Intermediate Language.
2. What are the types of comment in C# with examples?
Single line
Eg:
1
//This is a Single line comment

ii. Multiple line (/* */)
Eg:
1
2
3
/*This is a multiple line comment
We are in line 2
Last line of comment*/

iii. XML Comments (///).
Eg:
1
2
3
/// summary;
///  Set error message for multilingual language.
/// summary

3. Can multiple catch blocks be executed?
No, Multiple catch blocks can’t be executed. Once the proper catch code executed, the control is transferred to the finally block and then the code that follows the finally block gets executed.
A multiple catch block can also be specified with a different exception type is called exception filters. A multiple catch block is useful when you want to handle different exceptions in different ways.
Example: Multiple catch block

class Program
{
    static void Main(string[] args)
    {
        Console.Write("Please enter two numbers: ");
       
        try
        {
            int num1 = int.Parse(Console.ReadLine());
            int num2 = int.Parse(Console.ReadLine());

            int result = num1 / num2;

            Console.WriteLine("{0} / {1} = {2}", num1, num2, result);
        }
        catch(DivideByZeroException ex)
        {
            LogError(ex);
            Console.Write("Cannot divide by zero. Please try again.");
        }
        catch(InvalidOperationException ex)
        {
            LogError(ex);
            Console.Write("Not a valid number. Please try again.");
        }
        catch(FormatException  ex)
        {
            LogError(ex);
            Console.Write("Not a valid number. Please try again.");
        }

        Console.ReadKey();
    }

}
    
Note: A multiple catch block with the same exception type is not allowed. It will give a compile time error.
Example: Invalid catch blocks

try
{
    //code that may raise an exception
}
catch //cannot have both catch and catch(Exception ex)
{
    Console.WriteLine("Exception occurred");
}
catch(Exception ex) //cannot have both catch and catch(Exception ex)
{
    Console.WriteLine("Exception occurred");
}

Example: Invalid catch block

try
{
    //code that may raise an exception
}
catch
{
    // this catch block must be last block
}
catch (NullReferenceException nullEx)
{
    Console.WriteLine(nullEx.Message);
}
catch (InvalidCastException inEx)
{
    Console.WriteLine(inEx.Message);
}

4. What is the difference between public, static and void?
Public declared variables or methods are accessible anywhere in the application. Static declared variables or methods are globally accessible without creating an instance of the class. Static member are by default not globally accessible it depends upon the type of access modified used. The compiler stores the address of the method as the entry point and uses this information to begin execution before any objects are created. And Void is a type modifier that states that the method or variable does not return any value.
5. What is an object?  
An object is an instance of a class through which we access the methods of that class. “New” keyword is used to create an object. A class that creates an object in memory will contain the information about the methods, variables and behavior of that class.
6. Define Constructors?  
A constructor is a member function in a class that has the same name as its class. The constructor is automatically invoked whenever an object class is created. It constructs the values of data members while initializing the class.
7. What is Jagged Arrays?
The array which has elements of type array is called jagged array. The elements can be of different dimensions and sizes. We can also call jagged array as Array of arrays.
Example:

int[][] jagArray = new int[5][];

In the above declaration the rows are fixed in size. But columns are not specified as they can vary.

Declaring and initializing jagged array.

int[][] jaggedArray = new int[5][];

jaggedArray[0] = new int[3];
jaggedArray[1] = new int[5];
jaggedArray[2] = new int[2];
jaggedArray[3] = new int[8];
jaggedArray[4] = new int[10];

jaggedArray[0] = new int[] { 3, 5, 7, };
jaggedArray[1] = new int[] { 1, 0, 2, 4, 6 };
jaggedArray[2] = new int[] { 1, 6 };
jaggedArray[3] = new int[] { 1, 0, 2, 4, 6, 45, 67, 78 };
jaggedArray[4] = new int[] { 1, 0, 2, 4, 6, 34, 54, 67, 87, 78 };

You can also initialize the array upon declaration like this:

int[][] jaggedArray = new int[][]
{
new int[] { 3, 5, 7, },
new int[] { 1, 0, 2, 4, 6 },
new int[] { 1, 6 },
new int[] { 1, 0, 2, 4, 6, 45, 67, 78 }
};

You can use the following shorthand form:

int[][] jaggedArray =
{
new int[] { 3, 5, 7, },
new int[] { 1, 0, 2, 4, 6 },
new int[] {1, 2, 3, 4, 5, 6, 7, 8},
new int[] {4, 5, 6, 7, 8}
};

Note: Notice that you cannot omit the new operator from the elements initialization because there is no default initialization for the elements.

8. What is the difference between ref & out parameters?
An argument passed as ref must be initialized before passing to the method whereas out parameter needs not to be initialized before passing to a method.
Ref
Out
The parameter or argument must be initialized first before it is passed to ref.
It is not compulsory to initialize a parameter or argument before it is passed to an out.
It is not required to assign or initialize the value of a parameter (which is passed by ref) before returning to the calling method.
A called method is required to assign or initialize a value of a parameter (which is passed to an out) before returning to the calling method.
Passing a parameter value by Ref is useful when the called method is also needed to modify the pass parameter.
Declaring a parameter to an out method is useful when multiple values need to be returned from a function or method.
It is not compulsory to initialize a parameter value before using it in a calling method.
A parameter value must be initialized within the calling method before its use.
When we use REF, data can be passed bi-directionally.
When we use OUT data is passed only in a unidirectional way (from the called method to the caller method).
Both ref and out are treated differently at run time and they are treated the same at compile time.
Properties are not variables, therefore it cannot be passed as an out or ref parameter.
Example
Ref
1.   public static string GetNextName(ref int id)  
2.   {  
3.       string returnText = "Next-" + id.ToString();  
4.       id += 1;  
5.       return returnText;  
6.   }  
Out
1.   public static string GetNextName(out int id)  
2.   {  
3.       id = 1;  
4.       string returnText = "Next-" + id.ToString();  
5.       return returnText;  
6.   }  
Ref / Out keyword and method Overloading

Both ref and out are treated differently at run time and they are treated the same at compile time, so methods cannot be overloaded if one method takes an argument as ref and the other takes an argument as an out.

Example code
1.   public static string GetNextName(ref int id)  
2.   {  
3.       string returnText = "Next-" + id.ToString();  
4.       id += 1;  
5.       return returnText;  
6.   }  
7.   public static string GetNextName(out int id)  
8.   {  
9.       id = 1;  
10.     string returnText = "Next-" + id.ToString();  
11.     return returnText;  
12. }  
Output when the code is compiled:
Cannot define overloaded method ‘GetNextName’ because it differs from another method only on ref and out.
9. What is the use of using statement in C#?  
The using block is used to obtain a resource and use it and then automatically dispose of when the execution of block completed.
When you are using an object that encapsulates any resource, you have to make sure that when you are done with the object, the object's Dispose method is called. This can be done more easily using the using statement in C#. The using statement simplifies the code that you have to write to create and then finally clean up the object. The using statement obtains the resource specified, executes the statements and finally calls the Disposemethod of the object to clean up the object. The following piece of code illustrates its use.
Eg.
using (TextWriter w = File.CreateText("log.txt"))
{
    w.WriteLine("This is line one");
}
Eg.
string connString = "Data Source=localhost;Integrated " + 
  "Security=SSPI;Initial Catalog=Northwind;";
 
using (SqlConnection conn = new SqlConnection(connString))
{
  SqlCommand cmd = conn.CreateCommand();
  cmd.CommandText = "SELECT ID, Name FROM Customers";
  
  conn.Open();
 
  using (SqlDataReader dr = cmd.ExecuteReader())
  {
    while (dr.Read())
      Console.WriteLine("{0}\t{1}", dr.GetString(0), dr.GetString(1));
  }
}
The using statement is only useful for objects with a lifetime that does not extend beyond the method in which the objects are constructed. Remember that the objects you instantiate must implement the System.IDisposable interface.
 You can achieve the same result by putting the object inside a try block and then calling Dispose in a finally block; in fact, this is how the using statement is translated by the compiler. The code example earlier expands to the following code at compile time (note the extra curly braces to create the limited scope for the object
{
  Font font1 = new Font("Arial", 10.0f);
  try
  {
    byte charset = font1.GdiCharSet;
  }
  finally
  {
    if (font1 != null)
      ((IDisposable)font1).Dispose();
  }
}
10. What is serialization?  
When we want to transport an object through network then we have to convert the object into a stream of bytes. The process of converting an object into a stream of bytes is called Serialization. For an object to be serializable, it should implement ISerialize Interface. De-serialization is the reverse process of creating an object from a stream of bytes.
Serialization is the process of converting an object into a stream of bytes to store the object or transmit it to memory, a database, or a file. Its main purpose is to save the state of an object in order to be able to recreate it when needed. The reverse process is called deserialization.


The object is serialized to a stream, which carries not just the data, but information about the object's type, such as its version, culture, and assembly name. From that stream, it can be stored in a database, a file, or memory.

Eg.
using System;
using System.IO;
using System.Linq;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading.Tasks;
namespace DemoApplication
{
  [Serializable]
  class Tutorial
  {
  public int ID;
  public String Name;
   static void Main(string[] args)
   {
    Tutorial obj = new Tutorial();
    obj.ID = 1;
    obj.Name = ".Net";
 
    IFormatter formatter = new BinaryFormatter();
    Stream stream = new FileStream(@"E:\ExampleNew.txt",FileMode.Create,FileAccess.Write);
 
    formatter.Serialize(stream, obj); // Serialize the object
    stream.Close();
 
    stream = new FileStream(@"E:\ExampleNew.txt",FileMode.Open,FileAccess.Read);
    Tutorial objnew = (Tutorial)formatter.Deserialize(stream);
 
    Console.WriteLine(objnew.ID);
    Console.WriteLine(objnew.Name);
 
    Console.ReadKey();
  }
 }
}

Code Explanation: -
1.    We create the object "stream" to open the file Example.txt in reading only mode.
2.    We then use the formatter class which is used to deserialize the object, which is stored in the Example.txt file. The object returned is set to the object objnew.
Finally, we display the properties of the object "objnew" to the console using the "ID" and "name" properties.
11. Can “this” be used within a static method?  
We can’t use ‘This’ in a static method because we can only use static variables/methods in a static method.
12. What is difference between constants and read-only?  
Constant variables are declared and initialized at compile time. The value can’t be changed afterwards. Read only is used only when we want to assign the value at run time.
A constant member is defined at compile time and cannot be changed at runtime. Constants are declared as a field, using the const keyword and must be initialized as they are declared.
public class MyClass
{
    public const double PI1 = 3.14159;
}

A readonly member is like a constant in that it represents an unchanging value. The difference is that a readonly member can be initialized at runtime, in a constructor, as well being able to be initialized as they are declared.
public class MyClass1
{
     public readonly double PI2 = 3.14159;
 
     //or
 
     public readonly double PI3;
 
     public MyClass2()
     {
         PI3 = 3.14159;
     }
}

const
·         They can not be declared as static (they are implicitly static)
·         The value of constant is evaluated at compile time
·         constants are initialized at declaration only
readonly
·         They can be either instance-level or static
·         The value is evaluated at run time
·         readonly can be initialized in declaration or by code in the constructor

13. What is an interface class?  
Interface is an abstract class which has only public abstract methods and the methods only have the declaration and not the definition. These abstract methods must be implemented in the inherited classes.
public interface ITransactions {
   // interface members
   void showTransaction();
   double getAmount();
}

14. What are value types and reference types?  

Value types:

Value types are stored in the Stack whereas reference types stored on heap.
A data type is a value type if it holds a data value within its own memory space. It means variables of these data types directly contain their values.
For example, consider integer variable int i = 100;
The system stores 100 in the memory space allocated for the variable 'i'. The following image illustrates how 100 is stored at some hypothetical location in the memory (0x239110) for 'i':
1
int, enum , byte, decimal, double, float, long
 Reference Types:
Unlike value types, a reference type doesn't store its value directly. Instead, it stores the address where the value is being stored. In other words, a reference type contains a pointer to another memory location that holds the data.
For example, consider following string variable:
string s = "Hello World!!";

1
string , class, interface, object

15. What are Custom Control and User Control?  
Custom Controls are controls generated as compiled code (Dlls), those are easier to use and can be added to toolbox. Developers can drag and drop controls to their web forms. Attributes can be set at design time. We can easily add custom controls to Multiple Applications (If Shared Dlls), If they are private then we can copy to dll to bin directory of web application and then add reference and can use them.
User Controls are very much similar to ASP include files, and are easy to create. User controls can’t be placed in the toolbox and dragged – dropped from it. They have their design and code behind. The file extension for user controls is ascx.
16. What are sealed classes in C#?  
We create sealed classes when we want to restrict the class to be inherited. Sealed modifier used to prevent derivation from a class. If we forcefully specify a sealed class as base class, then a compile-time error occurs.
sealed class SealedClass
{
    public int Add(int x, int y)
    {
        return x + y;
    }
}  
The main purpose of a sealed class is to take away the inheritance feature from the user so they cannot derive a class from a sealed class. 

Some points to remember:   

1.  A class, which restricts inheritance for security reason is declared, sealed class.
2.  Sealed class is the last class in the hierarchy.
3.  Sealed class can be a derived class but can't be a base class.
4.  A sealed class cannot also be an abstract class. Because abstract class has to provide functionality and here we are 
     restricting it to inherit.
17. What is method overloading?  
Method overloading is creating multiple methods with the same name with unique signatures in the same class. When we compile, the compiler uses overload resolution to determine the specific method to be invoke.
class BC
{
  public void Display()
  {
     System.Console.WriteLine("BC::Display");
  }
}
 
class DC : BC
{
  new public void Display()
  {
     System.Console.WriteLine("DC::Display");
  }
}
 
class Demo
{
  public static void Main()
  {
     BC b;
     b = new BC();
     b.Display();    
  }
}
Virtual Keyword

It tells the compiler that this method can be overridden by derived classes.
public virtual int myValue()
{
    -
    -
    -
 }
Override Keyword

In the subclass, it tells the compiler that this method is overriding the same named method in the base class.
public override int myValue()
{
     -
     -
     -
}

18. What is the difference between Array and Arraylist?  
In an array, we can have items of the same type only. The size of the array is fixed. An arraylist is similar to an array but it doesn’t have a fixed size.
Array
ArrayList
Array is strongly typed. This means that an array can store only specific type of items\elements.
ArrayList can store any type of items\elements.
Array stores fixed number of elements. Size of an Array must be specified at the time of initialization.
ArrayList grows automatically and you don't need to specify size.
No need to cast elements of an array while retriving because it is strongly type and stores specific type of items only.
Items of ArrayList need to be cast to appropriate data type while retriving.
Use static helper class Array to perform different tasks on the array.
ArrayList itself includes various utility methods for various tasks.
In arrays we can store only one datatype either int, string, char etc…
In arraylist we can store all the datatype values
Array cant accept null
ArrayList collection accepts null
Arrays belong to System.Array namespace
using System;
Arraylist belongs to System.Collection namespaces
using System.Collections;
Example -
int[] intArray=new int[]{2};
intArray[0] = 1;
intArray[2] = 2;
Example -
ArrayList Arrlst = new ArrayList();
Arrlst.Add("Sagar");
Arrlst.Add(1);
Arrlst.Add(null);

19. Can a private virtual method be overridden?  
No, because they are not accessible outside the class.
20. Describe the accessibility modifier “protected internal”.

Protected Internal variables/methods are accessible within the same assembly and also from the classes that are derived from this parent class.
21. What are the differences between System.String and System.Text.StringBuilder classes?
System.String is immutable. When we modify the value of a string variable then a new memory is allocated to the new value and the previous memory allocation released. System.StringBuilder was designed to have concept of a mutable string where a variety of operations can be performed without allocation separate memory location for the modified string.
string s = string.Empty;
for (i = 0; i < 1000; i++) {
  s += i.ToString() + " ";
}

StringBuilder sb = new StringBuilder();
for (i = 0; i < 1000; i++) {
  sb.Append(i);
  sb.Append(' ');
}

22. What’s the difference between the System.Array.CopyTo() and System.Array.Clone() ?
Using Clone() method, we creates a new array object containing all the elements in the original array and using CopyTo() method, all the elements of existing array copies into another existing array. Both the methods perform a shallow copy.
object[] myarray = new object[] { "one", 2, "three", 4, "really big number", 2324573984927361 };
 
//create shallow copy by CopyTo
//You have to instantiate your new array first
object[] myarray2 = new object[myarray.Length];
//but then you can specify how many members of original array you would like to copy 
myarray.CopyTo(myarray2, 0);
 
//create shallow copy by Clone
object[] myarray1;
//here you don't need to instantiate array, 
//but all elements of the original array will be copied
myarray1 = myarray.Clone() as object[];
 
//if not sure that we create a shalow copy lets test it
myarray[0] = 0;
Console.WriteLine(myarray[0]);// print 0
Console.WriteLine(myarray1[0]);//print "one"
Console.WriteLine(myarray2[0]);//print "one"

23. How can we sort the elements of the array in descending order?
Using Sort() methods followed by Reverse() method.
int[] array = new int[] { 3, 1, 4, 5, 2 };
Array.Sort<int>( array );
Array.Reverse( array );

int[] array = new int[] { 3, 1, 4, 5, 2 };
    Array.Sort<int>(array,
                    new Comparison<int>(
                            (i1, i2) => i2.CompareTo(i1)
                    ));

24. Write down the C# syntax to catch exception?
To catch an exception, we use try catch blocks. Catch block can have parameter of system.Exception type.
Eg:
1
2
3
4
5
6
7
try
{
GetAllData();
}
catch(Exception ex)
{
}

In the above example, we can omit the parameter from catch statement.
25.   What’s the difference between an interface and abstract class?
Interfaces have all the methods having only declaration but no definition. In an abstract class, we can have some concrete methods. In an interface class, all the methods are public. An abstract class may have private methods.
Posted by at

No comments:

Post a Comment


This is a User Friendly Blog.
Simple Interface and Simple Controls are used.
Post your comments so i can modify blog regarding your wish.

Subscribe to: Post Comments (Atom)