• Save
C# 4.0
Upcoming SlideShare
Loading in...5
×
 

Like this? Share it with your network

Share

C# 4.0

on

  • 3,023 views

Presentation about the new features of the C# programming language

Presentation about the new features of the C# programming language

Statistics

Views

Total Views
3,023
Views on SlideShare
3,011
Embed Views
12

Actions

Likes
2
Downloads
0
Comments
0

2 Embeds 12

http://www.slideshare.net 11
http://www.lmodules.com 1

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

C# 4.0 Presentation Transcript

  • 1. C# 3.0 LINQ Language Integrated Query C# 2.0 Genéricos C# 1.0 Código Managed
  • 2. Declarativo Dinâmico Concorrente
  • 3. O quê? Como? Imperativo Declarativo
  • 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. 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. 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. Programação dinâmica em C# 4.0  Parâmetros opcionais e argumentos com  nome Interoperabilidade com COM  Co- e contra-variância 
  • 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. Javascript
  • 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. 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. dynamic calc = GetCalculator(); int sum = calc.Add(10, 20); Now we’re talking!
  • 13. dynamic’s dynamic calc = GetCalculator(); int sum = calc.Add(10, 20); NOT Nova Keyword var !
  • 14. Linguagens dinâmicas
  • 15. IDispatch Objecto IDynamicObject Introspecção
  • 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. 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. IDynamicObject
  • 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. Programação dinâmica em C# 4.0  Parâmetros opcionais e argumentos com  nome Interoperabilidade com COM  Co- e contra-variância 
  • 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. 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. 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. 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. 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. Programação dinâmica em C# 4.0  Parâmetros opcionais e argumentos com  nome Interoperabilidade com COM  Co- e contra-variância 
  • 27. Importação dinâmica de tipos  Omissão de ref  No-PIA  Lookup dinâmico  Parâmetros opcionais  Argumentos com nome 
  • 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. 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. 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. 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. 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. 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. 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. //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. 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. Office
  • 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. 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. 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. 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. 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. 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. 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. 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. Visual Studio 2010 CTP  ◦ http://go.microsoft.com/fwlink/?LinkId=131310 “The Future of C#”  ◦ by Anders Helsberg @ PDC’08 Nemerle:  ◦ http://nemerle.org