Lap around .net 4
Download as PPTX, PDF0 likes473 views
This document summarizes .NET 4 features including ASP.NET improvements, parallel computing, the Dynamic Language Runtime, compatibility with previous .NET versions, and in-process side-by-side execution of assemblies from different .NET versions. Key points covered include new Web Forms client ID modes, Parallel LINQ for leveraging multi-core CPUs, the Managed Extensibility Framework for component extensibility, and the ability to run 3.5 and 4.0 assemblies simultaneously in the same process.
![Dynamically Typed ObjectsCalculator calc = GetCalculator();int sum = calc.Add(10, 20);object calc = GetCalculator();TypecalcType = calc.GetType();object res = calcType.InvokeMember("Add",BindingFlags.InvokeMethod, null,newobject[] { 10, 20 });int sum = Convert.ToInt32(res);ScriptObject calc = GetCalculator();object res = calc.Invoke("Add", 10, 20);int sum = Convert.ToInt32(res);Statically typed to be dynamicdynamic calc = GetCalculator();int sum = calc.Add(10, 20);Dynamic method invocationDynamic conversion](https://image.slidesharecdn.com/laparound-net4-100427012046-phpapp01/85/Lap-around-net-4-42-320.jpg)
Lap around .net 4
- 1. A Tour of .NET 4Scott HanselmanPrincipal Program Manager [email protected] @shanselman on Twitter
- 2. Cost Cuttingin VS 2010
- 3. Layoffs.
- 4. Layoffs.
- 5. Layoffs.
- 6. Layoffs.
- 7. Layoffs.
- 8. A Look Back…<configuration> <system.web> <compilation debug="true”targetFramework="4.0" /> </system.web></configuration>SP13.53.0.NET 1.0.NET 1.1.NET 2.0.NET 4200220032010 RTM2005-08CLR 1.0CLR 1.1CLR 2.0CLR 4
- 9. Web Forms 4 - Client ID
- 10. Web Forms 4 - Client ID
- 11. Clean HTMLAbility to specify client IDs on controlsImproves client script and CSS supportClientIdMode = Static, Predictable, Auto, InheritCSS rendering supportRemove the need to use CSS adaptersDefer to CSS and bypass existing style propertiesSupport non-table-based HTML renderingViewState improvementsDisable at app/page level, enable per control
- 12. Data Control Improvements<asp:chart /> now built-into ASP.NET 4.0
- 13. Core ASP.NET ImprovementsCache ExtensibilityEnable disk based cachingIntegrate with new “Velocity” distributed cacheAutomatically Pre-Start ApplicationsEnable applications to precache/load dataPerf Monitoring on a per-application basisSyntax for automatically HTML encoding<%: Message %>
- 14. DeploymentEnd to end packaging and deploying of web applications Enables customized configurationsSupports databases, SSL certs, custom registry entries, file ACLs, etcWorks great with hosted environments
- 15. ASP.NET Web Forms 4Client Id / Routingdemo
- 17. Microsoft AJAX CDNFree CDN hosting of AJAX library scriptsASP.NET AJAX 4jQuery and jQuery Validation<script src=“http://ajax.microsoft.com/ajax/jquery/jquery-1.3.2.min.js” type="text/javascript“ />Built-in support with <asp:scriptmanager>
- 18. AJAX 4 - Client TemplatesServer-Side (WebForms):<ItemTemplate> <li><%# Eval("Name") %></li></ItemTemplate>Client-Side<ul class="sys-template"> <li>{{ Name }}</li></ul>
- 19. AJAX 4 - DataContextASMX1. RequestWCFADO.NETData ServicesDataContext2. JSON DataASP.NET MVCJsonResult3. Modify Data4. Save DataEtc.* DataContext includes change tracking automatically
- 20. ASP.NET AJAX 4Client Templates/Odatademo
- 21. ASP.NET AJAX 4Client Templatesdemo
- 22. WPF 4 Data Grid Ribbon Multi-Touch Windows 7 Enhancements
- 25. Managed Extensibility Framework?The Managed Extensibility Framework (MEF) is a new libraryin the .NET Framework that enables greater reuse of applications and components. Using MEF, .NET applications can make the shift from being statically compiled to dynamically composed
- 27. Open/Closed PrincipleSoftware entities should be open for extension, but closed for modification.
- 28. Knownvs. Unknown
- 29. Client ApplicationsWPF 4 DataGrid/ MEFdemo
- 30. Client ApplicationsWPF 4 DataGrid / MEFdemo
- 31. The Parallel Computing InitiativeLetting the brightest developers solve business problems, not concurrency problems.“Concurrency for the masses”
- 33. Parallel Computing with .NET 4Task Parallel Library (TPL)Parallel LINQ (PLINQ)Coordination Data Structures (CDS)System.Threading Improvements
- 34. Parallel LINQParallel LINQ (PLINQ)enables developers to easily leveragemanycore with a minimal impact to existing LINQ programming modelvar q = from p in people where p.Name == queryInfo.Name && p.State == queryInfo.State &&p.Year >= yearStart &&p.Year <= yearEnd orderbyp.Year ascending select p;.AsParallel()
- 35. Parallel ComputingParallel LINQ and PFXdemo
- 36. Parallel ComputingParallel LINQ (PLINQ)demo
- 37. Why the DLR?Dynamically-TypedRubyPythonStatically-TypedVBC#Common Language Runtime
- 38. Dynamically-TypedRubyPythonStatically-TypedVBDynamic Language RuntimeC#Common Language RuntimeWhy the DLR?
- 39. .NET Dynamic ProgrammingIronPythonIronRubyC#VB.NETOthers…Dynamic Language RuntimeExpression TreesDynamic DispatchCall Site CachingPythonBinderRubyBinderCOMBinderRuntimeBinderRuntimeBinder
- 40. DLR Integration Dynamic for all!demo
- 42. Dynamically Typed ObjectsCalculator calc = GetCalculator();int sum = calc.Add(10, 20);object calc = GetCalculator();TypecalcType = calc.GetType();object res = calcType.InvokeMember("Add",BindingFlags.InvokeMethod, null,newobject[] { 10, 20 });int sum = Convert.ToInt32(res);ScriptObject calc = GetCalculator();object res = calc.Invoke("Add", 10, 20);int sum = Convert.ToInt32(res);Statically typed to be dynamicdynamic calc = GetCalculator();int sum = calc.Add(10, 20);Dynamic method invocationDynamic conversion
- 43. Type EquivalenceInterop Assemblies translate between managed code and COMFor each interface, struct, enum, delegate, and member, contains a managed equivalent with marshalling data
- 44. However!Primary Interop Assemblies cause many pain points…
- 45. Go Away, PIA!Compilers embed the portions of the interop assemblies that the add-ins actually useRuntime ensuresthe embedded definitions of these types are considered equivalent
- 48. .NET Framework Compatibility.NET 4.0 is a highly compatible release.NET 4.0 does not auto–roll forwardYou must add a configuration file with a specific switch to get 3.5 apps to run on 4.0
- 49. CLR 2 - Existing Side-By-Side2.0 add-in3.0 add-in3.5 add-in1.1 add-in3.5.NET 1.13.0.NET 2.0Host Process (i.e. Outlook)
- 50. CLR 4 - In-Process Side-By-Side2.0 add-in3.0 add-in3.5 add-in4.0 add-in3.5.NET 4.03.0.NET 2.0Host Process (i.e. Outlook)
- 53. Be well,write good code,and stay in [email protected]://hanselman.com@shanselman on Twitter
- 54. Required Slide© 2009 Microsoft Corporation. All rights reserved. Microsoft, Windows, Windows Vista and other product names are or may be registered trademarks and/or trademarks in the U.S. and/or other countries.The information herein is for informational purposes only and represents the current view of Microsoft Corporation as of the date of this presentation. Because Microsoft must respond to changing market conditions, it should not be interpreted to be a commitment on the part of Microsoft, and Microsoft cannot guarantee the accuracy of any information provided after the date of this presentation. MICROSOFT MAKES NO WARRANTIES, EXPRESS, IMPLIED OR STATUTORY, AS TO THE INFORMATION IN THIS PRESENTATION.
Editor's Notes
- #4: If you would like to host your demo on the Virtual Server, please use the myVPC demo slide, not this slide.
- #17: Estimated Time: 3 minutesIn order to enable our ability to easily create dynamic UI and place the rendering process on the client, we need a way to define templates of markup that represent the UI we wish to create, and allow the runtime to instantiate them for us. This alleviates the need to write a bunch of DOM code or depend on server-rendering.If you’ve used WebForms before, you’re already familiar with the approach many of its server controls take. You have access to a set of properties that allow you to define arbitrary templates of content, complete with HTML, server controls, and data binding expressions. This model makes it very easy to create dynamic UI that is rendered server-side [Advance Animation].ASP.NET AJAX 4.0 introduces the ability to define templates as well, but purely client-side. Now you can create the HTML markup you want to use for representing your template, complete with HTML and data binding expressions. In this example, we’ve created an unordered list template whose content is a list item whose content is the value of the Name property of the JSON object that is bound to it. The data binding expression resembles that of WPF.
- #19: Estimated Time: 3 minutesIn order to enable our ability to easily create dynamic UI and place the rendering process on the client, we need a way to define templates of markup that represent the UI we wish to create, and allow the runtime to instantiate them for us. This alleviates the need to write a bunch of DOM code or depend on server-rendering.If you’ve used WebForms before, you’re already familiar with the approach many of its server controls take. You have access to a set of properties that allow you to define arbitrary templates of content, complete with HTML, server controls, and data binding expressions. This model makes it very easy to create dynamic UI that is rendered server-side [Advance Animation].ASP.NET AJAX 4.0 introduces the ability to define templates as well, but purely client-side. Now you can create the HTML markup you want to use for representing your template, complete with HTML and data binding expressions. In this example, we’ve created an unordered list template whose content is a list item whose content is the value of the Name property of the JSON object that is bound to it. The data binding expression resembles that of WPF.
- #20: Estimated Time: 2 minutesThe DataContext control essentially provides a connection between your client application and the server. The server component can be represented by any JSON compatible service, such as ASMX, WCF, and ADO.NET Data Services.The DataContext handles requesting data from the server [Advance Animation], as well as retrieving the returned JSON data. On the client, any JSON objects that were retrieved via a DataContext are participating in change tracking [Advance Animation]. This means that you can go about making any modifications you need, and can then simply save changes back to the server via the DataContext[Advance Animation] without having to worry about determining what changes have occurred.
- #21: If you would like to host your demo on the Virtual Server, please use the myVPC demo slide, not this slide.
- #22: ContosoAutomotive
- #26: 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.
- #27: 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.
- #29: MESSAGING:Due to it’s declarative-based and discovery-enabled approach, MEF becomes very powerful to use in an application where it is being used to put together a bunch of potentially unknown parts into a working application. You might also think about this as a 3rd party extending your application. When you are compiling your application (long before you ship), you have absolutely no idea on what sorts of extensions might be built for your application into the future. That’s the power of extensible applications, they can be extended and used in ways the original authors perhaps didn’t expect, or didn’t have the time to do themselves. If you are concerned strictly with the “known” part of the equation (composing different software entities together that are all known at compile time), there are other solutions that are available today that are very powerful for this scenario: namely IoC containers (IoC = Inversion of Control). The Managed Extensibility Framework was designed primarily with the unknown aspect of extension in mind.
- #30: If you would like to host your demo on the Virtual Server, please use the myVPC demo slide, not this slide.
- #31: ContosoAutomotive
- #32: 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.
- #33: 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.
- #35: 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.
- #36: If you would like to host your demo on the Virtual Server, please use the myVPC demo slide, not this slide.
- #37: BabyNames
- #38: 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).
- #39: 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
- #40: 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.
- #41: If you would like to host your demo on the Virtual Server, please use the myVPC demo slide, not this slide.
- #42: DynamicInterop from ManagedLanguages Ten-In-One
- #43: 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.
- #44: MESSAGING:Office has thousands of APIs for addins exposed through COM. But COM was designed for native code. Interop Assemblies help “translate” between managed and native code by containing all the marshalling data necessary to make communication possible.
- #45: MESSAGING:Let’s look at Office as an example. Add-ins in Excel, for instance, may very well need to talk to each other -> Because they have to talk to each other, they have to be using the same types for Excel -> Because of the way the type system works in the CLR, these types must also be in the same assembly -> So, the assembly is required to be in a common location (e.g. the GAC) in order for the add-ins to function properly.Well, Office currently does not require the .NET Framework to be installed on a machine. If a machine doesn’t have .NET installed, there’s no GAC, and hence nothing to deploy the PIA into. Herein lies the problem. Even if an add-in is only using a single function, enum, etc. from the interop assembly, the add-in must deploy the entire PIA along with itself. Office PIA is around 10-20mb, it’s HUGE. So you might have a 100k add-in “bringing along” a 20mb PIA.
- #46: MESSAGING:There are two primary things that enable PIAs to be buried, forever, never to rise again. Compiler enhancements (this embedding works down to the method level even, so even a full interface is not required).Runtime enhancementsEven though they are in different assembliesEven though they may have different subsetsHence, type equivalence allows two interfaces, enums, delegates and plain-old-data-structures to mark themselves as equivalent with each other.
- #47: If you would like to host your demo on the Virtual Server, please use the myVPC demo slide, not this slide.
- #48: ContosoAutomotive
- #50: MESSAGING:Side X Side releases solve app compat issueCOM objects and other addins for different layers of the same cake can easily live together on the same runtimeHighly compatible – but only certain kinds of functionality can be added
- #51: MESSAGING:Run both 2.0-based and 4.0-based CLR in the same processOld components use old CLRNew components use new CLR Configuration file and hosting APIs give you fine-grained control
- #52: If you would like to host your demo on the Virtual Server, please use the myVPC demo slide, not this slide.
- #53: ContosoAutomotive