Delegation (object-oriented programming)
In
The term delegation is also used loosely for various other relationships between objects; see
Overview
This sense of delegation as programming language feature making use of the method lookup rules for dispatching so-called self-calls was defined by Lieberman in his 1986 paper "Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems".
Delegation is dependent upon
Delegation can be characterized (and distinguished from forwarding) as late binding of self:[4]
... messages sent to the
self
(orthis
) variable in the parent will "come back" to the object that originally received the message.
That is, the self
in a method definition in the receiving object is not statically bound to that object at definition time (such as compile time or when the function is attached to an object), but rather at evaluation time, it is bound to the original object.
It has been argued that delegation may in some cases be preferred to inheritance to make program code more readable and understandable.[5] Despite explicit delegation being fairly widespread, relatively few major programming languages implement delegation as an alternative model to inheritance. The precise relationship between delegation and inheritance is complicated; some authors consider them equivalent, or one a special case of the other.[6]
Language support for delegation
In languages that support delegation via method lookup rules, method dispatching is defined the way it is defined for virtual methods in inheritance: It is always the most specific method that is chosen during method lookup. Hence it is the original receiver entity that is the start of method lookup even though it has passed on control to some other object (through a delegation link, not an object reference).
Delegation has the advantage that it can take place at run time and affect only a subset of entities of some type and can even be removed at run time. Inheritance, by contrast, typically targets the type rather than the instances, and is restricted to compile time. On the other hand, inheritance can be statically type-checked, while delegation generally cannot without generics (although a restricted version of delegation can be statically typesafe[7]). Delegation can be termed "run-time inheritance for specific objects."
Here is a pseudocode example in a C#/Java like language:
class A {
void foo() {
// "this" also known under the names "current", "me" and "self" in other languages
this.bar();
}
void bar() {
print("a.bar");
}
}
class B {
private delegate A a; // delegation link
public B(A a) {
this.a = a;
}
void foo() {
a.foo(); // call foo() on the a-instance
}
void bar() {
print("b.bar");
}
}
a = new A();
b = new B(a); // establish delegation between two objects
Calling b.foo()
will result in b.bar being printed, since this
refers to the original receiver object, b
, within the context of a
. The resulting ambiguity of this
is referred to as
Translating the implicit this
into an explicit parameter, the call (in B
, with a
a delegate) a.foo()
translates to A.foo(b)
, using the type of a
for method resolution, but the delegating object b
for the this
argument.
Using inheritance, the analogous code (using capital letters to emphasize that resolution is based on classes, not objects) is:
class A {
void foo() {
this.bar();
}
void bar() {
print("A.bar");
}
}
class B extends A {
public B() {}
void foo() {
super.foo(); // call foo() of the superclass (A)
}
void bar() {
print("B.bar");
}
}
b = new B();
Calling b.foo()
will result in B.bar. In this case, this
is unambiguous: there is a single object, b
, and this.bar()
resolves to the method on the subclass.
Programming languages in general do not support this unusual form of delegation as a language concept, but there are a few exceptions[citation needed].
Dual inheritance
If the language supports both delegation and inheritance one can do dual inheritance by utilizing both mechanisms at the same time as in
class C extends A {
delegationlink D d;
}
This calls for additional rules for method lookup, as there are now potentially two methods that can be denoted as the most specific (due to the two lookup paths).
Related areas
Delegation can be described as a low level mechanism for sharing code and data between entities. Thus it builds the foundation for other language constructs. Notably
More recently work has also been done on distributing delegation, so e.g. clients of a search engine (finding cheap hotel rooms) can use a shared entity using delegation to share best hits and general re-usable functionality.
Delegation has also been suggested for advice resolution in aspect-oriented programming by Ernst and Lorenz in 2003.
See also
- Delegation pattern
- Adapter pattern
- Hooking
- Continuation
- Implementation inheritance
- Inheritance semantics
- Schizophrenia (object-oriented programming)
- Virtual inheritance
- Wrapper function
Distinguish:
- Delegate (CLI)
- Delegation (programming)
- Object aggregation
- Forwarding (object-oriented programming)
Notes
- ^ Beck 1997 uses the terms "simple delegation" for when the receiving object does not have access to the sending object, and "self delegation" for when the receiving object does have access to the sending object; in modern language these are "forwarding" and "delegation", as used in this article.
References
- ^ Gamma et al. 1995, "Delegation", pp. 20–21.
- ^ Beck 1997, "Delegation", pp. 64–69.
- ^ Apple (2009-08-20). "Cocoa Fundamentals Guide: Delegates and Data Sources". Apple Developer Connection. Retrieved 2009-09-11.
- ^ "Intersecting Classes and Prototypes". Perspectives of Systems Informatics: 5th International Andrei Ershov Memorial Conference, PSI 2003, Akademgorodok, Novosibirsk, Russia, July 9-12, 2003, Revised Papers. p. 38.
- ^ [1]Trygve Reenskaug, Dept. of Informatics, University of Oslo, "The Case for Readable Code" (2007)
- .
- ISBN 978-3-540-66156-6. Archived from the original on 2015-03-04. Retrieved 2015-03-04.)
This paper proposes object-based inheritance (also known as delegation) as a complement to purely forwarding-based object composition. It presents a typesafe integration of delegation into a class-based object model and shows how it overcomes the problems faced by forwarding-based component interaction, how it supports independent extensibility of components and unanticipated, dynamic component adaptation.
{{cite book}}
: CS1 maint: bot: original URL status unknown (link
- doi:10.1145/960112.28718.)
{{cite book}}
:|journal=
ignored (help)CS1 maint: location missing publisher (link - Lynn Andrea Stein, Henry Liberman, David Ungar: A shared view of sharing: The Treaty of Orlando. In: Won Kim, Frederick H. Lochovsky (Eds.): Object-Oriented Concepts, Databases, and Applications ACM Press, New York 1989, ch. 3, pp. 31–48 ISBN 0-201-14410-7 (online at Citeseer)
- ISBN 978-0-201-63361-0.
- Malenfant, J.: On the Semantic Diversity of Delegation-Based Programming Languages, Proceedings of the OOPSLA95, New York: ACM 1995, pp. 215–230.
- ISBN 978-0134769042.
- Kasper Bilsted Graversen: The nature of roles---A taxonomic analysis of roles as a language construct. Ph.D. Thesis 2006, (Online at IT University of Copenhagen)
External links
- A new way to implement Delegate in C++
- Fast delegates in C++
- PerfectJPattern Open Source Project, Provides a reusable implementation of Delegates in Java