O documento resume as principais novidades do C# 4.0, incluindo argumentos opcionais e nomeados, tipos dinâmicos com o DLR, e melhorias na interoperabilidade com COM, como a remoção do uso obrigatório de ref. A variância para tipos genéricos também é introduzida, permitindo conversões entre tipos genéricos e específicos de forma covariante e contravariante.

1. C#4 – O que há de novo Giovanni Bassigiggio@giggio.net http://giovannibassi.comhttp://unplugged.giggio.net

3. Microsoft MVP

4. Consultoria, gestão, mentoring

5. Treinamento

6. C#, VB, J#, F#, IronRuby, etc... (Beta a beta)

7. Dezenas de artigos na .Net Magazine

8. Editor técnico da .Net Magazine

9. Palestrante

10. Professor universitário

11. Líder e fundador do .Net Architects (1º grupo de arquitetura de software com .Net do Brasil)

13. Cerca de sete mil mensagens desde sua criação

14. Em torno de mil mensagens por mês

15. Cerca de 350 membros online

16. 11 reuniões presenciais até agora

17. Revista a caminho

18. Podcast recentemente liberado

19. Efetivamente um dos maiores e mais ativos grupos do país

20. 100 pessoas presentes no último (e primeiro) evento

22. Blog técnico: http://unplugged.giggio.net

23. Site: http://giovannibassi.com

24. Twitter: @giovannibassi

25. .Net Architects: Grupo: http://dotnetarchitects.net Podcast: http://podcast.dotnetarchitects.net Online: http://tinyurl.com/DotNetArch Twitter: #DotNetArchitects Online @

26. Agenda

27. Ferramental eEvolução

28. 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...)

29. Evolução do C#

30. C# e VB Lado a Lado com VB Sem separação de perfil de desenvolvedor (Mas não espere XML Literals no C# )

31. Quatro Grandes Novidades Construções dinâmicas Argumentos opcionais e argumentos nomeados Variância para tipos genéricos Melhorias na interoperabilidade com o COM

32. Argumentos opcionais

33. 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)

34. VB (criando o método): PublicClass Elevador PublicSub Subir( _ OptionalByVal andares AsInteger = 1, _ OptionalByVal velocidade AsInteger = 1) EndSub EndClass

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

36. Chamada: como é agora? var elevador = newElevador(); elevador.Subir();

37. Declaração: como era antes? publicclassElevadorCS { publicvoid Subir() { this.Subir(1, 1); } publicvoid Subir(int andares) { this.Subir(andares, 1); } publicvoid Subir(int andares, int velocidade) { } }

38. Declaração: como é agora? publicclassElevadorCS { publicvoid Subir(int andares = 1, int velocidade = 1) { } }

39. Vantagens e desvantagens Vantagens Mais claro Mais explícito Mais simples Desvantagens Se mal usado pode incentivar métodos com parâmetros demais

41. Argumentos nomeados

42. Como era antes? var elevador2 = newElevadorCS(); elevador2.Subir(2, 3);

43. Como é agora? var elevador2 = newElevadorCS(); elevador2.Subir(); elevador2.Subir(velocidade: 2); elevador2.Subir(velocidade: 2,andares: 3);

44. 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 publicvoid Subir( int andares = 1, int velocidade = 1) {} elevador2.Subir( velocidade: this.ObterVelocidade(), andares: this.ObterAndares() ); Primeiro Segundo

45. Argumentos opcionais e nomeados

46. C# dinâmico

47. Motivação Motivação Hype das linguagens dinâmicas Produtividade Testes Interoperabilidade Extensibilidade

48. Exemplo Teste com Cucumber e RSpec (IronRuby): Feature: Search courses In order to ensure better utilization of courses Potential students should be able to search for courses Scenario: Search by topic Given there are 240 courses which do not have the topic "biology" And there are 3 courses A,B,C that each have "biology" as one of the topics When I search for "biology" Then I should see the following courses: | title | | A | | B | | C |

49. Entendendo a infra DynamicLanguage Runtime (DLR) agora é parte da BCL Microsoft.CSharp é obrigatória para trabalhar com dynamic Somente no .Net 4.0

50. Entendendo o dynamic Tipos são “estáticamentetipados 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

51. Exemplos dynamic d; dynamic d1 = 3; d1 = DateTime.Now; d.QualquerCoisa(3); Console.Writeline(d[10]); d.Propriedade1 = d.Propriedade2; d += 1; var a = d + Datetime.Now(); d("algumparâmetro", 3); var d2 = d.AlgumValor(); var d3 = ObterVariavelDinamica();

52. Entendendo o StaticDispatch É o comum até o C# 3.0 Ligação forte com o método sendo chamado Sem perda de performance

53. Entendendo o DynamicDispatch A resolução do método é feita em tempo de execução Se for uma chamada sobre um tipo dinâmico (dynamicreceiver), a chamada é dinâmica (ligada em runtime) Se for uma chamada sobre um tipo e método estáticos (staticreceiver), mas houver um parâmetro dinâmico, também é uma chamada dinâmica (ligada em runtime)

54. Cuidado O que acontece aqui? staticintFuncao(int z) { return 1; } staticvoid Main() { dynamic x = 3; DateTime y = Funcao(x); }

55. DynamicDispath != Virtual Dispath Só pra constar, porque não vai dar tempo de explicar Vejam uma discussão no .Net Architects: http://tinyurl.com/virtualdispatch

56. 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

57. 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

58. Static e DinamicDispatch no Reflector

59. Exemplo publicclassConversor { publicvoid Converter(string x) { } publicvoid Converter(decimal x) { } } publicclassSuperConversor : Conversor { publicvoid Converter(int x) { } }

61. Resposta publicclassConversor { publicvoid Converter(string x) { } publicvoid Converter(decimal x) { } } publicclassSuperConversor : Conversor { publicvoid Converter(int x) { } }

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

63. Regra 2 Dynamic é um Object. Cuidado com Boxing e Unboxing. dynamic d = new AlgumaClasse(); d.s = default(S); d.s.i = 6; S é uma struct i é um campo inteiro da struct Valendo mil reais… Qual o valor de i?

64. Não funcionam Métodos de extensão LINQ (depende de métodos de extensão)

65. C# dinâmico

66. COM Interop

67. Novidades Não precisamos mais da palavra-chave ref(o compilador coloca sozinho) Não precisamos de cast de tipos de valor para object Com o suporte de parâmetros opcionais e nomeados, passamos só o necessário Igualzinho ao que há no VB.Net desde o .Net 1.0 e VB 7 (2002) Temos ainda opção de mesclar o assembly de interop

68. Como era antes? ApplicationClassWordApp = newApplicationClass(); WordApp.Visible = true; objectmissing = System.Reflection.Missing.Value; objectreadOnly = false; objectfileName = "Documento.docx"; Word.Documentdoc = WordApp.Documents.Open( reffileName, refmissing, refreadOnly, refmissing, refmissing, refmissing, refmissing, refmissing, refmissing, refmissing, refmissing, refmissing, refmissing, refmissing, refmissing);

69. Como é no VB? DimWordApp = New Word.ApplicationClass() WordApp.Visible = True DimfileName = "Documento.docx" DimdocAsDocument = _ WordApp.Documents.Open( _ fileName:=fileName, ReadOnly:=True)

70. Como é agora? varWordApp = newApplicationClass(); WordApp.Visible = true; stringfileName = "Documento.docx"; vardoc = WordApp.Documents.Open( fileName, ReadOnly:false);

71. VB e C# lado a lado: varWordApp = newApplicationClass(); WordApp.Visible = true; stringfileName = "Documento.docx"; vardoc = WordApp.Documents.Open( fileName, ReadOnly:false); C# DimWordApp = New Word.ApplicationClass() WordApp.Visible = True DimfileName = "Documento.docx" DimdocAsDocument = _ WordApp.Documents.Open( _ fileName:=fileName, ReadOnly:=True) VB

72. O que é compilado: ApplicationWordApp = (Application) Activator.CreateInstance( Type.GetTypeFromCLSID(newGuid("000209FF-0000-0000-C000-000000000046"))); WordApp.Visible = true; stringfileName = "Documento.docx"; object <>r__ComRefCallLocal0 = fileName; object <>r__ComRefCallLocal1 = false; object <>r__ComRefCallLocal2 = Type.Missing; object <>r__ComRefCallLocal3 = Type.Missing; object <>r__ComRefCallLocal4 = Type.Missing; object <>r__ComRefCallLocal5 = Type.Missing; object <>r__ComRefCallLocal6 = Type.Missing; object <>r__ComRefCallLocal7 = Type.Missing; object <>r__ComRefCallLocal8 = Type.Missing; object <>r__ComRefCallLocal9 = Type.Missing; object <>r__ComRefCallLocala = Type.Missing; object <>r__ComRefCallLocalb = Type.Missing; object <>r__ComRefCallLocalc = Type.Missing; object <>r__ComRefCallLocald = Type.Missing; object <>r__ComRefCallLocale = Type.Missing; object <>r__ComRefCallLocalf = Type.Missing; objectaDoc = WordApp.Documents.Open( ref <>r__ComRefCallLocal0, ref <>r__ComRefCallLocal2, ref <>r__ComRefCallLocal1, ref <>r__ComRefCallLocal3, ref <>r__ComRefCallLocal4, ref <>r__ComRefCallLocal5, ref <>r__ComRefCallLocal6, ref <>r__ComRefCallLocal7, ref <>r__ComRefCallLocal8, ref <>r__ComRefCallLocal9, ref <>r__ComRefCallLocala, ref <>r__ComRefCallLocalb, ref <>r__ComRefCallLocalc, ref <>r__ComRefCallLocald, ref <>r__ComRefCallLocale, ref <>r__ComRefCallLocalf);

73. Mesclando o assembly de interop

74. Com interop

75. Variância

76. Variância O que é variância? Define como ocorrem as conversões entre tipos Covariância Permite conversões do mais específico para o mais genérico Contravariância Permite conversões do mais genérico para o mais específico Invariância Permite conversões apenas para o mesmo tipo

77. Conversões Contravariância Covariância A flecha indica a conversão

78. Já temos covariância no C# 3 Em arrays: string[] textos = {}; object[] objetos = textos; De métodos para delegates (no retorno): staticstringRetornaString() {} Func<object> func = RetornaString;

79. Já temos contravariância no C# 3 De métodos para delegates (nos parâmetros): staticvoidRecebeUmObjeto(objectobj) { } Action<string> func3 = RecebeUmObjeto;

80. Mas não há variância entre tipos genéricos no C# 3 IList<string> textos = newList<string>(); IList<object> objetos = textos; Não compila no C# 3.0 Porque... Um botão não é uma string objetos.Add(newButton());

81. Direção do dado Classe de genérico para específico Contravariante de específico para genérico Covariante Dado in out

82. Agora: Variância para tipos e delegates genéricos Covariante: publicinterfaceIEnumerable <out T> : IEnumerable { IEnumerator<T> GetEnumerator(); } Se consigoenumerarmamíferos, consigoenumeraranimais

83. Agora: Variância para tipos e delegates genéricos Exemplo de uso (covariante): IEnumerable<string> textos = ObterEnumerador(); IEnumerable<object> objetos = textos;

84. Agora: Variância para tipos e delegates genéricos Contravariante: publicinterfaceIComparer<in T> { int Compare(T x, T y); } Se consigocompararanimais, consigocompararmamíferos

85. Agora: Variância para tipos e delegates genéricos Exemplo de uso (contravariante): IComparer<object> comparadorObjetos; IComparer<string> comparadorStrings = comparadorObjetos;

86. Agora: Variância para tipos e delegates genéricos Covariante e Contravariante: publicdelegate TResultFunc<in T1, in T2, outTResult> (T1 arg1, T2 arg2);

87. Agora: Variância para tipos e delegates genéricos Exemplo de uso (covariante e contravariante):

88. Agora: Variância para tipos e delegates genéricos Exemplo de uso (contravariante): Func<Animal, Macaco> ConverteParaMacaco = animal => { varmacaco = animal asMacaco; if (macaco != null) returnmacaco; returnnull; }; Func<Mamifero, Mamifero> PassaUmMamiferoERetornaUmMamifero = ConverteParaMacaco;

89. Limitações Só tipos de referência (structs e tipos primitivos não são permitidos) Parâmetros out e ref são sempre invariantes Todos esses são inválidos: publicdelegatevoidAlgumDelegate<in T>(ref T valor);publicdelegatevoidAlgumDelegate<out T>(ref T valor); publicdelegatevoidAlgumDelegate<in T>(out T valor); publicdelegatevoidAlgumDelegate<out T>(out T valor);

90. variância

91. Recursos e links úteis (1) http://tinyurl.com/wccs1 (Webcast MSDN - C# 4 – Parte 1) http://tinyurl.com/wccs2 (Webcast MSDN - C# 4 – Parte 2) http://unplugged.giggio.net/?tag=/c%234 (Giovanni Bassi – MVP) http://renatoguimaraes.spaces.live.com (RenatoGuimarães – MVP)

92. Recursos e links úteis (2) http://msdn.microsoft.com/en-us/vcsharp/dd819407.aspx (C# 4 Resources) http://blogs.msdn.com/ericlippert/ (Eric Lippert - Microsoft) http://blog.fujiy.net/blog/category/Covariancia-e-Contravariancia.aspx (Série do Eric Lippert sobre covariância traduzida pelo Felipe Fujiy) http://blogs.msdn.com/samng/archive/tags/Runtime+binding/default.aspx (Sam NG - Microsoft)

93. Revista

94. Dúvidas ?

95. Obrigado! 

97. Blog técnico: http://unplugged.giggio.net

98. Site: http://giovannibassi.com

99. Twitter: @giovannibassi

100. .Net Architects: Grupo: http://dotnetarchitects.net Podcast: http://podcast.dotnetarchitects.net Online: http://tinyurl.com/DotNetArch Twitter: #DotNetArchitects Online @