Reflective programming

Historical background

Uses

Implementation

Security considerations

Examples

Common Lisp

(defclassfoo()())
(defmethodprint-hello((ffoo))(formatT"Hello from ~S~%"f))
;; Normal, without reflection
(let((foo(make-instance'foo)))
(print-hellofoo))
;; With reflection to look up the class named "foo" and the method
;; named "print-hello" that specializes on "foo".
(let*((foo-class(find-class(read-from-string"foo")))
(print-hello-method(find-method(symbol-function(read-from-string"print-hello"))
nil(listfoo-class))))
(funcall(sb-mop:method-generic-functionprint-hello-method)
(make-instancefoo-class)))

C

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedefstruct{
// ...
}Foo;
typedefvoid(*Method)(void*);
// The method: Foo::printHello
voidFoo_printHello([[maybe_unused]]void*instance){
(void)instance;// Instance ignored for a static method
printf("Hello, world!\n");
}
// Simulated method table
typedefstruct{
constchar*name;
Methodfn;
}MethodEntry;
MethodEntryfooMethods[]={
{"printHello",Foo_printHello},
{NULL,NULL}// Sentinel to mark end
};
// Simulate reflective method lookup
[[nodiscard]]
MethodfindMethodByName(constchar*name){
for(size_ti=0;fooMethods[i].name;i++){
if(strcmp(fooMethods[i].name,name)==0){
returnfooMethods[i].fn;
}
}
returnNULL;
}
intmain(){
// Without reflection
FoofooInstance;
Foo_printHello(&fooInstance);
// With reflection
Foo*fooReflected=malloc(sizeof(Foo));
if(!fooReflected){
fprintf(stderr,"Memory allocation failed\n");
return1;
}
constchar*methodName="printHello";
Methodm=findMethodByName(methodName);
if(m){
m(fooReflected);
}else{
fprintf(stderr,"Method '%s' not found\n",methodName);
}
free(fooReflected);
return0;
}

C++

importstd;
usingstd::nullopt;
usingstd::optional;
usingstd::string_view;
usingstd::vector;
usingstd::meta::access_context;
usingstd::meta::exception;
usingstd::meta::info;
usingstd::views::filter;
classFoo{
private:
// ...
public:
voidprintHello()constnoexcept{
std::println("Hello, world!");
}
};
[[nodiscard]]
constevalboolisNonstaticMethod(infomem)noexcept{
returnstd::meta::is_class_member(mem)
&&!std::meta::is_static_member(mem)
&&std::meta::is_function(mem);
}
[[nodiscard]]
constevaloptional<info>findMethod(infoty,constchar*name){
constexprautoctx=access_context::current();
constexprvector<info>members=std::meta::members_of(ty,ctx);
for(infomember:members|filter(isNonstaticMethod)){
if(std::meta::identifier_of(member)==name){
returnmember;
}
}
returnnullopt;
}
template<infoTy,autoName>
constexprautocreateInvokerImpl=[]()->auto{
usingType=[:Ty:];
staticconstexprinfoM=findMethod(Ty,Name).or_else(
[[noreturn]]
[]()->void{throwexception("Failed to retrieve method of M!");}
);
static_assert(
std::meta::parameters_of(M).size()==0&&
std::meta::return_type_of(M)==^^void
);
return[](Type&instance)->void{instance.[:M:]();};
}();
[[nodiscard]]
constevalinfocreateInvoker(infoty,string_viewname){
returnstd::meta::substitute(
^^createInvokerImpl,
{std::meta::reflect_constant(ty),std::meta::reflect_constant_string(name)}
);
}
intmain(intargc,char*argv[]){
Foofoo;
// Without reflection
foo.printHello();
// With reflection
autoinvokePrint=[:createInvoker(^^Foo,"printHello"):];
invokePrint(foo);
return0;
}

C#

namespaceWikipedia.Examples;
usingSystem;
usingSystem.Reflection;
classFoo
{
// ...
publicvoidPrintHello()
{
Console.WriteLine("Hello, world!");
}
}
publicclassInvokeFooExample
{
staticvoidMain(string[]args)
{
// Without reflection
Foofoo=new();
foo.PrintHello();
// With reflection
Objectfoo=Activator.CreateInstance(typeof(Foo));
MethodInfomethod=foo.GetType().GetMethod("PrintHello");
method.Invoke(foo,null);
}
}

Delphi, Object Pascal

usesRTTI,Unit1;
procedureWithoutReflection;
var
Foo:TFoo;
begin
Foo:=TFoo.Create;
try
Foo.Hello;
finally
Foo.Free;
end;
end;
procedureWithReflection;
var
RttiContext:TRttiContext;
RttiType:TRttiInstanceType;
Foo:TObject;
begin
RttiType:=RttiContext.FindType('Unit1.TFoo')asTRttiInstanceType;
Foo:=RttiType.GetMethod('Create').Invoke(RttiType.MetaclassType,[]).AsObject;
try
RttiType.GetMethod('Hello').Invoke(Foo,[]);
finally
Foo.Free;
end;
end;

eC

// Without reflection
Foofoo{};
foo.hello();
// With reflection
ClassfooClass=eSystem_FindClass(__thisModule,"Foo");
Instancefoo=eInstance_New(fooClass);
Methodm=eClass_FindMethod(fooClass,"hello",fooClass.module);
((void(*)())(void*)m.function)(foo);

Go

import(
"fmt"
"reflect"
)
typeFoostruct{}
func(fFoo)Hello(){
fmt.Println("Hello, world!")
}
funcmain(){
// Without reflection
varfFoo
f.Hello()
// With reflection
varfTreflect.Type=reflect.TypeOf(Foo{})
varfVreflect.Value=reflect.New(fT)
varmreflect.Value=fV.MethodByName("Hello")
ifm.IsValid(){
m.Call(nil)
}else{
fmt.Println("Method not found")
}
}

Java

packageorg.wikipedia.example;
importjava.lang.reflect.Method;
class Foo{
// ...
publicvoidprintHello(){
System.out.println("Hello, world!");
}
}
publicclass InvokeFooExample{
publicstaticvoidmain(String[]args){
// Without reflection
Foofoo=newFoo();
foo.printHello();
// With reflection
try{
Foofoo=Foo.class.getDeclaredConstructor().newInstance();
Methodm=foo.getClass().getDeclaredMethod("printHello",newClass<?>[0]);
m.invoke(foo);
}catch(ReflectiveOperationExceptione){
System.err.printf("An error occurred: %s%n",e.getMessage());
}
}
}

JavaScript/TypeScript

// Without reflection
constfoo=newFoo();
foo.hello();
// With reflection
constfoo=Reflect.construct(Foo);
consthello=Reflect.get(foo,'hello');
Reflect.apply(hello,foo,[]);
// With eval
eval('new Foo().hello()');

// Without reflection
constfoo:Foo=newFoo();
foo.hello();
// With reflection
constfoo:Foo=Reflect.construct(Foo);
consthello:(this:Foo)=>void=Reflect.get(foo,'hello')as(this:Foo)=>void;
Reflect.apply(hello,foo,[]);
// With eval
eval('new Foo().hello()');

Julia

julia>struct Point
x::Int
y
end
# Inspection with reflection
julia>fieldnames(Point)
(:x, :y)
julia>fieldtypes(Point)
(Int64, Any)
julia>p=Point(3,4)
# Access with reflection
julia>getfield(p,:x)
3

Objective-C

// Foo class.
@interface Foo : NSObject
- (void)hello;
@end
// Sending "hello" to a Foo instance without reflection.
Foo*obj=[[Fooalloc]init];
[objhello];
// Sending "hello" to a Foo instance with reflection.
idobj=[[NSClassFromString(@"Foo")alloc]init];
[objperformSelector:@selector(hello)];

Perl

# Without reflection
my$foo=Foo->new;
$foo->hello;
# or
Foo->new->hello;
# With reflection
my$class="Foo"
my$constructor="new";
my$method="hello";
my$f=$class->$constructor;
$f->$method;
# or
$class->$constructor->$method;
# with eval
eval"new Foo->hello;";

PHP

// Without reflection
$foo = new Foo();
$foo->hello();
// With reflection, using Reflections API
$reflector = new ReflectionClass("Foo");
$foo = $reflector->newInstance();
$hello = $reflector->getMethod("hello");
$hello->invoke($foo);

Python

fromtypingimport Any
classFoo:
 # ...
 defprint_hello() -> None:
 print("Hello, world!")
if __name__ == "__main__":
 # Without reflection
 obj: Foo = Foo()
 obj.print_hello()
 # With reflection
 obj: Foo = globals()["Foo"]()
 _: Any = getattr(obj, "print_hello")()
 # With eval
 eval("Foo().print_hello()")

R

# Without reflection, assuming foo() returns an S3-type object that has method "hello"
obj<-foo()
hello(obj)
# With reflection
class_name<-"foo"
generic_having_foo_method<-"hello"
obj<-do.call(class_name,list())
do.call(generic_having_foo_method,alist(obj))

Ruby

# Without reflection
obj=Foo.new
obj.hello
# With reflection
obj=Object.const_get("Foo").new
obj.send:hello
# With eval
eval"Foo.new.hello"

Rust

usestd::any::TypeId;
usebevy_reflect::prelude::*;
usebevy_reflect::{
FunctionRegistry,
GetTypeRegistration,
Reflect,
ReflectFunction,
ReflectFunctionRegistry,
ReflectMut,
ReflectRef,
TypeRegistry
};
#[derive(Reflect)]
#[reflect(DoFoo)]
structFoo{
// ...
}
implFoo{
fnnew()->Self{
Foo{}
}
fnprint_hello(&self){
println!("Hello, world!");
}
}
#[reflect_trait]
traitDoFoo{
fnprint_hello(&self);
}
implDoFooforFoo{
fnprint_hello(&self){
self.print_hello();
}
}
fnmain(){
// Without reflection
letfoo:Foo=Foo::new();
foo.print_hello();
// With reflection
letmutregistry:TypeRegistry=TypeRegistry::default();
registry.register::<Foo>();
registry.register_type_data::<Foo,ReflectFunctionRegistry>();
registry.register_type_data::<Foo,ReflectDoFoo>();
letfoo:Foo=Foo;
letreflect_foo:Box<dynReflect>=Box::new(foo);
// Version 1: call hello by trait
lettrait_registration:&ReflectDoFoo=registry
.get_type_data::<ReflectDoFoo>(TypeId::of::<Foo>())
.expect("ReflectDoFoo not found for Foo");
lettrait_object:&dynDoFoo=trait_registration
.get(&*reflect_foo)
.expect("Failed to get DoFoo trait object");
trait_object.print_hello();
// Version 2: call hello by function name
letfunc_registry:&FunctionRegistry=registry
.get_type_data::<FunctionRegistry>(TypeId::of::<Foo>())
.expect("FunctionRegistry not found for Foo");
ifletSome(dyn_func)=func_registry.get("print_hello"){
letresult:Option<Box<dynReflect>>=dyn_func
.call(&*reflect_foo,Vec::<Box<dynReflect>>::new())
.ok();
ifresult.is_none(){
println!("Function called, no result returned (as expected for void return)");
}
}else{
println!("No function named hello found in FunctionRegistry");
}
}

Xojo

' Without reflection
DimfooInstanceAsNewFoo
fooInstance.PrintHello
' With reflection
DimclassInfoAsIntrospection.Typeinfo=GetTypeInfo(Foo)
Dimconstructors()AsIntrospection.ConstructorInfo=classInfo.GetConstructors
DimfooInstanceAsFoo=constructors(0).Invoke
Dimmethods()AsIntrospection.MethodInfo=classInfo.GetMethods
ForEachmAsIntrospection.MethodInfoInmethods
Ifm.Name="PrintHello"Then
m.Invoke(fooInstance)
EndIf
Next

See also

References

Citations

Sources

• Jonathan M. Sobel and Daniel P. Friedman. An Introduction to Reflection-Oriented Programming (1996), Indiana University.
• Anti-Reflection technique using C# and C++/CLI wrapper to prevent code thief

Further reading

External links