Hai Friends,
As we know that getting more experience and then going for the interview requires more knowledge and if we see, it requires more practical knowledge.
So in the continuation, I am trying to post few questions of OOPS which are scenario based and will be helpful when you are going for the interviews with 3+ years experience. These questions will definitely make you to think something more which you were thinking before about the answer of a particular question. With the hope that these questions and answers will be helpful to you, I am posting them and will try to update and include more in the future.
These questions are scenario based questions in .Net technologies which will help to prepare for the interviews. Few questions are related to OOP’s concepts, and then few on Garbage Collector and memory related. So you can prepare them accordingly. These questions will be useful for those who are having the 3+ years experience and looking out for the opportunities in good companies.
1. How the Encapsulation is different from Abstraction? I think both are used to hide the unnecessary details? Then how they are different?
Ans.
Ans.
Yes, Both Encapsulation
and Abstraction do the same thing but with few differences.
Encapsulation mainly encapsulates the object
and so hides the details as well as it binds the data.
So Encapsulation = Hiding + Binding the
data
How it hides the data? Real-time Example?
Take the example of n-Tier application where
we have an additional layer called Business Objects. This layer
contains all the entities with their
properties. Take an entity name: Employee. This Employee will have the
class name
"EmployeeBO.cs" and contains the public properties like EmpId,
EmpName, Sal ets
EmployeeBO.cs
So this is the
presentation of one property in the Business object class. Now wherever we want
this attribute,
We just need to
create the object of this class and set/get the value of EmpId as:
// set the EmpId
EmployeeBo objEmployeeBO = new EmployeeBO();
objEmployeeBO.EmpId = 101;
// get the EmpId
int empId = objEmployeeBO.EmpID;
Now the question is where its setting
or getting the value?
EmpId is the public property in the
EmployeeBO class and contain no value. Only _empId contains the value
which is private and so it is not
accessible.
So binding of the data happens to the
EmpId through _empID and hiding happends through _empId which is
private. The Data is accessed through
the Public property while the actual data is in private variable. So
binding + hiding using
Encapsulation.
Abstraction is to ignore the
unnecessary details and get the required details. So it also hides the
unnecessary details. How?
Abstract class is the special type
of class which can contain the abstract and concrete members. If we define
The member (Method/Property) as
abstract, it must be overrides to the child class. We are not bothering here About the non-abstract or concrete
members. Which is an unnecessary detail? If we ad an additional concrete Member in the abstract class, we
need not to do anything in the child class. But if we add
the abstract members, we must have to override it.
So abstract doesn't care about the concrete members which are unnecessary for it and so it hides
those details.
2. What do you mean by early binding and late binding in the object bindings? Which is good? Please give me a scenario where you have used the early binding and late binding concepts in your application?
Ans.In .Net, the early
binding and last binding concepts comes under the polymorphism. As we know that
there are 2 types of polymorphism-
1. Compile Time
polymorphism
2. Run time
polymorphism
The Compile Time polymorphism
also called as the Overloading where we have the same method name with different behaviors. By implementing the multiple prototype of the same method,
we can achieve the behavior of the Overloading.
Also this behavior
is valid only for a single class. It means we should have all the overloaded
methods in the same class.
e.g.
The Run time
polymorphism also named as the Overriding. This concept works in between
classes or multiple classes or parent child classes where the child class has
to get the behavior of the base class by inheriting the base class.
In this concept
we generally have an abstract or virtual method in the base class and we override
that method in the child class by using the override method.
e.g.
So now we know
the Compile Time polymorphism and Run Time polymorphism. The compile time
polymorphism uses the concept of early binding and Run time polymorphism uses
it as the late binding.
In early binding,
the runtime (CLR) gets the behavior in the compilation of the program. It means
that the method behavior will get compiled before in the early binding.
In Late binding,
like Overriding, the behavior of the class and methods gets by the CLR when
creating the object means at runtime. So, in the late binding the behavior of
the class members identified by the CLR at runtime.
Now come to the
next part of the question-which is good?
One can’t say
about the answer of this question, there are the scenarios where the early
binding is good. When you have lot of objects and in that case, the early
binding behavior performs well. While the late binding will be good when we
have less objects. Let’s say you want the dropdown list to be loaded when you click
on it and not while the loading of the page. So in some scenario, it will be
good if we have while load and it will not be good when you click.
So it’s all
depends on how you have implemented and the form structure.
3. In garbage collection, how the object generations come in the picture? How many generations an object can have? Please tell me the process of disposing the objects based on the generations? Can an object move from one generation to another? If yes then why? What’s the need to have different generations as we are going to dispose the objects which are marked by the Garbage collector?
Ans.
Ans.
Let’s start
with what is Garbage collection
first and then we will come to our main question of the post. As we know that
all the objects created using the new operator
gets fits in to the Heap memory. So whenever a new object gets created, it
tries to fit in the heap memory. Now let’s say the heap memory is full and
there is no place to keep another newly created object.
In that
case the Garbage collector installed, which is the background process, runs
through CLR and take the unused objects memory. It mainly cleanup the heap
memory and the new objects get
placed in to it.
Now the question comes that for which objects
it reclaims for the memory? How the object generations come in the picture?
It depends
on the objects generations. The CLR finds out the objects which are no longer
used by the application since longer time and then the Garbage collection
reclaim their memory.
How many generations an object can have? Please tell me the process of disposing the objects based on the
generations?
Actually
there are 3 generations exists for the objects which are written under the .Net
framework library. When a new object gets created, by default it moves to the
generation 0.
Can an object move from one generation to
another?
Now when
the generation 0 objects gets occupied with the memory and garbage collector
gets called by the run-time. It checks the objects which are no longer used by
the application and mark them for deletion. After deleting or reclaim the
memory, the older objects moved to next generation i.e. Generation 1. Now the
next time the CLR will check for the Generation 1 object too and if it finds
that in generation 1 if the objects are not used since longer time, it will mark
them for release and move the remaining objects to generation 2.
In
generation the objects which are under the main method, exists as they gets
removed either at the end of the program or when both the generation 0 and
generation 1 objects are using.
What’s the need to have different generations
as we are going to dispose the objects which are marked by the Garbage
collector?
With the
different generation, it improves the performance of the application as the
Garbage collector need not to check for each of the objects in the memory. It
first checks for the generation 0 objects and reclaim the memory. If still
needs then goes to the generation 1 and then 2.
4. What is object graph in garbage collector? Is this the graph physically exists? Or how this graph gets created?
Ans. When the Garbage Collector gets called by the CLR to DE-allocate the memory in the heap, the Garbage Collector start finding the references of all the reachable objects which are currently in use. So it find the objects which are used by the processes and for rest of objects which are un-reachable or the Garbage collector is not able to find the references for them, it marks them for deletion.
Ans. When the Garbage Collector gets called by the CLR to DE-allocate the memory in the heap, the Garbage Collector start finding the references of all the reachable objects which are currently in use. So it find the objects which are used by the processes and for rest of objects which are un-reachable or the Garbage collector is not able to find the references for them, it marks them for deletion.
Here the Garbage collector makes an Object graph which
keeps track of all the objects which are marked for deletion. After the
deleting the references for those objects, the heap memory gets compacted and a
new root becomes available to use by the new created object.
Is this the graph
physically exists? Or how this graph gets created?
No, this object graph creates virtually by the Garbage
Collector to keep all the objects and to make them for deletion. This is the Garbage
Collector responsibility to create this object graph and gets the references of
each reachable object which are used by the application
5. Can we suppress the Garbage collector? If yes, then why do we need to suppress it as it is used to reclaim the unused memory and which improve s the performance of our application?
Ans. Yes, We can suppress the Garbage Collector. There is the Static method in GC class called as SupressFinalize.
GC.SuppressFinalize(objectName);
This Static method takes a parameter for the object. So we can pass it to suppress the claiming memory for this object.
Now the question comes "why do we need to suppress it as it is used to reclaim the unused memory",
So, whenever we are using dispose method for class object,which is capable of disposing the object and in that case we don't need to use this method to again reclaim the memory.
e.g.
public class DemoClass : IDisposable
Hence after implementation of Dispose() method, we need not to reclaim the memory using the Garbage collector and so we can use the SuppressFinalize() for the current class object.
6. We already have the Finalize method which reclaims the memory using the Garbage collector. This is automatic process then why do we have the Dispose () method? Is this method different from Finalize ()? What is the interface from which the Dispose () method inherited?
Ans. Yes, We have the Finalize() method which is used to reclaim the memory for the unused objects. The Finalize() method is sufficient to release the memory from heap for the un-referenced object but it is only for the managed objects. So Finalize() method can reclaim the managed objects memory from the heap which are not used since longer time.
Then what about the objects which are unmanaged? The objects which are out of .Net CLR? The objects where the CLR can't be used to manage? Dispose() method is used for all those objects which do not comes under CLR or under the Managed heap. Dispose() method can be overrides and can be written to reclaim the object of those classes. Dispose() method is implemented by using the IDisposable interface.
e.g.public class TestClass : IDisposable
{
public void Dispose()
{
Dispose(true);
}
Ans. Yes, We can suppress the Garbage Collector. There is the Static method in GC class called as SupressFinalize.
GC.SuppressFinalize(objectName);
This Static method takes a parameter for the object. So we can pass it to suppress the claiming memory for this object.
Now the question comes "why do we need to suppress it as it is used to reclaim the unused memory",
So, whenever we are using dispose method for class object,which is capable of disposing the object and in that case we don't need to use this method to again reclaim the memory.
e.g.
public class DemoClass : IDisposable
{
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
}
As we have seen above,the DemoClass is inherited by IDisposable interface and which have the Dispose method to implement.Hence after implementation of Dispose() method, we need not to reclaim the memory using the Garbage collector and so we can use the SuppressFinalize() for the current class object.
6. We already have the Finalize method which reclaims the memory using the Garbage collector. This is automatic process then why do we have the Dispose () method? Is this method different from Finalize ()? What is the interface from which the Dispose () method inherited?
Ans. Yes, We have the Finalize() method which is used to reclaim the memory for the unused objects. The Finalize() method is sufficient to release the memory from heap for the un-referenced object but it is only for the managed objects. So Finalize() method can reclaim the managed objects memory from the heap which are not used since longer time.
Then what about the objects which are unmanaged? The objects which are out of .Net CLR? The objects where the CLR can't be used to manage? Dispose() method is used for all those objects which do not comes under CLR or under the Managed heap. Dispose() method can be overrides and can be written to reclaim the object of those classes. Dispose() method is implemented by using the IDisposable interface.
e.g.public class TestClass : IDisposable
{
public void Dispose()
{
Dispose(true);
}
}
7. Can we call the Finalize() method to be executed explicitly when we want that particular object memory to be reclaim by the Garbage Collector? If yes, then where do we need to write the code? If no then why?
Ans. No, the Finalize() method can't be called as Explicitly. The Garbage collector calls it when the Heap memory is having no space to allocate the new object in the heap.
Finalize() method is mainly used to perform the cleanup on the unmanaged resources which are held by the current object.
Working Finalization: Until the Finalize method is overrides, the Garbage collection doesn't mark the object to claim its memory.Internally the Finalization Queue keep each of the objects which are marked for deletion by GC and then the Finalize() method gets called.
The Object must be inaccessible(no reference found) to put or keep in the Finalization Queue.
Limitations: There are the limitation for Finalization:
a. Un-Deterministic - it is hard to find that when the Finalize() method will be called.
b. There is no guarantee that which object will be disposed first.
The C# compiler doesn't allow the overriding of Finalize() method an due to that we need to write the Destructor of the class.
As the GC is non-Deterministic so we can implement the Dispose() method explicitly to claim the unused memory by the Garbage collection.
For More details on GC, check the link:
GC Internal
Ans. No, the Finalize() method can't be called as Explicitly. The Garbage collector calls it when the Heap memory is having no space to allocate the new object in the heap.
Finalize() method is mainly used to perform the cleanup on the unmanaged resources which are held by the current object.
Working Finalization: Until the Finalize method is overrides, the Garbage collection doesn't mark the object to claim its memory.Internally the Finalization Queue keep each of the objects which are marked for deletion by GC and then the Finalize() method gets called.
The Object must be inaccessible(no reference found) to put or keep in the Finalization Queue.
Limitations: There are the limitation for Finalization:
a. Un-Deterministic - it is hard to find that when the Finalize() method will be called.
b. There is no guarantee that which object will be disposed first.
The C# compiler doesn't allow the overriding of Finalize() method an due to that we need to write the Destructor of the class.
As the GC is non-Deterministic so we can implement the Dispose() method explicitly to claim the unused memory by the Garbage collection.
For More details on GC, check the link:
GC Internal
8. Can we inherit child class from 2 base classes? If yes then how? If not then why? What is this scenario called as in OOPs? How to implement this kind of scenario where we need to inherit the methods from more than one base class?
Ans. No, We can't inherit more than one base class in to child class. This leads to the Multiple Inheritance where the child class can inherit more than one base class and the Multiple Inheritance doesn't support in .Net.
So this scenario is called as Multiple inheritance(a type of inheritance in OOPs).
If you do so, you will see the error 'Interface name expected.' as below:
To implement these kind of scenarios, we need the help of Interfaces, Where we can convert the second base class to Interface and then we can inherit one base class and second Interface.
Ans. No, We can't inherit more than one base class in to child class. This leads to the Multiple Inheritance where the child class can inherit more than one base class and the Multiple Inheritance doesn't support in .Net.
So this scenario is called as Multiple inheritance(a type of inheritance in OOPs).
If you do so, you will see the error 'Interface name expected.' as below:
To implement these kind of scenarios, we need the help of Interfaces, Where we can convert the second base class to Interface and then we can inherit one base class and second Interface.
9. How the Virtual methods are different from General methods? Can we have a method in the base class and then in the child class can we write the same method? If not? Why? What is the error we will get if we write the same method in the child class with the same name as the parent class method name?
Ans. Yes, Virtual methods are different from the general method. The Virtual methods are the special type of methods which can be overrides in the child class and then the child class method will be the output or the default result.
And when creating the child class object, it will take the child class method as the preference as below:
So here we can see that the error will not come but it will show the warning to use the 'new' operator instead to hide the base class method. This scenario is called as Shadowing in the OOPs.
10. Why do we need abstract class or abstract members? Can’t we simply write the general methods and fulfill our requirements? Can we get any advantage by implantation of abstract members? As per the abstract class scenario, let’s say we have an abstract method called Show () in the abstract base class. Now if I am inheriting this base class to a child class, we need to override this abstract method to the child class. And then we will call this method by creating instance of child class.Now if we only have the method in the child class and then create the instance and call the same method? Then why abstract class method? Is that method doing anything here?
Ans. Abstract class or abstract members(methods, properties) are those which are not complete. So when the class contains at-least one abstract member,the class must be defined with abstract class.
We can also say that 'When the class does not provides the full functionality, we can declare the class as abstract'. the abstract class works based on the child class memory. Due to that we cant create the object of Abstract class, instead we can create the reference of the abstract class.
11. How abstract class and interfaces are different? Can’t we create an abstract class by having all the members as abstract members and wherever required inherit and implement its members? Then why interface? I think interface is also doing the same thing? Then how they are different?
12. Can we have abstract properties in Interface? If yes, then how to write the syntax for the abstract property which is having the return type string?
13. Can we write static methods inside a non-static class? Is it possible to call a non-static method inside the static method? If yes then how?
14. Shadowing is the special type of overriding? How? Please explain?
15. When we inherit a class which is having the private members. Are the private members also gets inherited? If yes? Why cant’ we get them by the class object? If no then why?
16. What is the Difference between Coupling and Cohesion? If the components are more cohesive the software is good? Or vice versa?
17. See the below code snippet and think about the output.
18. What is the Difference between HTTP enabled WCF Service and Web Services? I think if we restrict the WCF service just for the HTTP communication, both WCF and Web Service will have the same behavior. Then why still people prefer to have the WCF service rather than the Web Service. What all the things which can be achieved through HTTP enabled WCF service and cant be just from Web Service.
19. What is the Difference between SOAP enabled Services and ReST Services? Which one is preferred and why?
17. See the below code snippet and think about the output.
18. What is the Difference between HTTP enabled WCF Service and Web Services? I think if we restrict the WCF service just for the HTTP communication, both WCF and Web Service will have the same behavior. Then why still people prefer to have the WCF service rather than the Web Service. What all the things which can be achieved through HTTP enabled WCF service and cant be just from Web Service.
19. What is the Difference between SOAP enabled Services and ReST Services? Which one is preferred and why?