Top 34 C# Coding Interview Questions (SOLVED) To Crack Your Tech Interview

We can't use this in static method because keyword this returns a reference to the current instance of the class containing it.

Static methods (or any static member) do not belong to a particular instance. They exist without creating an instance of the class and call with the name of a class not by instance so we can't use this keyword in the body of static Methods, but in case of Extension Methods we can use it as the functions parameters.

Keep two stacks, let's call them inbox and outbox.

Enqueue:

• Push the new element onto inbox

Dequeue:

• If outbox is empty, refill it by popping each element from inbox and pushing it onto outbox
• Pop and return the top element from outbox

The different types of class in C# are:

• Partial class – Allows its members to be divided or shared with multiple .cs files. It is denoted by the keyword Partial.
• Sealed class – It is a class which cannot be inherited. To access the members of a sealed class, we need to create the object of the class.  It is denoted by the keyword Sealed.
• Abstract class – It is a class whose object cannot be instantiated. The class can only be inherited. It should contain at least one method.  It is denoted by the keyword abstract.
• Static class – It is a class which does not allow inheritance. The members of the class are also static.  It is denoted by the keyword static. This keyword tells the compiler to check for any accidental instances of the static class.

Class and struct both are the user defined data type but have some major difference:

Struct

• The struct is value type in C# and it inherits from System.Value Type.
• Struct is usually used for smaller amounts of data.
• Struct can't be inherited to other type.
• A structure can't be abstract.

Class

• The class is reference type in C# and it inherits from the System.Object Type.
• Classes are usually used for large amounts of data.
• Classes can be inherited to other class.
• A class can be abstract type.
• We can create a default constructor.

The virtual keyword is used while defining a class to specify that the methods and the properties of that class can be overridden in derived classes.

Finally block will be executed irrespective of exception. So while executing the code in try block when exception is occurred, control is returned to catch block and at last finally block will be executed. So closing connection to database / releasing the file handlers can be kept in finally block.

The idea behind linear search is to compare the search item with the elements in the list one by one (using a loop) and stop as soon as we get the first copy of the search element in the list. Now considering the worst case in which the search element does not exist in the list of size N then the Simple Linear Search will take a total of 2N+1 comparisons (N comparisons against every element in the search list and N+1 comparisons to test against the end of the loop condition).

    for (int i = 0; i < length; i++) { // N+1 comparisons
        if (array[i] == elementToSearch) { // N comparisons
            return i; // I found the position of the element requested
        }
    }

The idea of Sentinel Linear Search is to reduce the number of comparisons required to find an element in a list. Here we replace the last element of the list with the search element itself and run a while loop to see if there exists any copy of the search element in the list and quit the loop as soon as we find the search element. This will reduce one comparison in each iteration.

    while(a[i] != element) // N+2 comparisons worst case
        i++;

In that case the while loop makes only one comparison in each iteration and it is sure that it will terminate since the last element of the list is the search element itself. So in the worst case ( if the search element does not exists in the list ) then there will be at most N+2 comparisons (N comparisons in the while loop and 2 comparisons in the if condition). Which is better than (2N+1) comparisons as found in Simple Linear Search.

static long TotalAllEvenNumbers(int[] intArray) {
  return intArray.Where(i => i % 2 == 0).Sum(i => (long)i);
}

or

static long TotalAllEvenNumbers(int[] intArray) {
  return (from i in intArray where i % 2 == 0 select (long)i).Sum();
}

You can prevent a class from overriding in C# by using the sealed keyword.

Two words are anagrams of each other if they contain the same number of characters and the same characters. There are two solutions to mention:

1. You should only need to sort the characters in lexicographic order, and determine if all the characters in one string are equal to and in the same order as all of the characters in the other string. If you sort either array, the solution becomes O(n log n).
2. Hashmap approach where key - letter and value - frequency of letter,

• for first string populate the hashmap O(n)
• for second string decrement count and remove element from hashmap O(n)
• if hashmap is empty, the string is anagram otherwise not.

Yes, there is a difference:

• When you do throw ex, that thrown exception becomes the "original" one. So all previous stack trace will not be there.

• If you do throw, the exception just goes down the line and you'll get the full stack trace.

  static void Main(string[] args)
  {
      try
      {
          Method2();
      }
      catch (Exception ex)
      {
          Console.Write(ex.StackTrace.ToString());
          Console.ReadKey();
      }
  }
  
  private static void Method2()
  {
      try
      {
          Method1();
      }
      catch (Exception ex)
      {
          //throw ex resets the stack trace Coming from Method 1 and propogates it to the caller(Main)
          throw ex;
      }
  }
  
  private static void Method1()
  {
      try
      {
          throw new Exception("Inside Method1");
      }
      catch (Exception)
      {
          throw;
      }
  }

The this keyword is used to call other constructors, to initialize the class object. The following shows the implementation:

class ClassA
{
  public ClassA() : this(10)
  { }

  public ClassA(int pValue)
  {  }
}

Reverse the entire string, then reverse the letters of each individual word.

After the first pass the string will be

s1 = "Z Y X si eman yM"

and after the second pass it will be

s1 = "Z Y X is name My"

The == Operator (usually means the same as ReferenceEquals, could be overrided) compares the reference identity while the Equals() (virtual Equals()) method compares if two objects are equivalent.

This program will output the number 10 ten times.

Here’s why: The delegate is added in the for loop and “reference” (or perhaps “pointer” would be a better choice of words) to i is stored, rather than the value itself. Therefore, after we exit the loop, the variable i has been set to 10, so by the time each delegate is invoked, the value passed to all of them is 10.

The ?? operator is called the null-coalescing operator and is used to define a default value for nullable value types or reference types. It returns the left-hand operand if the operand is not null; otherwise, it returns the right operand.

string name = null;  
string myname = name ?? "Laxmi";  
Console.WriteLine(myname);