Whats New In C Sharp 4 And Vb 10


Published on

C#4.0 and Vb.NET

Published in: Technology
  • Be the first to comment

  • Be the first to like this

No Downloads
Total Views
On Slideshare
From Embeds
Number of Embeds
Embeds 0
No embeds

No notes for slide
  • MESSAGING:Functional: Features that allow developers to write code in a more functional way to apply lessons learned from functional programming languages.Lambdas, LINQConcise: Letting the compiler “get out of the way” so the developer can focus on the problem at hand, rather than specifying every little detail to the compilerType inference (“var” keyword)Declarative: Focusing more on the What not the How when describing problem solutions in softwareLINQ
  • MESSAGING:Perhaps one of the most important features introduced in .NET 3.5 was LINQ. LINQ is powerful for many reasons, perhaps the largest being it’s declarative programming model. Here’s a snippet of code that uses a typical imperative programming style to return parents that have a child with a given name. One of the problems with imperative styles of code, is it limits the amount of things that a compiler or a runtime can do to make the code better. This is because we are telling the machine exactly _how_ the code should execute via imperative constructs like foreach loops, if statements, etc.
  • MESSAGING:Here is the same piece of code using LINQ. Not only does it’s declarative nature make it more powerful (for many reasons), but it is also easier to read and understand the true nature of what the developer was wanting to do.
  • MESSAGING:The power of writing declarative code (versus imperative code) is that the developer focuses more on expressing the “WHAT needs to be done” rather than “HOW it is to be done.” This is important because it leads to many benefits. One of the benefits is that the impedance mismatch that happens between the problem a developer needs to solve, and how he solves it becomes less and less. Currently, expressing solutions in an imperative way does not allow a developer to express the true intent of his code.The only advantage of a declarative programming model is that the compiler and runtime can be more liberal with the changes it implements in order to make the code as efficient as possible. This is due to the fact that the code is no longer directly tied to the implementation of the underlying algorithm like it is when using imperative code.
  • MESSAGING:There are several trends in modern programming languages that we feel are important to address and capture with our programming language that we will continue to target. DeclarativeImperative languages focus heavily on the how.Programming logic is achieved via if statements, for loops, while loops, etc.Declarative languages focus on the whatTell the computer “what” you want done, and let it focus on how to get it done (so the language decides whether to achieve the goal via a for loop, foreach loop, recursion, etc.)Focusing on the what instead of the “how” is an important part of “stepping away from the compiler” and better expressing your true intent in code.DynamicAround dynamic languages, you often hear the comparison of dynamically-typed versus statically-typed languages.A better way to express this difference is thinking “late-bound” versus early-bound.Early-bound languages enforce calling conventions, matching contracts (method calls on specific types, for instance), at compile time. However, late-bound languages “punt” this decision until runtime. While early-bound languages gain me benefits like compile-time type-safety, they also enforce rigid constraints on the design of your codeIn this way, code written in early-bound languages becomes more difficult to change.For more information on this “flexibility”, check out Duck Typing in Ruby.ConcurrentConcurrency is a topic that is very important to start addressing ASAP. The “concurrency problem” is already here, not 5 years from now, but today.Functional languages like F# are very powerful when it comes to addressing concurrencyThis power comes from the immutable-by-default approach when enables easier-to-parallelize code since assumptions can be made about the behavior of the code because of no shared-stateF# introduces a very powerful mechanism for achieving concurrency called Asynchronous Workflows (has nothing to do with Workflow Foundation workflows)Async Workflows use Parallel Extensions to the .NET Framework under-the-hoodFor shared-stated languages like C# and Visual Basic, concurrency features are primarily coming from library features like Parallel ExtensionsLanguage teams are thinking hard about how to possibly integrate concurrency into the core language (this is a hard space).
  • MESSAGING:C# 1.0With the launch of the C# language, it was a major shift we took to a full managed environment. This was a big step for programming languages at Microsoft. C# 2.0 -With the second release of C# we introduced fully reified Generics into the language. This was a very powerful addition to the type system.C# 3.0 -C# 3.0 introduced LINQ which we talked about previouslyC# 4.0 -Not just “dynamic” as in late-binding, but those features that allow the compiler to “get out of the developer’s way”.
  • MESSAGING:Late-Binding Support: The ability to do runtime call dispatch rather than being forced into compile-time verification. Named and Optional Parameters: This allows us to clean up our code as we can see. It also goes hand-in-hand with #3, Improved COM interop (bye-bye “ref MissingValue”)Improved COM Interop: Better interop with COM, along with easier deployment via Type Equivalent and embedding of types.Covariance and Contravariance: This is really about patching a problem in our generic type system as it exists today. Most developers won’t be using the generic variance features directly, they will simply be able to do stuff they couldn’t do before.
  • MESSAGING:By encouraging C# and VB to co-evolve, each language can “push the boundaries” while not having the other language “fall behind”Co-evolution is like a rubber band, while the languages may not be identical with each release, they will “catch up” to each other with each subsequent release
  • MESSAGING:With previous releases, C# and Visual Basic have tended to “go separate ways”Very common feedback is “I want VB to have feature X from C#” and vice versaEven worse, what happens when the framework is designed in such a way that it makes heavy use a feature is easily used in one language or not the other?In this case, the framework stops being “language agnostic” and certain framework features being hard to use depending on the language being programmed in.An example of this today are frameworks that make heavy use of lambda expressions. In VB9, without the ability to easily use multi-line lambdas or statement lambdas, certain frameworks designed with C# in mind become much more difficult to use for VB developers.
  • MESSAGING:Visual Basic 1 – Visual Basic 3Made Windows programming accessibleHelped make Windows the premier platform in the worldVisual Basic 4 – Visual Basic 6Made targeting COM and OLE approachable for most developersVisual Basic 7 – Visual Basic 9Bringing the “ease of use” to the .NET platformHelped establish the CLR as the premier managed runtime in the worldVisual Basic 10Continuing this trend to make it easy to use and leverage the platform
  • MESSAGING:We show all these features in our demo.
  • MESSAGING:There is a good reason why the Dynamic Language Runtime (DLR) exists. The problem is that, today, dynamically-typed languages like Python and Ruby can’t easily run directly on top of the CLR as the CLR is primarily designed for statically-typed languages. By creating the DLR, we help plug that hole and allow dynamically-typed languages to run on top of the CLR (by working through the DLR).
  • MESSAGING:The DLR provides core services that are necessary for dynamically-typed languages to work on the CLRThe DLR also provides other services that can be used by statically-typed languages as well to achieve more dynamic behavior:Expression Trees (including Statements)Dynamic DispatchCall Site Caching
  • MESSAGING:The power of the DLR is that there are many binders for the DLR. Yes, we can interop with dynamic languages like Python and Ruby like we expect to. However, perhaps even more importantly, there are binders available for .NET, Silverlight, and Office. This allows us to interact between these platforms in very powerful ways that we were unable to currently.
  • MESSAGING:As long as we stay in our statically-typed world, interacting with objects is a pleasant and intuitive experience. However, as soon as you step out of that boundary and have to start using reflection, your code becomes much less elegant, harder to read, and harder to maintain. Using ScriptObject in the DLR makes this a bit easier as it provides some direct method calls to invoke methods with specific parameters. And while this is an improvement, it’s still a departure from the way we are used to interacting with objects.Using the new dynamic keyword in C# 4, we can call the .Add method above exactly as it were statically typed like in our first code snippet. In this case, the calc object is statically typed to be dynamic (yes, that’s true). Once we have a dynamic object references, we can dynamically invoke methods, do dynamic conversion, etc.
  • MESSAGING:There is much to be excited about with Visual Studio 2010. Whether you are a C# developer, a VB developer, or an F# developer, there is a lot of stuff coming.
  • Whats New In C Sharp 4 And Vb 10

    1. 1. Visual Studio 2010 and .NET Framework 4 Training Workshop
    2. 2. What’s New In C# 4.0 and Visual Basic 10 Name Title Organization Email
    3. 3. Where We’re At Today Our managed languages are starting to share some very similar features: Functional Concise Declarative
    4. 4. LINQ, The Power of Declarative IList<Person> FindParentsWithChildNamed(string childName) { var matches = new List<Person>(); foreach(var person in _people) { foreach(var child in person.Children) { Before if (child.Name.Equals(childName)) { matches.Add(person); break; } } } return matches; }
    5. 5. LINQ, The Power of Declarative IList<Person> FindParentsWithChildNamed(string childName) { var matches = from person in people from child in person.Children After where child.Name.Equals(childName) select person; return matches.ToList(); }
    6. 6. Why Declarative Matters… What How Imperative Declarative
    7. 7. Addressing Language Trends Declarative Dynamic Concurrent
    8. 8. The Evolution of C# C# 4.0 Dynamic C# 3.0 LINQ C# 2.0 Generics C# 1.0 Managed Code
    9. 9. New C# 4.0 Features 1. Late-Binding Support 2. Named and Optional Parameters 3. Improved COM Interop 4. Covariance and Contravariance
    10. 10. Simplifying Your Code with C# 4.0
    11. 11. Co-evolving C# and VB Think of co-evolution as a game of leap-frog…
    12. 12. There’s a problem when co-evolution doesn’t exist…
    13. 13. The Evolution of Visual Basic VB10 Continuing the trend VB7-VB9 Power and Simplicity for VB4-VB6 .NET Components Made Easy VB1 – VB3 Windows Programming Made Easy
    14. 14. New VB10 Features 1. Auto-Implemented Properties 2. Collection Initializers 3. Statement Lambdas 4. Covariance and Contravariance 5. Implicit Line Continuation
    15. 15. VB 10
    16. 16. Why a “Dynamic Language Runtime”? Dynamically-Typed Ruby Python Statically-Typed VB C# Common Language Runtime
    17. 17. Why a “Dynamic Language Runtime”? Dynamically-Typed Ruby Python Statically-Typed VB C# Dynamic Language Runtime Common Language Runtime
    18. 18. .NET Dynamic Programming IronPython IronRuby C# VB.NET Others… Dynamic Language Runtime Expression Trees Dynamic Dispatch Call Site Caching Python Ruby Object JScript COM Binder Binder Binder Binder Binder
    19. 19. Dynamically Typed Objects Calculator calc = GetCalculator(); int sum = calc.Add(10, 20); object calc = GetCalculator(); Type calcType = calc.GetType(); object res = calcType.InvokeMember(quot;Addquot;, BindingFlags.InvokeMethod, null, new object[] { 10, 20 }); ScriptObject calc = GetCalculator(); int sum = Convert.ToInt32(res); object res = calc.Invoke(quot;Addquot;, 10, 20); int sum = Convert.ToInt32(res); Statically typed to be dynamic dynamic calc = GetCalculator(); int sum = calc.Add(10, 20); Dynamic Dynamic method conversion invocation
    20. 20. Dynamic Language Interop
    21. 21. Summary… 1. Targeting the current trends in programming languages 2. Addressing current pain points in developing for Windows and the .NET Framework 3. Laying the foundation to enable developers to solve tomorrow’s problems
    1. A particular slide catching your eye?

      Clipping is a handy way to collect important slides you want to go back to later.