Interview Topics

Topics to be read before attending interview

OOPS (AEIP)
23 DESIGN PATTERNS –

https://medium.com/@buihuycuong/the-23-gang-of-four-design-patterns-974ae8d1a957

http://geekswithblogs.net/subodhnpushpak/archive/2009/09/18/the-23-gang-of-four-design-patterns-.-revisited.aspx

1. SOLID PRINCIPLES – https://medium.com/mindorks/solid-principles-explained-with-examples-79d1ce114ace
2. MVC FILTERS – https://www.tutorialsteacher.com/mvc/filters-in-asp.net-mvc
3. ASP.NET CORE
4. WEB API Exceptions – https://www.exceptionnotfound.net/the-asp-net-web-api-exception-handling-pipeline-a-guided-tour/
5. Extension methods – https://www.tutorialsteacher.com/csharp/csharp-extension-method
6. Delegates –
7. Async
8. Threading
9. Design Patterns
10. 
    ANGULAR
    PWA
    AZURE
    SQL SERVER

AWS

COMPLETE WEBSITE UI DESIGN SAMPLES LIKE ONLINE STORE
ADOBE XD
ANGULAR CRUD WITH CORE
VUE CRUD WITH API

CRUD Example videos to be seen

Asp.Net Core – CRUD

Web API – CRUD

Asp.Net MVC – CRUD

Angular – CRUD

Polymorphism

Same function name with different parameters.

Static Polymorphism – Early Binding -means methods, properties are detected and checked during compile time.  

Early binding improves the performance and ease of development. Application runs faster since there is no-type cast in early binding.

Early binding reduces the number of severity of run-time errors upfront before going it to runtime.

class Program
    {
        static void Main(string[] args)
        {
            clsEstateAgent obj = new clsEstateAgent();
            obj.AgentCode = 1001;
            obj.AgentName = "Khadak";
            obj.AddAgent();
            obj.DeleteAgent();
        }
    }
Here from above code you can see that there is no "DeleteAgent" method written in the class code so hence it should throw an error by compiler during compile time. So compile and check it.

Dynamic Polymorphism – is implemented by abstract classes and virtual functions.Implementation is completed when a derived class inherits from it. Abstract classes contain abstract methods, which are implemented by the derived class.

class Program
    {
        static void Main(string[] args)
        {
            dynamic DynObj = "Quest";
            Console.WriteLine(DynObj.GetType());

        }
    }

dynamic objects are detected during runtime and therefor it is late binding.

Inheritance

 Inherit the properties from one class (base) to another (child) class.

The inheritance will enable us to create a new class by inheriting the properties from other classes to reuse, extend and modify the behavior of other class members based on our requirements.

public class X

{

    public void GetDetails()

    {

        // Method implementation

    }

}

public class Y : X

{

    // your class implementation

}

class Program

{

    static void Main(string[] args)

    {

        Y y = new Y();

        y.GetDetails();           

    }

}

Encapsulation

Encapsulation  is a mechanism to hide actual implementation from outside , by using private access specifier for methods and properties in a class. Example is TV Remote – you don’t know how it works internally.

So, this is basically a concept of hiding the code [show only essential data of object – It is abstraction]. Actually, Encapsulation is used hide the member function, variable, etc. to the outside world.

So, Encapsulation is a way of encapsulating the data [wrapping the data] into a single unit called class. Through encapsulation, we can protect our data.

Why Encapsulation

If you think, there is some code that should not be exposed to outside code. There you can use Access Modifier to encapsulate the data.

Real Time Example

Let us take an example of TV, When we watch TV, we need only TV and Remote. To use Remote Key we can manage everything of a TV. There is no one interesting in knowing what is happening when we press the Remote button.

Using the Remote, we can increase the Volume, change the channel, and change the color of Screen, etc. But we never think how it is happening in the backend.

Actually in Remote System, on every key press there is some logic behind this. That is not useful for everyone. Remote encapsulate the logic and when we press the key, it performs the action. So, this is a real time example of Encapsulation. Not only Remote, you can see lot of devices around you which use Encapsulation like your phone, your car, etc.

1. classTV  
2. {  
3.     //background method to increase the volume of TV on key press  
4.     privatevoidVolumePlus()  
5.         {  
6.             Console.WriteLine(“Volumen Plus”);  
7.         }  
8.         //background method to decrease the volume of TV on key press  
9.     privatevoidVolumeMinus()   
10.         {  
11.             Console.WriteLine(“Volumen Minus”);  
12.         }  
13.         //color change of Color Tube on key press  
14.     privatevoidColorTube()   
15.         {  
16.         Console.WriteLine(“Color Tube of a Television”);  
17.         }  
18.     publicvoidTVKeys()   
19.     {  
20.         Console.WriteLine(“Television Keys”);  
21.     }  
22.     publicvoidTVRemote() {  
23.         Console.WriteLine(“Television Remote”);  
24.     }  
25.     publicvoidTVScreen() {  
26.         Console.WriteLine(“Television Screen”);  
27.     }  
28.   
29. }  

Above example will clear your doubts, you can see in above example some methods are private. It is because they will perform the logic on key press in background. We don’t need to know about this. But some are public, that will be accessible to us.

Azure Interview Questions with Answers

azure-interview-questions-with-answers-convertedDownload

PDF file