C#4 - Parte 1 - Dinamismo E Argumentos opcionais e nomeados

ASP.NET MVC – C#4 – Dinamismo
e argumentos opcionais e
nomeados

Giovanni Bassi
giggio@giggio.net
blog: http://unplugged.giggio.net

Online @

Email: giggio@giggio.net
Blog técnico: http://unplugged.giggio.net
Site: http://giovannibassi.com

.Net Architects:
Grupo: http://dotnetarchitects.net
Online: http://tinyurl.com/DotNetArch

Evento

Palestras:
Programando com prazer com Domain Driven Design (DDD)
Utilizando Injeção de dependência com Unity (Enterprise Library)
ASP.Net MVC: tome seu HTML de volta
ORM - Sendo preguiçoso com Nhibernate
Testes: garantindo que seu código faz o que você quer

Data: 27/Junho
Local: Unip Tatuapé - São Paulo/SP
Valor: R$ 50

http://dotnetarchitects.net/dnad2009

Agenda

Evolução do Argumentos
Ferramental
C# opcionais

Demo e 1ª
C# Argumentos
parada para
Dinâmico nomeados
perguntas

2ª parada
Recursos e
Demo para
Links úteis
perguntas

Ferramental

• C# 4.0 (Visual C# 2010) está presente no Visual Studio
2010 Beta 1 lançado em Maio

• Download do Beta tem apenas 1.3 GB, disponível em:
– http://tinyurl.com/vs10b1

• Também no VS10:
– VB X
– F#
– DLR (suporte para IronRuby, IronPython, etc...)

Evolução C#

C#4
C#3 • Facilidade
de uso
• LINQ
C#2
• Generics

C#1
• Versão
inicial

C# e VB

• Lado a Lado com VB

• Sem separação de perfil de desenvolvedor
(Mas não espere XML Literals no C# )

4 novidades

• Construções dinâmicas

• Argumentos opcionais e argumentos nomeados

• Variância para tipos genéricos

• Melhorias na interoperabilidade com o COM

Esclarecendo

• Argumentos opcionais
– Permite omitir argumentos na chamada de uma função,
usando valores padrão

• Argumentos nomeados
– Permite dizer os nomes dos argumentos em uma chamada
de função

• Igualzinho há no VB.Net desde o .Net 1.0 e VB 7 (2002)

Argumentos

• Argumentos opcionais
VB (criando o método):
Public Class Elevador
Public Sub Subir(Optional ByVal andares As Integer = 1,_
Optional ByVal velocidade As Integer = 1)
End Sub
End Class

Argumentos

• Chamada: como era antes?
var elevador = new Elevador();
elevador.Subir(1,1); //Obrigatório informar

Argumentos

• Chamada: como é agora?
var elevador = new Elevador();
elevador.Subir();

Argumentos

• Declaração: como era antes?
public class ElevadorCS
{
public void Subir()
{
this.Subir(1, 1);
}
public void Subir(int andares)
{
this.Subir(andares, 1);
}
public void Subir(int andares, int velocidade)
{
}
}

Argumentos

• Declaração: como é agora?
public class ElevadorCS
{
public void Subir(int andares = 1,
int velocidade = 1)
{
}
}

Argumentos

• Vantagens
– Mais claro
– Mais explícito
– Mais simples

• Desvantagens
– Se mal usado pode incentivar métodos com parâmetros
demais

Argumentos

• Regras
– Parâmetros opcionais são os últimos do método
int velocidade)
{}

Argumentos

• Regras
– Parâmetros opcionais são os últimos do método
int velocidade)
{}

– Somente constantes
public void Subir(int andares,
int velocidade = ObterVelocidade())
{}

Argumentos

• Como era antes?

var elevador2 = new ElevadorCS();
elevador2.Subir(2, 3);

Argumentos

• Como é agora?

var elevador2 = new ElevadorCS();
elevador2.Subir();
elevador2.Subir(velocidade: 2);
elevador2.Subir(velocidade: 2, andares: 3);

Argumentos

• Regras
– Você pode nomear qualquer argumento, seja ele opcional
ou não
– Argumentos nomeados podem ser chamados em qualquer
ordem
– As chamadas são feitas na ordem em que são declaradas
do chamador, e não na função
public void Subir(
int andares = 1,
int velocidade = 1) {}
elevador2.Subir(
Primeiro velocidade: this.ObterVelocidade(),

Segundo andares: this.ObterAndares()
);

Demo

Demo

Argumentos opcionais e
nomeados

C# Dinâmico

• Motivação

– Hype das linguagens dinâmicas

– Produtividade

– Testes

– Interoperabilidade

C# Dinâmico

• Entendendo a infra

– Dynamic Language Runtime (DLR) agora é parte da BCL

– Microsoft.CSharp é obrigatória para trabalhar com dynamic

– Somente no .Net 4.0

C# Dinâmico

• Entendendo o dynamic

– Tipos são “estáticamente tipados como dinâmicos”

– Tipos dinâmicos são System.Object’s

– Tipos dinâmicos se propagam nas chamadas

– Tipos dinâmicos não possuem checagem em tempo de
compilação ou Intelisense

C# Dinâmico

• Exemplos
dynamic d;
dynamic d = 3;
object o = 3;
d.QualquerCoisa(3);
Console.Writeline(d[10]);
d.Propriedade1 = d.Propriedade2;
d += 1;
var a = d + Datetime.Now();
d(quot;algum parâmetroquot;, 3);

C# Dinâmico

• Mais Exemplos
var d2 = d.AlgumValor();
var d3 = ObterVariavelDinamica();

Dispatch

• Entendendo o Static Dispatch

– É o comum até o C# 3.0

– Ligação forte com o método sendo chamado

– Sem perda de performance

Demo

Demo

Static Dispatch no Reflector

Dispatch

• Entendendo o Dynamic Dispatch

– A resolução do método é feita em tempo de execução

– Se for uma chamada sobre um tipo dinâmico (dynamic
receiver), a chamada é dinâmica (ligada em runtime)

– Se for uma chamada sobre um tipo e método estáticos
(static receiver), mas houver um parâmetro dinâmico,
também é uma chamada dinâmica (ligada em runtime)

Dispatch

• Como o DLR encontra o método

– Verifica o cache de chamadas, se houver, utiliza

– Se o objeto for um IDynamicMetaObjectProvider, utiliza
sua implementação

– Se não for, utiliza o Binder do C#, no caso, com Reflection

– Se não achar: RuntimeBinderException

Dispatch

• Resolução de sobrecargas (overloads)

– Mesma regra: se a chamada do método for dinâmica, o
overload é avaliados somente em runtime

– O DLR busca uma assinatura idêntica no cache

– Se houver ele usa, senão ele busca uma converter os
parâmetros, e achando, guarda no cache

– Se não achar: RuntimeBinderException

Demo

Demo

Dinamic Dispatch no Reflector

Dispatch

• Exemplo:

public class Conversor
{
public void Converter(string x) { }
public void Converter(decimal x) { }
}

public class SuperConversor : Conversor
{
public void Converter(int x) { }
}

Dispatch

• Qual sobrecarga é chamada em cada caso?

Conversor c1 = new SuperConversor();
int i = 10;
c1.Converter(i);

Conversor c2 = new SuperConversor();
dynamic d1 = 10;
c2.Converter(d1);

Regra base 1

A idéia é replicar o comportamento estático,
como se as chamadas não fossem
dinâmicas

Não funciona

• Métodos de extensão

• LINQ (depende de métodos de extensão)

Regra base 2

Dynamic é um Object. Cuidado com Boxing
e Unboxing.
dynamic d = new AlgumaClasse();
d.s = default(S); S é uma struct
d.s.i = 6; i é um campo inteiro da struct

Demo

Demo

C# Dinâmico

http://msdn.microsoft.com/en-us/vcsharp/dd819407.aspx (C# 4
Resources)

http://blogs.msdn.com/ericlippert/ (Eric Lippert - Microsoft)

http://blogs.msdn.com/samng/archive/tags/Runtime+binding/default
.aspx (Sam NG - Microsoft)

http://unplugged.giggio.net/unplugged/?tag=/c%234 (Giovanni Bassi
- MVP)

http://renatoguimaraes.spaces.live.com (Renato Guimarães – MVP)

Obrigado

Giovanni Bassi
giggio@giggio.net
blog: http://unplugged.giggio.net

C#4 - Parte 1 - Dinamismo E Argumentos opcionais e nomeados

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a C#4 - Parte 1 - Dinamismo E Argumentos opcionais e nomeados

Semelhante a C#4 - Parte 1 - Dinamismo E Argumentos opcionais e nomeados (20)

Mais de Giovanni Bassi

Mais de Giovanni Bassi (20)

C#4 - Parte 1 - Dinamismo E Argumentos opcionais e nomeados