.Net Architecture Questions

  1. What are design patterns?

    Design patterns are recurring solution to recurring problems in software architecture. There are three basic classification of patterns - creational, structural and behavioral patterns.

    Creational Patterns

    • Abstract Factory: creates an instance of several families of classes
    • Builder: Separates object construction from its representation
    • Factory: Creates an instance of several derived classes
    • Prototype: A fully initialized instance to be copied or cloned
    • Singleton: A class in which only a single instance can exist

    Structural Patterns

    • Adapter: Match interfaces of different classes
    • Bridge: Separates an object’s interface from its implementation
    • Composite: A tree structure of simple and composite objects
    • Decorator: Add responsibilities to objects dynamically
    • Façade: A single class that represents an entire subsystem
    • Flyweight:A fine-grained instance used for efficient sharing
    • Proxy:An object representing another object

    Behavioral Patterns

    • Mediator: Defines simplified communication between classes
    • Memento:Capture and restore an object’s internal state
    • Interpreter: A way to include language elements in a program
    • Iterator: Sequentially access the elements of a collection
    • Chain of Responsibility: A way of passing a request between a chain of objects
    • Command: Encapsulate a command request as an object
    • State: Alter an object’s behavior when its state changes
    • Strategy: Encapsulates an algorithm inside a class
    • Observer: A way of notifying change to a number of classes
    • Template: Defer the exact steps of an algorithm to a subclass
    • Visitor: Defines a new operation to a class without change

  2. What is the difference between Factory and Abstract Factory Patterns?

    The main difference between factory and Abstract factory is factory method uses inheritance to decide which object has to be instantiated while abstract factory uses delegation to decide instantiation of object. We can say Abstract factory uses factory method to complete the architecture. Abstract Factory is one level higher in abstraction over Factory.

    Here is an example: The actual product section i.e. Class “Product” it inherits from an abstract class “AbstractProduct”. The creational aspect section i.e. “ConcreteCreator” class which inherits from class “Creator”.

    There are some rules the client will have to follow who will need the “Product” object. He will never refer directly to the actual “Product” object he will refer the “Product” object using “AbstractProduct”. Client will never use “New” keyword to create the “Product” object but will use the “Creator” class which in turn will use the “ConcreteCreator” class to create the actual “Product” object. So what are the benefits from this architecture? All creational and initializing aspects are now detached from the actual client. As your creational aspect is now been handled in “ConcreteCreator” and the client has reference to only “Creator”, so any implementation change in “CreateProduct” will not affect the client code. In short now your creational aspect of object is completely encapsulated from the client’s logic.

    “Abstract factory” pattern creates objects for families of classes. In short it describes collection of factor methods from various different families. In groups related factory methods. It creates objects from multiple families rather one product.

  3. What is MVC pattern?

    The main purpose using MVC pattern is to decouple the GUI from the Data. It also gives the ability to provide multiple views for the same Data. MVC pattern separates objects in to three important sections:

    • Model: This section is specially for maintaining data. It is actually where business logic, querying database, database connection etc. is actually implemented.
    • View: Displaying all or some portion of data, or probably different view of data. View is responsible for look and feel, sorting, formatting etc.
    • Controller: They are event handling section which affects either the model or the view. Controller responds to the mouse or keyboard input to command model and view to change. Controllers are associated with views. User interaction triggers the events to change the model, which in turn calls some methods of model to update its state to notify other registered views to refresh
      their display.

    Here are the various sections of ASP.NET which maps to MVC sections:

    • Model: This section is represented by DataView, DataSet, Typed DataSet, Business components, business entity models etc. Now this section can then be tied up to either windows application or web UI.
    • View: ASPX, ASCX, or windows application UI like data grid etc. form the view part of it.
    • Controller: In ASP.NET the behind code is the controller as the events are handled by that part. Controller communicates both with Model as well as view.

  4. How can we implement Singleton pattern in .NET?

    Singleton pattern mainly focuses on having one and only one instance of the object running. Example a windows directory service which has multiple entries but you can only have single instance of it through out the network.

    Following are the three steps needed to implement singleton pattern in .NET:

    • First create your class with static members.


      Public class ClsStaticClass
      Private shared objCustomer as clsCustomer
      End class

      This ensures that there is actually only one Customer object throughout the project.

    • Define a private constructor to your class. Defining a private constructor to class does not allow a client to create objects directly.

      • Finally provide a static method to get access to your Singleton object.

  5. How do you implement Prototype pattern in .NET?

    We need to implement cloning. Cloning is achieved by using ICloneable of the System namespace. It has a “Clone” method which actually returns the reference of the same copy. Clone method allows a Shallow copy and not a deep copy. In Shallow copy if you make changes to the cloned object it actually changes on the main object itself. So how is deep copy achieved, by using “ISerializable” interface? So what you do is first serialize the object then deserialize back
    to a complete new copy. Now any changes to this new copy do not reflect on the original copy of the object, this is called as Deep copy.

  6. What are the situations you will use a Web Service and Remoting in projects?

    “Web services” uses “remoting” concepts internally. But the major difference between “web service” and “remoting” is that “web service” can be consumed by clients who are not .NET platform. While remoting you need the client to be .NET compliant. Regarding the speed issue “Remoting” is faster than “Web Services”. /p>

  7. Can you give a practical implementation of FAÇADE patterns?

    Façade pattern sits on the top of lot of subsystems and makes access easy to interfaces of these subsystems. Basic purpose of Façade is to make interfacing between many modules and classes manageable.

    Let’s say we have four subsystems :

    • Customer
    • Product
    • Payment
    • Invoicing

    All the four modules were built at initial stage completely independent. The main interaction between all these subsystems is customer placing order. This functionality can be attained by using all these subsystems, which involves complex interaction between them.

    That is where FAÇADE comes in to action. We have built a FAÇADE called as “FACADEORDER” which sits on the top of all these subsystem and fulfill our functionality.

  8. What is three tier architecture?

    The three tier software architecture emerged in the 1990s to overcome the limitations of he two-tier architecture. There are three layers when we talk about three tier architecture:
    User Interface (Client): This is mostly the windows user interface or the Web interface but this has only the UI part.

    Mid layer: Middle tier provides process management where business logic and rules are executed and can accommodate hundreds of users (as compared to only 100 users with the two tier architecture) by providing functions such as queuing, application execution, and database staging.

    Data Access Layer: This is also called by the famous acronym “DAL” component. It has mainly the SQL statement which do the database operation part of the job. The three tier architecture is used when an effective distributed client/server design is needed that provides (when compared to the two tier) increased performance, flexibility, maintainability, reusability, and scalability, while hiding the complexity of distributed processing from the user.

  9. What are Microsoft Application Blocks?

    Application Blocks are C# and VB.NET classes distributed as Visual Studio projects that can be downloaded from Microsoft’s Web site and used in any .NET application, including ASP.NET Web applications. They are useful and powerful tools that can make
    applications more maintainable, scalable and efficient

    Secondly which application blocks has been used depends on really what you have implemented. But there are two famous MAB:

    • Data Access Block The Data Access Block provides static methods located in the SqlHelper class that encapsulates the most common data access tasks performed with Microsoft SQL server. If the term “static method” is new to you, it means that the class methods can be called without instantiating an instance of the class. For example, the method ExecuteReader () within the SqlHelper class can be called by simply using the statement SqlHelper.ExecuteReader () - no object
      instantiation of the SqlHelper class is required.
    • Exception Management block The Exception Management Application Block provides a simple yet extensible
      framework for handling exceptions. With a single line of application code you can easily log exception information to the Event Log or extend it by creating your own components that log exception details to other data sources or notify operators, without affecting your application code. The Exception Management Application Block can easily be used as a building block in your own .NET application

  10. What is Service Oriented architecture?

    “Services” are components which expose well defined interfaces and these interfaces communicate through XML messages. Using SOA you can build workflow, which uses interfaces of these components. SOA is typically useful when you are crossing
    heterogeneous technical boundaries, organizations, domain etc.

    In .NET SOA technically uses Web services to communicate with each service which is crossing boundaries. You can look SOA which sits on top of web services and provides a workflow.

    SOA uses service components which operate in their own domain boundary. Here are some points of service :

    • They are independent components and operate in their own boundary and own technology.
    • They have well defined interfaces which use XML and WSDL to describe themselves.
    • Services have URL where anyone can find them and clients can bind to these URL to avail for the service.
    • Services have very loosely coupled architecture. In order to communicate to service you only have to know the WSDL. Your client can then generate proxy from the WSDL of the service.

  11. What are different ways you can pass data between tiers?

    There are many ways you can pass data between tiers :

    • Dataset the most preferred one as they maintain data in XML format
    • Datareader
    • Custom classes
    • XML

  12. What is Windows DNA architecture?

    The Windows Distributed interNet Applications Architecture (DNA) is a Microsoft blueprint for robust, scalable, distributed business software. Windows DNA has evolved over time and was not preplanned. It gives all combined advantages of Centralized
    mainframe, application servers, internet technologies and Personal computers. Windows DNA is an evolution which started from mainframes (where all logic was centralized), Fox pro ages ( where we talked in terms of two tier systems), VB6 / SQL SERVER (three tier where we talked in terms of having one more tier which was mainly COM where business logic resided), COM+ ( looking in terms of transactions and fulfilling ACID rules) and finally the DNA.

  13. What is aspect oriented programming?

    Aspect-oriented software development is a new technology for separation of concerns (SOC) in software development. The techniques of AOSD make it possible to modularize crosscutting aspects of a system.

    Aspect oriented programming does not oppose OOP but rather supports it and makes it more maintainable. When we talk in terms of objects it is an entity which maps to real world domain. Object has attributes which represent the state of object and also define its behavior. By rule of object oriented programming object should be stand alone and communicate with other objects using messages or defined interface.

    One object should not communicate with other object directly rather communicate through defined interfaces. Every object satisfies some “Concern” in relation to the system.

    There are mainly two types of concern from an object perspective:

    • Core / Main concerns which it and its work should satisfy.
    • System concerns which are not related to business functionalities but software related concerns example audit trail, Error handling, Security etc.

    When one or many concerns span across module it is called as cross cutting.

March 21, 2008 | Posted Under .Net Interview Questions 

Comments

Leave a Reply

You must be logged in to post a comment.