• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Design pattern proxy介紹 20130805
 

Design pattern proxy介紹 20130805

on

  • 146 views

 

Statistics

Views

Total Views
146
Views on SlideShare
146
Embed Views
0

Actions

Likes
0
Downloads
0
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Design pattern proxy介紹 20130805 Design pattern proxy介紹 20130805 Presentation Transcript

    • Design Pattern-Proxy介紹 演說者:林政融 日期:2013/08/05
    • Agenda  C#的Design Pattern ◦ Creational Patterns ◦ Structural Patterns ◦ Behavioral Patterns  Design Pattern – Proxy  Dynamic Proxy
    • C#的Design Pattern
    • 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 of 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  Chain of Resp. A way of passing a request between a chain of objects  Command Encapsulate a command request as an object  Interpreter A way to include language elements in a program  Iterator Sequentially access the elements of a collection  Mediator Defines simplified communication between classes  Memento Capture and restore an object's internal state
    • Behavioral Patterns(continue)  Observer A way of notifying change to a number of classes  State Alter an object's behavior when its state changes  Strategy Encapsulates an algorithm inside a class  Template Method Defer the exact steps of an algorithm to a subclass  Visitor Defines a new operation to a class without change
    • Design Pattern – Proxy
    • Definition  Provide a surrogate or placeholder for another object to control access to it.
    • UML class diagram
    • Sample Code using System; namespace DoFactory.GangOfFour.Proxy.Structural { /// <summary> /// MainApp startup class for Structural /// Proxy Design Pattern. /// </summary> class MainApp { /// <summary> /// Entry point into console application. /// </summary> static void Main() { // Create proxy and request a service Proxy proxy = new Proxy(); proxy.Request(); // Wait for user Console.ReadKey(); } }
    • Sample Code(Subject) /// <summary> /// The 'Subject' abstract class /// </summary> abstract class Subject { public abstract void Request(); }
    • Sample Code(RealSubject) /// <summary> /// The 'RealSubject' class /// </summary> class RealSubject : Subject { public override void Request() { Console.WriteLine("Called RealSubject.Request()"); } }
    • Sample Code(Proxy) /// <summary> /// The 'Proxy' class /// </summary> class Proxy : Subject { private RealSubject _realSubject; public override void Request() { // Use 'lazy initialization' if (_realSubject == null) { _realSubject = new RealSubject(); } _realSubject.Request(); } } }
    • Sample Code2 using System; namespace DoFactory.GangOfFour.Proxy.RealWorld { /// <summary> /// MainApp startup class for Real-World /// Proxy Design Pattern. /// </summary> class MainApp { /// <summary> /// Entry point into console application. /// </summary> static void Main() { // Create math proxy MathProxy proxy = new MathProxy(); // Do the math Console.WriteLine("4 + 2 = " + proxy.Add(4, 2)); Console.WriteLine("4 - 2 = " + proxy.Sub(4, 2)); Console.WriteLine("4 * 2 = " + proxy.Mul(4, 2)); Console.WriteLine("4 / 2 = " + proxy.Div(4, 2)); // Wait for user Console.ReadKey(); } }
    • Sample Code2(IMath) /// <summary> /// The 'Subject interface /// </summary> public interface IMath { double Add(double x, double y); double Sub(double x, double y); double Mul(double x, double y); double Div(double x, double y); }
    • Sample Code2(Math) /// <summary> /// The 'RealSubject' class /// </summary> class Math : IMath { public double Add(double x, double y) { return x + y; } public double Sub(double x, double y) { return x - y; } public double Mul(double x, double y) { return x * y; } public double Div(double x, double y) { return x / y; } }
    • Sample Code2(MathProxy) /// <summary> /// The 'Proxy Object' class /// </summary> class MathProxy : IMath { private Math _math = new Math(); public double Add(double x, double y) { return _math.Add(x, y); } public double Sub(double x, double y) { return _math.Sub(x, y); } public double Mul(double x, double y) { return _math.Mul(x, y); } public double Div(double x, double y) { return _math.Div(x, y); } } }
    • Dynamic Proxy
    • Use of Static Proxy  Situation: when do add, save the result to DB public double Add(double x, double y) { var result = _math.Add(x, y); // Implement the method to save the result to db save(result); return result; }
    • Static Proxy  Advantage: easy to revise the original method  Disadvantage: just only revise the method that use the declared proxy
    • Dynamic Proxy(Interface) public interface IProxyInvocationHandler { Object Invoke( Object proxy, MethodInfo method, Object[] parameters ); }
    • Dynamic Proxy(Impl) Public Object Invoke(Object proxy, System.Reflection.MethodInfo method, Object[] parameters) { Object retVal = null; // is invoked, otherwise an exception is thrown indicating they // do not have permission if ( SecurityManager.IsMethodInRole( userRole, method.Name ) ) { // The actual method is invoked retVal = method.Invoke( obj, parameters ); } else { throw new IllegalSecurityException( "Invalid permission to invoke " + method.Name ); } return retVal; }
    • Dynamic Proxy(Impl) Public Object Invoke(Object proxy, System.Reflection.MethodInfo method, Object[] parameters) { Object retVal = null; // is invoked, otherwise an exception is thrown indicating they // do not have permission if ( SecurityManager.IsMethodInRole( userRole, method.Name ) ) { // The actual method is invoked retVal = method.Invoke( obj, parameters ); } else { throw new IllegalSecurityException( "Invalid permission to invoke " + method.Name ); } return retVal; }
    • Use of Dynamic Proxy public interface ITest { void TestFunctionOne(); Object TestFunctionTwo( Object a, Object b ); } public class TestImpl : ITest { public void TestFunctionOne() { Console.WriteLine( "In TestImpl.TestFunctionOne()" ); } public Object TestFunctionTwo( Object a, Object b ) { Console.WriteLine( "In TestImpl.TestFunctionTwo( Object a, Object b )" ); return null; }
    • Use of Dynamic Proxy(continue) public class TestBed { static void Main( string[] args ) { ITest test = (ITest)SecurityProxy.NewInstance( new TestImpl() ); test.TestFunctionOne(); test.TestFunctionTwo( new Object(), new Object() ); } }
    • References http://www.dofactory.com/Default.aspx http://www.codeproject.com/Articles/5511/Dynam ic-Proxy-Creation-Using-C-Emit