Visual Studio 2010 and .NET Framework 4 Beta 1 are available for download. .NET 4 Beta 1 contains new functionality and improvements throughout the framework. In this post I’ll discuss the changes specific to the BCL.
Many of the features listed below were previously announced when we released the .NET Framework 4 CTP back in November of last year. I’ve included these features again below for completeness. New functionality in Beta 1 that wasn’t present in the CTP is denoted as such.
- Code Contracts
System.Diagnostics.Contracts provides a language-agnostic way to express coding assumptions in .NET programs. The contracts take the form of pre-conditions, post-conditions, and object invariants. Contracts act as checked documentation of your external and internal APIs. The contracts are used to improve testing via runtime checking, enable static contract verification, and could be used in documentation generation. We partnered with Microsoft Research to deliver this feature in .NET 4. More information and links to the tools are available on the Code Contracts DevLabs site.
(new in Beta 1) The latest release of the tools works with Visual Studio 2010 Beta 1.
- Parallel Extensions
The Parallel Computing Platform team worked with us to add the Task Parallel Library (TPL), Coordination Data Structures, and Parallel LINQ (PLINQ) to the BCL in .NET 4. This includes an improved ThreadPool scheduling algorithm for tasks, Task and Task<T>, the static Parallel class, concurrent collections in System.Collections.Concurrent, and other coordination data structures such as Lazy<T>, CountdownEvent, Barrier, SemaphoreSlim, SpinLock, SpinWait, and ManualResetEventSlim. More information is available over at the PFX team’s blog.
System.Numerics.BigInteger is an arbitrary-precision integer data type. BigInteger supports all the standard integer operations, including bit manipulation. It can be used from any .NET language, and some of the new .NET languages—such as F# and IronPython—have support built-in to the language. We partnered with the Microsoft Solver Foundation team to deliver this in .NET 4.
- Variance annotations (new in Beta 1)
C# and VB now support safe co- and contra-variance for generic interface and delegate types. Co-variance means that a generic of a type, e.g. an IEnumerable<String>, can be treated as a generic of any supertype, e.g. an IEnumerable<Object>. Contra-variance means that a generic of a type, e.g. an Action<Object>, can be treated as a generic of a subtype, e.g. an Action<String>. In C#, co-variance is annotated with the “out” keyword and contra-variance is annotated with the “in” keyword. VB has similar “In” and “Out” keywords. We’ve annotated several interfaces and delegates in the BCL for variance, including: IEnumerable<T>, IEnumerator<T>, IComparer<T>, IEqualityComparer<T>, IComparable<T>, the Action and Func delegates, Predicate<T>, Comparison<T>, EventHandler<TEventArgs>, and Converter<TInput, TOutput>.
- Tuples (new in Beta 1)
We’ve added common Tuple types in the BCL to facilitate language interoperability and to reduce duplication in the framework. A tuple is a simple generic data structure that holds an ordered set of items of heterogeneous types. Tuples are supported natively in languages such as F# and IronPython, but are also easy to use from any .NET language such as C# and VB.
- SortedSet<T> (new in Beta 1)
We’ve added a SortedSet<T> collection along with a new ISet<T> interface. SortedSet<T> uses a self-balancing tree which maintains data in sorted order for performance guarantees with insertion, deletion, and searches. Both the new SortedSet<T> and the existing HashSet<T> implement ISet<T>.
- File System Enumeration Improvements (new in Beta 1)
System.IO.Directory and System.IO.DirectoryInfo have new APIs for enumerating the file system that return IEnumerable<T>s instead of arrays. These new APIs are more efficient than the array-based APIs because they do not need to allocate a (potentially large) array and you can access the first results immediately instead of waiting for the entire array to be created and returned. We’ve also added new convenience APIs for efficiently reading, writing, and appending lines from/to a text file using IEnumerable<String>. These new APIs are useful in LINQ scenarios where you may want to quickly and efficiently query the contents of a text file and write out the results to a log file without allocating any arrays.
System.IO.MemoryMappedFiles exposes the memory mapping functionality provided by Windows as first-class managed APIs. Memory mapped files can be used to efficiently edit very large files and can also be used to create shared memory for inter-process communication. Along with this feature, we’re introducing System.IO.UnmanagedMemoryAccessor, a new class that enables random access to unmanaged memory similar to how UnmanagedMemoryStream enables sequential access to such memory.
- Registry Improvements (new in Beta 1)
We’ve added support to Microsoft.Win32.RegistryKey for accessing alternate registry views (32bit and 64bit views) on 64bit Windows. We’ve also added the ability to create volatile keys—keys that are stored in memory and are not persisted when the hive unloads (which typically happens on reboot). In addition, we’ve added new extensibility APIs that take and return a SafeRegistryHandle to make it easier to interoperate with Win32 registry APIs that do not have managed wrappers.
- Globalization data updated to Unicode 5.1 (new in Beta 1)
Culture data in .NET 4 has been updated, including updating the character information to Unicode 5.1. We have also added support for new cultures, including new neutral cultures.
- ResourceManager Improvements
The ResourceManager in System.Resources has been improved to respect the user’s preferred UI languages when looking for localized resources, instead of only using the CurrentUICulture’s parent chain. This means if the user has specified in Windows that she prefers French and Spanish, the ResourceManager will look for French and Spanish resources before falling back to the neutral resources. This change is present in Silverlight 2 as well as .NET 4.
- Compression Improvements
The compression algorithms in System.IO.Compression have been improved in .NET 4. DeflateStream and GZipStream no longer inflate already compressed data. This means that in many cases you’ll see better compression ratios when using these streams on .NET 4. We’ve also removed the 4 GB size limit, so you can now compress streams over 4 GB in length.
You can learn more about what’s new in the BCL in .NET Framework 4 on Channel9: Inside .NET 4: Meet the BCL Team.
We hope you enjoy the new functionality and improvements in Beta 1. Be sure to let us know if you run into any issues or if you have any further suggestions. And look out for even more improvements and refinements in the next preview release of .NET Framework 4.