Overview of VS2010 and .NET 4.0


Published on

This slide deck was used at the ObjectSharp At The Movies event as an overview of the new features of VS2010 and functionality added to .NET 4.0

  • 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
  • Launch VS2010Note that Start Page is now WPF => customizable Management of Recent Projects much easier – pinning, removalCreate a Web Project – Empty ASP.NET application called HelloWorldWeb Notice multi-targetingRight Click in the Project-> Add New Item, Write Web Form in the search box and name it Page Default.aspx Point out searchingOpen Default.aspx, and choose the Design surface if not chosen alreadyOpen Toolbox, expand “Standard” Drop a Button and Label onto our page from the ToolboxRename Button -> btnSend. Change Button.Text -> “Press Me”Rename Label -> lblMessage. Remove value from Label.TextDouble-Click our Button in the designer to create a click event handler in code-behind.In the event handler, type “Mes” Note that even though “Mes” was typed, lblMessage was foundChoose lblMessage from Intellisense and set its Text property to “Clicked!”Highlight the line of code we just wrote.Extract Method: Right Click -> Refector -> Extract MethodCall the method ChangeTextAdd a string parameter named message to the ChangeText method, and pass in “Clicked!” from the Button’s click event handler.Press “ctrl+,” (hold down control and press comma) to bring up Quick Search dialog.Enter “Page” as search item.Delete “Page” search item and type “PL” instead.Press enter to “OK” and accept dialog.In the Page_Load method, call our ChangeText to set text to “Not Clicked”Click the cursor on the name of our ChangeText method.Right Click on the name of the ChangeText method -> View Call Hierarchy.
  • MESSAGING:New Library = just an assembly, a normal .dll, used by any .NET languageDynamically Composed = composition takes place at runtime and composition behavior differs depending on how it is configured.
  • MESSAGING:Now this has a great impact on the capabilities of our applications. Thanks to the ever-increasing power of our computers, computing power has been on a steady incline. And for the most part, our applications have been able to track this computing power increase merely by relying on the fact that faster computers will be released that will, in turn, make their own applications faster (just by running on the faster hardware). In this world, sequential programming wasn’t a problem because the ever-increasing computer power allowed our sequential programs to keep on running faster and faster as new hardware was released.However, along this computing power trend, a shift was made to CPUs containing multiple cores. Computers now contained multiple cores, where each single core was slightly less powerful than a complete processor was before. And while it would be nice to think our applications could continue to follow the computing power trend just as they did before, that’s not reality.The reality is that if we continue to use the same programming models as we use today, our performance will plateau. Not only will it plateau, there is a possibility that performance will decrease a bit as many cores are introduced that each are just a little less powerful than their predecessors (for less power consumption, less heat dissapation, etc.). Cleary, new tools for us developers to write applications with are necessary.
  • MESSAGING:Today, concurrency usually has to be done by the brightest developers in a business. The problem with this is that the brightest developers are then being consumed by concurrency minutia rather than being able to be focused on core business problems and helping the business’s bottom line. By providing new libraries and tools that make it easy to write parallel code, we hope to allow the best and brightest developers focus on the business problems at hand. This in turn enables other developers to be able to address concurrency and parallelism.This is the long term goal of Microsoft with the Parallel Computing Initiative. Visual Studio 2010 and .NET Framework 4 is merely the first step being taken in this direction.
  • MESSAGING:There are three primary improvement areas in Visual Studio 2010 and .NET Framework 4 that we will discuss in this talk: System.Threading improvements, introduction of Parallel Extensions to the .NET Framework, and a new unified cancellation model coming in .NET Framework 4.
  • MESSAGING:Several important new primitives coming to System.ThreadingBarrier and CountdownEvent make coordinating multithreaded code easier than it was beforeTechnical descriptions are boring and not the best candidate for learningLet’s learn Barrier and CountdownEvent through analogy
  • MESSAGING:The new Barrier synchronization primitive allows you to provide “sync-points” where all threads/tasks of execution meet at. Then, no threads/tasks continue until all of them have arrived at the barrier. This is a way that now you can easily introduce “check points” into your parallel operations if there are naturally areas where you want different execution units to meet. A Barrier can be re-used multiple times to issue many “check points” that could occur in the code.As an example, think about a road trip. If some friends are taking a road trip to Seattle, for instance, they might all meet at the gas station first. They shouldn’t leave the gas station until all of them arrive so they can leave together. In this case, the gas station itself could represent the barrier. There is a natural “check point” that occurs before all of them leave and start driving again to Seattle.
  • MESSAGING:A new unified cancellation model is being introduced with .NET Framework 4. This new model allows many different operations (like separate threads of execution, I/O calls, etc.) to be organized in such a way that they can all be cancelled with one simple call in a unified way (no matter what the operation itself is).The new CancellationTokenSource and CancellationToken constructs is what the new unified cancellation model is comprised of. The CancellationTokenSource is the core of this model. From a CancellationTokenSource, you can pass out as many CancellationTokens as you wish to various types of operations that are or are not happening in parallel. Then you can use the CancellationTokenSource to signify that everything needs to be cancelled by calling a Cancel() method. Then the cancellation is reflected in all the various tokens.One key aspect of this new model is that the individual tokens that are passed out have no way to signify cancellation themselves. There is also no way to get from a reference to a CancellationToken back to the original CancellationTokenSource. This is by design. When you are passing out tokens to as many operations as you need to in order to keep your cancellation unified, the last thing you want to do is to allow some random token to be able to signify a Cancel() request and then cancel all the other processing that is happening.Think of this another way, compare cancellation tokens by the devices handed out at some restaurants to signify that you (as the customer) are ready to be seated. Though you have the device in your hand, there is no possible way for you personally to make it go off (that would kind of defeat the purpose). The only party that can signal that you are “ready to be seated” is the restaurant itself. This is the same relationship the CancellationTokenSource and CancellationToken have to each other.
  • MESSAGING:Parallel Extensions is simply a .NET library (meaning, normal .NET code that can be used by any .NET-based language). It contains three different pieces: PLINQ, TPL, and CDS (System.Collections.Concurrent). Parallel Extensions addresses everything from declarative and imperative data parallelism, to imperative task parallelism.
  • MESSAGING:The task scheduler in Parallel Extensions is very smart and powerful. There are two aspects that make it so: the ability for different worker threads to “steal work” from other threads when there is work to be done, and the addressing of data locality when a thread is determining what work to actually do.When a thread needs to find more work to do, it looks in three different places (in the following order):It’s local queueThe global queueOther thread’s queues that have work to be doneIt’s important to know that data locality is addressed when a thread needs to grab more work to do:When pulling from the local queue, the worker pulls the last item added to the queue. This is because the last item added to the queue has the greatest chance of still being fresh in the cache, as opposed to older items which are more likely have expired and been flushed from cache.When pulling from another worker’s queue, the current worker pulls the oldest item added to the queue. This is because the oldest item added to the queue has the greatest chance of not being in the cache even for its local worker (and hence needing to load in anyways).
  • MESSAGING:With the introduction of the new Parallel static class, it becomes much easier to parallelize independent statements. The great thing is that if program statements are completely independent from each other (i.e. they don’t share any common shared stated between the various calls are require the calls to take place in a given order), they can easily be parallelized using the new Parallel.Invoke() method. There are other static methods declared off the Parallel class that make other parallel operations easy as well (like Parallel.For() and Parallel.ForEach(). We’ll take a look at some of these in the demo.So one might ask: “Well, if it’s that simple, why doesn’t the compiler just do this for automatically?” The problem is that it’s not quite that simple. In our world of imperative code and shared state, there’s no easy way to guarantee that these methods being called don’t have some sort of state somewhere that they are sharing. It could be five method calls deep, it could be ten, it could be more. You, as the developer, are the one with the necessary knowledge to know where this is true. Therefore, Parallel.Invoke() is strictly an opt-in process. Otherwise, we could do more damage than good.
  • MESSAGING:PLINQ is a technology that allows developers to _easily_ leveragemanycore. The great thing about PLINQ is that if you are using LINQ-to-objects, there is a very minimal impact to your code in order for it to use PLINQ. All it takes to use PLINQ is adding “.AsParallel()” to your query. This will turn the query into a PLINQ query and will use the PLINQ execution engine when executed.One small change, and your code now takes advantage of all the hardware available to you.NOTES:AsParallel() works by returning an IParallelEnumerable so every subsequent query operator works against the new IParallelEnumerable rather than the normal IEnumerable. See the hands-on lab for Parallel Extensions for more details.
  • Overview of VS2010 and .NET 4.0

    1. 1.
    2. 2. An Overview of VS2010 and .NET 4.0<br />
    3. 3. Visual Studio Targets Many…<br />Complete<br />Team System<br />Professional<br />Feature Set<br />Express<br />Minimal<br />Hobbyist<br />Enterprise<br />Audience<br />
    4. 4. …and there are Four Pillars<br />Understanding <br />The Code<br />Building Web<br />Applications<br />Creating Office<br />Business<br />Applications<br />Using The<br />Power of<br />C++<br />
    5. 5. Breakpoint Grouping<br />Parallel Tasks Window<br />New Look & Feel<br />Extensible Test Runner<br />Dynamic Data Tooling<br />Generate From Usage<br />Highlight References<br />WPF-based Editor<br />Click-Once Enhancements for Office<br />Breakpoint Labeling<br />Call Hierarchy<br />Web Deploy<br />Improved WPF Tooling<br />Sharepoint Tooling<br />Historical Debugging<br />MVC Tooling<br />Inline Call Tree<br />Minidump Debugging<br />Quick Search<br />JQueryIntellisense<br />Concurrency Profiler<br />Breakpoint Import/Export<br />Document Map Margin<br />64-bit Mixed-Mode<br />Parallel Stacks Window<br />HTML Snippets<br />Improved Multi-Monitor<br />web.config Transformation<br />New Visual Studio 2010 Features…<br />
    6. 6. The Two Faces of Visual Studio 2010<br />Visual Studio As An Editor<br />An improved focus on… <br />Writing code,<br />Understanding code,<br />Navigating code,<br />Publishing code<br />
    7. 7. New VS2010 Capabilities<br />
    8. 8. The Two Faces of Visual Studio 2010<br />Visual Studio As A Platform<br />New Editor allows for easy extensibilityto provide a rich and robust editing experience<br />Online Visual Studio Gallery integrated directly into Visual Studio<br />
    9. 9. Extension Manager<br />
    10. 10. But Didn’t You Say Extensibility?<br />Available through the Managed Extensibility Framework (MEF)<br />New library in the .NET Framework<br />Enables greater reuse of applications and components. <br />Shift applications from being statically to dynamically composed<br />
    11. 11. Composite Application?<br />Isn’t that like Prism?<br />Sort of<br />MEF != Prism<br />Prism is just UI guidance<br />Uses an IoC container (Unity)<br />MEF is a dependency injection framework<br />Closer to Unity<br />Can actually be used with Prism<br />
    12. 12. Applications Made Out of Parts<br />
    13. 13. The Import/Export Business<br />Import<br />Need<br />Export<br />Got<br />Parts<br />
    14. 14. The Extensibility Scenario<br />Application<br />Need <br />Menus<br />Need a Toolwindow<br />Got a MenuService<br />Got a Toolwindow<br />Got a Menu<br />Extension A<br />Extension B<br />Need a MenuService<br />
    15. 15. …Put into Geek Terms<br />Part<br />Import<br />Menus<br />Import “Toolwindow”<br />Import IMenuService<br />Export “Toolwindow”<br />Export aMenu<br />Part<br />Part<br />Export IMenuService<br />
    16. 16. And Why Should I Care?<br />Because the Visual Studio 2010 IDE is a MEF application<br />Integration with menus<br />Integration with toolbars<br />Integration with the editor<br />
    17. 17. Extending Visual Studio<br />
    18. 18. The Target of CLR 4<br />Working Better Together…<br />In-Proc SxS<br />Managed Extensibility Framework<br />Working Better Together…<br />Native/Managed Interop<br />DLR Integration<br />Faster<br />Threading<br />Parallel Extensions<br />Garbage Collection<br />Profiling<br />With Fewer Bugs…<br />Code Contracts<br />Debugging<br />Corrupted State Exceptions<br />
    19. 19. Base Class Library Improvements<br />Numerics<br />BigInteger, Complex<br />Data Structures<br />Tuple<br />SortedSet<T>, ISet<T><br />I/O<br />Memory-Mapped File<br />Unified Cancellation Model<br />
    20. 20. Side-by-Side (Sxs) at .NET 3.5<br />2.0 add-in<br />3.0 add-in<br />3.5 add-in<br />1.1 add-in<br />3.5<br />.NET 1.1<br />3.0<br />.NET 2.0<br />Host Process (i.e. Outlook)<br />
    21. 21. Side-By-Side (SxS) at .NET 4.0<br />2.0 add-in<br />3.0 add-in<br />3.5 add-in<br />4.0 add-in<br />3.5<br />.NET 4.0<br />3.0<br />.NET 2.0<br />Host Process (i.e. Outlook)<br />
    22. 22. The target of CLR 4<br />Working Better Together…<br />In-Proc SxS<br />Managed Extensibility Framework<br />Native/Managed Interop<br />DLR Integration<br />Faster<br />Threading<br />Parallel Extensions<br />Garbage Collection<br />Profiling<br />With Fewer Bugs…<br />Code Contracts<br />Debugging<br />Corrupted State Exceptions<br />
    23. 23. “Moore’s Law scaling should easily let us hit the 80-core mark in mainstream processors within the next ten years and quite possibly even sooner.”<br />- Justin Ratner, CTO, Intel<br />
    24. 24. The Parallel Computing Initiative<br />Based on the following premise:<br />Let the brightest developers solve business problems, not concurrency problems.<br />“Concurrency for the masses”<br />
    25. 25. Concurrency Landscape<br />For Visual Studio 2010 and the .NET Framework 4…<br />System.Threading<br />Parallel Extensions<br />Unified Cancellation Model<br />
    26. 26. New System.Threading Primitives<br />A Barrier is a synchronization primitive that enforces the stopping of execution between a number of threads or processes at a given point and prevents further execution until all threads or processors have reached the given point.<br />A CountdownEvent is a synchronization primitive that enables ongoing tracking of a given workload in order to determine if processing of that workload is finished or not.<br />YUCK!<br />
    27. 27. Barrier<br />“Let’s all head to Wasaga! We’ll meet at the gas station and leave from there.”<br />Dennis<br />Mac<br />Barrier<br />Wasaga<br />Charlie<br />Gas Station<br />
    28. 28. Unified Cancellation<br />“Sir, we are ready to seat you…” - Hostess<br />Cancellation<br />Token<br />Source<br />Cancellation<br />Token<br />
    29. 29. The Unified Cancellation Model<br />
    30. 30. Parallel Extensinos<br />A .NET Library that supports:<br />declarative and imperative data parallelism<br />imperative task parallelism<br />Also provides a set of data structures that make coordination easier.<br />Parallel LINQ (PLINQ)<br />Task Parallel Library (TPL)<br />Coordination Data Structures (CDS)<br />
    31. 31. “Work Stealing” in Action<br />Worker Thread 1<br />Worker Thread p<br />Program Thread<br />Task 3<br />Task 1<br />Task 4<br />Task 5<br />Task 2<br />
    32. 32. Parallel Static Class<br />When program statements are independent…<br /> …they can be parallelized<br />StatementA();<br />StatementB();<br />StatementC();<br />Parallel.Invoke(<br /> () => StatementA(),<br /> () => StatementB(),<br /> () => StatementC() );<br />
    33. 33. Parallel Static Class<br />
    34. 34. PLINQ<br />Parallel LINQ (PLINQ) enables developers to easily leverage manycore with a minimal impact to existing LINQ programming model<br />var q = from p in people<br />        where p.Name == queryInfo.Name && <br />p.State == queryInfo.State &&<br />p.Year >= yearStart &&<br />p.Year <= yearEnd<br />        orderbyp.Year ascending<br />        select p;<br />.AsParallel()<br />
    35. 35. Parallelizing LINQ<br />
    36. 36. The goal of CLR 4<br />Working Better Together…<br />In-Proc SxS<br />Managed Extensibility Framework<br />Native/Managed Interop<br />DLR Integration<br />Faster<br />Threading<br />Parallel Extensions<br />Garbage Collection<br />Profiling<br />With Fewer Bugs…<br />Code Contracts<br />Debugging<br />Corrupted State Exceptions<br />
    37. 37. Design By Contract<br />Code Contracts introduce a way to specify contractual information that is not represented by a method or type’s signature alone.<br />
    38. 38. What is a Contract?<br />A contract is…<br />An exchange of promises between two or more parties to do, or refrain from doing, something<br />Key concept here is ‘promise’<br />
    39. 39. Why Contracts?<br />Just because something compiles, doesn’t mean it works…<br />
    40. 40. A Contract contains…<br />Pre-conditions - must be true before<br />Post-conditions -must be true after<br />public Rational(int numerator, int denominator)<br />{<br />Contract.Requires(denominator > 0);<br /> …<br />}<br />public string GetPassword()<br />{<br />Contract.Ensures(Contract.Result<string>() != null);<br /> …<br /> return password;<br />}<br />
    41. 41. A Contract contains…<br />Invariants - must always be true<br />[ContractInvariantMethod]<br />protected void ObjectInvariant()<br />{<br />Contract.Invariant(denominator > 0);<br />}<br />
    42. 42. Code Contracts<br />
    43. 43. Database Choices<br />Value Props:<br />Full h/w control – size/scale<br />100% compatibility<br />Roll-your-own HA/DR/scale<br />Value Props:<br />100% of API surface area<br />Roll-your-own HA/DR/scale<br />Dedicated<br />On-premise<br /> SQL Server or other s/w on-premise<br /> Resource governance @ machine<br /> Security @ DB Server/OS<br />Value Props:<br />Auto HA, Fault-Tolerance<br />Friction-free scale<br />Self-provisioning<br />High compatibility<br />Resources<br />Hosted<br /> Hosted SQL Server or other<br /> Resource governance @ VM<br /> Security @ DB Server/OS<br />SQL Azure (RDBMS)<br /> Virtual DB server<br />Resource governance @ LDB<br /> Security @ LDB<br />Shared<br />Low<br />“Friction”/Control<br />High<br />SQL Azure V1 targets scenarios that live in the lower left quadrant<br />
    44. 44. Windows Azure Platform<br />Compute:Virtualized compute environment based on Windows Server<br />Storage: Durable, scalable, & available storage<br />Management: Automated, model-driven management of the service<br />Database:Relational processing for structured/unstructured data<br />Service Bus: General purpose application bus<br />Access Control: Rules-driven, claims-based access control<br />AppFabric<br />
    45. 45. Scenarios for V1<br />Departmental Applications<br />Simple application built by individual or department<br />Need simple deployment, self-management, IT: “Empowerment and Governance”<br />Web Applications<br />Small business or startup that uses the cloud as their IT<br />Simple deployment, self-management, scale on demand<br />ISV<br />ISV hosting software on behalf of customer<br />Multi-tenant support for billing and isolation<br />
    46. 46. V1 Application Topologies<br />SQL Azure access from outside MS Datacenter <br />(On-premises – ADO.NET)<br />SQL Azure access from within MS Datacenter <br />(Azure compute – ADO.NET)<br />Application/ <br />Browser<br />App Code / Tools<br />ADO.NET Data Svcs/REST - EF<br />HTTP/S<br />SOAP/REST<br />HTTP/S<br />App Code<br />(ASP.NET)<br />Windows Azure<br />T-SQL (TDS)<br />T-SQL (TDS)<br />SQL Data Services<br />SQL Data Services<br />MS<br />Datacenter<br />MS<br />Datacenter<br />Code Far<br />Code Near<br />
    47. 47. SQL AzureDeployment<br />DB Script<br />SQL Azure<br />TDS Gateway<br />
    48. 48. SQL AzureAccessing databases<br />Change Connection String<br />Your App<br />SQL Azure<br />TDS Gateway<br />
    49. 49. Connecting To SQL Azure<br />