C# Fundamental Part 3

Spread the love

75.       Is it possible to use this keyword within a static method in C#?

Answer: A special type of reference variable, this keyword is implicitly defined with each non-static method and constructor as the first parameter of the type class, which defines it. Static methods don’t belong to a particular instance. Instead, they exist without creating an instance of the class and calls with the name of the class. Because this keyword returns a reference to the current instance of the class containing it, it can’t be used in a static method. Although we can’t use this keyword within a static method, we can use it in the function parameters of Extension Methods.

76.        What can you tell us about the XSD file in C#?

Answer: XSD denotes XML Schema Definition. The XML file can have any attributes, elements, and tags if there is no XSD file associated with it. The XSD file gives a structure for the XML file, meaning that it determines what, and also the order of, the elements and properties that should be there in the XML file. Note: – During serialization of C# code, the classes are converted to XSD compliant format by the Xsd.exe tool.

77.        What do you mean by Constructor Chaining in C#?

Answer: Constructor chaining in C# is a way of connecting two or more classes in a relationship as an inheritance. Every child class constructor is mapped to the parent class constructor implicitly by using the base keyword in constructor chaining.

78.         Explain different states of a Thread in C#?

Answer: A thread in C# can have any of the following states:

  • Aborted – The thread is dead but not stopped
  • Running – The thread is executing
  • Stopped – The thread has stopped execution
  • Suspended – The thread has been suspended
  • Unstarted – The thread is created but has not started execution yet
  • WaitSleepJoin – The thread calls sleep, calls wait on another object, and calls join on some other thread

79.       Why do we use Async and Await in C#?

Answer: Processes belonging to asynchronous programming run independently of the main or other processes. In C#, using Async and Await keywords for creating asynchronous methods.

80.       What is an Indexer in C#, and how do you create one?

Answer: Also known as an indexed property, an indexer is a class property allowing accessing a member variable of some class using features of an array. Used for treating an object as an array, indexer allows using classes more intuitively. Although not an essential part of the object-oriented programming, indexers are a smart way of using arrays. As such, they are also called smart arrays. Defining an indexer enables creating classes that act like virtual arrays. Instances of such classes can be accessed using the [] array access operator. The general syntax for creating an indexer in C# is:

< modifier > <
return type > this[argument list] {
get {
// the get block code
set {
// the set block code

81.       What is the Race condition in C#?

Answer: When two threads access the same resource and try to change it at the same time, we have a race condition. It is almost impossible to predict which thread succeeds in accessing the resource first. When two threads try to write a value to the same resource, the last value written is saved.

82.What do you understand by Get and Set Accessor properties?

Answer: Made using properties, Get and Set are called accessors in C#. A property enables reading and writing to the value of a private field. Accessors are used for accessing such private fields. While we use the Get property for returning the value of a property, use the Set property for setting the value.

83.       Give a detailed explanation of the differences between ref and out keywords.

Answer: In any C# function, there can be three types of parameters, namely in, out and ref. Although both out and ref are treated differently at the run time, they receive the same treatment during the compile time. It is not possible to pass properties as an out or ref parameter. Following are the differences between ref and out keywords:

  • Initializing the Argument or Parameter – While it is not compulsory to initialize an argument or parameter before passing to an out parameter, the same needs to be initialized before passing it to the ref parameter.
  • Initializing the Value of the Parameter – Using ref doesn’t necessitate for assigning or initializing the value of a parameter before returning to the calling method. When using out, however, it is mandatory to use a called method for assigning or initializing a value of a parameter before returning to the calling method.
  • Usefulness – When the called method requires modifying the passed parameter, passing a parameter value by Ref is useful. Declaring a parameter to an out method is appropriate when multiple values are required to be returned from a function or method.
  • Initializing a Parameter Value in Calling Method – It is a compulsion to initialize a parameter value within the calling method while using out. However, the same is optional while using the ref parameter.
  • Data Passing – Using out allows for passing data only in a unidirectional way. However, data can be passed in a bidirectional manner when using ref.

84.       What is Singleton Design Patterns in C#? Explain their implementation using an example.

Answer: A singleton in C# is a class that allows the creation of only a single instance of itself and provides simple access to that sole instance. Because the second request of an instance with a different parameter can cause problems, singletons typically disallow any parameters to be specified. Following example demonstrates the implementation of Singleton Design Patterns in C#:

namespace Singleton {
class Program {
static void Main(string[] args) {
Calculate.Instance.ValueOne = 10.5;
Calculate.Instance.ValueTwo = 5.5;
Console.WriteLine("Addition : " + Calculate.Instance.Addition());
Console.WriteLine("Subtraction : " + Calculate.Instance.Subtraction());
Console.WriteLine("Multiplication : " + Calculate.Instance.Multiplication());
Console.WriteLine("Division : " + Calculate.Instance.Division());
Calculate.Instance.ValueTwo = 10.5;
Console.WriteLine("Addition : " + Calculate.Instance.Addition());
Console.WriteLine("Subtraction : " + Calculate.Instance.Subtraction());
Console.WriteLine("Multiplication : " + Calculate.Instance.Multiplication());
Console.WriteLine("Division : " + Calculate.Instance.Division());
public sealed class Calculate {
private Calculate() {}
private static Calculate instance = null;
public static Calculate Instance {
get {
if (instance == null) {
instance = new Calculate();
return instance;
public double ValueOne {
public double ValueTwo {
public double Addition() {
return ValueOne + ValueTwo;
public double Subtraction() {
return ValueOne - ValueTwo;
public double Multiplication() {
return ValueOne * ValueTwo;
public double Division() {
return ValueOne / ValueTwo;

A Singleton Design Pattern ensures that a class has one and only one instance and provides a global point of access to the same. There are numerous ways of implementing the Singleton Design Patterns in C#. Following are the typical characteristics of a Singleton Pattern:

  • A public static means of getting the reference to the single instance created
  • A single constructor, private and parameter-less
  • A static variable holding a reference to the single instance created
  • The class is sealed

84. What is the difference between Interface and Abstract Class in C#? 

Here are some of the common differences between an interface and an abstract class in C#.

  • A class can implement any number of interfaces but a subclass can at most use only one abstract class.
  • An abstract class can have non-abstract methods (concrete methods) while in case of interface, all the methods have to be abstract.
  • An abstract class can declare or use any variables while an interface is not allowed to do so.
  • In an abstract class, all data members or functions are private by default while in an interface all are public, we can’t change them manually.
  • In an abstract class, we need to use abstract keywords to declare abstract methods, while in an interface we don’t need to use that.
  • An abstract class can’t be used for multiple inheritance while the interface can be used as multiple inheritance.
  • An abstract class use constructor while in an interface we don’t have any type of constructor.

To learn more about the difference between an abstract class and an interface, visit Abstract Class vs Interface.  

85. What is enum in C#? 

An enum is a value type with a set of related named constants often referred to as an enumerator list. The enum keyword is used to declare an enumeration. It is a primitive data type that is user-defined.

An enum type can be an integer (float, int, byte, double, etc.). But if you use it beside int it has to be cast.

An enum is used to create numeric constants in the .NET framework. All the members of enum are enum type. There must be a numeric value for each enum type.

The default underlying type of the enumeration element is int. By default, the first enumerator has the value 0, and the value of each successive enumerator is increased by 1. 

  1. enum Dow {Sat, Sun, Mon, Tue, Wed, Thu, Fri};    

Some points about enum,

  • Enums are enumerated data types in c#.
  • Enums are not for the end-user, they are meant for developers.
  • Enums are strongly typed constant. They are strongly typed, i.e. an enum of one type may not be implicitly assigned to an enum of another type even though the underlying value of their members is the same.
  • Enumerations (enums) make your code much more readable and understandable.
  • Enum values are fixed. Enum can be displayed as a string and processed as an integer.
  • The default type is int, and the approved types are byte, sbyte, short, ushort, uint, long, and ulong.
  • Every enum type automatically derives from System.Enum and thus we can use System.Enum methods on enums.
  • Enums are value types and are created on the stack and not on the heap.

For more details follow the link, Enums in C#.  

86. What is the difference between “continue” and “break” statements in C#? 

Using break statement, you can ‘jump out of a loop’ whereas by using a continue statement, you can ‘jump over one iteration’ and then resume your loop execution.

Eg. Break Statement  

  1. using System;  
  2. using System.Collections;  
  3. using System.Linq;  
  4. using System.Text;  
  5. namespace break_example {  
  6.     Class brk_stmt {  
  7.         public static void main(String[] args) {  
  8.             for (int i = 0; i <= 5; i++) {  
  9.                 if (i == 4) {  
  10.                     break;  
  11.                 }  
  12.                 Console.WriteLine(“The number is ” + i);  
  13.                 Console.ReadLine();  
  14.             }  
  15.         }  
  16.     }  
  17. }  


The number is 0; 

The number is 1; 

The number is 2; 

The number is 3;

Eg. Continue Statement

  1. using System;  
  2. using System.Collections;  
  3. using System.Linq;  
  4. using System.Text;  
  5. namespace continue_example {  
  6.     Class cntnu_stmt {  
  7.         public static void main(String[] {  
  8.                 for (int i = 0; i <= 5; i++) {  
  9.                     if (i == 4) {  
  10.                         continue;  
  11.                     }  
  12.                     Console.WriteLine(“The number is “+ i);   
  13.                         Console.ReadLine();  
  14.                     }  
  15.                 }  
  16.             }  
  17.         }  


The number is 1;

The number is 2;

The number is 3;

The number is 5;

For more details, check out the following link: Break and Continue Statements in C# 

87. What is the difference between ref and out keywords?

The ref keyword passes arguments by reference. It means any changes made to this argument in the method will be reflected in that variable when control returns to the calling method.

Sr. No.Keyref keywordout keyword
1Purposeref keyword is used when a called method has to update the passed parameter.out keyword is used when a called method has to update multiple parameter passed.
2Directionref keyword is used to pass data in bi-directional way.out keyword is used to get data in uni-directional way.
3InitializationBefore passing a variable as ref, it is required to be initialized otherwise compiler will throw error.No need to initialize variable if out keyword is used.
4InitializationIn called method, it is not required to initialize the parameter passed as ref.In called method, it is required to initialize the parameter passed as out

88. What are Properties in C#?

C# properties are members of a C# class that provide a flexible mechanism to read, write or compute the values of private fields, in other words, by using properties, we can access private fields and set their values. Properties in C# are always public data members. C# properties use get and set methods, also known as accessors, to access and assign values to private fields.

89:What are accessors?

The get and set portions or blocks of a property are called accessors. These are useful to restrict the accessibility of a property. The set accessor specifies that we can assign a value to a private field in a property. Without the set accessor property, it is like a readonly field. With the ‘get’ accessor we can access the value of the private field. In other words, it returns a single value. A Get accessor specifies that we can access the value of a field publically.

We have three types of properties: Read/Write, ReadOnly, and WriteOnly. Let’s see each one by one.

90. What are extension methods in C#?

Extension methods enable you to add methods to existing types without creating a new derived type, recompiling, or otherwise modifying the original type. 

An extension method is a special kind of static method, but they are called as if they were instance methods on the extended type.

91.How to use extension methods?

An extension method is a static method of a static class, where the “this” modifier is applied to the first parameter. The type of the first parameter will be the type that is extended.

Extension methods are only in scope when you explicitly import the namespace into your source code with a using directive.

For more details on extension methods, you can read these articles, Extension Methods in C#.

92. What is the difference between the dispose and finalize methods in C#?

In finalize and dispose, both methods are used to free unmanaged resources. 


  • Finalize is used to free unmanaged resources that are not in use, like files, database connections in the application domain and more. These are resources held by an object before that object is destroyed.
  • In the Internal process, it is called by Garbage Collector and can’t be called manual by user code or any service.
  • Finalize belongs to System.Object class.
  • Implement it when you have unmanaged resources in your code, and make sure that these resources are freed when the Garbage collection happens.


  • Dispose is also used to free unmanaged resources that are not in use like files, database connections in the Application domain at any time.
  • Dispose is explicitly called by manual user code.
  • If we need to use the dispose method, we must implement that class via IDisposable interface.
  • It belongs to IDisposable interface.
  • Implement this when you are writing a custom class that will be used by other users.

For more details follow this link, Back To Basics – Dispose Vs Finalize.

93. What is the difference between String and StringBuilder in C#?

StringBuilder and string are both used to string values, but both have many differences on the bases of instance creation and also in performance.


A string is an immutable object. Immutable is when we create string objects in code so we cannot modify or change that object in any operations like insert new value, replace or append any value with the existing value in a string object. When we have to do some operations to change string simply it will dispose of the old value of string object and it will create a new instance in memory for hold the new value in a string object, for example:


  • It’s an immutable object that holds a string value.
  • Performance-wise, string is slow because it creates a new instance to override or change the previous value.
  • String belongs to the System namespace.


System.Text.Stringbuilder is a mutable object which also holds the string value, mutable means once we create a System.Text.Stringbuilder object. We can use this object for any operation like insert value in an existing string with insert functions also replace or append without creating a new instance of System.Text.Stringbuilder for every time so it’s using the previous object. That way, it works fast compared to the System.String. Let’s see an example to understand System.Text.Stringbuilder.


  • StringBuilder is a mutable object.
  • Performance-wise StringBuilder is very fast because it will use the same instance of StringBuilder object to perform any operation like inserting a value in the existing string.
  • StringBuilder belongs to System.Text.Stringbuilder namespace.

For more details, read the following article, Comparison of String and StringBuilder in C#.

94. What are delegates in C# and the uses of delegates?

A Delegate is an abstraction of one or more function pointers (as existed in C++; the explanation about this is out of the scope of this article). The .NET has implemented the concept of function pointers in the form of delegates. With delegates, you can treat a function as data. Delegates allow functions to be passed as parameters, returned from a function as a value and stored in an array. Delegates have the following characteristics:

  • Delegates are derived from the System.MulticastDelegate class.
  • They have a signature and a return type. A function that is added to delegates must be compatible with this signature.
  • Delegates can point to either static or instance methods.
  • Once a delegate object has been created, it may dynamically invoke the methods it points to at runtime.
  • Delegates can call methods synchronously and asynchronously.

The delegate contains a couple of useful fields. The first one holds a reference to an object, and the second holds a method pointer. When you invoke the delegate, the instance method is called on the contained reference. However, if the object reference is null then the runtime understands this to mean that the method is a static method. Moreover, invoking a delegate syntactically is the exact same as calling a regular function. Therefore, delegates are perfect for implementing callbacks.

  • Why Do We Need Delegates?

Historically, the Windows API made frequent use of C-style function pointers to create callback functions. Using a callback, programmers were able to configure one function to report back to another function in the application. So the objective of using a callback is to handle button-clicking, menu-selection, and mouse-moving activities. But the problem with this traditional approach is that the callback functions were not type-safe. In the .NET framework, callbacks are still possible using delegates with a more efficient approach. Delegates maintain three important pieces of information:

  • The parameters of the method.
  • The address of the method it calls.
  • The return type of the method.

A delegate is a solution for situations in which you want to pass methods around to other methods. You are so accustomed to passing data to methods as parameters that the idea of passing methods as an argument instead of data might sound a little strange. However, there are cases in which you have a method that does something, for instance, invoking some other method. You do not know at compile time what this second method is. That information is available only at runtime, hence Delegates are the device to overcome such complications.

Learn more about Delegates and Events in C# .NET

95. What are sealed classes in C#?

Sealed classes are used to restrict the inheritance feature of object-oriented programming. Once a class is defined as a sealed class, the class cannot be inherited. 

In C#, the sealed modifier is used to define a class as sealed. In Visual Basic .NET the Not Inheritable keyword serves the purpose of the sealed class. If a class is derived from a sealed class then the compiler throws an error. 

If you have ever noticed, structs are sealed. You cannot derive a class from a struct. 

The following class definition defines a sealed class in C#:

  1. // Sealed class    
  2. sealed class SealedClass    
  3. {       
  4. }    

Learn more about sealed classes here: Sealed Classes in C#

96. What are partial classes?

A partial class is only used to split the definition of a class in two or more classes in the same source code file or more than one source file. You can create a class definition in multiple files, but it will be compiled as one class at run time. Also, when you create an instance of this class, you can access all the methods from all source files with the same object.

Partial Classes can be created in the same namespace. It isn’t possible to create a partial class in a different namespace. So use the “partial” keyword with all the class names that you want to bind together with the same name of a class in the same namespace. Let’s see an example:

To learn about partial classes, visit Partial Classes in C# With Real Example.

97. What is IEnumerable<> in C#?

IEnumerable is the parent interface for all non-generic collections in System.Collections namespace like ArrayList, HastTable etc. that can be enumerated. For the generic version of this interface as IEnumerable<T> which a parent interface of all generic collections class in System.Collections.Generic namespace like List<> and more. 

In System.Collections.Generic.IEnumerable<T> have only a single method which is GetEnumerator() that returns an IEnumerator. IEnumerator provides the power to iterate through the collection by exposing a Current property and Move Next and Reset methods if we don’t have this interface as a parent so we can’t use iteration by foreach loop or can’t use that class object in our LINQ query.

For more details, visit Implement IEnumerable Interface in C#.

98. What is the difference between late binding and early binding in C#?

Early Binding and Late Binding concepts belong to polymorphism in C#. Polymorphism is the feature of object-oriented programming that allows a language to use the same name in different forms. For example, a method named Add can add integers, doubles, and decimals.

Polymorphism we have 2 different types to achieve that: 

  • Compile Time also known as Early Binding or Overloading.
  • Run Time is also known as Late Binding or Overriding.

Compile Time Polymorphism or Early Binding

In Compile time polymorphism or Early Binding, we will use multiple methods with the same name but different types of parameters, or maybe the number of parameters. Because of this, we can perform different-different tasks with the same method name in the same class which is also known as Method overloading.

See how we can do that in the following example:

Run Time Polymorphism or Late Binding

Run time polymorphism is also known as late binding. In Run Time Polymorphism or Late Binding, we can use the same method names with the same signatures, which means the same type or the same number of parameters, but not in the same class because the compiler doesn’t allow for that at compile time. Therefore, we can use that bind at run time in the derived class when a child class or derived class object will be instantiated. That’s why we call it Late Binding. We have to create my parent class functions as partial and in driver or child class as override functions with the override keyword. 


Learn more here, Understanding Polymorphism in C#.

99. What are the differences between IEnumerable and IQueryable?

Before we go into the differences, let’s learn what the IEnumerable and IQueryable are.


Is the parent interface for all non-generic collections in System.Collections namespace like ArrayList, HastTable, etc. that can be enumerated. The generic version of this interface is IEnumerable<T>, which a parent interface of all generic collections class in System.Collections.Generic namespace, like List<> and more. 


As per MSDN, the IQueryable interface is intended for implementation by query providers. It is only supposed to be implemented by providers that also implement IQueryable<T>. If the provider does not also implement IQueryable<T>, the standard query operators cannot be used on the provider’s data source.

The IQueryable interface inherits the IEnumerable interface so that if it represents a query, the results of that query can be enumerated. Enumeration causes the expression tree associated with an IQueryable object to be executed. The definition of “executing an expression tree” is specific to a query provider. For example, it may involve translating the expression tree to an appropriate query language for the underlying data source. Queries that do not return enumerable results are executed when the Execute method is called.

  • IEnumerable exists in System.Collections Namespace.
  • IQueryable exists in System. Linq Namespace.
  • Both IEnumerable and IQueryable are forward collection.
  • IEnumerable doesn’t support lazy loading
  • IQueryable support lazy loading
  • Querying data from a database, IEnumerable execute a select query on the server side, load data in-memory on a client-side and then filter data.
  • Querying data from a database, IQueryable execute the select query on the server side with all filters.
  • IEnumerable Extension methods take functional objects.
  • IQueryable Extension methods take expression objects means expression tree.
  • IEnumerable is useful when we want to iterate the collection of objects which deals with in-process memory.
  • IQueryable is useful when we want to iterate a collection of objects which deals with ad-hoc queries against the data source or remote database, like SQL Server.
  • IList is useful when we want to perform any operation like Add, Remove or Get item at specific index position in the collection.

100. What happens if the inherited interfaces have conflicting method names?

If we implement multiple interfaces in the same class with conflict method names, we don’t need to define all. In other words, we can say if we have conflict methods in the same class, we can’t implement their body independently in the same class because of the same name and same signature. Therefore, we have to use the interface name before the method name to remove this method confiscation. Let’s see an example:

  1. interface testInterface1 {  
  2.     void Show();  
  3. }  
  4. interface testInterface2 {  
  5.     void Show();  
  6. }  
  7. class Abc: testInterface1,  
  8.     testInterface2 {  
  9.         void testInterface1.Show() {  
  10.             Console.WriteLine(“For testInterface1 !!”);  
  11.         }  
  12.         void testInterface2.Show() {  
  13.             Console.WriteLine(“For testInterface2 !!”);  
  14.         }  
  15.     }  

Now see how to use these in a class:

  1. class Program {  
  2.     static void Main(string[] args) {  
  3.         testInterface1 obj1 = new Abc();  
  4.         testInterface1 obj2 = new Abc();  
  5.         obj1.Show();  
  6.         obj2.Show();  
  7.         Console.ReadLine();  
  8.     }  
  9. }  


For one more example follow the link: Inherit Multiple Interfaces and They have Conflicting Method Name

101. What are the Arrays in C#?

In C#, an array index starts at zero. That means the first item of an array starts at the 0th position. The position of the last item on an array will total the number of items – 1. So if an array has 10 items, the last 10th item is in the 9th position. 

In C#, arrays can be declared as fixed-length or dynamic.

fixed-length array can store a predefined number of items.

dynamic array does not have a predefined size. The size of a dynamic array increases as you add new items to the array. You can declare an array of fixed length or dynamic. You can even change a dynamic array to static after it is defined.

Let’s take a look at simple declarations of arrays in C#. The following code snippet defines the simplest dynamic array of integer types that do not have a fixed size.

int[] intArray;

As you can see from the above code snippet, the declaration of an array starts with a type of array followed by a square bracket ([]) and the name of the array.

The following code snippet declares an array that can store 5 items only starting from index 0 to 4. 

  1. int[] intArray;    
  2. intArray = new int[5];    

The following code snippet declares an array that can store 100 items starting from index 0 to 99. 

  1. int[] intArray;    
  2. intArray = new int[100];    

Learn more about Arrays in C#: Working with Arrays In C#

102. What’s the difference between the Array.CopyTo() and Array.Clone()?

The Array.Clone() method creates a shallow copy of an array. A shallow copy of an Array copies only the elements of the Array, whether they are reference types or value types, but it does not copy the objects that the references refer to. The references in the new Array point to the same objects that the references in the original Array point to.

The CopyTo() static method of the Array class copies a section of an array to another array. The CopyTo method copies all the elements of an array to another one-dimension array. The code listed in Listing 9 copies contents of an integer array to an array of object types. 

Learn more about arrays here, Working with Arrays in C#.

1- CopyTo require to have a destination array when Clone return a new array.
2- CopyTo let you specify an index (if required) to the destination array.

103. Can Multiple Catch Blocks be executed in C#? 

We can use multiple catch blocks with a try statement. Each catch block can catch a different exception. The following code example shows how to implement multiple catch statements with a single try statement.

  1. using System;    
  2. class MyClient {    
  3.     public static void Main() {    
  4.         int x = 0;    
  5.         int div = 0;    
  6.         try {    
  7.             div = 100 / x;    
  8.             Console.WriteLine(“Not executed line”);    
  9.         } catch (DivideByZeroException de) {    
  10.             Console.WriteLine(“DivideByZeroException”);    
  11.         } catch (Exception ee) {    
  12.             Console.WriteLine(“Exception”);    
  13.         } finally {    
  14.             Console.WriteLine(“Finally Block”);    
  15.         }    
  16.         Console.WriteLine(“Result is {0}”, div);    
  17.     }    
  18. }    

To learn more about Exception Handling in C#, please visit, Exception Handling in C#.

104. What are Singleton Design Patterns and how to implement them in C#? 

What is a Singleton Design Pattern? 

  1. Ensures a class has only one instance and provides a global point of access to it.
  2. A Singleton is a class that only allows a single instance of itself to be created and usually gives simple access to that instance.
  3. Most commonly, singletons don’t allow any parameters to be specified when creating the instance since the second request of an instance with a different parameter could be problematic! (If the same instance should be accessed for all requests with the same parameter then the factory pattern is more appropriate.)
  4. There are various ways to implement the Singleton Pattern in C#. The following are the common characteristics of a Singleton Pattern.
    1. A single constructor, that is private and parameterless.
    1. The class is sealed.
    1. A static variable that holds a reference to the single created instance, if any.
    1. A public static means of getting the reference to the single created instance, creating one if necessary.

Example of how to write code with Singleton:

  1. namespace Singleton {  
  2.     class Program {  
  3.         static void Main(string[] args) {  
  4.             Calculate.Instance.ValueOne = 10.5;  
  5.             Calculate.Instance.ValueTwo = 5.5;  
  6.             Console.WriteLine(“Addition : ” + Calculate.Instance.Addition());  
  7.             Console.WriteLine(“Subtraction : ” + Calculate.Instance.Subtraction());  
  8.             Console.WriteLine(“Multiplication : ” + Calculate.Instance.Multiplication());  
  9.             Console.WriteLine(“Division : ” + Calculate.Instance.Division());  
  10.             Console.WriteLine(“\n———————-\n”);  
  11.             Calculate.Instance.ValueTwo = 10.5;  
  12.             Console.WriteLine(“Addition : ” + Calculate.Instance.Addition());  
  13.             Console.WriteLine(“Subtraction : ” + Calculate.Instance.Subtraction());  
  14.             Console.WriteLine(“Multiplication : ” + Calculate.Instance.Multiplication());  
  15.             Console.WriteLine(“Division : ” + Calculate.Instance.Division());  
  16.             Console.ReadLine();  
  17.         }  
  18.     }  
  19.     public sealed class Calculate {  
  20.         private Calculate() {}  
  21.         private static Calculate instance = null;  
  22.         public static Calculate Instance {  
  23.             get {  
  24.                 if (instance == null) {  
  25.                     instance = new Calculate();  
  26.                 }  
  27.                 return instance;  
  28.             }  
  29.         }  
  30.         public double ValueOne {  
  31.             get;  
  32.             set;  
  33.         }  
  34.         public double ValueTwo {  
  35.             get;  
  36.             set;  
  37.         }  
  38.         public double Addition() {  
  39.             return ValueOne + ValueTwo;  
  40.         }  
  41.         public double Subtraction() {  
  42.             return ValueOne – ValueTwo;  
  43.         }  
  44.         public double Multiplication() {  
  45.             return ValueOne * ValueTwo;  
  46.         }  
  47.         public double Division() {  
  48.             return ValueOne / ValueTwo;  
  49.         }  
  50.     }  
  51. }  

To read more about Singleton in depth so follow the link, Singleton Design Pattern in C# 

105. Difference between Throw Exception and Throw Clause 

The basic difference is that the Throw exception overwrites the stack trace. This makes it hard to find the original code line number that has thrown the exception.

Throw basically retains the stack information and adds to the stack information in the exception that it is thrown.

Let’s see what it means to better understand the differences. I am using a console application to easily test and see how the usage of the two differ in their functionality.

  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using System.Text;  
  5. namespace TestingThrowExceptions {  
  6.     class Program {  
  7.         public void ExceptionMethod() {  
  8.             throw new Exception(“Original Exception occurred in ExceptionMethod”);  
  9.         }  
  10.         static void Main(string[] args) {  
  11.             Program p = new Program();  
  12.             try {  
  13.                 p.ExceptionMethod();  
  14.             } catch (Exception ex) {  
  15.                 throw ex;  
  16.             }  
  17.         }  
  18.     }  
  19. }  

Now run the code by pressing the F5 key and see what happens. It returns an exception and look at the stack trace.

To learn more about throw exceptions, please visit, Difference Between Throw Exception and Throw Clause 

106. What are Indexers in C#?

C# introduces a new concept known as Indexers which are used for treating an object as an array. The indexers are usually known as smart arrays in C#. They are not an essential part of object-oriented programming.

Defining an indexer allows you to create classes that act as virtual arrays. Instances of that class can be accessed using the [] array access operator.

Creating an Indexer 

  1. < modifier > <    
  2. return type > this[argument list] {    
  3.     get {    
  4.         // your get block code    
  5.     }    
  6.     set {    
  7.         // your set block code    
  8.     }    
  9. }    

In the above code,


can be private, public, protected or internal.

<return type>

can be any valid C# types.

To learn more about indexers in C#, visit Indexers in C#.

107. Difference between the Equality Operator (==) and Equals() Method in C#

Both the == Operator and the Equals() method are used to compare two value type data items or reference type data items. The Equality Operator (==) is the comparison operator and the Equals() method compares the contents of a string. The == Operator compares the reference identity while the Equals() method compares only contents. Let’s see with some examples.

In this example, we assigned a string variable to another variable. A string is a reference type and in the following example, a string variable is assigned to another string variable so they are referring to the same identity in the heap and both have the same content so you get True output for both the == Operator and the Equals() method.

  1. using System;    
  2. namespace ComparisionExample {    
  3.     class Program {    
  4.         static void Main(string[] args) {    
  5.             string name = “sandeep”;    
  6.             string myName = name;    
  7.             Console.WriteLine(“== operator result is {0}”, name == myName);    
  8.             Console.WriteLine(“Equals method result is {0}”, name.Equals(myName));    
  9.             Console.ReadKey();    
  10.         }    
  11.     }    
  12. }    

For more details, check out the following link, Difference Between Equality Operator ( ==) and Equals() Method in C#.

108. What’s the Difference between the Is and As operator in C#

“is” operator

In C# language, we use the “is” operator to check the object type. If two objects are of the same type, it returns true, else it returns false.

Let’s understand this in our C# code. We declare two classes, Speaker and Author.

  1. class Speaker {    
  2.     public string Name {    
  3.         get;    
  4.         set;    
  5.     }    
  6. }    
  7. class Author {    
  8.     public string Name {    
  9.         get;    
  10.         set;    
  11.     }    
  12. }    

Now, let’s create an object of type Speaker:

  1. var speaker = new Speaker { Name=”Gaurav Kumar Arora”};    

Now, let’s check if the object is Speaker type:

  1. var isTrue = speaker is Speaker;     

In the preceding, we are checking the matching type. Yes, our speaker is an object of Speaker type.

  1. Console.WriteLine(“speaker is of Speaker type:{0}”, isTrue);   

So, the results are true.

But, here we get false:

  1. var author = new Author { Name = “Gaurav Kumar Arora” };     
  2. var isTrue = speaker is Author;     
  3. Console.WriteLine(“speaker is of Author type:{0}”, isTrue);    

Because our speaker is not an object of Author type.

“as” operator

The “as” operator behaves in a similar way as the “is” operator. The only difference is it returns the object if both are compatible with that type. Else it returns a null.

Let’s understand this in our C# code.

  1. public static string GetAuthorName(dynamic obj)     
  2.   {     
  3.      Author authorObj = obj as Author;     
  4.      return (authorObj != null) ? authorObj.Name : string.Empty;     
  5.   }     

We have a method that accepts a dynamic object and returns the object name property if the object is of the Author type. 

Here, we’ve declared two objects:

  1. var speaker = new Speaker { Name=”Gaurav Kumar Arora”};   
  2. var author = new Author { Name = “Gaurav Kumar Arora” };     

The following returns the “Name” property:

  1. var authorName = GetAuthorName(author);     
  2. Console.WriteLine(“Author name is:{0}”, authorName);    

It returns an empty string:

  1. authorName = GetAuthorName(speaker);     
  2. Console.WriteLine(“Author name is:{0}”, authorName);     

Learn more about is vs as operators here, “is” and “as” Operators of C#

109. How to use Nullable<> Types in C#?

A nullable type is a data type is that contains the defined data type or the null value.

This nullable type concept is not compatible with “var”.

Any data type can be declared nullable type with the help of operator “?”. 

For example, the following code declares the int ‘i’ as a null.

  1. int? i = null;  

As discussed in the previous section “var” is not compatible with nullable types. So, if you declare the following, you will get an error.

  1. var? i = null;  

To learn more about nullable types in C#, read the following, Getting started with Nullable Types in C#.

110. What are Generics in C#?

Generics allow you to delay the specification of the data type of programming elements in a class or a method until it is actually used in the program. In other words, generics allow you to write a class or method that can work with any data type.

You write the specifications for the class or the method, with substitute parameters for data types. When the compiler encounters a constructor for the class or a function call for the method, it generates code to handle the specific data type.

Generic classes and methods combine reusability, type safety and efficiency in a way that their non-generic counterparts cannot. Generics are most frequently used with collections and the methods that operate on them. Version 2.0 of the .NET Framework class library provides a new namespace, System.Collections.Generic, that contains several new generic-based collection classes. It is recommended that all applications that target the .NET Framework 2.0 and later use the new generic collection classes instead of the older non-generic counterparts such as ArrayList.

Features of Generics

Generics are a technique that enriches your programs in the following ways:

  • It helps you to maximize code reuse, type safety, and performance.
  • You can create generic collection classes. The .NET Framework class library contains several new generic collection classes in the System.Collections.Generic namespace. You may use these generic collection classes instead of the collection classes in the System.Collections namespace.
  • You can create your own generic interfaces, classes, methods, events, and delegates.
  • You may create generic classes constrained to enable access to methods on specific data types.
  • You may get information on the types used in a generic data type at run-time using reflection.

Generics in C# is a feature that allows for the creation of reusable code by creating parameterized types. In simple terms, it enables us to create classes, interfaces, and methods that work with different data types without having to define the data type explicitly.

  1. By using generics, we can write code that is more flexible and less prone to errors. For example, instead of writing a separate method for each data type, we can write a single method that can work with different types of data.
  2. The main benefit of using generics is that it provides type safety. When we define a generic class, interface or method, we can specify the type parameter that it can work with. This ensures that the code will only accept and operate on data types that match the specified type parameter, preventing errors that can occur due to data type mismatches.
  3. Generics also help in reducing code duplication, as it is possible to write a generic class or method that can work with any data type, instead of writing multiple methods or classes for different data types.
  4. C# provides a number of built-in generic types, such as List<T>, Dictionary<TKey, TValue>, and Nullable<T>. We can also create our own generic classes, interfaces, and methods by using the syntax <T>, where T is the type parameter that can be replaced with any valid data type.

Advantages of Generics

  • Reusability: You can use a single generic type definition for multiple purposes in the same code without any alterations. For example, you can create a generic method to add two numbers. This method can be used to add two integers as well as two floats without any modification in the code.
  • Type Safety: Generic data types provide better type safety, especially in the case of collections. When using generics you need to define the type of objects to be passed to a collection. This helps the compiler to ensure that only those object types that are defined in the definition can be passed to the collection.
  • Performance: Generic types provide better performance as compared to normal system types because they reduce the need for boxing, unboxing, and typecasting of variables or objects.

111. Describe Accessibility Modifiers in C#

Access modifiers are keywords used to specify the declared accessibility of a member or a type.

Access modifiers are keywords used to specify the scope of accessibility of a member of a type or the type itself. For example, a public class is accessible to the entire world, while an internal class may be accessible to the assembly only. 

Why use access modifiers?

Access modifiers are an integral part of object-oriented programming. Access modifiers are used to implement the encapsulation of OOP. Access modifiers allow you to define who does or who doesn’t have access to certain features.

In C# there are 6 different types of Access Modifiers:

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

To learn more about access modifiers in C#, click here, What are Access Modifiers in C#?

112. What is the Difference between an Array and ArrayList in C#?

Here is a list of differences between the two:

Array can store only elements of the same data types.ArrayList can store elements of different data types.
Arrays cannot accept null valuesArrayList can accept null values.
Arrays are available in System.Array namespaceArrayLists are available in System.Collections namespace
Array has static and fixed-size.ArrayList allows the dynamic size and memory allocation.
Arrays are strongly typed.ArrayLists are not strongly typed.
Insertion and deletion operations are faster than ArrayListInsertion and deletion operations are slower than Array.

To learn more about arrays, collections, and ArrayLists, click here, Collections in C#: ArrayList and Arrays.

113. How do you use the “using” statement in C#?

There are two ways to use the using keyword in C#. One is as a directive and the other is as a statement. Let’s explain!

  1. using Directive 
    Generally, we use the using keyword to add namespaces in code-behind and class files. Then it makes available all the classes, interfaces and abstract classes and their methods and properties on the current page. Adding a namespace can be done in the following two ways:
  2. Using Statement 
    This is another way to use the using keyword in C#. It plays a vital role in improving performance in Garbage Collection.

Learn more here, The “Using” Statement in C#

114. What is a Jagged Array in C#?

A jagged array is an array whose elements are arrays. The elements of a jagged array can be of different dimensions and sizes. A jagged array is sometimes called an “array of arrays.”

A special type of array is introduced in C#. A Jagged Array is an array of an array in which the length of each array index can differ.


  1. 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 a jagged array.

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

Learn more here, Jagged Array in C#

115. What is Multithreading with .NET?

Multithreading allows a program to run multiple threads concurrently. This article explains how multithreading works in .NET. This article covers the entire range of threading areas from thread creation, race conditions, deadlocks, monitors, mutexes, synchronization and semaphores and so on.

The real usage of a thread is not about a single sequential thread, but rather using multiple threads in a single program. Multiple threads running at the same time and performing various tasks are referred to as Multithreading. A thread is considered to be a lightweight process because it runs within the context of a program and takes advantage of the resources allocated for that program.

A single-threaded process contains only one thread while a multithreaded process contains more than one thread for execution.

To learn more about threading in .NET, visit, Multithreading with .NET

108. What are Anonymous Types in C#?

Anonymous types allow us to create new types without defining them. This is a way of defining read-only properties in a single object without having to define each type explicitly. Here, Type is generated by the compiler and is accessible only for the current block of code. The type of properties is also inferred by the compiler.

We can create anonymous types by using “new” keyword together with the object initializer. 


  1. var anonymousData = new     
  2. {    
  3.     ForeName = “Jignesh”,    
  4.     SurName = “Trivedi”    
  5. };    
  6. Console.WriteLine(“First Name : ” + anonymousData.ForeName);    

Anonymous Types with LINQ Example

Anonymous types are also used with the “Select” clause of LINQ query expression to return a subset of properties.


If any object collection has properties calling FirstName, LastName, DOB, etc… and you want only FirstName and LastName after the Querying the data, then:

  1.     class MyData {    
  2.         public string FirstName {    
  3.             get;    
  4.             set;    
  5.         }    
  6.         public string LastName {    
  7.             get;    
  8.             set;    
  9.         }    
  10.         public DateTime DOB {    
  11.             get;    
  12.             set;    
  13.         }    
  14.         public string MiddleName {    
  15.             get;    
  16.             set;    
  17.         }    
  18.     }    
  19.     static void Main(string[] args) {    
  20.         // Create Dummy Data to fill Collection.    
  21.         List < MyData > data = new List < MyData > ();    
  22.         data.Add(new MyData {    
  23.             FirstName = “Jignesh”, LastName = “Trivedi”, MiddleName = “G”, DOB = new DateTime(1990, 12, 30)    
  24.         });    
  25.         data.Add(new MyData {    
  26.             FirstName = “Tejas”, LastName = “Trivedi”, MiddleName = “G”, DOB = new DateTime(1995, 11, 6)    
  27.         });    
  28.         data.Add(new MyData {    
  29.             FirstName = “Rakesh”, LastName = “Trivedi”, MiddleName = “G”, DOB = new DateTime(1993, 10, 8)    
  30.         });    
  31.         data.Add(new MyData {    
  32.             FirstName = “Amit”, LastName = “Vyas”, MiddleName = “P”, DOB = newDateTime(1983, 6, 15)    
  33.         });    
  34.         data.Add(new MyData {    
  35.             FirstName = “Yash”, LastName = “Pandiya”, MiddleName = “K”, DOB = newDateTime(1988, 7, 20)    
  36.         });    
  37.     }    
  38.     var anonymousData = from pl in data    
  39.     select new {    
  40.         pl.FirstName, pl.LastName    
  41.     };    
  42.     foreach(var m in anonymousData) {    
  43.         Console.WriteLine(“Name : ” + m.FirstName + ” ” + m.LastName);    
  44.     }    
  45. }   

116. What is a Hashtable in C#?

A Hashtable is a collection that stores (Keys, Values) pairs. Here, the Keys are used to find the storage location and is immutable and cannot have duplicate entries in a Hashtable. The .Net Framework has provided a Hash Table class that contains all the functionality required to implement a hash table without any additional development. The hash table is a general-purpose dictionary collection. Each item within the collection is a DictionaryEntry object with two properties: a key object and a value object. These are known as Key/Value. When items are added to a hash table, a hash code is generated automatically. This code is hidden from the developer. Access to the table’s values is achieved using the key object for identification. As the items in the collection are sorted according to the hidden hash code, the items should be considered to be randomly ordered.

The Hashtable Collection

The Base Class libraries offer a Hashtable Class that is defined in the System.Collections namespace, so you don’t have to code your own hash tables. It processes each key of the hash that you add every time and then uses the hash code to look up the element very quickly. The capacity of a hash table is the number of elements the hash table can hold. As elements are added to a hash table, the capacity is automatically increased as required through reallocation. It is an older .Net Framework type.

Declaring a Hashtable

The Hashtable class is generally found in the namespace called System.Collections. So to execute any of the examples, we have to add using System.Collections; to the source code. The declaration for the Hashtable is:

  1. Hashtable HT = new Hashtable ();  

117. What is LINQ in C#?

LINQ stands for Language Integrated Query. LINQ is a data querying methodology that provides querying capabilities to .NET languages with a syntax similar to a SQL query.

LINQ has a great power of querying on any source of data. The data source could be collections of objects, database or XML files. We can easily retrieve data from any object that implements the IEnumerable<T> interface.

Advantages of LINQ 

  1. LINQ offers an object-based, language-integrated way to query over data no matter where that data came from. So through LINQ, we can query a database and XML as well as collections. 
  2. Compile-time syntax checking.

It allows you to query collections like arrays, enumerable classes, etc… in the native language of your application, like in VB or C# in much the same way you would query a database using SQL.

Advantages of LINQ
  1. LINQ offers an object-based, language-integrated way to query over data no matter where that data came from. So through  LINQ we can query database, XML as well as collections. 
  2. Compile time syntax checking
  3. It allows you to query collections like arrays, enumerable classes etc in the native language of your application, like VB or C# in much the same way as you would query a database using SQL
LINQ to Object

LINQ to Object provides functionality to query in-memory objects and collections. Any class that implements the IEnumerable<T> interface (in the System.Collections.Generic namespace) can be queried with SQO.


LINQ to ADO.NET deals with data from external sources, basically anything ADO.NET can connect to. Any class that implements IEnumerable<T> or IQueryable<T> (in the System.Query namespace) can be queried with SQO.  

  • LINQ to SQL (DLinq) {Queries performed against the relation database only Microsoft SQL Server Supported} 
  • LINQ to DataSet {Supports queries by using ADO.NET data sets and data tables} 
  • LINQ to Entities 
LINQ to XML (XLinq)

LINQ to XML is used to query XML data sources.

1 thought on “C# Fundamental Part 3”

Leave a Comment

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

https://www.cooljerseyedge.com, https://www.collegeshopfan.com, https://www.kcchiefsgearusa.com, https://www.dlionsgearusa.com, https://www.bravensgearusa.com, https://www.cbengalsgearusa.com, https://www.gbpackersgearusa.com, https://www.htexansgearusa.com, https://www.laramsgearusa.com, Josh Allen Wyoming Jersey, https://www.dcowboysgearusa.com, https://www.mdolphinsgearusa.com, https://www.aliexfanshop.com, https://www.bestplayershop.com, https://www.collegeedgeshop.com, https://www.giantsonlinefans.com