C# Interview Questions
What is C#?
C# Is a programming language which runs on .NET framework. Compiler is a computer program that transforms computer code written in source language into target language.
C# compiler converts code into Intermediate language (MSIL)
C# can be used to create
- web apps( ASP.net web forms, ASP.net MVC)
- desktop apps( WinForms, WPF)
- mobile apps( Xamarin)
C# needs CLR for memory management and execution CLR(common language runtime)
What is an object in C#?
A class is a template that defines what a data structure will look like, and how data will be stored, managed, and transferred.
A class has fields, properties, methods, and other members.Objects are created using class instances. A class defines the type of an object. Objects store real values in computer memory.
What is Managed or Unmanaged Code?
Managed Code
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.
Unmanaged Code
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.
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.
What is Boxing and Unboxing in C#?
Boxing and Unboxing both are used for type conversions.
Boxing – Converting Value type to Reference Type
Boxing is an implicit conversion. Here is an example of boxing in C#. so converting a simpla data type to object.
int anum = 123;
Object obj = anum; //Boxing as we are changing from integer to object.
Console.WriteLine(anum);
Console.WriteLine(obj);
Unboxing – Converting Reference Type to Value Type
Object obj2 = 123;
int anum2 = (int)obj; //we are converting object back to integer
Console.WriteLine(anum2);
Console.WriteLine(obj);
What is the difference between a struct and a class in C#?
Class and struct are both user-defined data types, but have some major differences:
Struct
The struct is a value type in C#
Struct is usually used for smaller amounts of data. Struct can’t be inherited from other types. No need to create an object with a new keyword.
Class
The class is a reference type in C# Classes are usually used for large amounts of data. Classes can be inherited from other classes.
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.
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. Basically a Value Type with a set of related constants.
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.
public enum Dow
{
Sat,
Sun,
Mon,
Tue,
Wed,
Thu,
Fri
};
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.
for(int i=0; i<10; i++)
{
if(i==0) continue;
Console.WriteLine(I);
if(I==4) break;
}
In the above loop , zero will not be printed because loop continues if i == 0, skipping all statements below
In case of I == 4 once it reaches break statement , loop exists and no values are printed from 5
What is the difference between constant and readonly in C#?
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.
we usually assign it during constructor.
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.
The out keyword passes arguments by reference. This is very similar to the ref keyword.
ASP.NET
To learn more about ref and out keywords, read the following article: Ref Vs Out Keywords in C#
Can “this” be used within a static method?
We can't use 'this' in a static method because the keyword 'this' returns a reference to the current instance of the class containing it. Static methods (or any static member) do not belong to a particular instance. They exist without creating an instance of the class and are called with the name of a class, not by instance, so we can’t use this keyword in the body of static Methods. However, in the case of Extension Methods, we can use the parameters of the function.
Let’s have a look at the “this” keyword.
The "this" keyword in C# is a special type of reference variable that is implicitly defined within each constructor and non-static method as a first parameter of the type class in which it is defined.
Learn more here: The this Keyword In C#.
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.
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.
Learn more here: Property in C#
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.
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#.
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
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.
For more details follow this link, Back To Basics - Dispose Vs Finalize.
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.
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.
For more details, read the following article, Comparison of String and StringBuilder in C#.
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
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#:
// Sealed class
sealed class SealedClass
{
}
Learn more about sealed classes here: Sealed Classes in C#
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:
ASP.NET
To learn about partial classes, visit Partial Classes in C# With Real Example.
What is boxing and unboxing in C#?
Boxing and Unboxing are both used for type converting, but have some differences:
Boxing
Boxing is the process of converting a value type data type to the object or to any interface data type which is implemented by this value type. When the CLR boxes a value means when CLR converting a value type to Object Type, it wraps the value inside a System.Object and stores it on the heap area in the application domain.
Example
ASP.NET
Unboxing
Unboxing is also a process that is used to extract the value type from the object or any implemented interface type. Boxing may be done implicitly, but unboxing has to be explicit by code.
Example:
ASP.NET
The concept of boxing and unboxing underlies the C# unified view of the type system in which a value of any type can be treated as an object.
To learn more about boxing and unboxing, visit Boxing and Unboxing in C#.
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.
ASP.NET
For more details, visit Implement IEnumerable Interface in C#.
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:
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#.
What are the differences between IEnumerable and IQueryable?
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<T>, 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<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.
ASP.NET
Learn more here: IEnumerable vs IQuerable.
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:
interface testInterface1
{
void Show();
}
interface testInterface2
{
void Show();
}
class Abc: testInterface1, testInterface2
{
void testInterface1.Show() {
Console.WriteLine("For testInterface1 !!");
}
void testInterface2.Show() {
Console.WriteLine("For testInterface2 !!");
}
}
//Now see how to use these in a class:
class Program {
static void Main(string[] args) {
testInterface1 obj1 = new Abc();
testInterface1 obj2 = new Abc();
obj1.Show();
obj2.Show();
Console.ReadLine();
}
}
Output
ASP.NET
For one more example follow the link: Inherit Multiple Interfaces and They have Conflicting Method Name
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.
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.
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.
int[] intArray;
intArray = new int[5];
The following code snippet declares an array that can store 100 items starting from index 0 to 99.
int[] intArray;
intArray = new int[100];
Learn more about Arrays in C#: Working with Arrays In C#
What is the Constructor Chaining in C#?
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.
For more examples, follow the link: Constructors In C#
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#.
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.
using System;
class MyClient {
public static void Main() {
int x = 0;
int div = 0;
try {
div = 100 / x;
Console.WriteLine("Not executed line");
} catch (DivideByZeroException de) {
Console.WriteLine("DivideByZeroException");
} catch (Exception ee) {
Console.WriteLine("Exception");
} finally {
Console.WriteLine("Finally Block");
}
Console.WriteLine("Result is {0}", div);
}
}
To learn more about Exception Handling in C#, please visit, Exception Handling in C#.
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.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace TestingThrowExceptions {
class Program {
public void ExceptionMethod() {
throw new Exception("Original Exception occurred in ExceptionMethod");
}
static void Main(string[] args) {
Program p = new Program();
try {
p.ExceptionMethod();
} catch (Exception ex) {
throw ex;
}
}
}
}
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
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
< modifier > <
return type > this[argument list] {
get {
// your get block code
}
set {
// your set block code
}
}
In the above code,
<modifier>
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#.
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.
using System;
namespace ComparisionExample {
class Program {
static void Main(string[] args) {
string name = "sandeep";
string myName = name;
Console.WriteLine("== operator result is {0}", name == myName);
Console.WriteLine("Equals method result is {0}", name.Equals(myName));
Console.ReadKey();
}
}
}
For more details, check out the following link, Difference Between Equality Operator ( ==) and Equals() Method in C#.
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.
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);
Learn more about is vs as operators here, "is" and "as" Operators of C#
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.
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.
var? i = null;
To learn more about nullable types in C#, read the following, Getting started with Nullable Types in C#.
What are Different Ways a Method can be Overloaded?
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.
Read the following article to learn more here, Method Overloading in C#.
What is an Object Pool in .Net?
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.
To learn more about object pooling in C# and .NET, read the following, Object Pooling in .NET.
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.
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.
Learn more about generic classes in C# here, Using Generics In C#.
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:
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.
To learn more about access modifiers in C#, click here, What are Access Modifiers in C#?
What is a Virtual Method in C#?
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.
Learn more about virtual methods in C# here, Virtual Method in C#.
What are Value types and Reference types in C#?
In C#, data types can be of two types, value types, and reference types. Value type variables contain their object (or data) directly. If we copy one value type variable to another then we are actually making a copy of the object for the second variable. Both of them will independently operate on their values, Value type data types are stored on a stack and reference data types are stored on a heap.
In C#, basic data types include int, char, bool, and long, which are value types. Classes and collections are reference types.
For more details, follow this link, C# Concepts: Value Type and Reference Type
What is Serialization in C#?
Serialization in C# is the process of converting an object into a stream of bytes to store the object to memory, a database, or a file. Its main purpose is to save the state of an object in order to be able to recreate it when needed. The reverse process is called deserialization.
There are three types of serialization,
Binary serialization (Save your object data into binary format).
Soap Serialization (Save your object data into binary format; mainly used in network-related communication).
XmlSerialization (Save your object data into an XML file).
Learn more about serialization in C# here, Serializing Objects in C#
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!
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:
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#
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.
Example
int[][] jagArray = new int[5][];
In the above declaration, the rows are fixed in size. But columns are not specified as they can vary.
Declaring and initializing a jagged array.
int[][] jaggedArray = new int[5][];
jaggedArray[0] = new int[3];
jaggedArray[1] = new int[5];
jaggedArray[2] = new int[2];
jaggedArray[3] = new int[8];
jaggedArray[4] = new int[10];
jaggedArray[0] = new int[] { 3, 5, 7, };
jaggedArray[1] = new int[] { 1, 0, 2, 4, 6 };
jaggedArray[2] = new int[] { 1, 6 };
jaggedArray[3] = new int[] { 1, 0, 2, 4, 6, 45, 67, 78 };
jaggedArray[4] = new int[] { 1, 0, 2, 4, 6, 34, 54, 67, 87, 78 };
Learn more here, Jagged Array in C#
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
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)
});
var anonymousData = from pl in data
select new
{
pl.FirstName,
pl.LastName
};
foreach (var m in anonymousData)
{
Console.WriteLine("Name : " + m.FirstName + " " + m.LastName);
}
}
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:
Hashtable HT = new Hashtable ();
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
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.
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.
ASP.NET
What is File Handling in C#.Net?
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.
ASP.NET
For more details follow the links, File Handling in C# .NET
What is Reflection in C#?
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".
Here, we are defining a number of static methods in the program class to enumerate fields, methods, and interfaces in the specified type. The static method takes a single "System.Type" parameter and returns void.
static void FieldInvestigation(Type t) {
Console.WriteLine("*********Fields*********");
FieldInfo[] fld = t.GetFields();
foreach(FieldInfo f in fld) {
Console.WriteLine("-->{0}", f.Name);
}
}
static void MethodInvestigation(Type t) {
Console.WriteLine("*********Methods*********");
MethodInfo[] mth = t.GetMethods();
foreach(MethodInfo m in mth) {
Console.WriteLine("-->{0}", m.Name);
}
}
Can multiple catch blocks be executed?
No, Multiple catch blocks can't be executed. Once the proper catch code executed, the control is transferred to the finally block, and then the code that follows the finally block gets executed.
What is the difference between public, static, and void?
Public declared variables or methods are accessible anywhere in the application. Static declared variables or methods are globally accessible without creating an instance of the class. Static member are by default not globally accessible it depends upon the type of access modified used. The compiler stores the address of the method as the entry point and uses this information to begin execution before any objects are created. And Void is a type modifier that states that the method or variable does not return any value.
What is an object?
(C)Sharp your mind 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.
Define Constructors
A constructor is a member function in a class that has the same name as its class. The constructor is automatically invoked whenever an object class is created. It constructs the values of data members while initializing the class.
What is Jagged Arrays?
The Array which has elements of type array is called jagged Array. The elements can be of different dimensions and sizes. We can also call jagged Array as an Array of arrays.
What is the difference between ref & out parameters?
An argument passed as ref must be initialized before passing to the method whereas out parameter needs not to be initialized before passing to a method.
What is the use of 'using' statement in C#?
The 'using' block is used to obtain a resource and process it and then automatically dispose of when the execution of the block completed.
What is serialization?
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.
Can we use "this" command within a static method?
We can't use 'This' in a static method because we can only use static variables/methods in a static method.
What is the difference between constants and read-only?
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.
What is an interface class? Give one example of it
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.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DemoApplication
{
interface Guru99Interface
{
void SetTutorial(int pID, string pName);
String GetTutorial();
}
class Guru99Tutorial : Guru99Interface
{
protected int TutorialID;
protected string TutorialName;
public void SetTutorial(int pID, string pName)
{
TutorialID = pID;
TutorialName = pName;
}
public String GetTutorial()
{
return TutorialName;
}
static void Main(string[] args)
{
Guru99Tutorial pTutor = new Guru99Tutorial();
pTutor.SetTutorial(1,".Net by Guru99");
Console.WriteLine(pTutor.GetTutorial());
Console.ReadKey();
}
}
}
What are value types and reference types?
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!!";
What are Custom Control and User Control?
Custom Controls are controls generated as compiled code (Dlls), those are easier to use and can be added to toolbox. Developers can drag and drop controls to their web forms. Attributes can, 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.
What are sealed classes in C#?
We create sealed classes when we want to restrict the class to be inherited. Sealed modifier used to prevent derivation from a class. If we forcefully specify a sealed class as base class, then a compile-time error occurs.
What is method overloading?
Method overloading is creating multiple methods with the same name with unique signatures in the same class. When we compile, the compiler uses overload resolution to determine the specific method to be invoke.
What is the difference between Array and Arraylist?
In an array, we can have items of the same type only. The size of the array is fixed when compared. To an arraylist is similar to an array, but it doesn't have a fixed size.
Can a private virtual method can be overridden?
No, because they are not accessible outside the class.
Describe the accessibility modifier "protected internal".
Protected Internal variables/methods are accessible within the same assembly and also from the classes that are derived from this parent class.
What are the differences between System.String and System.Text.StringBuilder classes?
System.String is immutable. When we modify the value of a string variable, then a new memory is allocated to the new value and the previous memory allocation released. System.StringBuilder was designed to have a concept of a mutable string where a variety of operations can be performed without allocation separate memory location for the modified string.
What's the difference between the System.Array.CopyTo() and System.Array.Clone() ?
Using Clone() method, we creates a new array object containing all the elements in the original Array and using CopyTo() method. All the elements of existing array copies into another existing array. Both methods perform a shallow copy.
How can we sort the elements of the Array in descending order?
Using Sort() methods followed by Reverse() method.
Write down the C# syntax to catch an exception
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.
What's the difference between an interface and abstract class?
Interfaces have all the methods having only declaration but no definition. In an abstract class, we can have some concrete methods. In an interface class, all the methods are public. An abstract class may have private methods.
What is the difference between Finalize() and Dispose() methods?
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.
What are circular references?
Circular reference is situation in which two or more resources are interdependent on each other causes the lock condition and make the resources unusable.
What are generics in C#.NET?
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.
What is an object pool in .NET?
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.
List down the commonly used types of exceptions in .net
ArgumentException, ArgumentNullException , ArgumentOutOfRangeException, ArithmeticException, DivideByZeroException ,OverflowException , IndexOutOfRangeException ,InvalidCastException ,InvalidOperationException , IOEndOfStreamException , NullReferenceException , OutOfMemoryException , StackOverflowException etc.
What are Custom Exceptions?
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.
What are delegates?
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.
How do you inherit a class into other class in C#?
Colon is used as inheritance operator in C#. Just place a colon and then the class name.
public class DerivedClass : BaseClass
What is the base class in .net from which all the classes are derived from?
System.Object
What is the difference between method overriding and method overloading?
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.
What are the different ways a method can be overloaded?
Methods can be overloaded using different data types for a parameter, different order of parameters, and different number of parameters.
Why can't you specify the accessibility modifier for methods inside the interface?
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.
How can we set the class to be inherited, but prevent the method from being over-ridden?
Declare the class as public and make the method sealed to prevent it from being overridden.
What happens if the inherited interfaces have conflicting method names?
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.
What is the difference between a Struct and a Class?
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.
How to use nullable types in .Net?
Value types can take either their normal values or a null value. Such types are called nullable types.
Int? someID = null; If(someID.HasVAlue) { }
How we can create an array with non-default values?
We can create an array with non-default values using Enumerable.Repeat.
What is difference between "is" and "as" operators in c#?
"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.
What's a multicast delegate?
A delegate having multiple handlers assigned to it is called multicast delegate. Each handler is assigned to a method.
What are indexers in C# .NET?
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
What is difference between the "throw" and "throw ex" in .NET?
"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.
What are C# attributes and its significance?
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.
How to implement a singleton design pattern in C#?
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(); }
What is the difference between directcast and ctype?
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.
Is C# code is managed or unmanaged code?
C# is managed code because Common language runtime can compile C# code to Intermediate language.
What is Console application?
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.
https://stackgig.com/topic/9/c-interview-questions-and-answers
Code compilation in C#:
->source code is compiled by C# compiler into a managed module.(like when we create a console app & compile it creates a .exe file, web app - .dll files).
->Assembly: In web application there are different program files which are written in different languages(.dll or .exe etc). Assembly combines & get together into a single assembly. It also contains images (i.e. resource files) & multiple managed modules.
->Executing the assembly by CLR.
CLR is the run-time enviornment in the .NET Framework that runs the codes and helps in making the development process easier by providing the various services.
Managed and unmanaged code: a code which is aimed to get the services of the managed runtime enviroment execution like CLR is known as managed code.
The managed runtime environment provides different types of services like garbage collection, type checking, exception handling, bounds checking, etc. to code automatically without the interference of the programmer. It also provides memory allocation, type safety, etc to the code.
A code which is directly executed by the operating system is known as Unmanaged code. It always aimed for the processor architecture and depends upon computer architecture.
Static classes:
Static classes are created by using static keyword. And it contain static datamembers, static methods and static constructor. Instance of static classes cannot be created. They are sealed.
Sealed classes:
Sealed classes are used to restrict the users from inheriting the class.
To make a method as sealed, it has to be declared as Virtual in its base class.
Abstract class: abstract class cannot be instantiated. It is designed to be inherited by subclasses that either implement or override its methods. Abstract class may contain method definations, fields and constructors.
Partial classes:
A partial class splits the definition of a class over two or more source (.cs) files. We can create a class definition in multiple physical files but it will be compiled as one class when the calsses are compiled.
Partial class is used to create multiple classes with same name by using partial keyword. All the fields and methods in partial classes can be accessed by creating single instance of the class.
What is Tuples?
C# tuple is a data structure that is used to store sequence of elements. Tuple with n elements are known as n-tuple.
We can use Tuple for the following reasons.
To represent a single set of data.
To provide easy access and manipulation of data.
To return multiple values from a method without using out parameter.
To pass multiple values to a method through a single parameter.
Why we should use generics?
Generic provides lot of advantages during programming. We should use generics for the following reasons:
It allows creating class, methods which are type-safe
It is faster. Because it reduce boxing/un-boxing
It increase the code performance
It helps to maximize code reuse, and type safety
A generic class is a special kind of class that can handle any types of data. We specify the data types during the object creations of that class. It is declared with the bracket
What are the different types of assemblies?
There are two types of assemblies Private and Shared assembly. A private assembly is used by a single application and is stored in application directory.So it is application specific. A shared assembly is stored in the global assembly cache - GAC and can be used by different applications.
How to Force Garbage Collection?
You can force this by adding a call to GC.Collect.
Ienumerable :
It is used when we want to iterate among classes using foreach loop.
It provides read-only access to collections. We cannot change any item inside an ienumerable list.
Icollection:
This is inherited from ienumerable interface which means that any class that implements Icollection interface can also be enumerated using foreach loop.
In the IEnumerable interface we don't know how many elements there are in the collection whereas the ICollection interface gives us this extra property for getting the count of items in the collection.
Ilist:
Ilist interface implements both icollection and ienumerable interfaces. This interface allows us to add and remove items from collection. Also provides support for accessing items from the index.
StreamReader and StreamWriter:
C# file operations normally use streams to read and write to files. Stream is an additional layer created between an application and a file.
Streams are normally used when reading data from large files. Data from large files is broken into small chunks and sent to the stream. These chunks of data can be read from the application.
When a write operation is carried out on file, the data is first written to the stream and from stream written to the file. Same for read operation, data is first transffered into stream and then read from application via stream.
Regular expression is a template for matching a set of input. It can consist of constructs, character literals, and operators. Regex is used for string parsing, as well as replacing the character string. Following code searches a string “C#” against the set of inputs from the languages array using Regex:
string[] languages = {“C#”, “Python”, “Java”};
foreach(string s in languages)
{
if(System.Text.RegularExpressions.Regex.IsMatch(s,“C#”))
{
Console.WriteLine(“Match found”);
}
}
}
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.
Processes belonging to asynchronous programming run independently of the main or other processes.
In C#, using Async and Await keywords for creating asynchronous methods.
Race condition:
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.
A parameter is a definition of what will be sent to a method. A parameter occurs within the definition of a method. An argument is a value that is passed to a method.
Namespaces: used for organizing large code projects.
Constructors:
They are a special methods of the class which gets automatically invoked whenever an isntance of class is created.
Construtor has same name as class and can be overloaded using different method signatures.
Constructors contain collection of instructions that need to be executed at the time of object creation.
enumerated data type:
An enumerated data type is another user defined value data type which provides a way for attaching strings to numbers thereby increasing comprehensibility of the code. The enum keyword automatically enumerates a list of words by assigning them values 0,1,2, and so on.
Using Statement and using directive:
The using statement is used to create an object and a scope block, at the end of which, the object is disposed via IDisposable and explicitly destroyed.
The main function of this statement is to manage unused resources and release them automatically.
The using directive is used to reference namespaces.
The two classes of exceptions that exist in C#: System exceptions and application exceptions.
Data or method hiding:
occurs when you create a method or data element in a derived class that replaces a base method or data element. This occurs when the new keyword is used to create the new method or method signature. It can also be referred to as shadowing.
Why is Main() method static:
Static members are scoped to the class level (rather than the object level) and can thus be invoked without the need to first create a new class instance. The Main() method is static because it’s available to run when your program starts and as it is the entry point of the program, it runs without creating an instance of the class. In other words, static functions exist before a class is instantiated, so static is applied to the main entry point.
What is the string[] argument in the Main() method used for?
The string[] argument will contain the command line arguments passed to the application, which are then available within the Main() method.
The Main() method must be marked private. The reason behind this is so other applications cannot invoke the entry point. The Main() method cannot be declared public.
When you use the yield keyword in a statement, you indicate that the method, operator, or get accessor in which it appears is an iterator.
The checked keyword is used to explicitly enable overflow checking for integral-type arithmetic operations and conversions.
Early Binding:
When an object is assigned to a object variable C# compiler performs a process called binding.
In early binding it checks the methods or properties during compile time. The compiler already knows what type of object it is and what type of methods and properties it holds. The performance is fast as early bound objects allow the compiler to allocate memory and perform other optimizations before an application executes.
Dynamic objects provide another way, other than the object type, to late bind to an object at run time.
Reflection is the process of describing the metadata of types, methods and fields in a code. The namespace System.Reflection enables you to obtain data about the loaded assemblies, the elements within them like classes, methods and value types.
Reflections needed when we want to determine / inspect contents of an assembly.
To view attribute information at run time
To view the structure of assemblies at run time (classes, resources, methods)
It allows dynamic/late binding to methods and properties
In serialization, it is used to serialize and de-serialize objects
In web service, it is used to create and consume SOAP messages and also to generate WSDL
Debugging tools can use reflection to examine the state of an object
What is the difference between reflection and dynamic?
Both Reflection and dynamic are used to operate on an object during run time. But they have some differences:
Dynamic uses reflection internally
Reflection can invoke both public and private members of an object. But dynamic can only invoke public members of an object
A singleton is a design pattern used when only one instance of an object is created and shared; that is, it only allows one instance of itself to be created. Any attempt to create another instance simply returns a reference to the first one.
Boxing: converting value type to a ref type. It is implicit conversion process in which object type is used. Value type is always stored in stack and ref type in heap.
Unboxing : coverting ref type to value type. It Is explicit conversion.
lambda expression is an anonymous function that you can use to create delegates or expression tree types. By using lambda expressions, we can write local functions that can be passed as arguments or returned as the value of function calls. Lambda expressions are particularly helpful for writing LINQ query expressions.
Anonymous types:
Anonymous types in C# are the types which do not have a name or you can say the creation of new types without defining them. It is a temporary data type which is inferred based on the data that you insert in an object initializer.
The type of the anonymous type is automatically generated by the compiler according to the value assigned to its properties.
You create an anonymous type using the new operator with an object initializer syntax. The implicitly typed variable- var is used to hold the reference of anonymous types.
Anonymous types are class types that derive directly from object, and that cannot be cast to any type except object.
Extension methods:
Extension methods allow us to add methods to the existing types without modifying original type.
Extension method is defined as static method but it is called as instance of method.
Delegates are ideally suited to implement event driven programming.
Delegate is a reference type variable that holds the reference to a method. Delegate allows methods to be passed as parameters.
A delegate doesn't need to know the class of the object to which it needs to refer to. All it needs to know is the signature of the method to which it would point. Proper usage of delegates can promote code re-usability and flexibility in the designs.
Thread:
A thread is an independent execution path, able to run simultaneously with the other threads within a given process.
Thread can be defined as the excution flow of any program and defines a unique flow of control.
The thread cycle starts with the creation of the object of system.threading.thread class and ends when the thread terminates.
final – constant declaration.
finally – The finally block always executes when the try block exits, except System.exit(0) call. This ensures that the finally block is executed even if an unexpected exception occurs.
finalize() – method helps in garbage collection. A method that is invoked before an object is discarded by the garbage collector, allowing it to clean up its state.
What is the significance of the Finalize method in .NET?:
The .NET garbage collector handles almost all of the cleanup activity for your objects. However, unmanaged resources (example: Windows API created objects, File objects, Database connection objects, COM objects, etc.) are outside the scope of the .NET framework. We have to explicitly cleanup our utilized resources. For these types of objects, the .NET framework provides the Object.Finalize() method. This method can be overridden and allows an author to clean up unmanaged resources.
Object.Finalize() method can be overridden by defining a class destructor.
Dispose() method: belongs to the IDisposable interface.
The disposeof() method releases the unused resources by an object of the class.
If any object wants to release its unmanaged code, the best way to go about this is to implement IDisposable and override the Dispose() method. Once the class has exposed the Dispose() method, it is the responsibility of the client to call the Dispose() method to do the cleanup.
To force the Idisposable.Dispose() to be called automatically call the base Dispose() method within the destructor as well as within the Dispose() method. Next, suppress the Finalize() method using GC.SuppressFinalize() method. This is the best way to clean unallocated resources and to avoid the hit of running the garbage collector twice.
Difference between Dispose() and finalize():
Finalize: Internally, it is called by Garbage Collector and cannot be called by user code.
Dispose: Explicitly, it is called by user code and the class implementing dispose method must implement IDisposable interface.
Finalize: It belongs to the Object class.
Dispose: It belongs to IDisposable interface.
Finalize: Implement it when you have unmanaged resources in your code, and want to make sure that these resources are freed when garbage collection happens.
Dispose: Implement this when you are writing a custom class that will be used by other users.
Finalize: There are performance costs associated with Finalize method.
Dispose: There are no performance costs associated with the Dispose method.
Interface:
An interface is basically a contract—it doesn’t have any implementation. An interface can contain only method declarations; it cannot contain method definitions.
Advantages:
Allows implement polymorphic behaviour, develop loosely coupled systems, enable mockig for better unit testing, implement multi class inheritance, can be used for implementing Dependency injection.
Abstract classes are useful when you need a class for the purpose of inheritance and polymorphism.
Difference between Abstract class and Interfaces:
Abstract classes can have implementations for some of its members, but the interface can't have implementation for any of its members.
Interfaces cannot have fields where as an abstract class can have fields.
A class may implement an unlimited number of interfaces, but may inherit from only one abstract class.
4.When a class or struct implements an interface, the class or struct must provide an implementation for all of the members that the interface defines.
- Abstract class members can have access modifiers where as interface members cannot have access modifiers.
When do you choose interface over an abstract class or vice versa?
If you have an implementation that will be the same for all the derived classes, then it is better to go for an abstract class instead of an interface. So, when you have an interface, you can move your implementation to any class that implements the interface. Where as, when you have an abstract class, you can share implementation for all derived classes in one central place, and avoid code duplication in derived classes.
explicit interface implementation:
If a class implements two interfaces that contain a member with the same signature, then implementing that member on the class will cause both interfaces to use that member as their implementation. If the two interface members do not perform the same function, however, this can lead to an incorrect implementation of one or both of the interfaces. It is possible to implement an interface member explicitly—creating a class member that is only called through the interface, and is specific to that interface. This is accomplished by naming the class member with the name of the interface and a period.
Inheritance:
One class can inherit the features (fiels and methods) of another class.
Polymorphism :
While the inheritance allows to inherit fields and methods, polymorphism uses those methods to perform different tasks. Perform single action in different ways.
Base class method overrides the derived class method when they share same name. To resolve this we can add Virtual keyword to the method inside base class and by using override keyword for each derived class methods.
Abstraction:
Data abstraction is the process of hiding certain details and showing only essential information to the user.
Abstract class: is a restricted class that cannot be used to create objects
Abstract method: can only be used in an abstract class, and it does not have a body. The body is provided by the derived class (inherited from).
Encapsulation:
encapsulation is a protective shield that prevents the data from being accessed by the code outside this shield.
The variables or data of a class are hidden from any other class and can be accessed only through any member function of own class in which they are declared.
As in encapsulation, the data in a class is hidden from other classes, so it is also known as data-hiding.
Encapsulation can be achieved by: Declaring all the variables in the class as private and using c# properties in the class to set and get the values of variables.
Can multiple catch blocks be executed:
No, multiple catch blocks can’t be executed. Multiple catch blocks can be declared. Once the proper catch code is executed, the control is transferred to the finally block and then the code that follows the finally block gets executed.
Object, class: class is a group of related methods and variables. A class will have all the required properties and methods for performing operations and we create an instance of this class called object. All the instances share same attributes and the behaviour of the class. But the values of attributes are unique for each object.
The new operator instantiates a class by allocating memory for new object and returning ref to that memory. It also invokes constructor.
When an object is created using the new operator, memory is allocated for the class in the heap, the object is called an instance and its starting address will be stored in the object in stack memory.
jagged arrays:
An array that has elements of type array is called a jagged array. The elements can be of different dimensions and sizes. We can also call jagged arrays an array of arrays.
Different ways of passing parameters:
Value type: by default parameters are passed by value. In this method a duplicate copy is made and sent to the called function. Changes in the value in the called method will not effect calling method.
Ref: parameters use the address of the actual parameters to formal parameters. Process is bidirectional and any changes in the parameter will reflect. Requires ref keyword.
Out: output parameters don't create a new storage location and are passed by reference. It requires out keyword in front of variables to identify in both actual and formal parameters.
The process of out is unidirectional i.e. we don't have to supply value to the formal parameters but we get back processed value.
Params: It is used when we don't know the number of parameters will be passed to the called method.
Difference between ref and out parameters:
An argument passed by ref (by reference) must be initialized before passing to the method, whereas the out parameter, need not be initialized before being passed to a method. The value of the out variable must be assigned to prior to passing control back from the called method.
serialization and deserialization:
When we want to transport an object through a network 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 inherit the ISerialize interface. De-serialization is the reverse process of creating an object from a stream of bytes.
Can we use 'this' keyword in static methods:
We can't use 'this' in a static method because the keyword 'this' returns a reference to the current instance of the class containing it. Static methods (or any static member) do not belong to a particular instance. They exist without creating an instance of the class and are called with the name of a class, not by instance, so we can’t use this keyword in the body of static Methods.
Constant and readonly keyword:
Constants: the value of the field or local variable is constant, which means that it can't be modified. The static modifier is not allowed in a constant declaration. A constant expression is an expression that can be fully evaluated at compile time. Therefore, the only possible values for constants of reference types are string and null.
A constant field can only be initialized at the declaration of the field.
Readonly: A readonly field can be initialized either at the declaration or in a constructor. Therefore, readonly fields can have different values depending on the constructor used.
A const field is a compile-time constant whereas the readonly field can be used for run-time constants.
sealed keyword:
When applied to a class, the sealed modifier prevents other classes from inheriting from it. sealed modifier can also be used on a method or property that overrides a virtual method or property in a base class. This enables us to allow classes to derive from your class and prevent them from overriding specific virtual methods or properties.
Difference between sealed and abstarct keyword:
The sealed modifier prevents a class from being inherited and the abstract modifier requires a class to be inherited.
Method overloading:
Creating multiple methods with same name and class but with different signatures.(method can have same name but different arguments).When we compile, the compiler uses overload resolution to determine the specific method to invoke.
A method can overload by having different data types, a different number of parameters, or a different order of parameters.
Method overriding:
Creating a method in derived class with the same signature as method in base class but has new implemntation by using override declaration.
Difference method overriding and hiding:
In method overriding we are changing the implementation of the method derived from base class. And a base class reference variable pointing to a child class object will invoke the overriden method in child class.
In method hiding when new keyword is used in child class, it will hide the base class method. And when a base class reference variable pointing to a child class object, it will invoke the hidden base class method.
We cannot use the virtual modifier with the static, abstract, private, or override modifiers.
Protected Internal variables and methods are accessible from classes that are derived from a parent class located within the same assembly.
String and string Builder:
String class objects are immutable which means that if the user will modify any string object it will result into the creation of a new string object. It makes the use of string costly. So when the user needs the repetitive operations on the string then the need of StringBuilder come into existence. It provides the optimized way to deal with the repetitive and multiple string manipulation operations.
StringBuilder is used to represent a mutable string of characters. Mutable means the string which can be changed. So String objects are immutable but StringBuilder is the mutable string type. It will not create a new modified instance of the current string object but do the modifications in the existing string object
System.Array.CopyTo() and System.Array.Clone():
Using the Clone() method, we create a new array object containing all the elements in the original array. When using the CopyTo() method, all elements of the existing array are copied into another existing array. Both methods perform a shallow copy.
circular references:
When an object model points to a dependent object with a property or variable that holds a reference to the object that contains it.
object pool is a container having objects ready to be used. It tracks the object that is currently in use and total number of objects in the pool. This reduces the overhead of creating and re-creating objects.
Commanly used exceptions:
•ArgumentException
• ArgumentNullException
• ArgumentOutOfRangeException
• ArithmeticException
• DivideByZeroException
• OverflowException
• IndexOutOfRangeException
• InvalidCastException
• InvalidOperationException
• IOEndOfStreamException
• NullReferenceException
• OutOfMemoryException
• StackOverflowException
difference between the “is” and “as” operators in C#:
The “is” operator is used to check the compatibility of an object with a given type and returns the result as boolean. The “as” operator is used for casting an object to a type.
Indexers:
Indexers are known as smart arrays.Defining an indexer allows us to create classes that act as virtual arrays. Instances of that class can be accessed using the [] array access operator.
difference between the “throw” and “throw ex”:
The “throw” statement preserves the original error stack whereas “throw ex” will have the stack trace starting from the throw point.
Attributes:
Attributes are used in C# to convey declarative information or metadata about various code elements such as methods, assemblies, properties, types, etc. Attributes are added to the code by using \a declarative tag that is placed using square brackets ([ ]) on top of the required code element.
Once associated with a program entity, the attribute can be queried at run time and used in any number of ways like
• Associating help documentation with program entities.
Field:
Field is a member of a class or an object of any type that represents a memory location for storing a value.
Fields are used to store data that must be accessible to multiple methods of a class and available throughout the lifetime of an object. Generally, fields are used only for variables that have private or protected accessibility. Data that your class exposes to client code should be provided through methods, properties and indexers.
Properties:
Properties are the special type of class members that provides a flexible mechanism to read, write, or compute the value of a private field. Properties can be used as if they are public data members, but they are actually special methods called accessors. This enables data to be accessed easily and helps to promote the flexibility and safety of methods. Encapsulation and hiding of information can also be achieved using properties. It uses pre-defined methods which are “get” and “set” methods which help to access and modify the properties.
Accessors: The block of “set” and “get” is known as “Accessors”.
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.
An event is a way for a class to provide notifications to clients of that class when some interesting thing happens to an object.
difference between the break and continue statements;
The break statement is used to terminate the current enclosing loop or conditional statements in which it appears.
The continue statement is used to alter the sequence of execution. Instead of coming out of the loop, like the break statement did, the continue statement stops the current iteration and simply returns control back to the top of the loop.
use of a return statement:
The return statement is associated with procedures (methods or functions). On executing the return statement, the system passes control from the called procedure to the caller. This return statement is used for two purposes: 1. To return immediately to the caller of the currently executed code. 2. To return some value to the caller of the currently executed code.
Generics:
Generics are classes, structures, interfaces, and methods that have placeholders (type parameters) for one or more of the types that they store or use.
A generic collection class might use a type parameter as a placeholder for the type of objects that it stores; the type parameters appear as the types of its fields and the parameter types of its methods. A generic method might use its type parameter as the type of its return value or as the type of one of its formal parameters.
compile time polymorphism and run time polymorphism:
Compile time polymorphism is also known as method overloading. Method overloading means having two or more methods with the same name but with different signatures.
Runtime polymorphism is also known as method overriding, is having two or more methods with the same name, same signature but with different implementations.
The volatile keyword indicates that a field might be modified by multiple threads that are executing at the same time. Fields that are declared volatile are not subject to compiler optimizations that assume access by a single thread. This ensures that the most up-to-date value is present in the field at all times.
The volatile modifier is usually used for a field that is accessed by multiple threads without using the lock statement to serialize access.
New keyword:
When used as a declaration modifier, the new keyword explicitly hides a member that is inherited from a base class.
When you hide an inherited member, the derived version of the member replaces the base class version.
Although you can hide members without using the new modifier, you get a compiler warning. If you use new to explicitly hide a member, it suppresses this warning. To hide an inherited member, declare it in the derived class by using the same member name, and modify it with the new keyword.
async modifier operator:
Async allows a programmer to write asynchronous methods. By using Asynchronous programming we can avoid performance bottlenecks and enhance the overall responsiveness of your application.
Activities like accessing web resource can be sometimes slow and if such activity is blocked within a synchronous process, the entire application must wait.
In an asynchronous process, the application can continue with other work that doesn't depend on the web resource until the potentially blocking task finishes.
Does an await expression block the current thread:
An await expression in an async method doesn’t block the current thread while the awaited task is running. Instead, the expression signs up the rest of the method as a continuation and returns control to the caller of the async method.
• The marked async method can use Await or await to designate suspension points. The await operator tells the compiler that the async method can't continue past that point until the awaited asynchronous process is complete. In the meantime, control returns to the caller of the async method. The suspension of an async method at an await expression doesn't constitute an exit from the method, and finally blocks don’t run.
What is LINQ?
LINQ is Language Integrated Query, a collection of standard query operators which provides query facilities into.NET framework language like C#.
LINQ simplifies to communicate between the world of data and the world of objects.