Stedfortræder (designmønster)
Den aktuelle version af siden er endnu ikke blevet gennemgået af erfarne bidragydere og kan afvige væsentligt fra den
version , der blev gennemgået den 10. juli 2018; checks kræver
9 redigeringer .
| Stedfortræder |
|---|
| proxy |
| |
| Type |
strukturel |
| Formål |
Giver et surrogatobjekt, der styrer adgangen til et andet objekt. |
| fordele |
- fjerntliggende erstatning;
- den virtuelle proxy kan udføre optimeringen;
- beskyttende erstatning;
- "smart" link;
|
| Minusser |
- dramatisk stigning i responstid.
|
| Beskrevet i Design Patterns |
Ja |
Proxy ( Eng. Proxy ) er et strukturelt designmønster, der giver et objekt , der styrer adgangen til et andet objekt, opsnapper alle opkald (udfører funktionen som en container ).
Formål
Problem
Adgang til objektet skal kontrolleres uden at ændre klientens adfærd.
Det er nødvendigt at få adgang til objektet på en sådan måde, at du ikke opretter rigtige objekter direkte, men gennem et andet objekt, der kan have yderligere funktionalitet.
Løsning
Opret et surrogat til et rigtigt objekt. Proxyen gemmer en reference, der tillader Proxyen at henvise til det rigtige subjekt (et objekt i Proxy-klassen kan henvise til et objekt fra Subject-klassen, hvis grænsefladerne mellem det rigtige subjekt og Subjektet er de samme). Da grænsefladen "Reelt Emne" er identisk med "Emne"-grænsefladen, således at "Erstatningen" kan erstattes af "Reelt Emne", kontrollerer adgangen til det "Reelle Emne", kan være ansvarlig for at oprette eller slette " Virkeligt emne". "Subject" definerer en fælles grænseflade mellem "Real Subject" og "Proxy", så "Proxy" kan bruges overalt, hvor "Real Subject" forventes. Om nødvendigt kan anmodninger videresendes af "Suppleant" til "Reelt Subjekt".
Arter
- Logging proxy : logger alle opkald til "Emnet" med deres parametre.
- Remote proxy ( eng. remote proxies ): giver kommunikation med "Emnet", som er placeret i et andet adresserum eller på en fjernmaskine. Kan også være ansvarlig for at kode anmodningen og dens argumenter og sende den kodede anmodning til det rigtige "emne"
- Virtual Proxies ( eng. virtuelle proxyer ): sikrer kun oprettelsen af et rigtigt "emne", når det virkelig er nødvendigt. Det kan også cache nogle af oplysningerne om det rigtige "emne" for at forsinke dets oprettelse,
- Copy-on-write : giver en kopi af "emnet", når klienten udfører visse handlinger (et specialtilfælde af den "virtuelle proxy").
- Beskyttelsesfuldmagter : Kan kontrollere, om den, der ringer, har de nødvendige tilladelser til at fuldføre anmodningen .
- Caching-proxy : giver midlertidig lagring af beregningsresultater, før de vises til flere klienter, som kan dele disse resultater.
- Screening proxy : beskytter "Emnet" mod farlige klienter (eller omvendt).
- Synkroniseringsproxy : Udfører synkroniseret adgangskontrol til "Emnet" i et asynkront flertrådsmiljø .
- "Smart" link ( eng. smart reference proxy ): udfører yderligere handlinger, når der oprettes et link til "Emnet", beregner for eksempel antallet af aktive links til "Emnet".
Fordele og ulemper ved at bruge
Fordele
- fjerntliggende erstatning;
- den virtuelle proxy kan udføre optimeringen;
- beskyttende erstatning;
- "smart" link (pointer) ;
Ulemper
- dramatisk stigning i responstid.
Omfang
Proxy-mønsteret kan bruges, når du arbejder med en netværksforbindelse, med et stort objekt i hukommelsen (eller på disken), eller med enhver anden ressource, der er svær eller svær at kopiere. Et velkendt use case er et objekt, der tæller antallet af referencer.
Proxy og relaterede mønstre [1]
- En adapter giver en særskilt grænseflade til et objekt.
- Proxyen giver den samme grænseflade.
- Dekoratøren giver en udvidet grænseflade.
Implementeringseksempler
Implementeringseksempel
offentlig klasse Main {
public static void main ( String [] args ) {
// Create math proxy
IMath p = new MathProxy ();
// Gør det matematiske
system . ud . println ( "4 + 2 = " + s . add ( 4 , 2 ));
System . ud . println ( "4 - 2 = " + p . sub ( 4 , 2 ));
System . ud . println ( "4 * 2 = " + p . mul ( 4 , 2 ));
System . ud . println ( "4/2 = " + s . div ( 4 , 2 ));
}
}
/**
* "Emne"
*/
offentlig grænseflade IMath {
offentlig dobbelttilføj ( dobbelt x , dobbelt y ) ;
offentlig dobbelt sub ( dobbelt x , dobbelt y );
offentlig dobbelt mul ( dobbelt x , dobbelt y );
offentlig dobbelt div ( dobbelt x , dobbelt y );
}
/**
* "Reelt emne"
*/
offentlig klasse Math implementerer 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 ;
}
offentlig dobbelt div ( dobbelt x , dobbelt y ) {
return x / y ;
}
}
/**
* "Proxy Object"
*/
public class MathProxy implementerer IMath {
privat matematik matematik ;
public double add ( double x , double y ) {
lazyInitMath ();
returnere matematik . tilføje ( x , y );
}
public double sub ( double x , double y ) {
lazyInitMath ();
returnere matematik . sub ( x , y );
}
offentlig dobbelt mul ( dobbelt x , dobbelt y ) {
lazyInitMath ();
returnere matematik . mul ( x , y );
}
offentlig dobbelt div ( dobbelt x , dobbelt y ) {
lazyInitMath ();
returnere matematik . div ( x , y );
}
private void lazyInitMath () {
if ( math == null ) {
math = new Math ();
}
}
}
Implementeringseksempel
objekt Hoved udvider App {
val p : IMath = nyt MathProxy
System . ud . println ( "4 + 2 = " + s . add ( 4 , 2 ))
System . ud . println ( "4 - 2 = " + s . sub ( 4 , 2 ))
System . ud . println ( "4 * 2 = " + p . mul ( 4 , 2 ))
System . ud . println ( "4/2 = " + s . div ( 4 , 2 ))
}
/**
* "Subject"
*/
trait IMath {
def add ( x : Double , y : Double ): Double
def sub ( x : Dobbelt , y : Dobbelt ): Dobbelt
def mul ( x : Dobbelt , y : Dobbelt ): Dobbelt
def div ( x : Dobbelt , y : Dobbelt ): Dobbelt
}
/**
* "Reelt emne"
*/
klasse Math udvider IMath {
def add ( x : Double , y : Double ) = x + y
def sub ( x : Dobbelt , y : Dobbelt ) = x - y
def mul ( x : Dobbelt , y : Dobbelt ) = x * y
def div ( x : Dobbelt , y : Dobbelt ) = x / y
}
/**
* "Proxy Object"
*/
klasse MathProxy udvider IMath {
private lazy val math = new Math
def add ( x : Double , y : Double ) = matematik . tilføje ( x , y )
def sub ( x : Dobbelt , y : Dobbelt ) = matematik . sub ( x , y )
def mul ( x : Dobbelt , y : Dobbelt ) = matematik . mul ( x , y )
def div ( x : Dobbelt , y : Dobbelt ) = matematik . div ( x , y )
}
Implementeringseksempel
/**
* "Emne"
*/
klasse IMath {
offentligt :
virtuel dobbelt add ( dobbelt , dobbelt ) = 0 ;
virtuel dobbelt sub ( dobbelt , dobbelt ) = 0 ;
virtuel dobbelt mul ( dobbelt , dobbelt ) = 0 ;
virtuel dobbelt div ( dobbelt , dobbelt ) = 0 ;
};
/**
* "Reelt emne"
*/
klasse Math : public IMath {
offentligt :
virtuel dobbelttilføj ( dobbelt x , dobbelt y ) { _
returner x + y _
}
virtual double sub ( double x , double y ) {
returnere x - y ;
}
virtuel dobbelt mul ( dobbelt x , dobbelt y ) {
returner x * y _
}
virtuel dobbelt div ( dobbelt x , dobbelt y ) {
returnere x / y _
}
};
/**
* "Proxyobjekt"
*/
klasse MathProxy : public IMath {
offentligt :
MathProxy ()
{
matematik = ny matematik ();
}
virtuel ~ MathProxy ()
{
slet matematik ;
}
virtuel dobbelttilføj ( dobbelt x , dobbelt y ) { _
returnere matematik -> tilføje ( x , y );
}
virtual double sub ( double x , double y ) {
returnere matematik -> sub ( x , y );
}
virtuel dobbelt mul ( dobbelt x , dobbelt y ) {
returnere matematik -> mul ( x , y );
}
virtuel dobbelt div ( dobbelt x , dobbelt y ) {
returnere matematik -> div ( x , y );
}
privat :
IMath * matematik ;
};
#include <iostream>
bruger std :: cout ;
bruger std :: endl ;
int main () {
// Opret matematisk proxy
IMath * proxy = ny MathProxy ();
// Udfør matematikken
<< "4 + 2 = " << proxy - > add ( 4 , 2 ) << endl ;
cout << "4 - 2 = " << proxy -> sub ( 4 , 2 ) << endl ;
cout << "4 * 2 = " << proxy -> mul ( 4 , 2 ) << endl ;
cout << "4 / 2 = " << proxy -> div ( 4 , 2 ) << endl ;
slet proxy ;
returnere 0 ;
}
Implementeringseksempel
bruger System ;
ved hjælp af System.Threading ;
klasse MainApp
{
static void Main ()
{
// Create math proxy
IMath p = new MathProxy ();
// Gør matematikkonsollen . WriteLine ( "4 + 2 = " + p . Tilføj ( 4 , 2 ));
Konsol . WriteLine ( "4 - 2 = " + p . Sub ( 4 , 2 ));
Konsol . WriteLine ( "4 * 2 = " + p . Mul ( 4 , 2 ));
Konsol . WriteLine ( "4 / 2 = " + p . Div ( 4 , 2 ));
// Vent på
brugerkonsollen . læs ();
}
}
/// <resumé>
/// Emne - emne
/// </summary>
/// <remarks>
/// <li>
/// <lu> definerer en fælles for <see cref="Math"/> og <see cref="Proxy"/> interface, så klasse
/// <see cref="Proxy"/> kan bruges hvor som helst <see cref="Math"/></lu>
/// </ li>
/ // </remarks>
offentlig grænseflade IMath
{
double Add ( double x , double y );
dobbelt Sub ( dobbelt x , dobbelt y );
dobbelt Mul ( dobbelt x , dobbelt y );
dobbelt Div ( dobbelt x , dobbelt y );
}
/// <resumé>
/// RealSubject - real object
/// </summary>
/// <remarks>
/// <li>
/// <lu>definerer det reelle objekt repræsenteret af proxyen</lu>
// / </li>
/// </remarks>
klasse Math : IMath
{
public Math ()
{
Console . WriteLine ( "Opret objekt Math. Vent..." );
tråd . Søvn ( 1000 );
}
public double Tilføj ( 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 ;}
}
/// <resumé>
/// Proxy er en proxy
/// </summary>
/// <remarks>
/// <li>
/// <lu> gemmer en reference, der tillader proxyen at henvise til den rigtige
/// emne. Klasseobjekt <see cref="MathProxy"/> kan henvise til klasseobjekt
/// <see cref="IMath"/> hvis klassegrænseflader <see cref="Math"/> og <see cref="IMath"/ > er de samme;</lu>
/// <lu>giver en grænseflade, der er identisk med den for <see cref="IMath"/>, så en proxy
/// altid kan leveres i stedet for det rigtige emne;</ lu>
/// < lu>kontrollerer adgangen til det rigtige emne og kan være ansvarlig for at oprette
/// og slette det;</lu>
/// <lu>andre pligter afhænger af typen af proxy:
/// < li>
/// <lu><b >fjern proxy</b> er ansvarlig for at kode anmodningen og dens argumenter
/// og sende den kodede anmodning til det rigtige emne
/// i et andet adresserum;</lu >
/// <lu><b>virtuel proxy</b> kan cache yderligere
/// oplysninger om det reelle emne for at forsinke dets oprettelse.</lu>
/// <lu><b>beskyttende proxy</b > kontrollerer, om den, der ringer op
/// har de nødvendige tilladelser til at foretage anmodningen; </lu>
/// </li>
/// </lu>
/// </li>
/// < /remarks>
class MathProxy : IMath
{
Math math ;
public MathProxy ()
{
math = null ;
}
/// <resumé>
/// Hurtig betjening - kræver ikke et rigtigt emne
/// </summary>
/// <param name="x"></param>
/// <param name="y" >< /param>
/// <returns></returns>
public double Tilføj ( double x , double y )
{
return x + y ;
}
public double Sub ( double x , double y )
{
return x - y ;
}
/// <summary>
/// Langsom drift - kræver oprettelse af et rigtigt emne
/// </summary>
/// <param name="x"></param>
/// <param name="y" >< /param>
/// <returns></returns>
public double Mul ( double x , double y )
{
if ( math == null )
math = new Math ();
returnere matematik . Mul ( x , y );
}
public double Div ( double x , double y )
{
if ( math == null )
math = new Math ();
returnere matematik . Div ( x , y );
}
}
Implementeringseksempel
/* Emne */
klasse IMath {
add ( x , y ) {}
sub ( x , y ) {}
}
/* Real Subject */
class RMath udvider IMath {
add ( x , y ) {
return x + y ;
}
sub ( x , y ) {
returner x - y ;
}
}
/* Proxy */
klasse MathProxy udvider IMath {
math = new RMath ()
add ( x , y ) {
returner dette . matematik . add ( x , y )
}
sub ( x , y ) {
returner dette . matematik . sub ( x , y )
}
}
const test = new MathProxy ()
advarsel ( test . add ( 3 , 2 )) // 5
alert ( test . sub ( 3 , 2 )) // 1
Implementeringseksempel
modul ProxyPattern
# Proxy har den samme grænseflade som et rigtigt emne
# Real Subject
class Account
attr_reader :balance
def initialize ( balance = 0 )
@balance = balance
end
def indbetaling ( beløb )
@saldo += beløb
slut
def tilbagetrækning ( beløb )
@saldo -= beløb
slut
slut
modul Beskyttelse
# Yderligere funktionalitet til at kontrollere adgangen til det virkeligeSubject
# Proxy
-klasse AccountProxy
def initialize ( subject , current_user )
@subject = subject
@current_user = current_user
@balance = 0
end
def indbetaling ( beløb )
@subject . depositum ( beløb ) hvis autorisation
afsluttes
def tilbagetrækning ( beløb )
@emne . trække ( beløb ) hvis autorisation
afsluttes
def balance
@emne . balance
ende
privat
def autorisere
sætter 'Adgang nægtet', medmindre @current_user == ' admin ' @current_user == 'admin' slutningen
def selv . køre
sætter '=> Proxy::Protection'
sætter 'som bruger'
protected_account = AccountProxy . ny ( Konto . ny , 'bruger' )
protected_account . depositum ( 20 )
protected_account . trække ( 10 )
sætter beskyttet_konto . balance
sætter 'som admin'
protected_account = AccountProxy . ny ( Account . new , 'admin' )
protected_account . depositum ( 20 )
protected_account . trække ( 10 )
sætter beskyttet_konto . balance
sætter ' '
ende
modul Virtuel
# Forsinket reel indlæsning af emne (doven indlæsning)
# Proxy
klasse AccountProxy
def initialize ( local_balance = 0 )
@local_balance = local_balance
end
def indbetaling ( beløb )
@local_balance += beløb
slut
def tilbagetrækning ( beløb )
@local_balance -= beløb
slut
def balance
emne . balance
ende
def emne
@subject ||= Konto . ny ( @lokal_balance )
_
_
def selv . køre
sætter '=> Proxy::Virtual'
local_account = AccountProxy . ny
lokal_konto . indbetaling ( 20 )
lokal_konto . trække ( 10 )
lokal_konto . indbetaling ( 15 )
lokal_konto . trække ( 5 )
sætter 'Ingen rigtig konto endnu:'
sætter local_account . inspicere
lokal_konto . saldo
sætter 'Reel konto blev oprettet:'
sætter lokal_konto . inspicere
sætter ' '
ende
def selv . køre
beskyttelse . runVirtual
. _ løb ende ende
Implementeringseksempel
<?php
/// Emne - emne
/// definerer en fælles grænseflade mellem Math og "Proxy", så
/// "Proxy"-klassen kan bruges hvor som helst
grænseflade IMath
{
function Add ( $x , $y );
funktion Sub ( $x , $y );
funktion Mul ( $x , $y );
funktion Div ( $x , $y );
}
/// RealSubject - det rigtige objekt
/// definerer det rigtige objekt repræsenteret af proxyen
klasse Math implementerer IMath
{
public function __construct ()
{
print ( "Create object Math. Vent..." );
søvn ( 5 );
}
public function Add ( $x , $y ){ return $x + $y ;}
public function Sub ( $x , $y ){ return $x - $y ;}
public function Mul ( $x , $y ){ return $x * $y ;}
offentlig funktion Div ( $x , $y ){ return $x / $y ;}
}
/// Proxy - proxy
/// gemmer et link, der tillader proxyen at henvise til det rigtige
/// emne. Klasseobjektet "MathProxy" kan få adgang til klasseobjektet "
Math" ///, hvis grænsefladerne for "Math"- og "IMath"-klasserne er de samme;
/// giver en grænseflade, der er identisk med "IMath"-grænsefladen, så en proxy
/// kan altid leveres i stedet for det rigtige emne;
/// kontrollerer adgangen til det rigtige emne og kan være ansvarlig for at oprette
/// og slette det;
/// andre pligter afhænger af typen af proxy:
/// den eksterne proxy er ansvarlig for at kode anmodningen og dens argumenter
/// og sende den kodede anmodning til det rigtige emne
/// i et andet adresserum;
/// Den virtuelle proxy kan cache yderligere
/// information om det virkelige emne for at forsinke dets oprettelse.
/// den beskyttende proxy kontrollerer, om opkalderen
/// har de nødvendige tilladelser til at udføre anmodningen;
klasse MathProxy implementerer IMath
{
protected $math ;
offentlig funktion __construct ()
{
$this -> math = null ;
}
/// Hurtig betjening - kræver ikke en ægte subjekt
public funktion Tilføj ( $x , $y )
{
return $x + $y ;
}
public function Sub ( $x , $y )
{
return $x - $y ;
}
/// Langsom drift - kræver oprettelse af en reelt emne
public funktion Mul ( $x , $y )
{
if ( $this -> math == null )
$this -> math = new Math ();
returner $this -> matematik -> Mul ( $x , $y );
}
public function Div ( $x , $y )
{
if ( $this -> math == null )
$this -> math = new Math ();
return $this -> matematik -> Div ( $x , $y );
}
}
$p = ny MathProxy ;
// Udskriv matematikken ( "4 + 2 = " . $p -> Tilføj ( 4 , 2 ));
print ( "4 - 2 = " . $p -> Sub ( 4 , 2 ));
print ( "4 * 2 = " . $p -> Mul ( 4 , 2 ));
print ( "4 / 2 = " . $p -> Div ( 4 , 2 ));
?>
Implementeringseksempel
//file IMath.as
package
{
public interface IMath
{
function add ( a : Number , b : Number ) : Number ;
funktion sub ( a : Tal , b : Tal ) : Tal ;
funktion mul ( a : Tal , b : Tal ) : Tal ;
funktion div ( a : Tal , b : Tal ) : Tal ;
}
}
//file MathSubject.as
package
{
public class MathSubject implementerer IMath
{
public function add ( a : Number , b : Number ) : Number
{
return a + b ;
}
public function sub ( a : Tal , b : Tal ) : Tal
{
retur a - b ;
}
offentlig funktion mul ( a : Tal , b : Tal ) : Tal
{
retur a * b ;
}
public function div ( a : Tal , b : Tal ) : Tal
{
return a / b ;
}
}
}
//file MathProxy.as
pakke
{
public class MathProxy implementerer IMath
{
private var math : MathSubject ;
offentlig funktion MathProxy ()
{
math = nyt MathSubject ();
}
offentlig funktion add ( a : Tal , b : Tal ) : Tal
{
retur matematik . tilføje ( a , b );
}
public function sub ( a : Tal , b : Tal ) : Tal
{
retur matematik . sub ( a , b );
}
offentlig funktion mul ( a : Tal , b : Tal ) : Tal
{
retur matematik . mul ( a , b );
}
offentlig funktion div ( a : Tal , b : Tal ) : Tal
{
if ( b != 0 )
returnerer matematik . div ( a , b );
else
{
trace ( "Division med nul." );
returnummer . _ POSITIVE_INFINITY ; } } } }
//file Main.as-
pakke
{
import flash.display.Sprite ;
public class Main udvider Sprite
{
public function Main ()
{
playWithMath ( new MathSubject ());
playWithMath ( ny MathProxy ());
}
public function playWithMath ( math : IMath ) : void
{
trace ( math . add ( 5 , 0 ));
spore ( matematik . sub ( 5 , 0 ));
spore ( matematik . mul ( 5 , 0 ));
spore ( matematik . div ( 5 , 0 ));
}
}
}
Implementeringseksempel
# -*- kodning: utf-8 -*-
class IMath :
"""Grænseflade for proxy og reelt emne"""
def add ( self , x , y ):
raise NotImplementedError ()
def sub ( selv , x , y ):
raise NotImplementedError ()
def mul ( selv , x , y ):
raise NotImplementedError ()
def div ( selv , x , y ):
raise NotImplementedError ()
klasse Math ( IMath ):
"""Reelt emne"""
def add ( selv , x , y ):
returner x + y
def sub ( selv , x , y ):
returner x - y
def mul ( selv , x , y ):
returner x * y
def div ( selv , x , y ):
returner x / y
klasse Proxy ( IMath ):
"""Proxy"""
def __init__ ( selv ):
selv . matematik = matematik ()
def add ( selv , x , y ):
returner x + y
def sub ( selv , x , y ):
returner x - y
def mul ( selv , x , y ):
returnere selv . matematik . mul ( x , y )
def div ( selv , x , y ):
returnere float ( 'inf' ) hvis y == 0 andet selv . matematik . div ( x , y )
p = Proxy ()
x , y = 4 , 2
print '4 + 2 = ' + str ( p . add ( x , y ))
print '4 - 2 = ' + str ( p . sub ( x , y ))
print '4 * 2 = ' + str ( p . mul ( x , y ))
udskriv '4 / 2 = ' + str ( p . div ( x , y ))
Implementeringseksempel
Importer System.Threading
Klasse MainApp
Shared Sub Main ()
' Opret matematisk proxy
Dim p As IMath = New MathProxy ()
Udfør matematikkonsollen . WriteLine ( "4 + 2 = " & s . Tilføj ( 4 , 2 ))
Konsol . WriteLine ( "4-2 = " & p . Subtr ( 4 , 2 ))
Konsol . WriteLine ( "4 * 2 = " & p . Mul ( 4 , 2 ))
Konsol . WriteLine ( "4 / 2 = " & s . Div ( 4 , 2 ))
'Vent på
brugerkonsollen . Læs ()
End Sub
End Class
''' <summary>
''' Emne - emnet for
''' </summary>
''' <remarks>
''' <li>
''' <lu> definerer fælles for <see cref="Math"/ > og <see cref="Proxy"/> interface, så klassen
''' <see cref="Proxy"/> kan bruges hvor som helst <see cref="Math"/></lu>
''' </ li>
''' </remarks>
Offentlig grænseflade IMath
Funktion Tilføj ( ByVal x As Double , ByVal y As Double ) As Double
Function Subtr ( ByVal x As Double , ByVal y As Double ) As Double
Function Mul ( ByVal x As Double , ByVal y As Double ) Som Dobbeltfunktion
Div ( ByVal x As Double , ByVal y As Double ) Som Double End Interface _
''' <summary>
''' RealSubject - det rigtige objekt
''' </summary>
''' <remarks>
''' <li>
''' <lu>identificerer det rigtige objekt repræsenteret af proxyen</lu >
'' ' </li>
''' </remarks
> Klassematematik implementerer IMath
Offentlig under ny ()
konsol . WriteLine ( "Opret objekt Math. Vent..." )
Tråd . Søvn ( 1000 )
End Sub
Public Function Add ( ByVal x As Double , ByVal y As Double ) As Double Implementer IMath . Tilføj
Retur x + y
Slutfunktion _
Public Function Subtr ( ByVal x As Double , ByVal y As Double ) As Double Implementer IMath . Subtr
Return x - y
Slutfunktion _
Public Function Mul ( ByVal x As Double , ByVal y As Double ) As Double Implementer IMath . Mul
Return x * y
Slutfunktion _
Offentlig funktion Div ( ByVal x As Double , ByVal y As Double ) As Double Implementer IMath . Div
Return x / y
Slutfunktion _
slutklasse _
''' <summary>
''' Proxy proxy
''' </summary>
''' <remarks>
''' <li>
''' <lu> gemmer en reference, der tillader proxyen at henvise til den rigtige
'' ' emne. Et objekt af klassen <see cref="MathProxy"/> kan henvise til et objekt af klassen
''' <see cref="IMath"/>, hvis klassen interfacer <see cref="Math"/> og <see cref= "IMath"/ > er de samme;</lu>
''' <lu>giver en grænseflade, der er identisk med den for <see cref="IMath"/>, så pladsholderen
''' altid kan angives i stedet for ægte emne;</lu>
''' < lu>kontrollerer adgangen til det rigtige emne og kan være ansvarlig for dets oprettelse
''' og sletning;</lu>
''' <lu>andre pligter afhænger af typen af fuldmægtig :
''' <li>
''' <lu><b >fjernproxy</b> er ansvarlig for at kode anmodningen og dens argumenter
''' og sende den kodede anmodning til det rigtige emne i et
andet adresseområde '' ';</lu>
''' <lu><b>virtuel proxy</b> kan cache yderligere information
''' om det virkelige emne for at forsinke dets oprettelse.</lu>
''' <lu><b> beskyttende proxy</b> kontrollerer, om den, der ringer
''' har de nødvendige tilladelser til at fremsætte anmodningen; </lu>
''' </li>
''' </lu>
''' </li>
''' < /bemærkninger>
Klasse MathProxy
implementerer IMath
Privat matematik Som matematik = ingenting
''' <resumé>
''' Hurtig betjening - kræver ikke et rigtigt emne
''' </summary>
Offentlig funktion Tilføj ( ByVal x As Double , ByVal y As Double ) As Double Implementerer IMath . Tilføj
Retur x + y
Slutfunktion _
Public Function Subtr ( ByVal x As Double , ByVal y As Double ) As Double Implementer IMath . Subtr
Return x - y
Slutfunktion _
''' <summary>
''' Langsom drift - kræver oprettelse af et rigtigt emne
''' </summary>
Public Function Mul ( ByVal x As Double , ByVal y As Double ) As Double Implementerer IMath . Mul
Hvis matematik ikke er noget , så
matematik = Ny matematik ()
End If
Returner matematik . Mul ( x , y )
Slutfunktion _
Offentlig funktion Div ( ByVal x As Double , ByVal y As Double ) As Double Implementer IMath . Div
Hvis matematik ikke er noget , så
matematik = Ny matematik ()
End If
Returner matematik . Div ( x , y )
Slutfunktion Slutklasse
_ _
Implementeringseksempel
//
emneprotokol match {
func add ( x : Int , y : Int ) -> Int
func sub ( x : Int , y : Int ) -> Int
func mul ( x : Int , y : Int ) -> Int
func div ( x : Int , y : Int ) -> Int
}
// Real Subject
class MatchImp : Match {
func add ( x : Int , y : Int ) -> Int {
return x + y
}
func sub ( x : Int , y : Int ) -> Int {
return x - y
}
func mul ( x : Int , y : Int ) -> Int {
return x * y
}
func div ( x : Int , y : Int ) -> Int {
return x / y
}
}
// Proxy
klasse MatchProxy : Match {
private lad math = MatchImp ()
func add ( x : Int , y : Int ) -> Int {
return math . tilføje ( x : x , y : y )
}
func sub ( x : Int , y : Int ) -> Int {
returnere matematik . sub ( x : x , y : y )
}
func mul ( x : Int , y : Int ) -> Int {
return math . mul ( x : x , y : y )
}
func div ( x : Int , y : Int ) -> Int {
returnere matematik . div ( x : x , y : y )
}
}
// brug proxy
lad proxy = MatchProxy ()
udskrive ( "7 * 8 = \( proxy . mul ( x : 8 , y : 7 )) " )
Se også
- Post-objekt programmering
Noter
- ↑ Udviklerens dagbøger // Proxy (downlink) . Hentet 26. maj 2010. Arkiveret fra originalen 14. maj 2010. (ubestemt)
Litteratur
- CodeLIB.YOURS // Proxy arkiveret 14. maj 2010 på Wayback Machine
- E. Gamma, R. Helm, R. Johnson, J. Vlissides . Teknikker til objektorienteret design. Design Patterns.=Design Patterns.Elementer af genanvendelig objektorienteret software. - Sankt Petersborg. : Peter, 2001. - 368 s. — ISBN 5-272-00355-1 .
- Eric Freeman, Elizabeth Freeman, Kathy Siera, Bert Bates. Design mønstre. - Sankt Petersborg. : Peter, 2012. - 656 s. - ISBN 978-5-459-00435-9 .
Links