Design pattern proxy介紹 20130805

Design Pattern-Proxy介紹
演說者：林政融
日期：2013/08/05

Agenda
 C#的Design Pattern
◦ Creational Patterns
◦ Structural Patterns
◦ Behavioral Patterns
 Design Pattern – Proxy
 Dynamic Proxy

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

Definition
 Provide a surrogate or placeholder for
another object to control access to it.

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);
}
}
}

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;
}

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

Design pattern proxy介紹 20130805

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (7)

Ähnlich wie Design pattern proxy介紹 20130805

Ähnlich wie Design pattern proxy介紹 20130805 (20)

Mehr von LearningTech

Mehr von LearningTech (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Design pattern proxy介紹 20130805