2+ yrs .Net Interview Questions and Answers for Quick Reference

Hai Friends,

In the continuation of the series of the Interview Questions in the Microsoft Technologies, I am posting few more questions which will be helpful for the Quick reference in learning the concepts related to WCF, Assembly,  SQL Server,Interface & Abstract Class etc.

1. What is the difference between Web Services and WCF.

Ans. 

A. WCF Services = Web Services + Remoting + Security + Reliability + Messaging Queue

B. Not only that, hosting is also one of the powerful feature in WCF where the service can be hosted in Self Hosting, Hosting in Windows Services, Hosting on another Service etc.

C. Supports DataContractSerializer which is fast and can serialize fields and properties.

D. Integrated Logging mechanism.

2. What are the different ways of hosting a WCF service.
Ans.

A. Hosting on Console application

B. Hosting on Windows application

C. Hosting on Windows services

D. Hosting on IIS

E. Hosting on WAS(Windows Activation Service) 

3. Explain the different types of triggers in SQL Server.
Ans.

A. DDL Trigger- Trigger fires on DDL Commands

B. DML Trigger- Trigger fires on DML Commands

C. InsteadOf Trigger- Trigger fires on View updation

4. Difference between BasicHttpBinding and WSHttpBinding.
Ans.

A. BasicHttpBinding does not enable message level security while the WSHttpBinding enables Message level as well as Transport level security.

B. BasicHttpBinding has the default windows authentication while the WSHttpBinding support WS* authentication and security.

C. BasicHttpBinding only supports HTTP to access the service while WSHttpBinding suppors HTTP and HTTPS(secure)

D. Data which travels through the BasicHttpBinding is in XML format and no encryption allowed while the data travels through WSHttpBinding goes in Encrypted format.

5. What are the different types of assemblies available in .NET?
Ans.

A. Private Assembly

B. Shared Assembly

C. Satellite Assembly

6. What is a strong name and how do you give a strong name to an assembly?
Ans.

Unique identification of an assembly called as strong name. By strong name we can differentiate the assemblies which are having the same name.

We can generate the Strong name using the command:

SN -K dllName

7. What is InsteadOf trigger.
Ans. 

To update the Views, InsteadOf trigger is used. This is the only use of InsteadOf trigger. There is no use except this.

8. Can we use Insert/Update statements in views in SQL SERVER?

Ans. 

No, In general, View made to works only on the Query/Select command. So we can't have DML commands inside the View. So no Insert/update operations are allowed.

But there is a provision where we can make the views as updatable by using the DML statements inside the views but it is more complicated when there are views which are created by using the joins in the queries.

So its not preferable to make the view as updatable.

9. What are abstract classes and Interface and what the difference between the two.
Ans.

When the class does not provides the full functionality, the class must be declared as the abstract class.

There are 2 types of abstract classes-

A. Partial Abstract Class (Abstract Class)- Class which can support the abstract members(methods, properties) as well as concrete members(methods, properties), the class can be declared as the abstract class.

Abstract class works based on the child class memory. We can't create the object of the abstract class, only the reference can be created for the abstract class.

All the abstract members must be overrides in the child class using the Override keywords.

B. Fully Abstract class (Interface) - The collection of abstract members (methods, properties) is called as interface.

Interface contains all the abstract members.

When you have limited scope for the functionality, Abstract class is better but when there is the requirement to implement the global functions, interface is best way to do.

e.g. When u have some feature which can be implemented in several classes and classes are interrelated, use Abstract class but when the feature can be application level and used by various independent classes, use Interface.

10. What are the advantages of Interface over abstract classes?
Ans.

When you have some feature which can be implemented in several classes and classes are interrelated, use Abstract class but when the feature can be application level and used by various independent classes, use Interface.

Interfaces are more rigid than Abstract classes.

e.g. let's say, i have a method called Show() to show the message in various classes, we can have interface for this. Now let's say, I have implemented this interface in 100 classes where I want to use the Show() method to show some message.

Tomorrow there is some requirement to have the new Print Functionality to let's say in 50 various classes. Now the one way is to add this Print() in the same interface so that we can just implement it to those classes. But what about the rest 50, where we don't want this print.. So this is drawback of Interface.

That is the reason the Single Responsibility principle and then the interface Segregation Principle came where a class/interface should have only one responsibility. Like in the above example, there are more responsibility and got the problem.

Abstract class is best when the scope is limited. Let's say I want to calculate the Area of few shapes. So we can say that this is limited as few classes can use this so we can create the abstract class with the abstract method called Area and then implement to those classes by inheriting the abstract class.

The scope of the Abstract class is till the immediate child class. So you can't use it in grand child or grandparent classes.

11. What is a sealed class?
Ans.

When the class provides full functionality, we can declare the class as Sealed Class. Full functionality means, the class doesn't need anything from outside like loading the external files etc. The sealed class can’t be inherited and can't be extended. We can create the object of sealed class so instantiation of the sealed class is possible.when the class is self-dependent, the class be made as sealed class. 

Overall when we want the class prevented to be inherited, we can declare the class as sealed class. Also If we want that our method should not be overridable, we can create the methods as sealed method.

E.g.If you see the definitions of the datatypes, they all are sealed by default becasue they cant be extended.

public sealed class String : IComparable, ICloneable, IConvertible, IComparable<string>, IEnumerable<char>, IEnumerable, IEquatable<string>

{

  // Summary:

  //     Represents the empty string. This field is read-only.

  public static readonly string Empty;

  // Summary:

  //     Initializes a new instance of the System.String class to the value indicated

  //     by a specified pointer to an array of Unicode characters.

  //

  // Parameters:

  //   value:

  //     A pointer to a null-terminated array of Unicode characters.

  //

  // Exceptions:

  //   System.ArgumentOutOfRangeException:

  //     The current process does not have read access to all the addressed characters.

  //

  //   System.ArgumentNullException:

  //     value is null.

  //

  //   System.ArgumentException:

  //     value specifies an array that contains an invalid Unicode character, or value

  //     specifies an address less than 64000.

  [CLSCompliant(false)]

  [SecurityCritical]

  public String(char* value);

.... 

Here we can see that String class is of Sealed type.We can create the object of the sealed class as:

String obj = new String();

bu we cant inherit these classes as they are not inheritable.

12. What kind of authentication mechanism you have used in your WCF project.
Ans.

There are various authentication modes which can be used for the WCF service like-

A. No Authentication- When the service doesn't requires any authentication and its public to access and use, this type of authentication mode is used.

B. Windows Authentication – This type of service depends on the windows credential so if the user is having the windows credentials, they can use and access the service.

C. Form Authentication – This type of authentication requires certain and valid user name and password to access the service.

D. Certificate Based – There are the secure cervices where each request needs certain authentication mechanism which can be the 3rd party like .X509 certificates to validate the access requests.

E. Custom Authentication- This can be mixed with two or more authentication mechanism.

F. Token Based Authentication – Depends on the token provided by the service provider. So based on the token, the client can access the service.

13. How do you configure a WCF Service to use Network Authentication?

Ans. 

We need to set the remote settings for this.

Below is the reference url:

http://technet.microsoft.com/en-us/library/cc742824.aspx

14. What is Garbage Collection? How is Garbage Collector invoked in .NET?
Ans.

When the heap memory is filled with the objects and there is no memory left to accommodate the new object, Garbage collector gets called by the CLR. So it's an activity which is initiated by the run time (CLR). When the garbage collector gets called, it tries to find out each referenced objects which are in use by the applications. The objects which are not reachable, it marks them to delete. Based on the reachable objects, the garbage collector prepares the object graph, which has the reference of each reachable object. Now based on the object graph which contain the object generations too, the Garbage collector checks for the generation 0 objects and marks them for deletion and move rest of the objects to generation 1. The heap memory gets compacted for the new object and new object gets placed in the heap memory.

This is the uncertain and un-deterministic process as the Garbage collector doesn't know when it will be called. Its all based on the capacity memory of the heap. When the heap memory get filled and a new object is initiated, the runtime (CLR) calls the Garbage collector.

15. Can you force Garbage Collector to be invoked from c# code?
Ans.

Yes, When we have something called the unmanaged objects(C++, VC++,VB 6.0), then we need to explicitly release the memory. To do this, we can use the Dispose() method to free-up these object.

Sometimes, we need to force the garbage collector to be called to free-up the memory, so we can use the GC.Collect() method to do so.

16. How is var keyword used in .NET.Difference between var and dynamic keywords.
Ans. 

var keyword is newly introduces with the .net 3.5 and it is used to make the assignment for any type of data. It can store any type of data irrespective of its datatype.

So when we don't know that what type of data, the certain process will return, we can use the var keyword.

e.g.

var connection = new SqlConnection(connectionString);

Here the connection variable can store the SQLConnection type.

Dynamic keyword is newly introduces with the .net 4.0 version and is used to keep not only the any type of data but also the reference will be constant.

For the var, the type is made at the compile time while in case of Dynamic; the type is inferred in runtime.

e.g.

var customer = new Customer();

customer.GetCustomers();

Here the compiler will check for the GetCustomers()method. If the GetCustomers() method doesn't exists, it will show error during the compilation.

But for the dynamic,

dynamic  customer = new Customer();

customer.GetCustomers();

Here the compiler will not check for the GetCustomers() method during the compilation. But at the run-time, if the method is not available, it will throw error.

So the main use of dynamic is when we don't want the compiler should check for certain errors during compilation. It will skip the error if they are of dynamic type. 

17. Difference between Stored Procedures and Functions.
Ans.

Stored Procedure and Functions are the database objects which are the pre-compiled names SQL statements.

A. Stored procedure can take in as well as Out parameters while function can take only in parameters'.

B. Stored Procedure may or may not return the value while the Function must return a value. Returning a value in stored procedure depends on the input parameter. If the input parameter is of type out, then it will return the value.

C. We can use the function inside the stored procedure but stored procedure can't be used inside a function.

18. What are the different types of contracts available in WCF
Ans.

A. Service Contract- In Interface

B. Operation Contract - For Operations

C. Data Contract -Based on custom type

D. Message Contract - For Custom message

E. Fault Contract - For Error or Exception Handling

19. What is the static variable and what are the static variables in dot net.
Ans.

When the variable is shared by multiple class members (method, properties etc), we can make that variable as Static (in VB.Net Shared). To access these variables, we don't need to create the object of the class. We can directly call the static class members using the Class name. These variables get loaded when the class gets loaded in to the memory.

20. If I have 2 interfaces with same method same parameter and same return type. Both interface implemented from one Class. Then how can i call to these methods.
Ans.

Two interfaces with the same methods and same parameters can be implemented using the external interface functionality, rather than internal interface.
By default, when we implement the interface, we need to implement all the method to the implemented class.
But if the methods are same, then we can take the help of explicit interface as:
interface inf1
{
 void Print();
 void Show();
}
interface inf2
{
 void Print();
 void Show();
}

Now we will implement these interfaces in a single class:

class MyChildClass: inf1, inf2

{
 public void inf1.Print() // explicit interface call
 {
  //implement Print() method details for the first interface
 }
 public void inf1.Show()
 {
  //implement Show() method details for the first interface
 }
 public void inf2.Print()
 {
  //implement Print() method details for the second interface
 }
 public void inf2.Show()
 {
  //implement Show() method details for the second interface
 }
}

21. Can method overloading and overriding possible in simultaneously in program.
Ans.

Yes, both overloading and overriding concept can be implemented simultaneously between the parent can child classes as:

Class MyBaseClass

{
 public void Print()
 {
   // Print method implementation
 }
 public void Print(string fileName) // overloaded method
 {
   // Print method implementation with the file name
 }
 public virtual void Print()
 {
   // Print method implementation
 }
}
Class ChildClass:MyBaseClass
{
 public override void Print() // overriding implementation
 {
   // Print method implementation
 }
}

22. What is the use of "using" keyword?
Ans.

"using" keyword is used in 2 scenarios:
1. To write the namespace as:
using System.Data.SqlClient;

2. To clean up the memory automatically after the use of object as:
using(var f = new SqlCommand())
{
 // some other iomplementation
}

The above code will delete the memory used by the 'f' object after the completion of the transaction.

23. What is dispose and finalize method and how it works
Ans.

Finalize and Dispose methods comes under the System.GC namespace and used to free up the memory occupied the objects. Garbage collector uses these objects to free up the memory.

When there is no enough memory to allocate the new object in the Heap, Garbage collector gets called automatically to free up the memory. It mainly creates the object graph and finds the objects which are not used since longer time. Based on the generations, it removes the objects.
Dispose method is called manually by programmer to remove the objects.
It uses IDisposable interface which has the Dispose method and this can be implemented in the code.

Scenario Based Questions in Microsoft Technologies - .Net with Answers

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.

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. 

    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.

    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

{

   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

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.
    

  

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:

 

   Now, if we have the same method in the child class as base class then it        will hide the base class method by default and what ever is implemented in    the child class will get executed.
  

    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?