Qual è la differenza tra la classe proxy e la delega in Python?

Question

Qual è la differenza tra la classe proxy e la delega in Python?

#1 da (2 voti)
#2 da (1 voti)
#3 da (0 voti)

1

A proxy, in its most general form, is a class functioning as an interface to something else. The proxy could interface to anything: a network connection, a large object in memory, a file, or some other resource that is expensive or impossible to duplicate. In short, a proxy is a wrapper or agent object that is being called by the client to access the real serving object behind the scenes

Hmm !, come apparirebbe in termini di codice?

Wiki

delegation refers to one object relying upon another to provide a specified set of functionalities

Questa classe ad esempio delega le sue funzionalità a un altro oggetto:

class CustomInt: 

    def __init__(self): 
        self.obj = int() 

    def __getattr__(self, attr): 
        return getattr(self.obj, attr)   # Delegation

Poiché è una classe che funziona come interfaccia per qualcos'altro, posso considerarla come una classe proxy?

python class class-design

posta direprobs 24.10.2015 - 14:27

fonte

3 risposte

Leggi altre domande sui tag python class class-design

Scala: DSL per algoritmi ripetitivi Ridurre l'arità delle funzioni [chiuso]

score 2 · Answer 1

Un proxy non ha altre funzionalità oltre alle azioni di inoltro. Una classe che delega aggiunge anche le proprie funzionalità.
In questo, in effetti, un proxy è un caso speciale di delega.
Come ha detto @Jules, il tuo esempio è uno di un proxy.

score 1 · Answer 2

Sì. La tua classe è un proxy, e questo è lo schema tipico usato per implementare un proxy in un linguaggio dinamico (nei linguaggi statici, ogni metodo deve essere tipicamente inoltrato individualmente). I proxy di solito cambiano anche il comportamento dell'oggetto proxy su un modo sottile (ad esempio impedendo l'accesso a determinati metodi, ospitando l'oggetto di destinazione in un processo separato o su un'altra macchina, ecc.).

score 0 · Answer 3

Se implementiamo un semplice proxy, questo è il seguente:

# Simple demonstration of the Proxy pattern.

class Implementation:
    def f(self):
        print("Implementation.f()")
    def g(self):
        print("Implementation.g()")
    def h(self):
        print("Implementation.h()")

class Proxy:
    def __init__(self):
        self.__implementation = Implementation()
    # Pass method calls to the implementation:
    def f(self): self.__implementation.f()
    def g(self): self.__implementation.g()
    def h(self): self.__implementation.h()

p = Proxy()
p.f(); p.g(); p.h()

Non è necessario che l'Implementazione abbia la stessa interfaccia del Proxy; fintanto che Proxy sta in qualche modo "parlando per" la classe a cui si riferisce il metodo chiama allora l'idea di base è soddisfatta (nota che questa affermazione è in contrasto con la definizione di Proxy in GoF). Tuttavia, è conveniente disporre di un'interfaccia comune in modo che l'implementazione sia obbligata a soddisfare tutti i metodi che il proxy deve chiamare.

Naturalmente, in Python abbiamo un meccanismo di delega integrato, quindi rende il proxy ancora più semplice da implementare:

# Simple demonstration of the Proxy pattern.

class Implementation2:
    def f(self):
        print("Implementation.f()")
    def g(self):
        print("Implementation.g()")
    def h(self):
        print("Implementation.h()")

class Proxy2:
    def __init__(self):
        self.__implementation = Implementation2()
    def __getattr__(self, name):
        return getattr(self.__implementation, name)

p = Proxy2()
p.f(); p.g(); p.h();

Il bello dell'uso di getattr () è che Proxy2 è completamente generico e non legato a nessuna particolare implementazione (in Java, è stato inventato un "proxy dinamico" piuttosto complicato per realizzare questa stessa cosa ).