Visual C ++ .NET: What's New for MFC DEVELOPERS?

MFC 7.0 apps are now created with a default manifest resource, allowing them to respond to Windows XP themes right out of the box. You can further override individual themes for controls by calling SetWindowTheme. As you can see in Figure 1, Windows XP themes change The Visual Styles of The Caption Bar, Scroll Bars, And Other Aspects of A Window.figure 1 Windows XP Themes

CWnd has been updated to add Active Accessibility support. Calling EnableActiveAccessibility allows you to override the default support to add your own non-windowed elements. MFC handles normal windows as well as windowless ActiveX controls. Windowless controls are lightweight ActiveX controls that are optimized for faster Rendering.

Windows 2000 and Windows XP have new File Open and Save dialog boxes (see Figure 2). MFC 7.0 applications using the CFileDialog class automatically take advantage of the new user interface.Figure 2 New File Open Dialog Box

For printing support, Windows 2000 has more extensible print property sheets (see Figure 3), replacing the older print dialog box. The new CPrintDialogEx encapsulates this functionality. You can customize the print property sheet by either extending the lower portion of the General page or adding your own property sheets.Figure 3 Print Property SheetsEnhanced ActiveX Control ContainmentMFC 7.0 added support for containing windowless ActiveX controls and the control container is now overridable. Many new control containers such as Visual Basic® 6.0 can take advantage of this performance optimization, and now Mfc Does, Too. ATL HAS Support for Building Windowless ActiveX Controls.

Now that the container hosts ActiveX controls, the control container is accessible to your application. You can override pieces of the COleControlSite to add custom containment behavior. This greatly increases the flexibility you now have with MFC.Type-safe Message Maps

And finally, MFC 7.0 message maps have been made more type-safe by providing stricter type checking of return values ​​and parameters of the message handler functions. This will alert the developer to unsafe handlers that previous versions of MFC let slip. For example, it used to be OK to return void (instead of LRESULT) on an ON_MESSAGE or ON_REGISTERED_MESSAGE handler, and the compiler would not generate any warning. With MFC 7.0, the compiler will generate an error message.Smorgasbord of Utilities

New utilities in MFC include a regular expression class, 64-bit date and time functions, template collection classes, security classes, wrappers for the Win32 CryptoAPI functions, classes and macros to support performance counters, and support for thread pools. In the next few sections we'll briefly describe these new utilities.Regular Expression ClassThe regular expression class adds to MFC's string searching and pattern matching capabilities Regular expression support is provided by two templates:.. CAtlRegExp and CAtlReMatchContext These templates can be specialized to support both Multibyte Character Set (MBCS) and UNICode strings.

To Use Regular Expressions, CATLREGEXP MUST FIRSSIALIZED with The Search Expression Using The Parse Method, As You Can See Here:

CATLREGEXP <> Re; // Using the default character trait

Re.Parse ("ab.d");

CATLRematchContext MC;

Re.match ("Abcd", & MC); // Returns True, Successful Match

Re.match ("BBCD", & MC); // Returns False, NO Match

Then the CAtlRegExp object can be used to match against a text string. The results of any matches are returned to the CAtlReMatchContext object. If matches are found in the string, CAtlReMatchContext :: GetMatch returns the starting and ending positions of the matched sequences.64 -bit Time and Date Functions

Your code may be safe from the Year 2000 bug, but did you know that the time and date functions in the standard C runtime library will fail after 19:14:07 on January 18, 2038? The new 64-bit time and date functions Can be used to represent a date Until Midnight of Decemr 31, 3000.

CTime and CTimeSpan have new methods to use 64-bit time / date values, including CTimeSpan :: GetDays64, CTimeSpan :: GetTotalHours64, CTimeSpan :: GetHours64, CTimeSpan :: Serialize64, CTime :: GetTime64, and CTime :: Serialize64.All these methods use the __int64 native compiler type C runtime library functions have also been updated to support 64-bit time / date: _ctime64, _wctime64, _ftime64, _futime64, _gmtime64, _localtime64, _time64, _utime64, _wutime64; _findfirst64, _wfindfirst64, _findnext64, _wfindnext64. ; and _stat64, _wstat64.atl collections and array classes

ATL 7.0 adds five new template collection classes: CAtlArray, CAtlList, CAtlMap, CRBMap, and CRBMultiMap (described in Figure 4) Why do you need more collection classes when you already have MFC and STL collections The new classes expand on the existing collections.? to allow for element types that are not 100 percent compatible with primitive type comparison and copying semantics such as smart pointers, auto pointers, and so on. The new collections accomplish this by using element trait classes, which define how the elements are copied, moved ., compared, and hashed A number of element traits are already defined for commonly used element types:. CAutoPtrElementTraits, CAutoVectorPtrElementTraits, CComQIPtrElementTraits, CStringElementTraits, and so on Unlike MFC collections, ATL collections do not support serialization.

To Use the collections, specify Both The element type and element trait in the templates, Like So:

CRBMAP ,

Cautoptr , CautopTrelementTraits >

This defines a dictionary, mapping CString's to CMyObject auto pointers CMyObject's elements are deleted automatically when they are removed from the collection.Security ClassesSecurity classes provide wrappers for all the common Windows NT security structures for access control ATL 7.0 defines wrappers for..:

· Access Control Lists with CaCl

· Discretionary Access Control Lists with cdacl

· SYSTEM Access Control Lists with csacl

· Security Identifier (SID) with csid

· Access token with caccriptiontoken

· Access token Groups with ctokengroups

· Access Token Privileges with ctokenprivileges

· Security Descriptors with csecuritydesc

· Security Attributes with CsecurityAttributes

A Number of Global Functions

Unfortunately, ATL 7.0 Does Not Provide Higher-Level Abstractions To The Windows NT Security Model

Cryptographic classes are wrappers to the Win32 CryptoAPI, providing functionality for encrypting, decrypting, hashing, digital signature, and key management (see Figure 5). Just like the security classes, you have to understand the Win32 CryptoAPI to make use of these classes. Performance Counters

Performance counters are very useful for monitoring the health and performance of a running application by providing various operating statistics at runtime. A new set of classes and macros have been added to support performance counters, and they are very easy to add into your own application using C Attributes from Your Application, You NEED TO IMPLEMENT THREE TYPES OF Objects: a Performance Monitor Object Manager, Performance Objects, and Performance Counters.

There is usually only one Performance Monitor Object Manager in your app;. It exposes a number of Performance Objects, each contains one or more Performance Counters The performance counter classes need to reside in a DLL, so you may need to create a separate DLL for Your app for the counter.

Here's How To Define The Performance Monitor Object Manager:

[Perfmon (Name = "MyApplication", Register = true)]

Class CMYApplicationPerfmon

{

}

Figure 6 shows how to define a Performance Object and Performance Counter.

To Use the counter itize the Performance Monitor Object Manager and create an instance of the Performance Object, as you can see in Figure 7.

With the Performance Object, you can update The Performance Counters Directly As Member of the Performance Object:

Void setCounter (Ulong Value)

{

IF (g_pstatsobject)

g_pstatsObject-> samplecounter = value;

}

That's it! If you do not want to use C attributes, there are corresponding classes and macros that you can use instead. You should also be aware that setting counters to specific values ​​is generally safe without having to worry about thread synchronization, but performing calculations on the counters, such as incrementing or decrementing, requires the use of atomic operations such as InterlockedIncrement or synchronization using critical sections.Thread PoolsThread pools are very useful in high-performance server apps where you want to maximize the concurrency of your app while minimizing the context switching overhead. The optimal number of concurrent threads is generally a multiple of the number of processors on your server, and the thread pool allows you to queue up worker tasks to be executed.

The MFC 7.0 thread pool implementation is based on the Windows NT I / O Completion Port. CThreadPool is a templated class that you can specialize with your own worker class. When a thread is available, your worker's Execute function will be called. Workers are queued And Executed on a FIFO Basis.

To Define your worker class, you need to follow the worker archtype by defining:

· Initialize, Which is Called Once Per thread.

· Execute, Which is Called Once for Every Request Queued.

Terminate, Which is Called Once Per thread.

In The Worker Class, Declare The Requesttype TypeDef, Which Defines The Type of Data To Be Processed by Execute.

RequestType is an opaque type that can not be larger than sizeof (ULONG_PTR) (that is, 32 bits on x86 machines), so unfortunately you can not use large primitive types (such as double) or class instances.The following example defines a worker class, CMYWORKER, THAT WILL BE. The Request Type as a Pointer to CMYDATA.

Class CMYWORKER

{

PUBLIC:

TypedEf CMYDATA * REQUESTTYPE;

BOOL Initialize (Void * initparam);

Void Execute (CMYDATA * REQUEST, VOID * INTPARAM, OVERLAPPED * POVERLAPPED);

Void Terminate (void * initparam);

}

This Is How You Initialize and Queue A Task for the Thread Pool:

Cthreadpool threadpool;

Threadpool.initialize ();

ThreadPool.QueueRequest (New CMYDATA ());

Threadpool.shutdown (1000L);

Web Services, Web Applications, Andnetwork Classes

New in MFC 7.0 is support for consuming Web Services in MFC applications, writing Web Services, and writing Web applications with ATL server classes. In the following sections we'll show you how to generate code to access Web Services and call methods exposed by the service. We'll also explain how to generate HTML and inject it into an IStream with the support for HTML generation in MFC 7.0, how to use the MFC 7.0 new lightweight HTTP client, and how to send mail from MFC applications with new support for SMTP AND MIME-Encode Messages in Mfc 7.0.consuming Web Services in MFC

The Microsoft .NET vision centers on Web Services, where distributed systems on the Internet provide software building blocks that can be utilized through XML-based SOAP remote procedure calls, and UDDI / WDSL to discover and describe the available services. Web Services promise a whole new class of applications such as the Microsoft service codenamed "HailStorm," where the user can really take advantage of the ubiquity of the Internet. By integrating MFC desktop applications to Web Services, you can take advantage of server-based services and not be limited to a Web-based user interface. Unlike DCOM, Web Services can be easily accessed through firewalls and provide truly loosely coupled applications.Using Web Services in MFC is not much more difficult than using #import with COM objects. SProxy.exe is a command -Line Tool That Generates C Client Code to Access Web Services. The generated code is a proxy class thing encapsulates everything That You need to do in order to call the remote SERVICE.

Here's an esample of using sproxy.exe to generate myService.h from the Web service Exposed by an ATL Server:

Sproxy /out:myService.h

http://myserver/myservice.dll? Handler = GenmyServiceWSDL

To call the methods exposed by the Web Service, Simply Instantiate An Instance of The Proxy Class and Call ITS Methods, Just Like a Native C Class!

#include "myservice.h"

•••••

MyService :: CMYSERVICE Service;

HRESULT HR = Service.MYMETHOD (CCOMBSTR (L "a parameter");

HTML Generation Support

HTML generation support is provided by the CHtmlGen class and CHtmlGenBase <> template. CHtmlGen allows you to inject fully formed HTML into an IStream. To use CHtmlGen, simply initialize it with an IStream and call the various methods to generate the HTML tags, as you Can see in the following code.chtmlgen out;

Out.initialize (astream);

Out.html ();

Out.Head ();

Out.Title ("Test HTML");

Out.headend ();

Out.body ();

Out.a ("http://www.microsoft.com", "Microsoft");

Out.bodynd ();

Out.htmlend ();

A helper class caled atlhtmlattrs is buy to construct and hold name / value pairs of html attributes.http client

CAtlHttpClient is a lightweight HTTP client that can send requests to and receive responses from HTTP servers. CAtlHttpClient supports manually set proxies and various authentication schemes (currently, Basic and NTLM implementations are supplied). CAtlHttpClient makes synchronous HTTP requests, so you need multiple threads and .

Catlhttpclient client;

Client.navigate (_t (http://www.microsoft.com);

CSTRING ContentType;

Client.getHeaderValue (_T ("content-type"), contenttype);

BYTE * PBODY = client.getBody ();

Authentication is supported by CBasicAuthObject and CNTLMAuthObject. To use CBasicAuthObject, you must also supply a class that implements IAuthInfo, which returns the user domain, name, and password. CNTLMAuthObject defaults to using your current user name and password, but you can also supply an implementation of IAuthInfo for alternate identities. Custom authentication schemes can be implemented by deriving from CAtlBaseAuthObject.The following code adds the NTLM authentication scheme to an HTTP client. Without additional setup, the client will use the current logged-on user's identity for authentication.

CNTLMAUTHOBJECT NTLMAUTH;

Client.addAuthObject (_T ("ntlm"), & ntlmauth;

SMTP Support and Mime-Encode Merssis Support

The new SMTP support in MFC 7.0 allows you to send mail from MFC applications without using MAPI, Outlook®, or any other mail client. CSMTPConnection connects directly to an SMTP server and allows you to send MIME-encoded e-mail.

The mail message can be constructed using the CMimeMessage class, which also allows you to attach files, raw data, and other MIME-encoded messages. CMimeMessage supports all the common header fields including sender, sender name, recipients, CC, BCC, subject, Priority, And Content Type. this shows how to construct a mime message:

CmimeMessage Message;

Message.set Shender (_T ("someone@microsoft.com"));

Message.addreceIpient (receipient);

Message.setSubject (_T ("a test message");

Message.addText (_T ("this is a test message");

CSMTPConnection Connection;

Connection.Connect (Somesmtpserver);

Connection.sendMessage (MESSAGE);

High-Performance Database with OLE DB

ATL's OLE DB Consumer Templates are well-known for their superior performance and ease of use in accessing the OLE DB API. In MFC 7.0 it's even easier to use the ATL OLE DB Consumer Templates through C attributes. Attributes are a declarative syntax you place on a class, class member, or in global scope to give the compiler information about that object. The compiler can then generate code, generate metadata, or otherwise respond to the information in the attributes.For OLE DB, there are five attributes you will use : [db_source], [db_command], [db_column], [db_accessor], [db_table], and [db_param] These map closely to the OLE DB Consumer Template classes and maps, so they're probably somewhat intuitive Figure 8 is.. .

The code in Figure 8 declares a class which opens a connection to the database with the provided command. You instantiate it as you would any other normal C class. As you call the class's MoveNext function, the first three columns get automatically bound to the corresponding member variables. Binding by ordinal is a performance optimization. If you want to free yourself from the layout of the row, you can bind by name and let the compiler look it up. The use of attributes simplifies data access using OLE DB. Since attributes Just Expand to C Code, You Can Pass the Compiler A Command-Line Switch To See The Code After The Attributes Are Expanded.Updates To STL

New hash_map, hash_multimap, and hash_set classes are new hash-table-based extension classes in the Standard Template Library (STL). They are similar to std :: map, std :: multimap, and std :: set, but with different performance characteristics. Hash-table-based collections generally have faster lookup performance than the binary tree-based collections. Unlike map and set, the hash classes are not ordered containers.The latest STL implementation also fixes the known multithreading bugs in previous versions of the library , specifically in the map / set implementations and basic_string. in Visual C 6.0, basic_string was reference-counted, but the implementation was not thread-safe. in this version of STL, basic_string has been changed to a strictly copied implementation, eliminating the need To do thread-safen.

And Finally, STL HAS Better DLL Support. STL No Longer Holds Local Static Data Members, So They Can Be Exported from Dlls Without Problems.conClusion

Visual Studio .NET is a giant step forward for enhancing programmer productivity, and the Microsoft .NET initiative will likely change the programming landscape in the coming years. With this release of Visual C , MFC 7.0 has been updated to live in this new world of Web Services, while gaining better C standard compliance, full integration with ATL, and numerous enhancements to UI and utility classes. Best of all, these new features can be added to your existing MFC applications.