Design patterns in .Net
C# design pattern interview question: - DI vs IOC
The main goal of Inversion of control and Dependency injection
is to remove dependencies of an application. This makes the system more
decoupled and maintainable.
IOC (Inversion of control) is a general parent term while DI (Dependency injection) is a subset of IOC. IOC is a concept where the flow of application is inverted. So for example rather than the caller calling the method.
SomeObject.Call();
Will get replaced with an event based approach as shown below.
SomeObject.WhenEvent += Call();
In the above code the caller is exposing an event and when that event occurs he is taking action. It’s based on the Hollywood principle “Don’t call us we will call you”. In Hollywood when artists used to give auditions the judges would say them “Don’t call us we will call you”.
The above approach makes code more flexible as the caller is not aware of the object methods and the object is not aware of caller program flow.
A word of caution here, do not conclude that IOC are implemented by only events. You can delegate the control flow by callback delegates, observer pattern, events, DI (Dependency injection) and lot of other ways.
DI provides objects that an object needs. So rather than the dependencies construct themselves they are injected by some external means. For instance let’s say we have the following below class “Customer” who uses a “Logger” class to log errors. So rather than creating the “Logger” from within the class, you can inject the same via a constructor as shown in the below code snippet.
The biggest benefit achieved by the above approach is “Decoupling”. You can now invoke the customer object and pass any kind of “Logger” object as shown in the below code.
IOC (Inversion of control) is a general parent term while DI (Dependency injection) is a subset of IOC. IOC is a concept where the flow of application is inverted. So for example rather than the caller calling the method.
SomeObject.Call();
Will get replaced with an event based approach as shown below.
SomeObject.WhenEvent += Call();
In the above code the caller is exposing an event and when that event occurs he is taking action. It’s based on the Hollywood principle “Don’t call us we will call you”. In Hollywood when artists used to give auditions the judges would say them “Don’t call us we will call you”.
The above approach makes code more flexible as the caller is not aware of the object methods and the object is not aware of caller program flow.
A word of caution here, do not conclude that IOC are implemented by only events. You can delegate the control flow by callback delegates, observer pattern, events, DI (Dependency injection) and lot of other ways.
DI provides objects that an object needs. So rather than the dependencies construct themselves they are injected by some external means. For instance let’s say we have the following below class “Customer” who uses a “Logger” class to log errors. So rather than creating the “Logger” from within the class, you can inject the same via a constructor as shown in the below code snippet.
The biggest benefit achieved by the above approach is “Decoupling”. You can now invoke the customer object and pass any kind of “Logger” object as shown in the below code.
Customer obj = new Customer(new EmailLogger());
Customer obj1 =
new Customer(new EventViewerLogger());
Design Patterns?
What are design patterns
?
Design patterns are
recurring solution to recurring problems in software architecture.
(A) Can you list down all
patterns and their classification ?
Note :- This is advanced question
because anyone who asks to list down all patterns can
only be crazy for what he is
asking. But it is always a win-win situation for the interviewer.
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
Note :- The best way to remember
Creational pattern is by ABFPS (Abraham Became
First President of States).
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.
Note : To remember structural
pattern best is (ABCDFFP)
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.
Note :- Just remember Music……. 2
MICS On TV (MMIICCSSOTV).
Note:- No source code is provided
for architecture section as much of the things can be clear
from good UML diagrams.
(A)What is the difference
between Factory and Abstract Factory
Patterns?
Note: – This is quiet a confusing
architect question especially in design pattern section.
Interviewer can take you for a nice
ride. So get the difference in your heart.
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
259
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” object.
Figure: – 8.1
Class diagram of a factory Pattern
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.
260
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.
Note :- Just stick up to this
definition that Abstract factory classifies factory methods or
groups logically related factory
method together.
261
Figure:- 8.2
Class Diagram of Abstract Factory
(I)What is MVC pattern?
Twist: – How can you implement MVC
pattern in ASP.NET?
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:-
262
√ 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.NETwe 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.
I hope I was able to map
you imagination of ASP.NET with
the diagram given below.
263
Figure: – 8. 3
Data flow between MVC architectures.
(A)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.
Note:- May of developers would jump
to a conclusion saying using the “STATIC” keyword
we can have a single instance of
object. But that’s not the real case there is something more
that has to be done. But please
note we can not define a class as STATIC, so this will not
serve our actual purpose of
implementing singleton pattern.
Following are the three
steps needed to implement singleton pattern in .NET:-
264
√ 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.
Note: – 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.
(A)How do you implement
prototype pattern in .NET?
Twist: – How to implement cloning
in .NET ? What is shallow copy and deep copy ?
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.
(I)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.
(A)Can you give a
practical implementation of FAÇADE patterns?
265
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.
Figure: – 8.4
Façade in action
Above is a simple live
application of a Façade class. In this we have four subsystems :-
√ Customer
√ Product
266
√ 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.
(I) 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.
(B)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.
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.
267
(I)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
Note: – It’s beyond the scope the
book to look into details of application block. Best is go to
programs using their given classes
and documentation.
(A)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
268
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. 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.
269
Figure: – 8.5
SOA basic architecture
Above figure describes a
broader picture of what service oriented architecture will look
like. The basic
fundamental of SOA is a web service. In above diagram you can see there
are two services
available. One is the “Credit Card” service and other is “Address Check”
270
web service. Both these
services are provided by different company. Now we want to
build a functionality
which needs to validate a credit card and also check that addresses
are proper. In short we
will need functionalities of both the “CreditCard” and
“AddressCheck” service.
Also note the “CreditCard” service has its own business layer
and DAL components, which
can be in a proprietary language. It’s very much possible
that the whole Credit card
service is made in .NET and the Address check is SAP
implementation or JAVA
implementation. But because both the systems provide there
functionality using Web
services which is nothing but basically XML message
communication. So we have
made new service which sits like a FAÇADE on top of both
the web service and
performs both functionalities in one common service. You will see I
have made a third service
which sits on top of both the webservice and consumes them.
Also you can see that the
UI part of the systems have access to Business layer and Web
service of there system.
But the service which does both these check has only access to
the Web service.
Note:- It’s beyond the scope of
this book to discuss about SOA. But just to keep you safe
during interview this book has
tried to clear some basics of SOA.
(I)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
(A)What is Windows DNA
architecture?
Note :- If you have worked with
classic ASP this question can come to you.
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
271
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.
Figure :- 8.6
Windows DNA sections
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
No comments:
Post a Comment