What is aspect oriented programming?

I will try and make it as short as possible as this book is not a reference book. Just to save you from
interviewer I will give a short description of aspect oriented programming in .NET. First let us try and
define it which can probably save you during interview 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. Ok that statement can save you for the first
stage let us get down actually what is it. Let’s revisit back how software development cycle evolved. When
we look back at times of COBOL where we used to break the modules in small functionalities and use
reusability to its maximum. Then came the time when we talked in terms of Objects where things were
clearer as software was modeled in terms of real life examples. It worked fine and till today is the most
accepted way of implementing and organizing project. So why AOP ?? Aspect oriented programming does
not oppose OOP’s but rather supports it and make’s it more maintainable. So remove the logic from head
the AOP is replacement of OOP. No its brother of OOP helping him to be better. 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. “A concern is a particular goal, concept, or area of
interest” There are mainly two types of concern from an object perspective:-
• Core / Main concerns which it should satisfy and is his work.
• System concerns which are not related to business functionalities but software
related concerns example audit trail, Error handling, Security etc. Ok let us try to understand this
principle by some actual example.

Above is a class diagram which shows relationshipbetween

two classes “ClsCustomer” and “ClsAuditTrail”. “ClsCustomer” class does inserting of new customers in to
database and “ClsAuditTrail” does the auditing of what is changed in the customer class.

Now there are two concerns in this project :-

• Customer code should not exceed than 10 lengths (Business level concern) greater
• All customer data which is updated should be audited. (System level concern)
Here goes the class code. If you see the ClsCustomer implementation in the update method I have called
the Audit trail implementation. If you really look from object oriented point of view we are doing
something in customer class which is supposed to be not his implementation: - Audit Trail logging. Thus
we have also broken down the rule of encapsulation. In short the class not only handles his work but also
some other work which is not his concern.
Ok now let us define crosscutting which is one of important aspects of AOP.

When one or many concerns span across module it is called as cross cutting. Example in our audit trail
example we will probably need to audit trail for customer as well as supplier. So Audit trail can span
across other objects also that is termed as cross cutting.

Desing Pattern 1
Below are both the classes actually implemented as per class diagram 8.7. If you see the “Update”
method of the customer class, its doing both of the concerns that is checking for customer code length
and also maintaining the audit trail using the audit trail class.

Public Class ClsCustomer

Private pstrCustcode As String
Private pstrCustName As String
Public Property Code() As String
Get
Return pstrCustcode
End Get
Set(ByVal Value As String)
pstrCustcode = Value
End Set
End Property
Public Property CustomerName() As String
Get
Return pstrCustName
End Get
Set(ByVal Value As String)
pstrCustName = Value
End Set
End Property
Public Function Update() As Boolean
‘ first / core concern
If pstrCustcode.Length() > 10 Then
Throw New Exception("Value can not be greater than 10")
End If
' usingthe customer audit trail to do auditing
‘ second concern / system concern
Dim pobjClsAuditTrail As New ClsAuditTrail
With pobjClsAuditTrail
.NewValue = "1001"
.OldValue = "1003"
.UserName = "shiv"
.Update()
End With
' then inserting the customer in database
End Function
End Class
Public Class ClsAuditTrail
Private pstrUserName As String
Private pstrOldValue As String
Private pstrNewValue As String
Private pdblLogTime As Double
Public Property UserName() As String
Get
Return pstrUserName
End Get
Set(ByVal Value As String)
pstrUserName = Value
End Set
End Property
Public Property OldValue() As String
Get

Desing Pattern 2
Return pstrOldValue
End Get
Set(ByVal Value As String)
pstrOldValue = Value
End Set
End Property
Public Property NewValue() As String
Get
Return pstrNewValue
End Get
Set(ByVal Value As String)
pstrNewValue = Value
End Set
End Property
Public Property LogTime() As Double
Get
Return pdblLogTime
End Get
Set(ByVal Value As Double)
pdblLogTime = Value
End Set
End Property
Public Sub Update()
' do the logging activity here
End Sub
End Class

In short the customer class is doing many activity. There is lot of tangling of code. So
how do we overcome this problem...? Simple, separate the System level concern (Audit
Trail) from the core level concern ( Customer code check). This is achieved at this
moment in .NET using attribute programming.
Here is the change to the customer class

Imports System.Reflection
Public Class ClsCustomer
Private pstrCustcode As String
Private pstrCustName As String
Public Property Code() As String
Get
Return pstrCustcode
End Get
Set(ByVal Value As String)
pstrCustcode = Value
End Set
End Property
Public Property CustomerName() As String
Get
Return pstrCustName
End Get
Set(ByVal Value As String)
pstrCustName = Value
End Set
End Property
_
Public Function Update() As Boolean

Desing Pattern 3
If pstrCustcode.Length() > 10 Then
Throw New Exception("Value can not be greater than 10")
End If
' usingthe customer audit trail to do auditing
' then inserting the customer in database
End Function
End Class

And here is the change to the audit trail class

Imports System.Reflection
_
Public Class ClsAuditTrail
Inherits Attribute
Private pstrUserName As String
Private pstrOldValue As String
Private pstrNewValue As String
Private pdblLogTime As Double
Public Property UserName() As String
Get
Return pstrUserName
End Get
Set(ByVal Value As String)
pstrUserName = Value
End Set
End Property
Public Property OldValue() As String
Get
Return pstrOldValue
End Get
Set(ByVal Value As String)
pstrOldValue = Value
End Set
End Property
Public Property NewValue() As String
Get
Return pstrNewValue
End Get
Set(ByVal Value As String)
pstrNewValue = Value
End Set
End Property
Public Property LogTime() As Double
Get
Return pdblLogTime
End Get
Set(ByVal Value As Double)
pdblLogTime = Value
End Set
End Property
Public Sub New(ByVal pstrUserName As String, _
ByVal pstrOldValue As String, _
ByVal pstrnewValue As String, _
ByVal plng As Long)
Update()
End Sub

Desing Pattern 4
Public Sub Update()
' do the logging activity here
End Sub
End Class

The fun part of the code is below, you can see that the code audit trail is now separate
and the code check belongs to the customer code.
_
Public Function Update() As Boolean
If pstrCustcode.Length() > 10 Then
Throw New Exception("Value can not be greater than 10")
End If
' usingthe customer audit trail to do auditing
' then inserting the customer in database
End Function

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.

Above shown is a Windows DNA model which is a blue

print which Microsoft has proposed. So if interviewer is asking you have you worked with Windows DNA,
then answer is yes. You will see that you always use these sections in project. Do not get confused with
the terminology DNA.

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

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.
Desing Pattern 5
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. Let us note 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.

Have you ever worked with Microsoft Application Blocks, if yes then which?

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 which is making buzz around the industry:-
• 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

What is three tier architecture?

The three tier software architecture emerged in the 1990s to overcome the limitations of the 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.
Desing Pattern 6
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.

How can we implement observer pattern in .NET?

Observer patterns can be implemented using "Delegates" and "Events". I leave this to the readers to
implement one sample code for observer patterns.

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.

Above is a simple live application of a Façade class. In this we have four subsystems :-
• Customer
• Product
• Payment
• Invoicing
All the four modules when built at initial stage where built 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.

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

Well "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". So I think when deciding the architecture side of choosing between "Web services" and
"Remoting" keep the cross platform issue and the speed issue in mind.

Desing Pattern 7
 How do you implement prototype pattern in .NET?

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.

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.
• Second define a private constructor to your class.
• Finally provide a static method to get access to your singleton object.

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 your business logic,
querying database, database connection etc. is actually implemented.
• Views: - 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.
Ok now this was all in theory. Let us look at how in actually ASP.NET we can implement MVC pattern.
During interview with theory question they will be looking at have you really implemented MVC or its just
talks. Following are the various sections of ASP.NET which maps to MVC sections:-
•
Model: - This section is represented by Data view, 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.

Desing Pattern 8
 What is the difference between Factory and Abstract Factory Patterns?

First read the definition provided in the first question about both these patterns. The common thing they
have is that they belong to creational patterns. In short they hide the complexity of creating objects.
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.
The two class diagrams below will provide overview of what is the actual difference.
First figure shows a sample implementation of Factory Patterns. In this figure there are two basic
sections:-
• 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".
• Now 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".
• Second 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"
objec

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.
Now let's look at the second class diagram which provides an overview of what actually "Abstract factory"
pattern is. It creates objects for families of classes. In short it describes collection of factor methods from
various different families. In short it groups related factory methods. Example in this the class "Creator" is
implemented using the "Abstract" factory pattern. It now creates objects from multiple families rather one
product.

Desing Pattern 9
 What are design patterns ?

Design patterns are recurring solution to recurring problems in software architecture.

• Can you list down all patterns and their classification ?
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 Method:- 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 Resp:-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 Method:-Defer the exact steps of an algorithm to a subclass.
• Visitor:-Defines a new operation to a class without change.

Desing Pattern 10