The document discusses features of the C# programming language, including dynamic lookup, named and optional parameters, and overload resolution. It highlights how these features can affect method signatures and the implications of variance in type parameters. Additionally, it references training resources and discussions on the future of C# and related concepts in .NET programming.

1. Joseph Guadagno (jguadagno@sevdnug.org) Founder Southeast Valley .NET User Group Twitter: twitter.com/jguadagno

2. Dynamic lookup Named and optional parameters COM specific interop features Variance Potential features

3. The dynamic type Runtime lookup Dynamic objects Plain objects COM objects

5. No syntax for class creation Cannot find extension methods Anonymous functions (ie Lamda expressions) cannot appear as arguments.

6. Named parameters Optional parameters Overload resolution

7. public void PrintMe( string text, int copies, bool collate); PrintMe(text: “ Hello World ”, collate: true, copies: 1 );

8. public void PrintMe( string text, int copies = 1, bool collate = true ); PrintMe(“ Hello World ” );

9. A signature is applicable if all its parameters are either optional or have exactly one corresponding argument (by name or position) in the call which is convertible to the parameter type. Betterness rules on conversions are only applied for arguments that are explicitly given – omitted optional arguments are ignored for betterness purposes. If two signatures are equally good, one that does not omit optional parameters is preferred.

10. PrintMe(“ Hello World ” ); public void PrintMe( string text, int copies = 1); public void PrintMe( string text); public void PrintMe( object text);

12. Dynamic import Compiling without PIAs Omitting ref

14. Some COM interfaces are not yet available Indexed properties Default properties NOTE: these will only be used for dynamically typed objects. C# static objects will not support them.

15. Supported for interface and delegate types “ Statically checked definition-site variance” Value types are always invariant IEnumerable<int> is not IEnumerable<object> Similar to existing rules for arrays ref and out parameters need invariant type

17. Source code Source code Source File Source code Source code .NET Assembly Meta-programming Read-Eval-Print Loop Language Object Model DSL Embedding Compiler Compiler Class Field public Foo private string X

19. Visual Studio 2010 and .NET 4.0 Training http://cli.gs/VS2010training The Future of C#, Anders Hejlsberg http://cli.gs/FutureOfC LINQ Farm: Covariance and Contravariance in C# 4.0 http://cli.gs/LinqFarm

20. Joseph Guadagno (jguadagno@sevdnug.org) Founder Southeast Valley .NET User Group