IEG3080 Tutorial 11

Prepared by Ryan
Outline
 Enterprise Application Architecture
 Layering Structure
 Domain Logic

 C# Attribute

 Aspect Oriented Programming (AOP)

Enterprise Application
Architecture
 Complex systems always break down into
layers
 e.g. Networking – OSI 7 layers Model
 Pros
 Working on a single layer without knowing much
about other layers
 Minimizing dependencies between layers
 Con
 Transforming from layers harming performance
Enterprise Application
Architecture
 Enterprise Application Architecture – 3-layer
 Presentation Layer
 Display of information e.g. GUI windows, webpage
 Handling user commands
 Domain Logic Layer
 Business logic (Core)
 Data Source Layer
 Communication with database, messaging systems
Enterprise Application
Architecture
 Domain Logic Patterns
 Domain Model
 An object model of the domain that incorporates both
behavior and data
 Solving the problem in object-oriented way
 Pro – Handling complex logic in a well-organized way
 Con – “Impedance mismatch” between OO model and
relational database
 Enterprise Application
Architecture
 O/R Mapping Problems – Identity Problem
 OO – Different objects referenced by different
pointers
 Database – Different rows identified by primary
key
 Solutions
 Identity Field
Team ID Team Name

Key public class Team {

int TeamID;
Identity Field string TeamName;
}
Enterprise Application
Architecture
 O/R Mapping Problems – Identity Problem
 Solutions (Cont’d)
 Foreign Key Mapping
Team 1 Player
Team ID Player ID
Team Name
* Player Name

Team ID Team Name

Player ID Team ID Player

Name

Foreign Key Mapping

Enterprise Application
Architecture
 O/R Mapping Problems – Inheritance
Student
Name How to do mapping?
School

Secondary Student University Student

Class Department

CUHK Student
College
Enterprise Application
Architecture
 O/R Mapping Problems – Inheritance
 Single Table Inheritance
Name School Class Department College

 Wasting space – many null columns

 Concrete Table Inheritance
Name School Class

Name School Department

Name School Department College

 Changing the superclass  altering all the

subclasses’ tables
Enterprise Application
Architecture
 O/R Mapping Problems – Inheritance
 Class Table Inheritance
Name School

Class

Department

College

 Requiring multiple joins to rebuild an object

Enterprise Application
Architecture
 Solutions
 OO databases
 Not common (relational databases are widely
adopted)
 Tight coupling with the domain model
 Automated O/R mapping tools
 Not prefect (may solve 80% of the problems)
 Expensive
Enterprise Application
Architecture
 Other Domain Logic Patterns
 Transaction Scripts
 Organizes business logic by procedures where each
procedure handles a single request from the
presentation
 Server page (php, jsp), CGI scripts
 Table Module
 A single instance that handles the business logic for
all rows in a database table or view
 Commonly use in .NET development platform
C# Attribute
 C# Attribute
 Embedding information in C# code
 Placed in square brackets [ ], above an Attribute
Target (e.g. class, field or method)
[serializable]
public class Test { … }

 Reflection
 Querying information at run-time
 Dynamically invoking methods
C# Attribute
 Intrinsic Attribute
 Built-in attributes in .NET Common Library
Runtime (CLR)
 Examples
 In your assignment 1
 [assembly: AssemblyVersion(“1.0.0.0”)]
 [serializable]
 [STAThread]
C# Attribute
 Custom Attribute
Create your custom attribute Use your custom attribute

// Set what kinds of elements can use this custom attribute [MyAttribute("MyClass")]
[AttributeUsage(AttributeTargets.All)] public class Test {
public class MyAttribute : Attribute { // Define your own attribute [MyAttribute("MyMethod")]
string myName; public void Print {
Console.WriteLine("Test
public MyAttribute(string name) { Program");
myName = name; }
} }

public string Name {

get { return myName; }
}
}
C# Attribute
 Reflection – Querying information
public class MyProgram {
public static void Main() {
Type type = Type.GetType("Test");

foreach (Attribute attr in type.GetCustomAttributes(false)) { // Retrieve attributes for the class

MyAttribute myattr = attr as MyAttribute;
if (myattr != null)
Console.WriteLine(attr.Name);
}

foreach(MethodInfo method in type.GetMethods()) {

foreach (Attribute attr in method.GetCustomAttributes(false)) { // Retrieve attributes for the method
MyAttribute myattr = attr as MyAttribute;
if (myattr != null)
Console.WriteLine(“Method: {0} with Attribute: {1}”, method, attr.Name);
}
}
}
} Output
MyClass
Method: Void Print() with Attribute: MyMethod
C# Attribute
 Reflection – Invoking methods
public class MyProgram2 {
public static void Main() {
Type type = Type.GetType("Test");
Object o = Activator.CreateInstance(type); // Create a “type” object
MethodInfo mi = type.GetMethod("Print");
mi.Invoke(o, null); // Invoke method - “mi”
}
}

Output
Test Program
Aspect Oriented Programming
 OOP
 Breaking down a complex system into modules
 Encapsulating responsibilities into different
objects
 Problems
 Some tasks cut across multiple modules
(crosscutting concern)
 Logging
 Authentication
 Solution: Aspect Oriented Programming (AOP)
Aspect Oriented Programming
 AOP in C#
Non-AOP Implementation AOP Implementation

public class Test { [AttributeUsage(AttributeTargets.Class)]

public void TestMethod() { public class LogAttribute : ContextAttribute {
Log log = new Log(); // Code Here
log.Print("Enter"); // Log when entering this method }
Console.WriteLine("Test Method");
log.Print("Leave"); // Log with leaving this method public class LogProperty : IContextProperty,
} IContributeObjectSink {
} // Code Here
}

public class LogAspect : IMessageSink {

// Code Here
}

[Log]
public class Test : ContextBoundObject {
public void TestMethod() {
Console.WriteLine("Test Method");
}
}
Aspect Oriented Programming
 How does it work in C#
 “ContextAttribute” and “ContextBoundObject”
 Intercepting the calls(Interception)

Client YourObject
Without Interception
Intercepted by .NET

Transparent Message
Client YourObject
Proxy Sink

With Interception
References
 Enterprise Application Architecture
 M. Fowler, “Patterns of Enterprise Application
Architecture”, Addison Wesley
 C# Attribute
 http://www.oreilly.com/catalog/progcsharp/chapter/ch1
 Aspect Oriented Programming (AOP)
 http://www.codeproject.com/gen/design/aop.asp
 http://msdn.microsoft.com/msdnmag/issues/02/03/AOP