Visual Studio .NET
What You Need to Know Today About the New and Upgraded Features in Visual Studio .NET 2003
Carl Franklin
This article assumes you're familiar with Visual Studio .NET
Level of Difficulty
1
2
3
SUMMARY
Any time an upgrade of a favorite tool is released, questions about compatibility, versioning, and changes in methodology abound. The release of Visual Studio .NET 2003 is no exception. Developers will be relieved to learn that breaking changes have been kept to a minimum, and delighted to learn that important new features, like Visual J#, have been added. These and other new features of the .NET Framework 1.1 and Visual Studio .NET 2003, including mobile support and improved debugging, are discussed here.

Contents
I
f you ask developers what they think of Visual Studio® .NET 2003 and the Microsoft® .NET Framework version 1.1 you may get a cold response lamenting the lack of some features like the ability to break, edit, and continue in the debugger. If so, don't be discouraged. If you think there's nothing new or important in this new version, think again. There are plenty of new, exciting features, and if you're not so sure you want to take the plunge, you can take it in steps—you can still run Visual Studio .NET 2002 after you install Visual Studio .NET 2003.
Since Chris Sells has done a great job of explaining the compatibility issues and Windows® Forms features in "
Windows Forms: .NET Framework 1.1 Provides Expanded Namespace, Security, and Language Support For Your Projects" in this issue, I'll focus on all the other notable changes and features in .NET Framework version 1.1 and Visual Studio® .NET 2003. First, I'll focus on the changes that matter most, then get down to the minutiae.
Breaking Changes
The biggest "breaking" changes (updates that can break existing code) in the Framework can be found in its XML capabilities. In System.Xml.Xsl.XslTransform, an XmlResolver argument is now required on the Load and Transform methods. The only other breaking changes are that the System.Environment.HasShutdownStarted property is now Static, and the System.Security.Cryptography.DSACryptoServiceProvider class is now sealed (or in Visual Basic® .NET, NotInheritable). There are actually seven other changes that break code, but they are in the internal libraries iehost and iiehost. The remaining changes will not affect your code at all. In addition, there is support for multiple versions of the .NET Framework. You can create installers that target a specific version of the .NET Framework using a launch condition that checks for the correct version and redirects the user to a Web location to download redistributables if necessary.
New Language: Visual J# .NET 2003
Perhaps one of the biggest features of .NET Framework 1.1 is support for Visual J#™ .NET 2003, which is a managed version of the Java language. It's not the Java platform, but Java developers will feel right at home. Visual J# .NET also supports most of the features of Visual J++® 6.0, including Microsoft extensions. Add to that the ability to convert some Java binaries to run in the common language runtime (CLR), and Visual J# .NET is quite a nice little package for Java developers.
Since Visual J# .NET is just another CLR-targeted language, you can develop the same kinds of apps that developers using C# and Visual Basic .NET can (Web Services, ASP.NET, and so on). You also enjoy the security, cross-language, and deployment benefits of the .NET Framework.
The Visual J# Binary Converter Tool will transform Java bytecode into Microsoft intermediate language (MSIL). Be aware, however, that it works for most Java Development Kit (JDK) 1.1.4 level libraries and applications, but not all of them. The preferred method of porting is to recompile the Java-language source as Visual J# .NET. Use this tool only as a last resort.
Visual J# .NET is designed to provide class library support functionally equivalent to most of the JDK level 1.1.4 packages that were included in Visual J++ 6.0. It also provides classes specified in the College Board's Advanced Placement curriculum for Computer Science. Visual J# .NET also supports the Windows Foundation Classes (WFC) libraries and the following com.ms. packages: com.ms.lang, com.ms.dll, com.ms.com, com.ms.win32, com.ms.util, and com.ms.jdbc.odbc.
The Visual J# .NET compiler will not compile Java-language source code into Java-language bytecode, but into MSIL instead. Visual J# .NET does not support applet development, the ability to host applets in browsers, or the ability to create applications that will run on a Java VM. However, you can create Windows Forms controls that will render nicely in a browser on a client machine that has both the .NET Framework 1.1 runtime and the J# Redistributable Package 1.1 installed.
Visual J# .NET also does not support Java Native Interface (JNI), Raw Native Interface (RNI), and Remote Method Invocation (RMI). Figure 1 shows the relationships between Java binaries, source code, the JDK, and the .NET Framework.
Figure 1 Java Binaries, Source Code, the JDK, and the CLR
Java binaries can be converted to MSIL, although this is not a recommended practice. Once again, the best course of action is to convert Java-language source to Visual J# .NET so that you end up with pure Visual J# .NET source. An even better solution is to remove support for the JDK libraries altogether and recode directly to the .NET Framework. At that point you can move forward to CLR-targeted code without having to carry around legacy binaries or the JDK libraries. You will note that Visual J# .NET can target both the JDK-level 1.1.4 managed libraries and the .NET Framework proper.
Now, let's take a look at the language and compare it to C#. Figure 2 shows a simple Hello World application in C# developed in Visual Studio .NET 2003. Figure 3 is the same project written in Visual J# .NET.

Figure 3 Hello World in Visual J# .NET
package HelloJS;
import System.Drawing.*;
import System.Collections.*;
import System.ComponentModel.*;
import System.Windows.Forms.*;
import System.Data.*;
/**
* Summary description for Form1.
*/
public class Form1 extends System.Windows.Forms.Form
{
private System.Windows.Forms.Button button1;
/**
* Required designer variable.
*/
private System.ComponentModel.Container components = null;
public Form1()
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
//
// TODO: Add any constructor code after InitializeComponent call
//
}
/**
* Clean up any resources being used.
*/
protected void Dispose(boolean disposing)
{
if (disposing)
{
if (components != null)
{
components.Dispose();
}
}
super.Dispose(disposing);
}
#region Windows Form Designer generated code
/**
* Required method for Designer support - do not modify
* the contents of this method with the code editor.
*/
private void InitializeComponent()
{
this.button1 = new System.Windows.Forms.Button();
this.SuspendLayout();
//
// button1
//
this.button1.set_Location(new System.Drawing.Point(48, 40));
this.button1.set_Name("button1");
this.button1.set_TabIndex(0);
this.button1.set_Text("button1");
this.button1.add_Click( new System.EventHandler(this.button1_Click)
);
//
// Form1
//
this.set_AutoScaleBaseSize(new System.Drawing.Size(6, 15));
this.set_ClientSize(new System.Drawing.Size(192, 120));
this.get_Controls().Add(this.button1);
this.set_Name("Form1");
this.set_Text("Form1");
this.ResumeLayout(false);
}
#endregion
/**
* The main entry point for the application.
*/
/** @attribute System.STAThread() */
public static void main(String[] args)
{
Application.Run(new Form1());
}
private void button1_Click (Object sender, System.EventArgs e)
{
MessageBox.Show("Hello World");
}
}

Figure 2 Hello World in C#
using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
namespace HelloCS
{
/// <summary>
/// Summary description for Form1.
/// </summary>
public class Form1 : System.Windows.Forms.Form
{
private System.Windows.Forms.Button button1;
/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.Container components = null;
public Form1()
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
//
// TODO: Add any constructor code after
// InitializeComponent call
//
}
/// <summary>
/// Clean up any resources being used.
/// </summary>
protected override void Dispose( bool disposing )
{
if( disposing )
{
if (components != null)
{
components.Dispose();
}
}
base.Dispose( disposing );
}
#region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support—do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
this.button1 = new System.Windows.Forms.Button();
this.SuspendLayout();
//
// button1
//
this.button1.Location = new System.Drawing.Point(48, 48);
this.button1.Name = "button1";
this.button1.TabIndex = 0;
this.button1.Text = "button1";
this.button1.Click += new
System.EventHandler(this.button1_Click);
//
// Form1
//
this.AutoScaleBaseSize = new System.Drawing.Size(6, 15);
this.ClientSize = new System.Drawing.Size(208, 128);
this.Controls.Add(this.button1);
this.Name = "Form1";
this.Text = "Form1";
this.ResumeLayout(false);
}
#endregion
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main()
{
Application.Run(new Form1());
}
private void button1_Click(object sender, System.EventArgs e)
{
MessageBox.Show("Hello World");
}
}
}
As you can see, the two are very similar. The using statement becomes an Import statment. The C# bool datatype is a Boolean in Visual J# .NET. To derive a new class in C# you use the colon, like so:
public class Form1 : System.Windows.Forms.Form
Visual J# .NET uses the extends keyword instead:
public class Form1 extends System.Windows.Forms.Form
There are other obvious differences. The main point to remember is that Visual J# .NET is the Java language, not the Java platform. It is provided to allow Java developers (especially developers using J++) to leverage their talents and existing codebase.
Support for Mobile Devices
Although it might not seem big right now, because development for Pocket PC and Windows CE-powered devices is still gathering steam, support for mobile devices is huge. It's easy to imagine the significance of developing programs for these devices. They let you take your data with you wherever you go, modify it, bring it back to the desktop, and sync up.
If you've been following the beta versions of either the Smart Device Extensions (for developing binary client-side apps for mobile devices) or the Microsoft Mobile Internet Toolkit (for developing Web applications targeted to mobile devices), you've probably noticed a few name changes. You don't use the Mobile Internet Toolkit anymore. Now you create a mobile Web application and place mobile Web controls on mobile Web Forms. As for the Compact Framework, you still create smart device applications.
Generally, developing mobile applications goes much more smoothly with the final release than with previous betas you may have tried. The emulator seems to work well most of the time now, for example. Let me explain what's there for both mobile client and Web applications.
Mobile Client Applications
As the name implies, the .NET Compact Framework is a subset of the .NET Framework 1.1. There is no support for technologies that don't exist on Windows CE, like Active Directory® or Enterprise Services, but there is also no support for things that could have been included, like .NET Remoting and Configuration.
All the fundamental tools are there, however, including sockets, data access, support for calling Web Services, and graphics. I was able to write a quick utility to download an image from a URL and show it in a PictureBox in no time. You can easily get a bitmap object from a stream, and you can return a stream from an HttpWebResponse object. Put the two together and you've got a way to load images from URLs dynamically, as shown in Figure 4.

Figure 4 Loading Images from URLs
Imports System.Net
Imports System.IO
Private Sub LoadPictureFromURL(ByVal pb As PictureBox, _
ByVal URL As String)
Dim MyStream As Stream
Try
'-- Create request and response objects
Dim Request As HttpWebRequest = _
CType(WebRequest.Create(URL), HttpWebRequest)
Dim Response As HttpWebResponse = _
CType(Request.GetResponse(), HttpWebResponse)
'-- Get the response back as a Stream
MyStream = Response.GetResponseStream()
'-- Create a bitmap from that Stream
Dim Bm As Bitmap = New Bitmap(MyStream)
'-- Set the bitmap into the Picturebox
pb.Image = Bm
'-- Close the stream
MyStream.Close()
Catch ex As Exception
If Not MyStream Is Nothing Then
MyStream.Close()
End If
MsgBox(ex.Message)
End Try
End Sub
Since Beta 1, the Compact Framework team has added a DataGrid control, although finding it was tough. In some circumstances, the DataGrid doesn't show up in the Visual Studio .NET toolbox. You can get it by selecting the Toolbox, selecting Add/Remove Items, then pressing the Reset button in the Add/Remove dialog box. Other cool controls for Windows CE, like the TreeView, Toolbar, InputPanel, ListView, ProgressBar, TabControl, StatusBar, and TrackBar, are also available.
One feature I really like about mobile apps is that you can run a .NET Compact Framework-compiled assembly (mobile app) directly in the desktop version of the .NET Framework, without recompiling. To do this, Microsoft supplies a Retargetable enum keyword in the assembly manifest. I don't know if this is such a good practice, but it's good to know that it's possible to run a mobile app on the desktop. This won't work in reverse; you cannot copy a desktop .NET Framework-centric app onto a device and run it without recompiling.
You should definitely take care not to overdo a mobile application. Keep your interface simple. The stylus and software keyboard are limiting factors, and the overall goal of a mobile app is to let users enter data quickly with a very simple interface.
You can debug mobile applications on your PC using a hardware and software Pocket PC emulator that comes with Visual Studio .NET 2003. Note that you don't even need a device to write the code. When you are ready to deploy, you can deploy directly to the device or create a CAB file, which can be used to install the application on the device.
Figure 5 FnetSchedule
I have written a small mobile app called FnetSchedule that accesses a Web Service at http://www.franklins.net/fnservice/schedule.asmx to return a DataSet containing a schedule of upcoming hands-on Visual Basic .NET classes, along with a graphic for the location, as shown in
Figure 5. You can access it at
http://www.franklins.net/dotnet.
Mobile Web Applications
Mobile Web applications are ASP.NET applications that are targeted to devices like WAP-compatible cell phones. Smaller pages, less generated HTML and code, and a scaled down user interface are just the beginning. Like their big brother ASP.NET applications, mobile Web applications employ server-side controls that render device-specific content.
The best thing about mobile Web apps is that you can write one application and access it from just about any device, including cell phones. The controls in System.Mobile.Web.UI.MobileControls support more than 200 different devices, and that number is growing all the time. All of the device capabilities are stored in the Machine.Config file on the Web server. You can download device updates at
http://asp.net/mobile/deviceupdate.aspx.
Mobile Web Form controls include AdRotator, Calendar, Command (button), CompareValidator, CustomValidator, DeviceSpecific, Image, Label, Link, List, ObjectList, Panel, PhoneCall, RangeValidator, RegularExpressionValidator, RequiredFieldValidator, SelectionList, StyleSheet, TextBox, TextView, and a ValidationSummary control.
As with standard ASP.NET applications, the browser-based HTML controls are also available for access by client-side scripting languages like JavaScript and VBScript.
Among the controls I should point out here are the SelectionList, which can be a list, dropdown list, or combobox. Multiple items can be selected, and making a selection does not cause the form to post back. Also, the SelectionList does not support pagination, so it's ideal for small lists.
The DeviceSpecific control is an easy way to provide your own device-dependent content. You can render different code and HTML based on the type of client device.
The TextView control displays arbitrary amounts of text with optional markup tags. The format of the text in a TextView control is identical to that in literal text on a form. However, unlike literal text on a form, you can set the text in a TextView control. The TextView control supports internal pagination.
The PhoneCall control is an easy-to-use, text-based, output-only control that can be used to represent a phone number. For devices such as cell phones that support making phone calls, the PhoneCall control is presented as an interactive element that makes a call when activated. On other devices, the phone number is displayed as text with an optional hyperlink.
Finally, the ObjectList control provides a feature-rich view of a list of data objects. The ObjectList control inherits much of its behavior, including support for templated rendering, by using device template sets and internal pagination from the List control, but gives you more control than a list.
I was able to take my FnetSchedule app over to a mobile Web app with little modification. You can access it with your mobile device at http://www.franklins.net/mobile/schedule.
C++ Overhaul
The new version of C++ in Visual Studio .NET 2003 is perhaps the most significant upgrade to Visual C++® in a long time. Now C++ programmers can access the same Windows Forms engine that C# enjoys. This feature includes full support of the Toolbox and Server Explorer, which allows you to drag and drop or cut and paste controls and components directly onto your Windows Forms application. In addition, you can easily manipulate the properties of your controls and components through the Properties grid.
Visual C++ .NET is also more ANSI-conformant than the previous version. With this comes a number of breaking changes, many of which take the form of compiler errors, where they were waved through in previous releases. However, there are also a number of silent or runtime errors. Because of this conformance, in many cases it is possible to compile C++ code developed for other platforms.
Changes to the compiler include:
- A feature that allows you to create a delegate on a method of a value type.
- The /arch (Minimum CPU Architecture) compiler option, which has been added to take advantage of streaming SIMD Extensions (SSE) and SSE2 instructions.
- A /G7 (Optimize for Processor) compiler option to tell the compiler to optimize code generation for the specified processor.
- An enhanced /GS compiler option to help protect local variables from direct buffer overruns.
- The /Zm compiler option now specifies the precompiled header memory allocation limit.
- The /noBool option has been removed.
- /Gf is deprecated and will be removed in the next version of Visual C++.
Documentation has been provided for intrinsics _InterlockedCompareExchange, _InterlockedDecrement, _InterlockedExchange, _InterlockedExchangeAdd, and _InterlockedIncrement, and the _ReadWriteBarrier intrinsic has been added, which effectively blocks the optimization of reads and writes to global memory. This can be useful to ensure the state of global variables at a particular point in your code for multithreaded applications.
A handful of link options have been added as well: /ASSEMBLYDEBUG emits the Debuggable attribute with debug information tracking and disables just-in-time (JIT) optimizations. /ASSEMBLYLINKRESOURCE creates a link to a .NET Framework resource in the output file./DELAYSIGN lets you only place the public key in the assembly. /KEYFILE specifies a strong name key file. /KEYCONTAINER specifies a container for the key, and /SAFESEH tells the linker to only produce an image if it can also produce a table of the image's safe exception handlers.
Visual C++ .NET offers new property pages and a number of new objects, as well as new properties and methods for existing objects that enhance the project build model. Property pages include a Managed Resources Property Page, an XML Data Generator tool, a managed wrapper, a primary interop page, and an auxiliary managed wrapper property page.
New Data Providers for Oracle and ODBC
Probably the second biggest new feature (depending on how important Oracle and ODBC development is to you) is the addition of these two new ADO.NET data providers.
I can't comment on how well they work, except to say that reports on using ODBC for accessing DB2 have been very positive so far. Now you can avoid the COM layer (OLE DB) and code directly to the ODBC API (ODBC.DLL) and/or a managed-code Oracle provider, and just use the ADO.NET objects you already know and love.
Another change is that the System.Data.SqlClient.SqlDataReader HasRows property holds the value for whether a reader has returned data. This makes dealing with empty resultsets easier.
IP Version 6
The Internet is running out of IP addresses in the current 255.255.255.255 format. The demand for static IP addresses continues to grow. Tricky hardware and software schemes like Network Address Translation (NAT) and IP sharing on Web sites are necessary to get around the simple fact that there are only 2554 or about 4,300,000,000 unique numbers to use as IP addresses. This is a problem.
In 1995, the Internet Engineering Task Force (IETF) released the basic spec for Internet Protocol version 6 (IPv6). Most of today's Internet uses IPv4, which is nearly 20 years old. IPv6 is expected to gradually replace IPv4, with the two coexisting for a number of years during a transition period.
IPv6 addresses are 128 bits, as opposed to IPv4's 32-bit IP addresses. According to the
WIDE project if the total number of IPv4 addresses is represented as a millimeter, the total IPv6 address space would be 80 times the diameter of our galactic system. That should do it, don't you think?
Besides adding support for more IP addresses, IPv6 also adds many improvements to IPv4 in areas such as routing and stateless network autoconfiguration. IP addresses can be dynamically managed and assigned by the routers without resorting to Dynamic Host Configuration Protocol (DHCP). You can read all about autoconfiguration at
IPv6 Stateless Address Autoconfiguration.
Another great feature of IPv6 is true multicasting. This will allow routers to send the same packet to multiple routers. This allows clients to tap into streams of packets that have a single destination IP address, called a multicast Address, thereby eliminating the need for every client to get their own stream of data.
A live webcast with IPv4 looks like a regular webcast, but in reality the same packets are sent to multiple clients. It's sort of like radio broadcasting. There is a single wave. It is up to the client to put up the antennae and capture that data. Much less of a burden is put on the infrastructure, and everyone gets the same data at roughly the same time.
The .NET Framework 1.1 includes support for IPv6 in the System.Net namespace. You should expect to hear much more about IPv6 in the near future.
Changes in Visual Studio .NET
I'll get back to .NET Framework 1.1 in a minute, but first let me tell you what's new in Visual Studio .NET 2003.
Design The design of Visual Studio .NET 2003 is basically the same, but a bit snazzier. I find it's easier to get around the Start page, as shown in Figure 6. Unfortunately, you can still get lost in a docking maze, and that's not going to change anytime soon. Just remember to double-click a window's title bar to undock it, and then double-click the title bar to re-dock it, and you'll escape the worst of it. Also remember, you can always click the Reset Window Layout button in the Environment | General tab in the Tools | Options dialog.

Figure 6 Visual Studio .NET 2003 Start Page
Auto-completion features in Visual Basic .NET A Catch statement and End Try is now automatically written when you type Try. It's a nice feature (that should have been there all along), but how about automatic implementation of interfaces?
When you type an Implements statement in Visual Basic .NET, the interface is now written for you instantly. Try it. Create a new class with the following statement:
Public Class Foo
Implements IDisposable
End Class
As soon as you hit the Enter button after IDisposable, you get the following:
Public Class Foo
Implements IDisposable
Public Sub Dispose() Implements System.IDisposable.Dispose
End Sub
End Class
Adding Web references In Figure 7, the "Start Browsing for Web Services" pane in the Add Web Reference dialog box now provides Web links to available Web Services both locally and on the Internet. Interestingly, browsing the local machine for Web references had been available as early as Beta 1, but it was removed at the last minute. I'm glad to see it come back.
Figure 7 Start Browsing for Web Services
You can also rename the Web reference before you add it, as shown in Figure 8.
Figure 8 Rename Web Reference
New debugger features Remote debugging can now be done with pipes, which has security benefits not found in TCP/IP. Debugging with pipes requires the Remote Debug Manager, which is only available for C++. The debugger also gets support for SOS, a great managed code dump viewing tool, which gets hooked from the Command window. Error messages have been improved in general, particularly when debugging ASP.NET applications. Debug symbols can now reside on a separate symbol server, your own server, or the Microsoft public symbol server, and can automatically be downloaded if an exception occurs. In addition to all that, there are new debugging security settings so that, for example, you can specify who gets to debug and who doesn't.
Migrating settings from Visual Studio .NET 2002 You can copy certain Options dialog box settings from a previous version of Visual Studio .NET to the new version. If you have different versions of the program installed on the same machine, the first time you launch Visual Studio .NET 2003, a dialog box appears, giving you the choice to migrate your existing settings. Just click Yes to have your options and settings migrated.
Changes in the Solution Explorer One purpose of Visual Studio is to synchronize the designers with the underlying source code. This idea has now been taken one step further. A new option tells Visual Studio .NET that whenever you bring up a particular designer, it will be automatically selected in the Solution Explorer. Open the Projects and Solutions | Environment | Options dialog box, and check off Track Active Item.
Enterprise Services Low-level enrollment in Enterprise Services is now available. The idea is that now you can use Enterprise Services without having to inherit from a ServicedComponent.
ASP.NET features The big news here is the System.Web.UI.Page.ViewStateUserKey property. As you have probably experienced by now, letting ASP.NET manage the ViewState can be dicey. There's a great article that outlines the pitfalls of this at
Viewstate Optimization Strategies in ASP.NET.
Not only does care have to be taken for purposes of scalability, but there are security risks as well. The __VIEWSTATE variable can be hacked, which would open up your ASP.NET app for a one-click attack.
Setting the ViewStateUserKey property can help you prevent one-click attacks on your application. It does this by allowing you to assign an identifier to the __VIEWSTATE variable for individual users.
You can set this property to any string value, such as the user's session ID, but realize that you must set this property during the Page_Init phase of page processing. Setting this property during the Page_Load phase will cause an exception to be thrown.
Rounding out the new ASP.NET changes, the Checkbox, ListBox, ListControl, RadioButtonList, and Dropdown Listbox controls now support the SelectedValue property.
Enterprise Instrumentation Framework The Enterprise Instrumentation Framework (EIF) takes event logging, tracing, and performance counters and kicks them up a notch to support these functions (and more) across the network more easily. The EIF will help businesses reduce development and maintenance costs. It will help customers provide effective monitoring and troubleshooting in high-volume production environments, a key challenge when building distributed applications. To unify existing event logging and tracing mechanisms built into Windows, the EIF will provide a consistent, low-profile API and configuration layer. Developers can use this feature to publish audits, errors, warnings, business events, and diagnostic events for support teams to monitor and analyze. In short, you get better instrumentation across a wider scope of environments.
Support for Universal Time Universal Time is the international standard by which all other times are calculated. Coordinated Universal Time (UTC) was previously known as Greenwich Mean Time (GMT). Several classes in the .NET Framework have been upgraded to support values expressed in UTC.
Date and time in Windows Management Instrumentation (WMI) is represented in DMTF datetime format. This format is explained in the WMI SDK documentation. (The SDK is available at
Windows Management Instrumentation (WMI) Tools.) The lowest precision in DMTF is microseconds and in DateTime it is a Tick, which is equivalent to 100 nanoseconds. When you convert from Ticks, the value is rounded off to the nearest microsecond.
There is a new System.Management.ManagementDateTimeConverter class that converts between DMTF datetime format and CLR-compliant DateTime formats.
SMP thread synchronization .NET Framework 1.1 adds features for multiprocessor thread synchronization (volatile reads and writes, and memory flushing). Of course, these thread synchronizations should be handled with care.
Conclusion
So there you have it—a rundown of all the major changes to .NET Framework 1.1 and Visual Studio .NET 2003, with the exception of Windows Forms. It's hard to get used to the idea that installing new applications within .NET won't destroy or replace the old ones. Of course, knowing what I know about the .NET Framework, it should have been no surprise, since eliminating versioning problems is a major focus. But I was so used to spending hours and hours undoing what a rogue installation had done to my system. I don't know what I'm going to do with all of this newfound free time.
Carl Franklinis president of Franklins.Net (
http://www.franklins.net) where he teaches Visual Basic .NET classes and hosts .NET Rocks!, an Internet audio talk show for developers using the .NET Framework.