DEV010
Programação Orientada a
Aspectos em .NET
Tiago Dias
[email protected]
Software Architect, BRISA
Patrocinadores
Agenda
I - Introdução à Programação Orientada a
Aspectos (AOP)
II - Ferramentas AOP para .NET
III - AOP multi-dimensional: MDSoC
O software está a ficar
confundido…
Porquê a confusão?
“Bolas, nós faríamos melhor...”
Sim, mas se o software não misturasse tantos
requisitos
Software com muitos requisitos
Use cases simples deixam de ter os
resultados esperados
Novas funcionalidades que deviam ser
transparentes afectam funcionalidades
existentes
As funcionalidades, os assuntos, não estão
a ser separados no código!!
Separation of Concerns (SoC)
Concerns – assuntos, correspondem a:
Requisitos – Funcionais e Não Funcionais (NFR)
É o objectivo de:
Programação orientada aos objectos (OOP)
Modularização
Encapsulamento
Arquitectura orientadas aos Serviços (SOA)
Vários design patterns
Mas não são suficientes...
A programação orientada a aspectos (AOP)
vair pegar onde estas abordagens ficaram
AOP – Exemplo
Código emaranhado
Código espalhado
Requisitos funcionais:
Alimentação
Descanso
Procriar
Ser fêmea ou macho
Animal
Mamífero
Requisitos não funcionais
Tigre
Foca
OOP
Logging
Segurança
Audit
Cross-cutting concerns
AOP – Exemplo (2)
Factorização em aspectos:
Alimentação
Animal
Descanso
Procriar
Mamífero
Ser fêmea ou macho
Tigre
Foca
Logging
Segurança
OOP
Audit
Anatomia de um aspecto
Logging
Advice
Pointcuts
Prociar
Tigre
Joint-points
Pointcuts
public class Logging
{
[AroundBody("Tigre::*()]")]
public static object Log(MethodJoinPoint jp)
{
Debug.WriteLine("...");
object result = jp.Proceed();
Debug.WriteLine("...");
return result;
}
}
Advice
public class Tigre : Mamifero
public class Procriar
{
Pointcut { [Insert("Tigre")]
public void Rosnar()
{
public void Cortejar(Tigre femea)
base.EmiteSom("Roaarrr");
{
}
if(this.Femea || !femea.Femea)
}
public void Estender()
{
foreach(ParteDoCorpo pc
in this.partesDoCorpo)
pc.Estender();
}
}
}
...
throw Exception("...");
Advice
Joint-points
Exemplo utilizando o
Como são aplicados os
aspectos?
Weaving:
Código OO + Aspectos => Código em execução
Tigre
Tigre
Quando e como é feito é o principal
diferenciador entre as ferramentas AOP
AOP - Finalidades/Cenários
Separation of Concerns (SoC)
Alterações dinâmicas sem parar software
de produção
Permitir testar componentes onde é díficil
utilizar Mocks
...
II - Ferramentas AOP para .NET
Mapa Mundo AOP
Tipificação das ferramentas
DEMO: AspectDNG
As soluções AOP e a Microsoft
Mapa AOP
AspectJ™
PROSE
Axon
JAsCo
Nanning
DynAOP JMangler
Steamloom EAOP
JAML CeaserJ
Jiazzi
JAC
Arachne
TinyC2 AspectC
AspectC++
FeatureC++
XWeaver
IBM
BEA
WebSphere JRockit
HyperProbes JVM
JBoss
(J2EE)
Java
Eclipse Products
SiteVision
Jakarta
Hivemind Spring
(J2EE)
C++
.NET
Phx.Morph
Wicca Rapier.NET
Aspect#
AspectDNG Loom.NET
Weave.NET Wool Meta.NET
JAsCo.NET
Eos Aspect.NET
Aspects
AspectS
PostSharp
Hyper/J
SetPoint CLAW
AOPHP
Compose*
Apostle
Poly
Hyper/Net
SourceWeave.NET
AspectCOOL
PHPaspect
DemeterJ
AopDotN AOP.NET
Pythius PEAK
etAddin
Encase
Composition
AspectScheme
AspectL
AOP-Engine
Filters
AspectCocoa
Concern
AspectR
Manipulation
Environment
Other
Itálico = patrocínio Microsoft (mas não são produtos)
Slide adaptado de apresentação sobre o Wicca
Tipificação das ferramentas
AOP
Modelo de compilação e execução .NET:
Compilação
Código
Fonte
Compilador
Execução
MSIL
Compilador JIT
Ad-hoc compiler:
Compilação
Código
Fonte
Compilador
MSIL
Aspectualizado
Aspectos
É a abordagem do AspectJ (Java)
NKalore
http://aspectsharpcomp.sourceforge.net/
Alteração do Mono C# Compiler
Código
Nativo
Ferramentas AOP (2)
Ad-hoc Virtual Machine
Execução
MSIL
Compilador JIT
Código
Nativo
Aspectualizado
Aspectos
Agora viabilizada através do MS Phoenix
Poderá ser a melhor de todas as abordagens:
Dinâmica
Performant
Transparente
Implementação mais próxima (funciona
apenas em modo Debug):
Ferramentas AOP (3)
Ad-hoc Virtual Machine
Utiliza o Microsoft Phoenix
E tem como objectivo
http://www1.cs.columbia.edu/~eaddy/wicc
a
testar AOP num projecto
de grande escala: MS Phoenix
Actua no compilador JIT por intermédio do:
Microsoft Debugger Edit&Continue (.NET 2.0)
Também permite outras abordagens (ex. IL
Instrumentation)
Suporta weaving baseado em atributos
Ferramentas AOP (4)
Source-to-source
Compilação
Código
Fonte
Weaver
Código fonte
Aspectualizado
Aspectos
O weaving ocorre na Pré-compilação
A única abordagem em que é possível ver o
código weaved
Paradigma AOP alargado: Multi-dimensional
Separation of Concers - MDSoC
Utiliza o NRefactory, um parser de C# e
VB.Net do SharpDevelop 2.0
Ferramentas AOP (5)
IL Instrumentation
MSIL
Weaver
MSIL
Aspectualizado
Aspectos
Suportam qualquer linguagem compilável
em MSIL
Permitem a aspectualização de software sem
o código fonte
Ferramentas AOP (6)
IL Instrumentation
DEMO
Compose*
http://aspectdng.sourceforge.net
http://composestar.sourceforge.net
Os pointcuts podem usar XPath
Paradigma AOP:
Filtros de composição
http://www.postsharp.org/
LAOS – Lightweight A. O. System
http://setpoint.codehaus.org/
Aspect.NET
http://www.academicresourcecenter.net/curriculu
m/pfv.aspx?ID=6595
Suporte parcial da MS Research
Integração no Visual Studio
Pointcuts semânticos
Suporte parcial da MS Research
Ferramentas AOP (7)
IL Instrumentation
http://dotspect.tigris.org/
http://www.dsg.cs.tcd.ie/dynamic/?category_id=-26
Utiliza o RAIL para processar MSIL
DotNetAOP
Gripper-LOOM.NET
http://www.gotdotnet.com/workspaces/workspace.a
spx?id=1b78f7c1-895f-49a7-8fa6-1565db16d41b
http://www.dcl.hpi.unipotsdam.de/research/loom/gripper_loom.htm
NAop / AOP.NET
http://sourceforge.net/projects/aopnet/
Ferramentas AOP (8)
Factory Based Proxying
Compilação
Código fonte
Aspectualizado
Compilador
Necessário utilizar proxies (não transparente)
Tipicamente limitadas a uma só linguagem
http://www.castleproject.org/
aspectsharp
http://www.springframework.net
NAspect
http://www.puzzleframework.com
http://s2container.net.seasar.org/en
/index.html
Frameworks
Rapier-LOOM.NET
http://www.dcl.hpi.unipotsdam.de/research/loom/rapier_loom.htm
http://www.typemock.com
Os objectos são estendidos com funcionalidades
necessárias para a testabilidade através de proxies.
AspectDNG
Adicionar logging a todos os métodos
de uma aplicação
As soluções AOP e a
Microsoft
Enterprise Library e AOP
A EntLib
Uma solução AOP sobre a EntLib
MS Research Phoenix
O que é o Phoenix?
Soluções AOP suportadas sobre o Phoenix
Enterprise Library
Framework de requisitos não funcionais
(NFR framework)
Cada tipo de requisito não funcional existe sob
a forma de um Application Block:
Configuração, Segurança, Tratamento de
Excepções, Caching, Acesso a Dados e Validação
Utiliza intensivamente design patterns:
Factory
Provider
Strategy
Façade
Enterprise Library:
Application Blocks = Aspectos?
Será possível considerar os Application
Blocks como aspectos pré-criados
preparados para weaving?
NÃO
Oferecem a sua funcionalidade através de Factories e
outros Design Patterns que não são tão transparentes
como os Aspectos
É sempre necessário alterar o funcionamento do código
onde se aplicam
Contudo
Têm objectivos comuns aos da AOP (tal como os
design patterns)
Enterprise Library: Caching
Código não operacional
// Get the CacheManager
CacheManager myCacheManager = CacheFactory.GetCacheManager();
// Save the settings to the Cache
myCacheManager.Add("SiteSettings", mySettings);
Factory Pattern
// Retrieve settings from the cache
SiteSettings cachedSettings =
(SiteSettings)myCacheManager.GetData("SiteSettings");
if (cachedSettings != null)
{
Console.WriteLine("Name = {0}", cachedSettings.Name);
Console.WriteLine("Url = {0}", cachedSettings.Url);
Console.WriteLine("Email Address = {0}", cachedSettings.EmailAddress);
Console.ReadLine();
}
Código operacional
Enterprise Library: Validation
public class Customer
{
[NotNullValidator]
[StringLengthValidator(1, 100)]
public string Name
{
get { return name; }
set { name = value; }
}
Attribute based
[NotNullValidator]
public string Email
{
get { return email; }
set { email = value; }
}
Façade Pattern
public string ValidateCustomer()
{
ValidationResults results = Validation.Validate(this);
string message = string.Empty;
if (!results.IsValid) ...
}
}
Enterprise Library: Exception
Handling
try
{
int i = 5;
int j = 0;
int z = i / j;
}
catch(Exception ex)
{
bool rethrow =
Similar to Aspect Advice declaration
ExceptionPolicy.HandleException(ex, "Business Layer Policy");
if (rethrow)
{
throw;
}
}
Uma solução AOP sobre a
EntLib
Solução de Olaf Conijn proposta no seu blog:
http://bloggingabout.net/blogs/olaf/
Baseada num CTP da EntLib 2.0
Não é compatível com a versão final da
framework .NET 2.0 (erros runtime)
Utiliza estratégia de Factory Based-Proxying
AOP com a EntLib: Exemplo
Criar um espremedor de sumo (juicer)
Espremer 10 unidades
O espremedor e o fruto a espremer são
definidos em configuração
static void Main(string[] args
{
string containerName = "MyContainer";
Obtém um container (config)
IServiceContainer container =
ContainerFactory.CreateServiceContainer(containerName);
IJuicer juicer =
(IJuicer)container.GetServiceInstance(typeof(IJuicer));
juicer.Juice(10);
Console.WriteLine(juicer.CollectedJuice);
}
Fabrica um juicer
AOP com a EntLib: Exemplo (2)
AOP com a EntLib: Exemplo (3)
public class GenericMethodTracerAdvice: IAdvice
{
public object Invoke(IMethodInvocation invocation)
{
string traceMessage = string.Format(
"type: {0} method: {1}; parameters: {2}",
invocation.MethodCall.MethodBase.DeclaringType.Name,
invocation.MethodCall.MethodName,
invocation.MethodCall.MethodSignature);
Debug.WriteLine(string.Format("BEFORE[{0}]", traceMessage));
object result = invocation.ProceedInvocation();
Debug.WriteLine(string.Format("AFTER[{0}]", traceMessage));
return result;
}
}


Invoca o método original.
Pode ser omitido, criando um Advice do tipo Instead of
Microsoft Phoenix
O Microsoft Phoenix será o backend de uma
futura geração de compiladores e ferramentas
de linguagens da Microsoft
Em desenvolvimento (Microsoft Research)
1.8M linhas de código – 318K à mão
Permite a manipulação de programas ao nível
de uma representação intermédia (IR), ex. IL
Oferece APIs para criação de plug-ins e
ferramentas para diversas fases da
compilação e runtime - extensão e criação:
De compiladores e compiladores JIT
De ferramentas que manipulam a AST (ex.
Intellisense) ou a IL
Microsoft Phoenix (2)
Viabiliza conjunto alargado de soluções AOP
Ad-hoc compiler
Plug-ins para o compilador que utilizam a AST para
aplicar advice ou criar joint points dinâmicos (hooks)
IL instrumentation
Semelhante ao anterior mas através de uma ferramenta
de pós-processamento (carrega DLLs)
Ad-hoc VM
Através da extensão do Compilador JIT
O compilador JIT passa a aplicar advice dinamicamente
Os pointcuts são avaliados em runtime
É possível alterar pointcuts e advice
A fase de weaving deixa de ser necessária
Microsoft Phoenix (3)
O Phoenix está já a ser utilizado (num
release RDK):
Aspect Mining – detecção de código clonado
Mais info: http://www.cis.uab.edu/tairasr/phoenix/
Para a manipulação do código intermédio
(MSIL):
Aspect.NET
SetPoint AOP
Meta.NET
Wicca
III - AOP multi-dimensional
MDSoC
MDSoC – Multi-dimensional separation of
concerns
DEMO – MDSoC com Partial Types
DEMO – Hyper/Net
MDSoC – Multi-Dimensional
Separation of Concerns
Transformação num hiper-espaço:
Audit
Alimentação
Logging
Descanso
Procriar
Ser fêmea ou macho
Animal
Segurança
Mamífero
Ontologia
Tigre
Foca
OOP
MDSoC – Multi-dimensional
separation of concerns (2)
Desenvolvida desde 1999 por Peri Tarr e Harold
Ossher
Implementação Java: Hyper/J
Pós-compilador - funciona de modo análogo à
abordagem IL Instrumentation em .NET
Algumas ferramentas de aspectos .NET têm
liberdade sintáctica para suportar MDSoC (ex.
AspectDNG)
Nós pensamos em MDSoC :
“The thoughts perfectly slot themselves into the
rows, columns, layers, hyper-rows, hyper-columns,
and hyper-layers of a vast matrix.” Steven Pinker
MDSoC c/ Partial Types
Ferramentas MDSoC
Hyper/J – Java
Hyper VB.Net
??
Hyper C#
Limitado a trabalhar com uma só classe numa
GUI específica 
Hyper/Net
(Beyond Partial Types)
Sumário
AOP
Tem várias vantagens práticas
Existem implementações aceitáveis para testes e
projectos não críticos (esses existem?)
É uma área em maturação
MDSoC
Todos devíamos usar através dos partial types do
.NET
Existe poucas ferramentas para ir além dos partial
types
É uma área cujo potencial completo está muito
pouco explorado
Recursos AOP e MDSoC
Aspect Oriented Software
Development
http://AOSD.net (Wiki)
A minha página pessoal
Artigo Hyper/Net
http://ptsoft.net/tdd/
[email protected]
Pergunte aos Especialistas
Obtenha Respostas às Suas Questões
Depois da apresentação:
Área de Desenvolvimento
Questionário de Avaliação
Passatempo!
Complete o questionário de
avaliação e devolva-o no balcão
da recepção.
Habilite-se a ganhar uma Xbox
360 por dia!
DEV010
Programação Orientada a Aspectos
em .NET
© 2007 Microsoft Corporation. All rights reserved.
This presentation is for informational purposes only. Microsoft makes no warranties, express or implied, in this summary.