C# 3.0
                     LINQ
                     Language Integrated Query

   C# 2.0
                  Genéricos


C...
Declarativo




Dinâmico       Concorrente
O quê?




                 Como?


Imperativo   Declarativo
Estático                 Dinâmico
                    VS




   IntelliSense               Simples


Erros em tempo de
   ...
C# 4.0
                         Programação Dinâmica


         C# 3.0
                     LINQ
                     Lang...
Programação dinâmica

    ◦ Objectos de tipo dinâmico
    Parâmetros opcionais e argumentos com

    nome
    Interopera...
Programação dinâmica em C# 4.0

    Parâmetros opcionais e argumentos com

    nome
    Interoperabilidade com COM

   ...
Programação dinâmica em C# 4.0

    Parâmetros opcionais e argumentos com

    nome
    Interoperabilidade com COM

   ...
Javascript
Estático                Dinâmico
    - IntelliSense      - Interoperabilidade com COM
                                  (I...
Calculator calc = GetCalculator();
int sum = calc.Add(10, 20);


object calc = GetCalculator();
Type calcType = calc.GetTy...
dynamic calc = GetCalculator();
int sum = calc.Add(10, 20);




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



    NOT
  Nova Keyword


    var !
Linguagens dinâmicas
IDispatch




Objecto       IDynamicObject




          Introspecção
Nova API em .NET 4.0

    Dá suporte

    ◦ ao lookup dinâmico de C# 4
    ◦ à implementação das linguagens dinâmicas em...
public abstract class DynamicObject : IDynamicObject
{
  public virtual object GetMember(GetMemberBinder info);
  public v...
IDynamicObject
LINQ: Interacção fraca ou mesmo inexistente:

    ◦ Métodos de extensão dependem do contexto
      estático (i.e. cláusul...
Programação dinâmica em C# 4.0

    Parâmetros opcionais e argumentos com

    nome
    Interoperabilidade com COM

   ...
Parâmetros opcionais:

    ◦ Um parâmetro é opcional quando tem valor por
      omissão
    ◦ Disponíveis para métodos, i...
public StreamReader OpenTextFile(
    string path,
    Encoding encoding,
    bool detectEncoding,
    int bufferSize);

p...
public StreamReader OpenTextFile(
    string path,
    Encoding encoding = null,
                                      Par...
object fileName = quot;Test.docxquot;;
object missing =
       System.Reflection.Missing.Value;

doc.SaveAs(ref fileName,
...
public   void   M(string s, int i = 1);
public   void   M(object o);
public   void   M(int i, string s = “Hello”);
public ...
Programação dinâmica em C# 4.0

    Parâmetros opcionais e argumentos com

    nome
    Interoperabilidade com COM

   ...
Importação dinâmica de tipos

    Omissão de ref

    No-PIA

    Lookup dinâmico

    Parâmetros opcionais

    Argu...
Parâmetros ou retorno de métodos com o
 
     tipo IDL VARIANT
     ◦ Deixam de ser mapeados no tipo object, agora são
  ...
ref (*) de COM ≠ ref de C#

    C#: permite a alteração dos argumentos

    passados, em benefício do caller
    COM: ti...
Assemblies .NET de grande dimensão

    Facilitam escrita de código strongly-typed

    Úteis em design-time, mas podem ...
Características:

    ◦ Necessita das type libraries disponíveis em
     compile-time
    Vantagens:

    ◦ Compile-time...
Excel.Application objApp = new Excel.Application();
Excel.Workbooks objBooks = objApp.Workbooks;
Excel._Workbook objBook =...
Características:

    ◦ Implementação da interface IDispatch
    ◦ Não necessita de informação de tipo em compile-
     t...
Type objClassType = Type.GetTypeFromProgID(quot;Excel.Applicationquot;);
object objApp_Late = Activator.CreateInstance(obj...
//Get the first worksheet.
Parameters = new object[1];
Parameters[0] = 1;
object objSheet_Late = objSheets_Late.GetType()....
Junta o melhor do early-binding ao melhor

    do late-binding
    ◦ Invocação dinâmica de métodos
    ◦ Verificação dinâ...
Office
Programação dinâmica em C# 4.0

    Parâmetros opcionais e argumentos com

    nome
    Interoperabilidade com COM

   ...
Os arrays .NET são co-variantes


     void Process(object[] objects) { … }

     string[] strings = GetStringArray();
  ...
Os genéricos não permitem coisas como

    IList<string> strings = new List<string>();
                                  ...
Implementação de IEnumerable<T> em C# 4.0



public interface IEnumerable<out T> : IEnumerable   Indica que T
{          ...
Parâmetros de tipo podem ter modificador in


        public interface IComparer<in T>{
               public int Compare...
Co-variância apenas quando existe conversão

    por referência entre tipos
    IEnumerable<int> ≠> IEnumerable<object>

...
Interfaces
  System.Collections.Generic.IEnumerable<out T>
  System.Collections.Generic.IEnumerator<out T>
  System.Linq.I...
C# 5

    ◦ Meta-programação
    ◦ “Compiler as a Service” (.NET 5)
    ◦…
    Nemerle

           macro ReverseFor (i, ...
Visual Studio 2010 CTP

    ◦ http://go.microsoft.com/fwlink/?LinkId=131310
    “The Future of C#”

    ◦ by Anders Hels...
C# 4.0
C# 4.0
C# 4.0
C# 4.0
C# 4.0
C# 4.0
Upcoming SlideShare
Loading in...5
×

C# 4.0

1,707

Published on

Presentation about the new features of the C# programming language

Published in: Technology
0 Comments
2 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
1,707
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
0
Comments
0
Likes
2
Embeds 0
No embeds

No notes for slide

C# 4.0

  1. 1. C# 3.0 LINQ Language Integrated Query C# 2.0 Genéricos C# 1.0 Código Managed
  2. 2. Declarativo Dinâmico Concorrente
  3. 3. O quê? Como? Imperativo Declarativo
  4. 4. Estático Dinâmico VS IntelliSense Simples Erros em tempo de Sem compilação compilação Maior performance Meta-programação Mais robustas Mais flexíveis
  5. 5. C# 4.0 Programação Dinâmica C# 3.0 LINQ Language Integrated Query C# 2.0 Genéricos C# 1.0 Código Managed
  6. 6. Programação dinâmica  ◦ Objectos de tipo dinâmico Parâmetros opcionais e argumentos com  nome Interoperabilidade com COM melhorada  Co- e contra-variância de tipos genéricos 
  7. 7. Programação dinâmica em C# 4.0  Parâmetros opcionais e argumentos com  nome Interoperabilidade com COM  Co- e contra-variância 
  8. 8. Programação dinâmica em C# 4.0  Parâmetros opcionais e argumentos com  nome Interoperabilidade com COM  Co- e contra-variância 
  9. 9. Javascript
  10. 10. Estático Dinâmico - IntelliSense - Interoperabilidade com COM (IDispatch) - Performance - Acesso a objectos Javascript, Python, Ruby, etc. - Erros de compilação - Objectos .NET acedidos por - Refactoring introspecção
  11. 11. Calculator calc = GetCalculator(); int sum = calc.Add(10, 20); object calc = GetCalculator(); Type calcType = calc.GetType(); ScriptObject calc = object res = calcType.InvokeMember( GetCalculator(); quot;Addquot;, object res = BindingFlags.InvokeMethod, calc.Invoke(quot;Addquot;, 10, 20); WTF?! null, int sum = Convert.ToInt32(res); new object[] { 10, 20 }); int sum = Convert.ToInt32(res);
  12. 12. dynamic calc = GetCalculator(); int sum = calc.Add(10, 20); Now we’re talking!
  13. 13. dynamic’s dynamic calc = GetCalculator(); int sum = calc.Add(10, 20); NOT Nova Keyword var !
  14. 14. Linguagens dinâmicas
  15. 15. IDispatch Objecto IDynamicObject Introspecção
  16. 16. Nova API em .NET 4.0  Dá suporte  ◦ ao lookup dinâmico de C# 4 ◦ à implementação das linguagens dinâmicas em .NET (IronPython, IronRuby, etc.) Extensível através da interface IDynamicObject 
  17. 17. public abstract class DynamicObject : IDynamicObject { public virtual object GetMember(GetMemberBinder info); public virtual object SetMember(SetMemberBinder info, object value); public virtual object DeleteMember(DeleteMemberBinder info); public virtual object UnaryOperation(UnaryOperationBinder info); public virtual object BinaryOperation(BinaryOperationBinder info, object arg); public virtual object Convert(ConvertBinder info); public virtual object Invoke(InvokeBinder info, object[] args); public virtual object InvokeMember(InvokeMemberBinder info, object[] args); public virtual object CreateInstance(CreateInstanceBinder info, object[] args); public virtual object GetIndex(GetIndexBinder info, object[] indices); public virtual object SetIndex(SetIndexBinder info, object[] indices, object value); public virtual object DeleteIndex(DeleteIndexBinder info, object[] indices); public MetaObject IDynamicObject.GetMetaObject(); }
  18. 18. IDynamicObject
  19. 19. LINQ: Interacção fraca ou mesmo inexistente:  ◦ Métodos de extensão dependem do contexto estático (i.e. cláusulas using) ◦ Expressões lambda não podem ser passadas como parâmetro a uma chamada dinâmica a um método Criação de objectos a partir de objectos que  representam classes ◦ DLR suporta, mas C# não Não está previsto resolver estas limitações  em C# 4.0
  20. 20. Programação dinâmica em C# 4.0  Parâmetros opcionais e argumentos com  nome Interoperabilidade com COM  Co- e contra-variância 
  21. 21. Parâmetros opcionais:  ◦ Um parâmetro é opcional quando tem valor por omissão ◦ Disponíveis para métodos, indexers e construtores Argumentos com nome:  ◦ Passar argumento pelo seu nome e não pela sua posição na lista de invocação
  22. 22. public StreamReader OpenTextFile( string path, Encoding encoding, bool detectEncoding, int bufferSize); public StreamReader OpenTextFile( string path, Encoding encoding, bool detectEncoding); public StreamReader OpenTextFile( string path, Encoding encoding); public StreamReader OpenTextFile( string path);
  23. 23. public StreamReader OpenTextFile( string path, Encoding encoding = null, Parâmetros opcionais bool detectEncoding = true, int bufferSize = 1024); OpenTextFile(quot;foo.txtquot;, Omissão de parâmetros Encoding.UTF8); OpenTextFile(quot;foo.txtquot;, Encoding.UTF8, bufferSize: 4096); Argumento com nome (têm que aparecer por último) OpenTextFile( bufferSize: 4096, Argumentos com nome podem path: quot;foo.txtquot;, aparecer fora de ordem detectEncoding: false); Argumento obrigatório
  24. 24. object fileName = quot;Test.docxquot;; object missing = System.Reflection.Missing.Value; doc.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);
  25. 25. public void M(string s, int i = 1); public void M(object o); public void M(int i, string s = “Hello”); public void M(int i); O que não tem parâmetros opcionais e cuja conversão é “melhor” M(5); Que overload irá ser invocado?
  26. 26. Programação dinâmica em C# 4.0  Parâmetros opcionais e argumentos com  nome Interoperabilidade com COM  Co- e contra-variância 
  27. 27. Importação dinâmica de tipos  Omissão de ref  No-PIA  Lookup dinâmico  Parâmetros opcionais  Argumentos com nome 
  28. 28. Parâmetros ou retorno de métodos com o  tipo IDL VARIANT ◦ Deixam de ser mapeados no tipo object, agora são representados com dynamic Vantagens:  Antes Agora ((Excel.Range)excel.Cells[1, 1]) excel.Cells[1, 1].Value2 = .Value2 = quot;Helloquot;; quot;Helloquot;; Excel.Range range = Excel.Range range = (Excel.Range)excel.Cells[1,1]; excel.Cells[1,1];
  29. 29. ref (*) de COM ≠ ref de C#  C#: permite a alteração dos argumentos  passados, em benefício do caller COM: tipicamente apenas mais uma forma de  passar parâmetros Pode ser omitido  ◦ Compilador “insere os ref” e cria variáveis temporárias para cada um dos parâmetros ref
  30. 30. Assemblies .NET de grande dimensão  Facilitam escrita de código strongly-typed  Úteis em design-time, mas podem causar  problemas em run-time: ◦ Problemas de versioning ◦ Tempo de carregamento da aplicação ◦ Espaço ocupado em memória Podem continuar a ser usados em design-  time, mas não serão necessários em run-time
  31. 31. Características:  ◦ Necessita das type libraries disponíveis em compile-time Vantagens:  ◦ Compile-time syntax check ◦ IntelliSense ◦ Menos verificações em run-time: mais eficiente Desvantagens:  ◦ Problemas de versioning (alteração do layout em memória numa nova versão dum objecto quebra a compatibilidade com componentes que tenham sido compilados com a versão anterior)
  32. 32. Excel.Application objApp = new Excel.Application(); Excel.Workbooks objBooks = objApp.Workbooks; Excel._Workbook objBook = objBooks.Add( Missing.Value ); Excel.Sheets objSheets = objBook.Worksheets; Excel._Worksheet objSheet = objSheets.get_Item(1) as Excel._Worksheet; Excel.Range range = objSheet.get_Range(quot;A1quot;, Missing.Value); range.set_Value(Missing.Value, quot;Hello, World!quot; );
  33. 33. Características:  ◦ Implementação da interface IDispatch ◦ Não necessita de informação de tipo em compile- time Vantagens:  ◦ Elimina problemas de versioning associados ao early-binding Desvantagens:  ◦ Sem compile-time syntax check ◦ Sem IntelliSense ◦ Verificações de tipo em run-time
  34. 34. Type objClassType = Type.GetTypeFromProgID(quot;Excel.Applicationquot;); object objApp_Late = Activator.CreateInstance(objClassType); //Get the workbooks collection. object objBooks_Late = objApp_Late.GetType().InvokeMember( quot;Workbooksquot;, BindingFlags.GetProperty, null, objApp_Late, null); //Add a new workbook. object objBook_Late = objBooks_Late.GetType().InvokeMember( quot;Addquot;, BindingFlags.InvokeMethod, null, objBooks_Late, null ); //Get the worksheets collection. object objSheets_Late = objBook_Late.GetType().InvokeMember( quot;Worksheetsquot;, BindingFlags.GetProperty,null, objBook_Late,null); // Continues…
  35. 35. //Get the first worksheet. Parameters = new object[1]; Parameters[0] = 1; object objSheet_Late = objSheets_Late.GetType().InvokeMember( quot;Itemquot;, BindingFlags.GetProperty, null, objSheets_Late, Parameters ); //Get a range object that contains cell A1. Parameters = new object[2]; Parameters[0] = quot;A1quot;; Parameters[1] = Missing.Value; objRange_Late = objSheet_Late.GetType().InvokeMember( quot;Rangequot;, BindingFlags.GetProperty, null, objSheet_Late, Parameters ); //Write quot;Hello, World!quot; in cell A1. Parameters = new object[1]; Parameters[0] = quot;Hello, World!quot;; objRange_Late.GetType().InvokeMember( quot;Valuequot;, BindingFlags.SetProperty, null, objRange_Late, Parameters );
  36. 36. Junta o melhor do early-binding ao melhor  do late-binding ◦ Invocação dinâmica de métodos ◦ Verificação dinâmica de tipos ◦ PIA em design-time: IntelliSense e verificação de tipo em compile-time ◦ No-PIA em run-time: elimina os problemas de versioning e da performance no carregamento da aplicação
  37. 37. Office
  38. 38. Programação dinâmica em C# 4.0  Parâmetros opcionais e argumentos com  nome Interoperabilidade com COM  Co- e contra-variância 
  39. 39. Os arrays .NET são co-variantes  void Process(object[] objects) { … } string[] strings = GetStringArray(); Process(strings); Mas não são co-variantes de forma segura  void Process(object[] objects) { objects[0] = quot;Helloquot;; Excepção! objects[1] = new Button(); } Verificação em run-time
  40. 40. Os genéricos não permitem coisas como  IList<string> strings = new List<string>(); Genéricos são IList<object> objects = strings; // erro de compilação invariantes! Surpreendente? Talvez não…  Iria originar uma objects[0] = 5; string s = strings[0]; quebra de type-safety Por outro lado…  A variável objects é read-only IEnumerable<object> objects = strings; Passa a ser possível em casos onde a type-safety não possa ser – comprometida Os genéricos agora são co-variantes… E de forma segura!
  41. 41. Implementação de IEnumerable<T> em C# 4.0  public interface IEnumerable<out T> : IEnumerable Indica que T { apenas pode IEnumerator<T> GetEnumerator(); ocorrer como } output public interface IEnumerator<out T> : IEnumerator { bool MoveNext(); T Current { get; } } public interface IMyInterface<out X>{ void MyMethod(X param1); Erro de } compilação!
  42. 42. Parâmetros de tipo podem ter modificador in  public interface IComparer<in T>{ public int Compare(T left, T right); } “Um método que consegue comparar dois objectos do tipo – object, consegue comparar dois objectos de qualquer tipo.” Tipos genéricos podem usar os dois modificadores  public delegate TResult Func<in TArg, out TResult>(TArg arg); Func<object,string> Func<string,object> Pode ser usado como
  43. 43. Co-variância apenas quando existe conversão  por referência entre tipos IEnumerable<int> ≠> IEnumerable<object> ◦ Conversão entre int e object é por boxing e não por referência: tipos valor são sempre invariantes ◦ Semelhante às regras para arrays Tipos variantes apenas podem ser usados em  interfaces e delegates
  44. 44. 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>
  45. 45. C# 5  ◦ Meta-programação ◦ “Compiler as a Service” (.NET 5) ◦… Nemerle  macro ReverseFor (i, begin, body) syntax (quot;fordquot;, quot;(quot;, i, quot;;quot;, begin, quot;)quot;, body) { <[ for ($i = $begin; $i >= 0; $i--) $body ]> } ford (i ; n) print (i);
  46. 46. Visual Studio 2010 CTP  ◦ http://go.microsoft.com/fwlink/?LinkId=131310 “The Future of C#”  ◦ by Anders Helsberg @ PDC’08 Nemerle:  ◦ http://nemerle.org

×