As Novidades Do C#

Paulo Morgado

• A Evolução ao C#• Covariância e Contravariância• Argumentos com Nome e Opcionais• Programação Dinâmica• Melhoramentos na

Interoperabilidade com COM

Agenda

A Evolução do C#

C# 1.0Managed

C# 2.0Genericos

C# 3.0LINQ

A Evolução do C#

Tendências

Declarativa

ConcorrenteDinâmica

Dinâmico vs. Estático

Linguagens Dinâmicas

Simplicidade e concisão

Implicitamente tipadas

Meta-programação

Sem compilação

Linguagens Estáticas

Robustez

PerformanceFerramentas inteligentes

Melhor escalabilidade

VB

C#C# VB

Co-Evolução• Argumentos

com nome• Argumentos

opcionais• Propriedades

indexadas (COM)

• Instrucções Lambda

• Propriedades auto-implementadas

• Inicializadores de colecções

C# 1.0Managed

C# 2.0Genericos

C# 3.0LINQ

C# 4.0Programação Dinâmica

A Evolução do C#

• A evolução do C#• http://paulomorgado.net/

pt/blog/archive/2010/04/12/a-evolu-231-227-o-do-c.aspx

Recursos

Covariância e Contravariância

Em álgebra multilinear, covariância e contravariância descrevem como a descrição quantitativa de certas entidades geométricas ou físicas variam quando passam de um sistema de coordenadas para outro.

Wikipedia

Covariância e Contravariância

O tipo T é maior (>) que o tipo S se S é um subtipo (deriva) de T

Covariância e Contravariância

T ≥ Stypeof(T).IsAssignableFrom(typeof(S))

• Dados 2 tipos Base e Derivado, em que:• Existe uma conversão por referência (ou identidade) entre

Base e Derivado• Base ≥ Derived

• Uma definição de tipo genérico Genérico<T> é:• Covariante em T

• Se Genérico<Base> ≥ Genérico<Derivado>

• Contravariante em T• Se Genérico<Base> ≤ Genérico<Derivado>

• Invariante em T• Se nenhuma das regras anteriores se aplica

Covariância e Contravariância

Contravariante em Ttypeof(Base).IsAssignableFrom(typeof(Derivado))

typeof(G<Derivado>).IsAssignableFrom(typeof(G<Base>))

Covariante em Ttypeof(Base).IsAssignableFrom(typeof(Derivado))

typeof(G<Base>).IsAssignableFrom(typeof(G<Derivado>))

Covariância e Contravariância

Covariância e Contravariância

string[] strings = GetStringArray();Process(strings);

void Process(object[] objects){ objects[0] = "Hello"; // Ok objects[1] = new Button(); // Exception!}

Em C# (.NET), os arrays são covariantes

…mas não são covariantes seguros

void Process(object[] objects) { … }

Covariância e Contravariância

List<string> strings = GetStringList();Process(strings);

Até agora, no C# (.NET), os genéricos têm

sido invariantes

void Process(IEnumerable<object> objects){ // IEnumerable<T> é apenas de leitura // portanto é covariante seguro}

O C# 4.0 suporta

covariância e contravariância

segura

void Process(IEnumerable<object> objects) { … }

Covariância Segura

public interface IEnumerable<T>{ IEnumerator<T> GetEnumerator();}

public interface IEnumerator<T>{ T Current { get; } bool MoveNext();}

public interface IEnumerable<out T>{ IEnumerator<T> GetEnumerator();}public interface IEnumerator<out T>{ T Current { get; } bool MoveNext();}

out = covarianteapenas em posições de

saída

IEnumerable<string> strings = GetStrings();IEnumerable<object> objects = strings;

Pode ser tratado comomenos derivado

Contravariância Segura

public interface IComparer<T>{ int Compare(T x, T y);}

public interface IComparer<in T>{ int Compare(T x, T y);} IComparer<object> objComp =

GetComparer();IComparer<string> strComp = objComp;

in = contravarianteapenas em posições de

entrada

Pode ser tratado como mais derivado

• Suportada apenas para interfaces genéricas e delegates genéricos.

• Verificada/forçada estáticamente a partir da definição.• Tipos valor são sempre invariantes

• Um IEnumerable<int> não é um IEnumerable<object>• A regra para arrays é similar

• Parâmetros ref e out necessitam tipos parâmetros invariantes

Variância em C# 4.0

Interfaces

• System.Collections.Generic.IEnumerable<out T>• System.Collections.Generic.IEnumerator<out T>• System.Linq.IQueryable<out T>• System.Collections.Generic.IComparer<in T>• System.Collections.Generic.IEqualityComparer<in T>• System.IComparable<in T>

Delegates

• System.Func<in T, …, out R>• System.Action<in T, …>• System.Predicate<in T>• System.Comparison<in T>• System.EventHandler<in T>

Variância em .NET 4.0

• Covariância E Contravariância Em Genéricos• http://paulomorgado.net/pt/blog/archive/2010/04/13/c-4-0-covari-226-ncia-e-contravari-

226-ncia-em-gen-233-ricos.aspx

• Covariância E Contravariância Em Genéricos – Simplificado• http://paulomorgado.net/pt/blog

/archive/2010/04/15/c-4-0-covari-226-ncia-e-contravari-226-ncia-em-gen-233-ricos-simplificado.aspx

• Covarince and Contravariance in Generics• http://msdn.microsoft.com/library/dd799517(VS.100).aspx

• Exact rules for variance validity• http://blogs.msdn.com/ericlippert/archive/2009/12/03/exact-rules-for-variância-validity.aspx

• Events get a little overhaul in C# 4, Afterward: Effective Events• http://

blogs.msdn.com/cburrows/archive/2010/03/30/events-get-a-little-overhaul-in-c-4-afterward-effective-events.aspx

Recursos

Argumentos com Nome e Opcionais

Argumentos com Nome e Opcionais

Greeting("Mr.", "Morgado", 42);

public void Greeting(string title, string name, int age)

Argumentos

Parâmetros

Têm sempre nome

Nunca são opcionais

Argumentos com Nome

int i = 0;Method(i, third: i++, second: ++i);

public void Method(int first, int second, int third)

int i = 0;int CS$0$0000 = i++;int CS$0$0001 = ++i;Method(i, CS$0$0001, CS$0$0000);

Argumentos Opcionais

int i = 0;Method(i, third: ++i);

public void Method(int first, int second = 2, int third = 3) public void Method(int first, int second = 5, int third = 6)

public void Method(int first)

int i = 0;int CS$0$0000 = ++i;Method(i, 2, CS$0$0000);

public void Method(int first, int second)

Parecem sobreposições (overloads)

Mas não

são!

• Classes de Argumentos

Argumentos Opcionais - Alternativa

XmlReaderSettings settings = new XmlReaderSettings();settings.ValidationType = ValidationType.Auto;XmlReader.Create("file.xml", settings);

XmlReader.Create( "file.xml", new XmlReaderSettings { ValidationType = ValidationType.Auto });

XmlReader.Create( "file.xml", new { ValidationType = ValidationType.Auto }); Ainda

não!

• Argumentos Com Nome E Opcionais• http://paulomorgado.net/pt/blog/archive/2010/04/16/c-4-0-argumentos-com

-nome-e-opcionais.aspx

• Alternativa Aos Argumentos Opcionais• http://paulomorgado.net/pt/blog/archive/2010/04/18/c-4-0-alternativa-aos-a

rgumentos-opcionais.aspx

• Named and Optional Arguments (C# Programming Guide)• http://msdn.microsoft.com/library/dd264739(VS.100).aspx

Recursos

Programação Dinâmica

Dynamic Language Runtime

PythonBinder

RubyBinder

COMBinder

JavaScript

Binder

ObjectBinder

Dynamic Language RuntimeExpression Trees

Dynamic Dispatch

Call Site Caching

IronPython

IronRuby C# VB.NET Others…

Objectos Tipados Dinâmicamente

Calculator calculator = GetCalculator();int sum = calc.Add(10, 20);object calculator = GetCalculator();

Type calculatorType = calculator.GetType();object res = calculatorType.InvokeMember("Add", BindingFlags.InvokeMethod, null, calculator, new object[] { 10, 20 });int sum = Convert.ToInt32(res);

ScriptObject calculator = GetCalculator();object res = calculator.Invoke("Add", 10, 20);int sum = Convert.ToInt32(res);

dynamic calc = GetCalculator();int sum = calc.Add(10, 20);

Estaticamente tipado para ser

dinâmico

Invocação de método

dinâmica

Conversão dinâmica

Objectos Tipados Dinâmicamente

dynamic x = 1;dynamic y = "Hello";dynamic z = new List<int> { 1, 2, 3 };

dynamic em tempo de

compilação

System.Int32 em tempo de

execução

Quando os operandos são dynamic:• A selecção do membro é diferida para tempo de execução• Em tempo de execução, os tipos reais são substituídos por dynamic• O resultado estático da operação é dynamic

Objectos Tipados Dinâmicamente

public static class Math{ public static decimal Abs(decimal value); public static double Abs(double value); public static float Abs(float value); public static int Abs(int value); public static long Abs(long value); public static sbyte Abs(sbyte value); public static short Abs(short value); ...}

double x = 1.75;double y = Math.Abs(x);

dynamic x = 1.75;dynamic y = Math.Abs(x);

Método seleccionado em tempo de compilação:

double Abs(double x)

Método seleccionado em

tempo de execução:double

Abs(double x)

dynamic x = 2;dynamic y = Math.Abs(x);

Método seleccionado em

tempo de execução:

int Abs(int x)

• IDynamicMetaObjectProvider• Representa um objecto dinâmico que pode ter operações

determinadas em tempo de execução.

• DynamicObject : IDynamicMetaObjectProvider• Permite definir o comportamento do objecto dinâmico

quando se pretende executar uma operação.

• ExpandoObject : IDynamicMetaObjectProvider• Objecto que permite que lhe sejam adicionados e

removidos membros.

Construção de Objectos Dinâmicos

• Programação Dinâmica• http://paulomorgado.net/pt/blog/archive/2010/04/18/c-4-0-programa-231-227-o-din-2

26-mica.aspx

• Proposta C#: Verificação Estática De Objectos Dinâmicos Em Tempo De Compilação• http://

paulomorgado.net/pt/blog/archive/2010/03/17/proposta-c-verifica-231-227-o-est-225-tica-de-objectos-din-226-micos-em-tempo-de-compila-231-227-o.aspx

• Using Type dynamic (C# Programming Guide)• http://msdn.microsoft.com/library/dd264736(VS.100).aspx

• Dynamic Language Runtime Overview• http://msdn.microsoft.com/library/dd233052(v=VS.100).aspx

Recursos

Melhoramentos na Interoperabilidade com COM

• Argumentos com nome e opcionais• Omissão do Modificador ref• Importação Dinâmica• Mapeamento automático object → dynamic• Propriedades indexadas

• Equivalência de Tipos e Tipos Embebidos (“NO PIA”)

Melhoramentos na Interoperabilidade com COM

Omissão do Modificador ref

object fileName = "Test.docx";object missing = Missing.Value;

document.SaveAs(ref fileName, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing);

document.SaveAs("Test.docx", Missing.Value,  Missing.Value, Missing.Value, Missing.Value,  Missing.Value, Missing.Value, Missing.Value,  Missing.Value, Missing.Value, Missing.Value,  Missing.Value, Missing.Value, Missing.Value,  Missing.Value, Missing.Value);

document.SaveAs("Test.docx");

Importação Dinâmica

((Excel.Range)(excel.Cells[1, 1])).Value2 = "Hello World!";

excel.Cells[1, 1] = "Hello World!";

Excel.Range range = (Excel.Range)(excel.Cells[1, 1]);

Excel.Range range = excel.Cells[1, 1];

Equivalência de Tipos e Tipos Embebidos (NO PIA)

• Melhoramentos Para Interoperabilidade Com COM• http://

paulomorgado.net/pt/blog/archive/2010/04/19/c-4-0-melhoramentos-para-interoperabilidade-com-com.aspx

• Type Equivalence and Embedded Interop Types• http://msdn.microsoft.com/library/dd997297.a

spx

Recursos

Demos

Q & A

Conclusão

• A Evolução ao C#• Covariância e Contravariância• Argumentos com Nome e Opcionais• Programação Dinâmica• Melhoramentos na

Interoperabilidade com COM

Conclusão

• Visual C# Developer Center• http://csharp.net/

• Visual C# 2010 Samples• http://code.msdn.microsoft.com/cs2010samples

• C# Language Specification 4.0• http://www.microsoft.com/downloads/details.aspx?familyid=

DFBF523C-F98C-4804-AFBD-459E846B268E&displaylang=en

Recursos

• .NET Reflector• http://www.red-gate.com/products/reflector/

• LINQPad• http://linqpad.net/

• Paulo Morgado• http://PauloMorgado.NET/

Recursos

Obrigado!