Download to read offline
![A Code Contract contains…
Invariants - must always be true
[ContractInvariantMethod]
protected void ObjectInvariant()
{
Contract.Invariant(denominator > 0);
}](https://image.slidesharecdn.com/dotnet4-241114124854-9d438753/85/Introduction-DotNet-4-0-Intro-by-Mohan-15-320.jpg)
Uploaded byMohan Arumugam
Introduction - DotNet 4.0 Intro by Mohan
.NET 4.0 introduces numerous enhancements, including improved performance and support for new languages such as F# and IronPython. Key features include the Dynamic Language Runtime, Code Contracts for coding assumptions, and the Managed Extensibility Framework for better dependency management. The update also brings significant improvements to various platforms like WPF, ASP.NET, and Windows Workflow, making development more efficient and streamlined.
More Related Content
![[CLPE] Novidades do .net Framework 4.0](https://cdn.slidesharecdn.com/ss_thumbnails/clnovidadesframework4-100422222852-phpapp01-thumbnail.jpg?width=640&height=640&fit=bounds)
Similar to Introduction - DotNet 4.0 Intro by Mohan
Introduction - DotNet 4.0 Intro by Mohan
- 1. What’s new in.Net 4.0 ?? Mohan
- 2. Consultant Certification Mohan Arumugam Technologies Specialist E-mail: moohanan@gmail.com Phone : +91 99406 53876 Profile Blogger Trainer Who Am I ?
- 3. Agenda • New Featuresin SharePoint 2013 • Development
- 4. The boring credentials… Decade of development experience Recently turned independant consultant Speaker & User Group Leader Microsoft MVP (ASP.NET) ASPInsider Writer Blog: blog.jesschadwick.com Articles: in CoDe and DevConnections magazines
- 5. What Is The.NET Framework? Base Class Libraries The CLR JIT & NGEN Garbage Collector Security Model Exception Handling Loader & Binder WPF Win Forms DLR ASP.NET WCF …and more! LINQ- to-SQL
- 6. .NET 4.0 Overview:New & Updated CLR & Framework The CLR The Base Class Library Performance, Concurrency & Parallelization New Languages (F#, IronPython) Language Enhancements Dynamic Language Runtime Code Contracts Managed Extensibility Framework (MEF) Platforms Entity Framework WPF Windows Workflow ASP.NET ASP.NET MVC Web Forms ASP.NET AJAX
- 7. .NET 4.0 Overview:New & Updated CLR & Framework The CLR The Base Class Library Performance, Concurrency & Parallelization New Languages Language Enhancements Dynamic Language Runtime Code Contracts Managed Extensibility Framework (MEF) Platforms Entity Framework WPF Windows Workflow ASP.NET • ASP.NET MVC • Web Forms • ASP.NET AJAX ( Platform demos if we have time )
- 8.
- 9. The Goals ofCLR 4 Working Better Together… Faster… With Fewer Bugs… In-Proc SxS Native/Managed Interop DLR Integration Managed Extensibility Framework Threading Parallel Extensions Garbage Collection Profiling Code Contracts Debugging Corrupted State Exceptions
- 10. Base Class LibraryAdditions Numerics BigInteger Data Structures Tuple (new Tuple<int,int,string>(1,2,”Test”)) ISet<T> (SortedSet<T> & HashSet<T>) I/O Memory-Mapped File
- 11. Performance, Concurrency, and ParallelExtensions Thread-safe collections (BlockingCollection<T>, ConcurrentDictionary<T>, etc.) Task Parallel Library (TPL) PLINQ Lazy Initialization eg: Lazy<IEnumerable<Order>> Orders { get; set;}
- 12.
- 13. Design By Contract Code Contracts provide a language-agnostic and declarative way to express coding assumptions in .NET programs.
- 14. A Code Contractcontains… Pre-conditions: must be true before public Rational(int numerator, int denominator) { Contract.Requires(denominator > 0); … } Post-conditions: must be true after public string GetPassword() { Contract.Ensures(Contract.Result<string>() != null); … return password; }
- 15. A Code Contractcontains… Invariants - must always be true [ContractInvariantMethod] protected void ObjectInvariant() { Contract.Invariant(denominator > 0); }
- 16.
- 17. Language Enhancements C#,Visual Basic, plus new Functional & Dynamic Languages
- 18. New C# 4.0Features 1. Improved COM Inter-op 2. Named and Optional Parameters 3. Covariance and Contravariance
- 19. New VB10 Features 1.Auto-Implemented Properties 2. Collection Initializers 3. Statement Lambdas 4. Implicit Line Continuation 5. Covariance and Contravariance
- 20. New VB10 Features 1.Automatic Properties 2. Collection Initializers 3. Statement Lambdas 4. Implicit Line Continuation 5. Covariance and Contravariance
- 21.
- 22. Covariance Describes the substitutionof related types, such that the ordering from the more restrictive type to the less restrictive type is preserved
- 23. Covariance Describes the substitutionof related types, such that the ordering from the more restrictive type to the less restrictive type is preserved class Derived : Base { } IEnumerable<Derived> d = new List<Derived>(); IEnumerable<Base> b = d;
- 24. Contravariance Describes the substitutionof related types, such that the ordering from the more restrictive type to the less restrictive type is reversed.
- 25. Contravariance Describes the substitutionof related types, such that the ordering from the more restrictive type to the less restrictive type is reversed. class Derived : Base { } public void DoSomething(Action<Derived> func); DoSomething((Base x) => x.Foo());
- 26.
- 27.
- 28.
- 29. Introducing… F#! F#Is… A functional programming language derived from OCaml and the ML family of languages Very good for computation-intensive problems, highly-parallel problems, and language-oriented programming A first-class .NET 4.0 language, with full Visual Studio 2010 support
- 30.
- 31. New C# 4.0Features 1. Improved COM Inter-op 2. Named and Optional Parameters 3. Covariance and Contravariance 4. Late-binding support (via dynamic keyword) (Will show up in our demos coming up next!)
- 32.
- 33. Why a “DynamicLanguage Runtime”? Common Language Runtime Statically-Typed C# VB Ruby Python Dynamically-Typed Dynamic Language Runtime
- 34. Python Binder Ruby Binder COM Binder JScript Binder Object Binder .NET Dynamic Programming DynamicLanguage Runtime Expression Trees Dynamic Dispatch Call Site Caching IronPython IronRuby C# VB.NET … whatever!
- 35.
- 36. Declarative Development ASP.NETWeb Forms (ASPX) XAML (WPF & Silverlight) Code Contracts MEF!
- 37.
- 38. What is MEF? MEFis… A way to manage dependencies A way to provide extensibility in your apps A framework to encourage loose coupling and reusability A new addition to the Base Class Library System.ComponentModel.Composition
- 39. What is MEF?(Simple Answer) Imports and Exports
- 40. What is MEF?(Simple Answer) Imports and Exports of components (“parts”)
- 41. What is MEF?(Complex Answer) Imports and Exports of components (“parts”) wired together via containers
- 42. What’s New inthe Platforms? WPF, ASP.NET, Workflow, etc!
- 43.
- 44. Lots of GoodStuff for WPF Multitouch Windows 7 taskbar Windows 7 ribbon Full Trust XBaps Cached compositions Textclarity Layout rounding ClickOnce improvements Focus mgt improvements Support for UIAccessible2 VSM integration Media element improvements Client profile Data controls Accessibility improvements Control themes Chart controls … hundreds of good bug fixes too!
- 45. Entity Framework It’snot just for databases anymore!
- 46. EF4 Enhancements Model-FirstDevelopment Persistence Ignorance (POCO support!) Application Patterns (Repository, Unit of Work, etc.) Customization of Queries & Generated Code
- 47.
- 48. WF challenges today Limited support for XAML-only workflows Versioning is problematic Composition difficult or impossible Writing custom activities and managing data flow is not easy enough today Limited WCF integration and activity support No generic server host environment Bottom line: A high bar to get to enough value to make it worth the tax
- 49. Moving towards .NET4.0 XAML-only workflows are the new default Unified model between WF, WCF, and WPF Extended base activity library Simplified WF programming model Support for arguments, variables, expressions Major improvements to WCF integration Runtime and designer improvements Hosting & management via "Dublin"
- 50. Extended base activitylibrary .NET 4.0 comes with several new activities Flow control • Flowchart • ForEach • DoWhile • Break WCF • Send • Receive • SendReply • SendParameters • ReceiveParameters • CorrelationScope • InitializeCorrelation • … Others • Assign • MethodInvoke • Persist • Interop • PowerShellCommand • ... Microsoft is planning to ship more activities via CodePlex
- 51. New flow chartmodel Flowcharts offer a middle ground between the sequential and state machine models Simple step-by-step model, with decisions and switches Allows you to return to previous activities in the workflow
- 52. Improving the Web ASP.NET MVC, Web Forms, and ASP.NET AJAX
- 53. ASP.NET MVC v.2“Officially” part of the framework New Features for v2: Areas Data Annotations support Templated Helpers Client-Side Validation
- 54. Web Forms • ClientID manipulation • Fine-Grained ViewState control
- 55. ASP.NET AJAX • Client-SideTemplates •Client-SideDataControls(DataView&DataContext) • DeclarativeInstantiation • CommandBubbling • LiveBindings
- 56. Questions? Please completethe online evaluation form
- 57. Thank you! Contact Info Email:jesschadwick@gmail.com Blog: blog.jesschadwick.com Twitter: twitter.com/jchadwick Resources • Visual Studio 2010: msdn.microsoft.com/en-us/vstudio • MEF Homepage: mef.codeplex.com • DLR Homepage: dlr.codeplex.com • IronPython Homepage: ironpython.codeplex.com
- 58. Mohan Arumugam Technologies Specialist E-mail: moohanan@gmail.com Phone : +91 99406 53876 Profile Thank You
Editor's Notes
- #10 BigInteger: an immutable type that represents an arbitrarily large integer whose value in theory has no upper or lower bounds Tuple: a small, finite list of objects; used to pass around multiple values in one object. Kind of like a dynamic struct. ISet<T>: collections that have unique elements and specific operations. Memory-Mapped File: gives you ability to work with files without loading them into memory and locking them from other processes
- #18 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.
- #19 MESSAGING: We show all these features in our demo.
- #20 MESSAGING: We show all these features in our demo.
- #27 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. Declarative Imperative languages focus heavily on the how. Programming logic is achieved via if statements, for loops, while loops, etc. Declarative languages focus on the what Tell 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. Dynamic Around 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 code In 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. Concurrent Concurrency 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 concurrency This 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-state F# 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-hood For shared-stated languages like C# and Visual Basic, concurrency features are primarily coming from library features like Parallel Extensions Language teams are thinking hard about how to possibly integrate concurrency into the core language (this is a hard space).
- #28 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. Declarative Imperative languages focus heavily on the how. Programming logic is achieved via if statements, for loops, while loops, etc. Declarative languages focus on the what Tell 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. Dynamic Around 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 code In 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. Concurrent Concurrency 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 concurrency This 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-state F# 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-hood For shared-stated languages like C# and Visual Basic, concurrency features are primarily coming from library features like Parallel Extensions Language teams are thinking hard about how to possibly integrate concurrency into the core language (this is a hard space).
- #29 MESSAGING: F# is a functional programming language for the .NET Framework. It combines the succinct, expressive, and compositional style of functional programming with the runtime, libraries, interoperability, and object model of .NET. F# is included in Visual Studio 2010 and is now a first-class language just like Visual Basic, C#, and C++. F# is very good for compute-intensive problems, highly parallel problems, and language-oriented programming. Since F# just generates normal MSIL and .NET assemblies, you can develop a library in F# that does your computations, and call your F# code from your C# application.
- #30 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. Declarative Imperative languages focus heavily on the how. Programming logic is achieved via if statements, for loops, while loops, etc. Declarative languages focus on the what Tell 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. Dynamic Around 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 code In 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. Concurrent Concurrency 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 concurrency This 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-state F# 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-hood For shared-stated languages like C# and Visual Basic, concurrency features are primarily coming from library features like Parallel Extensions Language teams are thinking hard about how to possibly integrate concurrency into the core language (this is a hard space).
- #31 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.
- #33 MESSAGING: The DLR provides core services that are necessary for dynamically-typed languages to work on the CLR The 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 Dispatch Call Site Caching
- #34 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.
- #35 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. Declarative Imperative languages focus heavily on the how. Programming logic is achieved via if statements, for loops, while loops, etc. Declarative languages focus on the what Tell 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. Dynamic Around 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 code In 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. Concurrent Concurrency 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 concurrency This 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-state F# 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-hood For shared-stated languages like C# and Visual Basic, concurrency features are primarily coming from library features like Parallel Extensions Language teams are thinking hard about how to possibly integrate concurrency into the core language (this is a hard space).