apier-LOOM€¢Rapier Loom .NET verwebt die Zielklasse mit der Aspektklasse bei der Instanzierung •Anstelle des new-operators wird eine spezielle Factory-Methode verwendet. Wolfgang

apier-LOOM.NETRDynamische Aspektweben mit

Microsoft .NETKonzepte, Beispiele

19.07.2005Wolfgang Schult - Aspektorientierte Programmierung2 Hasso-Plattner-Institut

Potsdam

Rapier LOOM.NET

Ist eine Assembly („Rapier.dll“), die zusätzlich eingebunden werden mussLäuft mit allen .NET Sprachen.Es ist kein zusätzliches Tool oder separater Compiler notwendig!


Potsdam

Entwicklung von Rapier-LOOM.NET

2001 20042002 2003

Nov. 2002, erste Veröffentlichung vom „dynamischen Weber“GI-Workshop, Berlin

März 2003, derdynamische Weber

wird auf der AOSD in Boston, MA, USA

vorgestellt.Version 0.7 ist über das Web verfügbar

Aug. 2003,Version 1.0

Dez. 2003,Version 1.02 unter

dem offiziellen Namen „Rapier-

Loom.NET“

März 2004,Version 1.2 Beta

www.rapier-loom.net

Sep. 2001, Microsoft Summer

Workshop Cambridge, UK

WrapperAssistentVersion 1.0

Apr. 2002, statischer Weber „LOOM.NET“

auf der ISORC, Washington D.C., USA vorgestellt.


Potsdam

Motivation

Weben von Aspekten normalerweise zur KompilierungszeitSchwierig bei konträren Aspekten

Anforderungen in Designphase müssen zur Laufzeit nicht mehr gültig seinFür manche Konfigurationen werden bestimmte Aspekte nicht benötigt


Potsdam

Also…

Entscheidung zur LaufzeitVerwebung läuft erst beim Erzeugen der Komponenten-InstanzKomponente kann mit Aspektinformationen ausgeliefert werden, die Entscheidung kann aber auch erst zur Laufzeit erfolgen

Ressourcennutzung kann optimiert werdenWenn für bestimmte Szenarien nicht benötigt


Potsdam

Rapier Loom.NETGrundlagen

Idie Idee,


Potsdam

Notation (cont.)

aspectclass

•Um einen Aspekt zu definieren, wird eine spezielle .Net Klasse verwendet

•Diese Aspektklasse enthält die modulübergreifenden Eigenschaften


Potsdam

Notation (cont.)

aspectclass

•Connection points in derAspektklasse definieren, an welchenPunkten diese Klasse mit anderenKlassen verwoben werden soll.

connection points


Potsdam

Notation

aspectclass

targetclass

targetclass

targetclass

•Eine Zielklasse ist eine .NET Klasse, welche mit einer Aspektklasse verwoben werden soll.

•Jede Klasse im System ist eine potentielle Zielklasse.


Potsdam

Verwebungsprozess (cont.)

aspectclass

targetclass

•Rapier Loom .NET verwebt die Zielklasse mit derAspektklasse bei der Instanzierung

•Anstelle des new-operators wird eine spezielle Factory-Methode verwendet.


Potsdam

Verwebungsprozess

aspectclass

targetclass

•Der Aspektweber generiert einen neuen Typ aus Zielklasseund Aspectklasse

•Die Loom.CreateInstance Funktion liefert ein Objektder verwobenen Klasse

interwoven class


Potsdam

Eine Aspect Klasse…

public class TA:Aspect{}

... ist eine .NET-Klasse, welche von Aspect abgeleitet ist


Potsdam

Aspektklasse (cont.)

public class TA:Aspect{

[ConnectionPointAttribute]public void m5(int i){// ...}

}

Der Aspectcode wird in den Methoden der Aspektklasse definiert

Diese Methoden müssen mit einem speziellen Attribute als ein Connection Point markiert sein


Potsdam

Aspektklasse


[ConnectionPointAttribute]public void m5(int i){// ...}

public m1() {…}private m2() {…}

}

Diese Methoden werden als Aspektmethoden bezeichnet

Eine Aspektklasse kann weitere Methodendefinieren. Diese werden aber nicht in den Verwebungsprozess einbezogen.


Potsdam

Verbindungspunktattribute...

...definieren, an welchen Stellen der Aspektcode mit einer Zielklasse verwoben wird:

[Call(Invoke)][Create(Invoke)][Introduces(Type)]*

VerbindungspunktkategorienBeforeInsteadAfter, AfterReturning, AfterThrowing


Potsdam

Beispiel

public class Trace:Aspect{

[Call(Invoke.Before)]public void m5(int i){// ...}

}

Invoke.Before: Vor der Ausführung der Methode

Invoke.After: Nach der Ausführung der Methode

Invoke.AfterReturning: Nach der Rückkehr aus der Methode

Invoke.AfterThrowing: Nach dem Werfen einer Exception

Invoke.Instead: Anstelle der Methode


Potsdam

Verwebungssteuerung (cont.)

Beziehungen zwischen Aspekten und Zielklassen

OpenClassDirectional

Aspekt kennt Zielklasse

AspectDirectionalClosed

Aspekt kennt Zielklasse nicht

Zielklasse kennt Aspekt

Zielklasse kennt Aspekt nicht


Potsdam

Verwebungssteuerung (cont.)

Eine Aspektmethode wird mit einer Zielklassenmethode verwoben, wenn:

Methodensignaturen gleich sind oder Parameterwildcards verwendet werdenMethodennamen identisch sindAlle Verwebungsattribute passenMethoden virtuell oder über ein IF definiert sind

Vewebungsattribute sind:Include, Exclude, IncludeIfAttributeDefined, ExcludeIfAttributeDefined, IncludeAll, DeclaredOnly, PreserveType


Potsdam

Verwebungssteuerung (cont.)public class A:IF1{public A(){…}public void m1(int i){…};public int m2(int i){…};[MyAttribute]public A m3(

object[] arr){…}

}

public class TA:Aspect{[Call(Invoke.Before)]public void m1(int i){ … }

}


Potsdam

Verwebungssteuerung (cont.)public class A:IF1{public A(){…}public void m1(int i) {…};public int m2(int i){…};[MyAttribute]public A m3(

object[] arr){…}

}

public class TA:Aspect{[Include(“m2”)][Call(Invoke.Before)]public int m1(int i){ … }

}


Potsdam


object[] arr){…}

}

public class TA:Aspect{[Include(“m*”)][Call(Invoke.Before)]public object m1(int i)

{ … }}


Potsdam


object[] arr){…}

}

public class TA:Aspect{[IncludeAll][Call(Invoke.Before)]public object m1(

object[] args){ … }

}


Potsdam


object[] arr){…}

}

public class TA:Aspect{[IncludeAll][ExcludeIfAttribute-

Defined(typeof(MyAttribute))][Call(Invoke.Before)]public object m1(


}


Potsdam


object[] arr){…}

}

public class TA:Aspect{[IncludeAll][Call(Invoke.Before)]public object m1([PreserveType]


}


Potsdam

Verwebungssteuerungpublic class A:IF1{public A(){…}public void m1(int i) {…};public int m2(int i){…};[MyAttribute]public A m3(

object[] arr){…}

}

public class TA:Aspect{[Create(

Invoke.Instead)]public object Create(Type typ)

{ … }}


Potsdam

Implizite Parameter

Abhängig vom Verwebungskontext kann eine Aspektmethode einen impliziten Parameter habenIst immer der erste Parameter der AspektmethodeWird bei Verwebungssteuerung nicht berücksichtigtKontext:

Call(Invoke.AfterReturning) -> RückgabewertCall(Invoke.AfterThrowing) -> ExceptionCreate(...) -> Objekttyp

[Call(Invoke.AfterThrowing)]public object m1(Exception e, object[] args)


Potsdam

Aspectkontext


[call(Invoke.Instead)]public object m5

(object[] args){// ...object ret=Context.Invoke(args);return ret;}

}

Wenn eine Aspektme-thode anstelle einer Zielklassenmethode verwoben wurde, kann diese über den Aspect-kontext aufgerufen werden.


Potsdam

Introductions

Interface IFoo{void foo();

}

[Introduce(typeof(IFoo))]public class IntrAsp:Aspect, IFoo{

public void foo() { … }}

Einweben von neuen Interfaces:

Alle Methoden des Interfaces sind im Verwobenen Objekt verfügbar und werden vom Aspekt behandelt.


Potsdam

Verwebung mit einerZielklasse

Entweder:[TA]Public class A {/*…*/}…A a= Weaver.CreateInstance(typeof(A)) as A;

Die Aspektklasse kann statisch durch die Benutzung als Attribut verwoben werden.


Potsdam

Verwebung mit einerZielklasse

Oder:

Public class A {/*…*/} …A a= Weaver.CreateInstance(typeof(A), null,new TA()) as A;

Die Aspektklasse kann dynamisch verwoben werden. Dabei wird ein Aspektobjektes als Para-meter an die CreateInstance Funktion des Webers übergeben.


Potsdam

Kurze Zusammfassung

AOP-Features werden durch einbinden der Aspektbibliothek zugänglichAspektklassen werden durch den Weber mit Zielklassen verwobenVerwebungspunkte werden durch Attribute beschriebenVerwebung kann dynamisch oder statisch erfolgen


Potsdam

Beispiele

IISingleton,Persistenz,verteiltes Mandelbrot


Potsdam

Beispiel Singleton

Mehrere Instanzen sollen gemeinsam eine Instanz eines Stacks verwendenDie Implementierung des Singleton-Patterns soll durch einen Aspekt erfolgen


Potsdam

Lösungpublic class SingletonAspect:Aspect{

private static WeakReference theObject;

[Create(Invoke.Instead)]public object Create(Type type){

object retval=null;if(theObject!=null) retval=theObject.Target;if(retval==null){

retval=Context.Invoke();theObject=new WeakReference(retval);

}return retval;

}}


Potsdam

Beispiel Persistenz

Der Singleton-Aspekt soll so erweitert werden, dass der Objektzustand persistent auf die Festplatte geschrieben wird


Potsdam

Lösung (cont.)[Include("Finalize")][Call(Invoke.Instead)]public void Serialize(){

FileStream fs=new FileStream("ser.dat",FileMode.Create);BinaryFormatter formatter = new BinaryFormatter();foreach(FieldInfo fi in Context.DeclaringType.GetFields( BindingFlags.Instance|BindingFlags.Public|BindingFlags.NonPublic))

{if(!fi.IsNotSerialized){

formatter.Serialize(fs,fi.GetValue(Context.Instance));}

}fs.Close();Context.Invoke();

}


Potsdam

Lösung[Create(Invoke.Instead)]public object Create(Type type){

...theObject=new WeakReference(retval);try{FileStream fs=new FileStream("ser.dat",FileMode.Open);BinaryFormatter formatter = new BinaryFormatter();foreach(FieldInfo fi in

Context.DeclaringType.GetFields(BindingFlags)){if(!fi.IsNotSerialized){

fi.SetValue(retval, formatter.Deserialize(fs));}

}} catch(FileNotFoundException) { }

...


Potsdam

Eine verteilte Mandelbrot-Berechnung

AOP wird benutztUm Verteilung von Daten und Berechnung zukontrollierenBenutzung des Hauptspeichers zu optimieren

Beide Aspekte haben konträre ZieleTradoffs und eingesetzte Umgebung sind erst zurLaufzeit bekannt

CX

CY

Speicher Fesrplatte

Calculate(...)


Potsdam

Mandelbrot Interfaceinterface IMandelbrot{

string Filename { get; }void Calculate(

double x1, double y1, double x2, double y2,int xRes, int yRes);

}


Potsdam

Mandelbrot: Der Speicher-Aspekt

CX

Festplatte

Speicher1

Speicher1

Speicher1

...

Calculate(...)

Calculate(...)

Calculate(...)

Calculate(...)1st

2nd

CYth

Idee:Zerlegung der Berechnung in ZeilenZeilen werden sukzessive berechnet und auf die Festplatte geschrieben Zum Schluss werden alle Dateien zusammengefügtAnstatt der gesamten Matrix wird nur der Speicher für eine Zeile benötigt


Potsdam

Lösung[Call(Invoke.Instead)]public void Calculate(double x1, double y1, double x2, double y2, int

xRes, int yRes){

...// split up in linesdouble dStep=(y2-y1)/((double)yRes);

...for(int i=0;i<yRes;i++){

// call original functionContext.Invoke(new object[]{x1,y1,x2,y1,xRes,1});y1+=dStep;// join the files togetherUtil.Copy(fn,fsdst);

}...


Potsdam

Mandelbrot: Der Verteilungs-Aspekt

CX

CY1

Speicher

Calculate(...)

CPU1

Festplatte

CX

CY2

Speicher

Calculate(...)

CPU2

InvokeOn(Raptor)InvokeOn(Tomcat)

Idee:Verteilung der Berechnung auf mehrere Prozessoren (Threads)Ergebnisse werden wieder zusammengefasst


Potsdam

Lösung cont.[Include(typeof(Mandelbrot))][Create(Invoke.Instead)]public object CreateObject(Type type, string filename){

this.filename=filename;// get processor count from current system...instances=new Object[iInstances];while(iInstances--!=0){

instances[iInstances]=Context.Invoke(newobject[]{GetFilename(iInstances)});

}return Context.Invoke(new object[]{filename});

}


Potsdam

Lösung[Call(Invoke.Instead)]public void Calculate(double x1, double y1, double x2, double y2, int

xRes, int yRes) {...System.Threading.ThreadPool.QueueUserWorkItem(

new WaitCallback(Distribute.InvokeWorker),new WorkItem(this, ev, instances[iNum],x1, ny1,x2,y2, xRes,yRes-(nyRes*(instances.Length-1))) );

...}public static void InvokeWorker(object para) {// unpack parameters from workitem and start calculationWorkItem item=(WorkItem)para;item.context.InvokeOn(item.target, item.args);... }


Potsdam

PerformancemessungenOverhead durch Weben (Instantiierung)

Mit verschiedenen Aspekten und ohne AspektUnterschiedlich komplexe Aspekte

Overhead bei MethodenaufrufenFunktionsmix (12 Zuweisungen, 8 Kontrollflussanweisungen, vierMethodenaufrufe)Jeder vierte mit Aspekt verwobenVerwebung anstelle und vor Ausführung der MethodeVariable Parameteranzahl

Testumgebung:Dual Pentium III 256 MB RAM Windows 2000(MP)

Messungen mit einem Testprogramminsgesamt 500 DurchläufeMit High-Resolution-Counter

mit Aspekt

ohne Aspekt

Wiederholu

ng

*

Anzahl Methoden

Dau

er i n

s

*jeweils 15.21µs

Durchschnittliche Dauer der Instantiierung mit und ohne Aspekt

Zweiter Aufruf einer Methode

Berechnung bei Zeilenwert von 20480

kein AspektVerteilungSpeicher


Potsdam

Zusammenfassung

Rapier Loom.NET eignet sich zum verweben von virtuellen Methoden und InterfacesAspekte können zur Laufzeit ein- und ausgeschaltet werdenKeine spezielle Laufzeitumgebung oder Compiler notwendighttp://www.rapier-loom.net

Documents

apier-LOOM€¢Rapier Loom .NET verwebt die Zielklasse mit der Aspektklasse bei der Instanzierung •Anstelle des new-operators wird eine spezielle Factory-Methode verwendet. Wolfgang