C# Concept

Question 1

What is C#?

Answer 1

C# is an object-oriented, type-safe, and managed language that is compiled by .Net framework to generate Microsoft Intermediate Language.

Question 2

Explain types of comment in C#?

Answer 2

Single line comments //

Multiple line comments /* */

Xml ///

Question 3

Can multiple catch blocks be executed?

Answer 3

No, Multiple catch blocks of similar type 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.

Question 4

What is the difference between public, static, and void?

Answer 4

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.

Question 5

What is an object?

Answer 5

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.

Question 6

Define Constructors

Answer 6

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.

Question 7

What Are Jagged Arrays?

Answer 7

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 an Array of arrays.

Question 8

8. What is the difference between ref & out parameters?

Answer 8

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.

Question 9

9. What is the use of ‘using’ statement in C#?

Answer 9

The ‘using’ block is used to obtain a resource and process it and then automatically dispose of when the execution of the block completed.

Question 10

10. What is serialization?

Answer 10

When we want to transport an object through a 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.

Question 11

11. Can we use “this” command within a static method?

Answer 11

We can’t use ‘This’ in a static method because we can only use static variables/methods in a static method.

Question 12

12. What is the difference between constants and read-only?

Answer 12

Constant variables are declared and initialized at compile time. The value can’t be changed afterward. Read-only is used only when we want to assign the value at run time.

Question 13

13. What is an interface class? Give one example of it

Answer 13

An 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.

Question 14

14. What are value types and reference types?

Answer 14

A value type holds a data value within its own memory space. Example

int a = 30;

Reference type stores the address of the Object where the value is being stored. It is a pointer to another memory location.

string b = “Hello Guru99!!”;

Question 15

15. What are Custom Control and User Control?

Answer 15

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, at design time. We can easily add custom controls to Multiple Applications (If Shared Dlls). So, 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.

Question 16

16. What are sealed classes in C#?

Answer 16

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.

Question 17

17. What is method overloading?

Answer 17

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.

Question 18

18. What is the difference between Array and Arraylist?

Answer 18

In an array, we can have items of the same type only. The size of the array is fixed when compared. To an arraylist is similar to an array, but it doesn’t have a fixed size.

Question 19

19. Can a private virtual method can be overridden?

Answer 19

No, because they are not accessible outside the class.

Question 20

20. Describe the accessibility modifier “protected internal”.

Answer 20

Protected Internal variables/methods are accessible within the same assembly and also from the classes that are derived from this parent class.

Question 21

21. What are the differences between System.String and System.Text.StringBuilder classes?

Answer 21

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 a concept of a mutable string where a variety of operations can be performed without allocation separate memory location for the modified string.

Question 22

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

Answer 22

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 methods perform a shallow copy.

Question 23

23. How can we sort the elements of the Array in descending order?

Answer 23

Using Sort() methods followed by Reverse() method.

Question 24

24. Write down the C# syntax to catch an exception

Answer 24

To catch an exception, we use try-catch blocks. Catch block can have a parameter of system.Exception type.

Eg:

try {
    GetAllData();
} 
catch (Exception ex) {
}
In the above example, we can omit the parameter from catch statement.

Question 25

25. What’s the difference between an interface and abstract class?

Answer 25

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.

Question 26

26. What is the difference between Finalize() and Dispose() methods?

Answer 26

Dispose() is called when we want for an object to release any unmanaged resources with them. On the other hand, Finalize() is used for the same purpose, but it doesn’t assure the garbage collection of an object.

Question 27

27. What are circular references?

Answer 27

Circular reference is situation in which two or more resources are interdependent on each other causes the lock condition and make the resources unusable.

Question 28

28. What are generics in C#.NET?

Answer 28

Generics are used to make reusable code classes to decrease the code redundancy, increase type safety, and performance. Using generics, we can create collection classes. To create generic collection, System.Collections.Generic namespace should be used instead of classes such as ArrayList in the System.Collections namespace. Generics promotes the usage of parameterized types.

Question 29

29. What is an object pool in .NET?

Answer 29

An object pool is a container having objects ready to be used. It tracks the object that is currently in use, total number of objects in the pool. This reduces the overhead of creating and re-creating objects.

Question 30

30. List down the commonly used types of exceptions in .net

Answer 30

ArgumentException, ArgumentNullException , ArgumentOutOfRangeException, ArithmeticException, DivideByZeroException ,OverflowException , IndexOutOfRangeException ,InvalidCastException ,InvalidOperationException , IOEndOfStreamException , NullReferenceException , OutOfMemoryException , StackOverflowException etc.

Question 31

31. What are Custom Exceptions?

Answer 31

Sometimes there are some errors that need to be handled as per user requirements. Custom exceptions are used for them and are used defined exceptions.

Question 32

32. What are delegates?

Answer 32

Delegates are same are function pointers in C++, but the only difference is that they are type safe, unlike function pointers. Delegates are required because they can be used to write much more generic type-safe functions.

Question 33

33. How do you inherit a class into other class in C#?

Answer 33

Colon is used as inheritance operator in C#. Just place a colon and then the class name.

public class DerivedClass : BaseClass

Question 34

34. What is the base class in .net from which all the classes are derived from?

Answer 34

System.Object

Question 35

35. What is the difference between method overriding and method overloading?

Answer 35

In method overriding, we change the method definition in the derived class that changes the method behavior. Method overloading is creating a method with the same name within the same class having different signatures.

Question 36

36. What are the different ways a method can be overloaded?

Answer 36

Methods can be overloaded using different data types for a parameter, different order of parameters, and different number of parameters.

Question 37

37. Why can’t you specify the accessibility modifier for methods inside the interface?

Answer 37

In an interface, we have virtual methods that do not have method definition. All the methods are there to be overridden in the derived class. That’s why they all are public.

Question 38

38. How can we set the class to be inherited, but prevent the method from being over-ridden?

Answer 38

Declare the class as public and make the method sealed to prevent it from being overridden.

Question 39

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

Answer 39

Implement is up to you as the method is inside your own class. There might be a problem when the methods from different interfaces expect different data, but as far as compiler cares you’re okay.

Question 40

40. What is the difference between a Struct and a Class?

Answer 40

Structs are value-type variables, and classes are reference types. Structs stored on the Stack causes additional overhead but faster retrieval. Structs cannot be inherited.

Question 41

41. How to use nullable types in .Net?

Answer 41

Value types can take either their normal values or a null value. Such types are called nullable types.

Int? someID = null;
If(someID.HasVAlue)
{
}

Question 42

42. How we can create an array with non-default values?

Answer 42

We can create an array with non-default values using Enumerable.Repeat.

Question 43

43. What is difference between “is” and “as” operators in c#?

Answer 43

“is” operator is used to check the compatibility of an object with a given type, and it returns the result as Boolean.

“as” operator is used for casting of an object to a type or a class.

Question 44

44. What’s a multicast delegate?

Answer 44

A delegate having multiple handlers assigned to it is called multicast delegate. Each handler is assigned to a method.

Question 45

45. What are indexers in C# .NET?

Answer 45

Indexers are known as smart arrays in C#. It allows the instances of a class to be indexed in the same way as an array.

Eg:

public int this[int index] // Indexer declaration

Question 46

46. What is difference between the “throw” and “throw ex” in .NET?

Answer 46

“Throw” statement preserves original error stack whereas “throw ex” have the stack trace from their throw point. It is always advised to use “throw” because it provides more accurate error information.

Question 47

47. What are C# attributes and its significance?

Answer 47

C# provides developers a way to define declarative tags on certain entities, eg. Class, method, etc. are called attributes. The attribute’s information can be retrieved at runtime using Reflection.

Question 48

48. How to implement a singleton design pattern in C#?

Answer 48

In a singleton pattern, a class can only have one instance and provides an access point to it globally.

Eg:

Public sealed class Singleton
{
Private static readonly Singleton _instance = new Singleton();
}

Question 49

49. What is the difference between directcast and ctype?

Answer 49

DirectCast is used to convert the type of object that requires the run-time type to be the same as the specified type in DirectCast.

Ctype is used for conversion where the conversion is defined between the expression and the type.

Question 50

50. Is C# code is managed or unmanaged code?

Answer 50

C# is managed code because Common language runtime can compile C# code to Intermediate language.

Question 51

51. What is Console application?

Answer 51

A console application is an application that can be run in the command prompt in Windows. For any beginner on .Net, building a console application is ideally the first step, to begin with.

Question 52

52. Give an example of removing an element from the queue

Answer 52

The dequeue method is used to remove an element from the queue.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args)
  {
   Queue qt = new Queue();
   qt.Enqueue(1);
   qt.Enqueue(2);
   qt.Enqueue(3);

foreach (Object obj in qt)
{
Console.WriteLine(obj);
}
Console.WriteLine(); Console.WriteLine();
Console.WriteLine(“The number of elements in the Queue “ + qt.Count);
Console.WriteLine(“Does the Queue contain “ + qt.Contains(3));
Console.ReadKey();
}
}
}

Question 53

3. What is Managed Code?

Answer 53

“Managed code is the code that is developed using the .NET framework and its supported programming languages such as C# or VB.NET. Managed code is directly executed by the Common Language Runtime (CLR or Runtime) and its lifecycle including object creation, memory allocation, and object disposal is managed by the Runtime. Any language that is written in .NET Framework is managed code”.

Question 54

Unmanaged Code

Answer 54

The code that is developed outside of the .NET framework is known as unmanaged code.

“Applications that do not run under the control of the CLR are said to be unmanaged. Languages such as C or C++ or Visual Basic are unmanaged.
The object creation, execution, and disposal of unmanaged code is directly managed by the programmers. If programmers write bad code, it may lead to memory leaks and unwanted resource allocations.”

The .NET Framework provides a mechanism for unmanaged code to be used in managed code and vice versa. The process is done with the help of wrapper classes.

Question 55

4. What is Boxing and Unboxing in C#?

Answer 55

4. What is Boxing and Unboxing in C#?

Boxing and Unboxing both are used for type conversions.

The process of converting from a value type to a reference type is called boxing. Boxing is an implicit conversion. Here is an example of boxing in C#.
// Boxing  
int anum = 123;  
Object obj = anum;  
Console.WriteLine(anum);  
Console.WriteLine(obj); 
The process of converting from a reference type to a value type is called unboxing. Here is an example of unboxing in C#.
// Unboxing  
Object obj2 = 123;  
int anum2 = (int)obj;  
Console.WriteLine(anum2);  
Console.WriteLine(obj);

Question 56

5. What is the difference between a struct and a class in C#?

Answer 56

Class and struct are both user-defined data types, but have some major differences:

Struct
The struct is a 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 from other types.
A structure can’t be abstract.
No need to create an object with a new keyword.
Do not have permission to create any default constructor.
Class
The class is a 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 from other classes.
A class can be an abstract type.
We can create a default constructor.

Question 57

7. What is enum in C#?

Answer 57

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.
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.

Question 58

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

Answer 58

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  
using System;  
using System.Collections;  
using System.Linq;  
using System.Text;  
namespace break_example {  
    Class brk_stmt {  
        public static void main(String[] args) {  
            for (int i = 0; i <= 5; i++) {  
                if (i == 4) {  
                    break;  
                }  
                Console.WriteLine("The number is " + i);  
                Console.ReadLine();  
            }  
        }  
    }  
}  
Output 

The number is 0;

The number is 1;

The number is 2;

The number is 3;

Eg. Continue Statement
using System;  
using System.Collections;  
using System.Linq;  
using System.Text;  
namespace continue_example {  
    Class cntnu_stmt {  
        public static void main(String[] {  
                for (int i = 0; i <= 5; i++) {  
                    if (i == 4) {  
                        continue;  
                    }  
                    Console.WriteLine(“The number is "+ i);   
                        Console.ReadLine();  
                    }  
                }  
            }  
        }  
Output

The number is 1;

The number is 2;

The number is 3;

The number is 5;

Question 59

9. What is the difference between constant and readonly in C#?

Answer 59

Const is nothing but “constant”, a variable of which the value is constant but at compile time. It’s mandatory to assign a value to it. By default, a const is static and we cannot change the value of a const variable throughout the entire program.

Readonly is the keyword whose value we can change during runtime or we can assign it at run time but only through the non-static constructor.

Question 60

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

Answer 60

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.

The out keyword passes arguments by reference. This is very similar to the ref keyword.

Question 61

12. What are Properties in C#?

Answer 61

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.

Question 62

What are accessors?

Answer 62

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.

Question 63

13. What are extension methods in C#?

Answer 63

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.

Question 64

How to use extension methods?

Answer 64

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

Question 65

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

Answer 65

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

Finalize
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
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.

Question 66

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

Answer 66

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

String

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:

ASP.NET

Note
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.
StringBuilder

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.

ASP.NET
Note
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.

Question 67

What are Delegates

Answer 67

16. 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.

Question 68

Why do we need Delegates

Answer 68

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.

Question 69

17. What are sealed classes in C#?

Answer 69

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#:

Question 70

18. What are partial classes?

Answer 70

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.

Question 71

20. What is IEnumerable<> in C#?

Answer 71

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 which a parent interface of all generic collections class in System.Collections.Generic namespace like List<> and more.

In System.Collections.Generic.IEnumerable 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.

Question 72

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

Answer 72

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:

ASP.NET

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.

Example

ASP.NET
Learn more here, Understanding Polymorphism in C#.

Question 73

22. What are the differences between IEnumerable and IQueryable?

Answer 73

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

IEnumerable

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, which a parent interface of all generic collections class in System.Collections.Generic namespace, like List<> and more.

IQueryable

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. If the provider does not also implement IQueryable, 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.

Question 74

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

Answer 74

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:

Question 75

24. What are the Arrays in C#?

Answer 75

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.

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

A 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.

Question 76

25. What is the Constructor Chaining in C#?

Answer 76

Constructor chaining is a way to connect two or more classes in a relationship as Inheritance. In Constructor Chaining, every child class constructor is mapped to a parent class Constructor implicitly by base keyword, so when you create an instance of the child class, it will call the parent’s class Constructor. Without it, inheritance is not possible.

Question 77

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

Answer 77

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.

Question 78

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

Answer 78

What is a Singleton Design Pattern? 
Ensures a class has only one instance and provides a global point of access to it.
A Singleton is a class that only allows a single instance of itself to be created and usually gives simple access to that instance.
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.)
There are various ways to implement the Singleton Pattern in C#. The following are the common characteristics of a Singleton Pattern.
A single constructor, that is private and parameterless.
The class is sealed.
A static variable that holds a reference to the single created instance, if any.
A public static means of getting the reference to the single created instance, creating one if necessary.

Question 79

30. What are Indexers in C#?

Answer 79

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.

Question 80

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

Answer 80

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.

Question 81

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

Answer 81

“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.
class Speaker {    
    public string Name {    
        get;    
        set;    
    }    
}    
class Author {    
    public string Name {    
        get;    
        set;    
    }    
}    
Now, let's create an object of type Speaker:
var speaker = new Speaker { Name="Gaurav Kumar Arora"};    
Now, let’s check if the object is Speaker type:
var isTrue = speaker is Speaker;     
In the preceding, we are checking the matching type. Yes, our speaker is an object of Speaker type.
Console.WriteLine("speaker is of Speaker type:{0}", isTrue);   
So, the results are true.

But, here we get false:
var author = new Author { Name = "Gaurav Kumar Arora" };     
var isTrue = speaker is Author;     
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.
public static string GetAuthorName(dynamic obj)
{
Author authorObj = obj as Author;
return (authorObj != null) ? authorObj.Name : string.Empty;
}
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:
var speaker = new Speaker { Name="Gaurav Kumar Arora"};   
var author = new Author { Name = "Gaurav Kumar Arora" };     
The following returns the "Name" property:
var authorName = GetAuthorName(author);     
Console.WriteLine("Author name is:{0}", authorName);    
It returns an empty string:
authorName = GetAuthorName(speaker);     
Console.WriteLine("Author name is:{0}", authorName);

Question 82

35. What are Different Ways a Method can be Overloaded?

Answer 82

Method overloading is a way to achieve compile-time polymorphism where we can use a method with the same name but different signatures. For example, the following code example has a method volume with three different signatures based on the number and type of parameters and return values.

Example
using System;    
using System.Collections.Generic;    
using System.Linq;    
using System.Text;    

namespace Hello_Word {
class overloding {
public static void Main() {
Console.WriteLine(volume(10));
Console.WriteLine(volume(2.5F, 8));
Console.WriteLine(volume(100L, 75, 15));
Console.ReadLine();
}

    static int volume(int x) {    
        return (x * x * x);    
    }    

    static double volume(float r, int h) {    
        return (3.14 * r * r * h);    
    }    

    static long volume(long l, int b, int h) {    
        return (l * b * h);    
    }    
}     }     Note  If we have a method that has two parameter object type and has the same name method with two integer parameters, when we call that method with int value, it will call that method with integer parameters instead of the object type parameters method.

Question 83

36. What is an Object Pool in .Net?

Answer 83

Object Pooling in .NET allows objects to keep in the memory pool so the objects can be reused without recreating them. This article explains what object pooling is in .NET and how to implement object pooling in C#.

What does it mean?

Object Pool is a container of objects that are ready for use. Whenever there is a request for a new object, the pool manager will take the request and it will be served by allocating an object from the pool.

How does it work?

We are going to use the Factory pattern for this purpose. We will have a factory method, which will take care of the creation of objects. Whenever there is a request for a new object, the factory method will look into the object pool (we use Queue object). If there is any object available within the allowed limit, it will return the object (value object), otherwise, a new object will be created and give you back.

Question 84

37. What are Generics in C#?

Answer 84

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.

ASP.NET

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.

Question 85

38. Describe Accessibility Modifiers in C#

Answer 85

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:

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

Question 86

39. What is a Virtual Method in C#?

Answer 86

A virtual method is a method that can be redefined in derived classes. A virtual method has an implementation in a base class as well as derived the class. It is used when a method’s basic functionality is the same but sometimes more functionality is needed in the derived class. A virtual method is created in the base class that can be overridden in the derived class. We create a virtual method in the base class using the virtual keyword and that method is overridden in the derived class using the override keyword.

When a method is declared as a virtual method in a base class then that method can be defined in a base class and it is optional for the derived class to override that method. The overriding method also provides more than one form for a method. Hence, it is also an example of polymorphism.

When a method is declared as a virtual method in a base class and that method has the same definition in a derived class then there is no need to override it in the derived class. But when a virtual method has a different definition in the base class and the derived class then there is a need to override it in the derived class.

When a virtual method is invoked, the run-time type of the object is checked for an overriding member. The overriding member in the most derived class is called, which might be the original member if no derived class has overridden the member.

Virtual Method
By default, methods are non-virtual. We can’t override a non-virtual method.
We can’t use the virtual modifier with static, abstract, private or override modifiers.

Question 87

45. What is Multithreading with .NET?

Answer 87

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.

Question 88

What are Anonymous Types in C#?

Answer 88

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.

Example 
var anonymousData = new     
{    
    ForeName = "Jignesh",    
    SurName = "Trivedi"    
};    
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.

Example

If any object collection has properties calling FirstName, LastName, DOB, etc... and you want only FirstName and LastName after the Querying the data, then:
    class MyData {    
        public string FirstName {    
            get;    
            set;    
        }    
        public string LastName {    
            get;    
            set;    
        }    
        public DateTime DOB {    
            get;    
            set;    
        }    
        public string MiddleName {    
            get;    
            set;    
        }    
    }    
    static void Main(string[] args) {    
        // Create Dummy Data to fill Collection.    
        List < MyData > data = new List < MyData > ();    
        data.Add(new MyData {    
            FirstName = "Jignesh", LastName = "Trivedi", MiddleName = "G", DOB = new DateTime(1990, 12, 30)    
        });    
        data.Add(new MyData {    
            FirstName = "Tejas", LastName = "Trivedi", MiddleName = "G", DOB = new DateTime(1995, 11, 6)    
        });    
        data.Add(new MyData {    
            FirstName = "Rakesh", LastName = "Trivedi", MiddleName = "G", DOB = new DateTime(1993, 10, 8)    
        });    
        data.Add(new MyData {    
            FirstName = "Amit", LastName = "Vyas", MiddleName = "P", DOB = newDateTime(1983, 6, 15)    
        });    
        data.Add(new MyData {    
            FirstName = "Yash", LastName = "Pandiya", MiddleName = "K", DOB = newDateTime(1988, 7, 20)    
        });    
    }    
    var anonymousData = from pl in data    
    select new {    
        pl.FirstName, pl.LastName    
    };    
    foreach(var m in anonymousData) {    
        Console.WriteLine("Name : " + m.FirstName + " " + m.LastName);    
    }    
}

Question 89

47. What is a Hashtable in C#?

Answer 89

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:
Hashtable HT = new Hashtable ();

Question 90

49. What is File Handling in C#.Net?

Answer 90

The System.IO namespace provides four classes that allow you to manipulate individual files, as well as interact with a machine directory structure. The Directory and File directly extend System.Object and supports the creation, copying, moving and deletion of files using various static methods. They only contain static methods and are never instantiated. The FileInfo and DirecotryInfo types are derived from the abstract class FileSystemInfo type and they are typically employed for obtaining the full details of a file or directory because their members tend to return strongly typed objects. They implement roughly the same public methods as a Directory and a File but they are stateful and members of these classes are not static.

Question 91

50. What is Reflection in C#?

Answer 91

Reflection is the process of runtime type discovery to inspect metadata, CIL code, late binding, and self-generating code. At the run time by using reflection, we can access the same “type” information as displayed by the ildasm utility at design time. The reflection is analogous to reverse engineering in which we can break an existing *.exe or *.dll assembly to explore defined significant contents information, including methods, fields, events, and properties.

You can dynamically discover the set of interfaces supported by a given type using the System.Reflection namespace.

Reflection typically is used to dump out the loaded assemblies list, their reference to inspect methods, properties etcetera. Reflection is also used in the external disassembling tools such as Reflector, Fxcop, and NUnit because .NET tools don’t need to parse the source code similar to C++.

Metadata Investigation

The following program depicts the process of reflection by creating a console-based application. This program will display the details of the fields, methods, properties, and interfaces for any type within the mscorlib.dll assembly. Before proceeding, it is mandatory to import “System.Reflection”.