Sort dates in Excel

• Select the Date column which wants to be sorted

• Click on Data Tab in Ribbon Control and then click on Text To Columns.  

• In the first menu, select Delimited and click on Next.  

• In the second menu, select a delimiter, use Tab; then click on Next.  

• In the final menu, select Date and from the pull-down menu, select the date form currently used,  for example DMY; then click Finish. 

• Then click on sort & filter and click on Sort oldest to newest Or Sort Newest to Oldest

The column is sorted now

Authentication from EAI webMethods to WCF web services

Authentication from EAI webMethods to WCF web services

Overview

The integration between EAI webMethods and WCF web services need to have an authentication to prevent unauthorized access of the WCF web services.

Implementing Security in WCF

When working with WCF or Web services, securing communication between the client and the service is very important.  Transfer security is concerned with guaranteeing the integrity and confidentiality of WCF service messages as they flow from application to application across the network. In WCF, transfer security is also responsible for providing authentication. 

WCF service should have a basicHttpBinding with transport security. When using transport security, the user credentials and claims are passed by using the transport layer. Transport security is used to provide point-to-point security between the two endpoints (service and client)

By default, basicHttpBinding does not support any security, so you will need to configure the binding to use transport security. This is a good option when you want to support interoperability with non-WCF or non-Windows clients.

Transport level security provides

• ·         Authentication of the sender.
• ·         Authentication of the service.
• ·         Message integrity
• ·         Message confidentiality.
• ·         Replay of message detection.

Figure 1 : Transport Security

Creating web service in EAI Web methods

1.       Set up the WCF service with Basic Authentication in the service config file as mentioned above.

2.       If hosted in IIS, make sure that the Directory security has Basic Authentication enabled. To do this in IIS 6, type inetmgr in the run command. Open IIS. Browse to WCF service virtual directory and right click and select properties. On the Directory Security tab, click on Edit button of Authentication and access control. Select Basic authentication and click OK.

Figure 2 : Enable Basic Authentication

To do this in IIS7,  type inetmgr in the run command. Open IIS. Browse to WCF service virtual directory. Double click on Authentication icon under Security Section. Enable only the basic authentication.

Figure 3: Enable Basic Authentication

3. Browse to the wsdl of WCF service in browser. On the login prompt, enter a valid AD user account and password. Save the WCF service in a local folder as .svc file

4.       Open IIS again and turn off basic authentication and turn on Anonymous authentication.

5.       Open the WCF service config file and remove the following lines

6.       Open Webmethods Developer to create the web service descriptor

7.       Right click on the folder where the web service descriptor needs to be created and select Newà All Choices

Figure 4: Webmethods Developer – Create web service descriptor

8.      Select the Web Service Descriptor option and click next

Figure 5: Webmethods Developer – Create web service descriptor

9.       Select web service descriptor as consumer and click Next

Figure 6: Webmethods Developer – Create web service descriptor

10.   Enter the name of the service and click Next

Figure 7: Webmethods Developer – Create web service descriptor

 11.   Browse to the svc file saved in step 3 and click on finish.

Figure 8: Webmethods Developer – Create web service descriptor

The service is now created in webMethods

12.   Open IIS again and turn on basic authentication and turn off Anonymous authentication.

13.   Open the WCF service config file and add the following lines wherever it is removed from the basicHttpBinding 

14.   Go to the EAI webMethods service call and pass in the user credentials in the transport authentication as below

Figure 9 : Webmethods developer – Pass Authentication details

Now the authentication is established between EAI and WCF to have the basicHttpBinding with transport security using Basic Authentication.

Silverlight 4.0 New Features

What’s new in Silverlight 4
Okay, now on to the details. Sit back, switch this post to your largest monitor, and grab a drink. This is a long post intentionally to provide you with details to the framework. In each area I’ll be sure to point out if there are existing resources (labs, videos, etc.) for that specific feature and be as concise as I can as to be “to the point” about what it provides, what are the requirements and some sample code, where appropriate. Here we go with the feature dump…
• Tooling
• Printing API
• Right-click event handling
• Webcam/microphone access
• Mouse wheel support
• RichTextArea Control
• ICommand support
• Clipboard API
• HTML Hosting with WebBrowser
• Elevated trust applications
• Local file access
• COM interop
• Notification (“toast”) API
• Network authentication
• Cross-domain Networking changes
• Keyboard access in full screen mode
• Text trimming
• ViewBox
• Right-to-left, BiDi and complex script
• Offline DRM
• H.264 protected content
• Silverlight as a drop target
• Data binding
o IDataErrorInfo and Async Validation
o DependencyObject Binding
o StringFormat, TargetNullValue, FallbackValue
• Managed Extensibility Framework (MEF)
• DataGrid enhancements
• Fluid UI support in items controls
• Implicit theming
• Google Chrome support

Tooling
With Visual Studio 2010, we finally have our designer surface back for Silverlight! Yes, you have an editable design surface for Silverlight…and actually this isn’t just limited to Silverlight 4…it is available for Silverlight 3. What is great about the Silverlight tools in VS2010 is that the databinding support is pretty rich in the designer surface as well.

Additionally, for WCF RIA Services, we have improved designer/editor support for using DomainSource classes as a Data Source in Visual Studio. Be sure to grab VS2010 for all your development needs. VS2010 allows for multi-targeting of Silverlight 3 and 4 applications.
Printing API
One of the top-most requested features in Silverlight has been to enable some printing support from the Silverlight application client-side versus always having the developer do things server-side. In Silverlight 4 we’re providing a printing API that we believe to be extensible for the developer and provide you with a simple printing of a visual tree, or a highly extensible model to enable you to create a virtual visual tree to print for the end user directly from Silverlight.
Code sample:
1: private void PrintAll_Click(object sender, RoutedEventArgs e)
2: {
3: // instantiate a new PrintDocument
4: PrintDocument docToPrint = new PrintDocument();
5:
6: // set a friendly name for display in print queues
7: docToPrint.DocumentName = "Entire Screen Sample";
8:
9: // wire up any starting code pre-printing (i.e., UI activity display)
10: docToPrint.StartPrint += (s, args) =>
11: {
12: ActivityDisplay.IsActive = true;
13: };
14:
15: // tell the API what to print
16: docToPrint.PrintPage += (s, args) =>
17: {
18: args.PageVisual = this.StackOfStuff;
19: };
20:
21: // wire up any clean-up code pre-printing (i.e., UI activity display)
22: docToPrint.EndPrint += (s, args) =>
23: {
24: ActivityDisplay.IsActive = false;
25: };
26:
27: // execute the print job
28: docToPrint.Print();
29: }
As you can see above, you can wire up pre- and post-print events for any type of preparation and clean-up code. The PrintPage is the important area here where the developer would pass a UIElement to print. This could be something that already exists in the visual tree, or something that is created virtually in-memory and not even added to the visual tree.

Right-click event handling
Do you have an application that has a need for a context-style menu (aka ‘right click’ menus)? Well, in addition to the MouseLeftButtonUp/Down events, we now enable the MouseRightButtonUp/Down events for you to attach to and handle. This enables the developer to take control over what you’d like to do when those events occur. This can be from handling simple commands for gaming (i.e., a right click is a different interaction in the game than the left click) or as well for providing context-style menus for additional functionality within the application.
1: public partial class MainPage : UserControl
2: {
3: public MainPage()
4: {
5: InitializeComponent();
6:
7: // wire up the event handlers for the event on a particular UIElement
8: ChangingRectangle.MouseRightButtonDown += new MouseButtonEventHandler(RectangleContextDown);
9: ChangingRectangle.MouseRightButtonUp += new MouseButtonEventHandler(RectangleContextUp);
10: }
11:
12: void RectangleContextUp(object sender, MouseButtonEventArgs e)
13: {
14: // create custom context menu control and show it.
15: ColorChangeContextMenu contextMenu = new ColorChangeContextMenu(ChangingRectangle);
16: contextMenu.Show(e.GetPosition(LayoutRoot));
17: }
18:
19: void RectangleContextDown(object sender, MouseButtonEventArgs e)
20: {
21: // handle the event so the default context menu is hidden
22: e.Handled = true;
23: }
24: }
The sample above shows a snippet from implementing a context menu within the application. The result of the above code looks like this:

As you can see, the event handling is simple and the flexibility exists for you, the developer, to choose what you want to happen functionally and visually when the right-click events occur.
Webcam and micrphone access
Need access to your user’s attached (or integrated) web camera and/or microphone? You got it. With a few simple lines of code you can request permission to your users to leverage their capture devices and then capture both the audio and video.
Sample code for requesting permission:
1: // request user permission and display the capture
2: if (CaptureDeviceConfiguration.AllowedDeviceAccess CaptureDeviceConfiguration.RequestDeviceAccess())
3: {
4: _captureSource.Start();
5: }
Sample code for capturing the video:
1: if (_captureSource != null)
2: {
3: _captureSource.Stop(); // stop whatever device may be capturing
4:
5: // set the devices for the capture source
6: _captureSource.VideoCaptureDevice = (VideoCaptureDevice)VideoSources.SelectedItem;
7: _captureSource.AudioCaptureDevice = (AudioCaptureDevice)AudioSources.SelectedItem;
8:
9: // create the brush
10: VideoBrush vidBrush = new VideoBrush();
11: vidBrush.SetSource(_captureSource);
12: WebcamCapture.Fill = vidBrush; // paint the brush on the rectangle
13:
14: // request user permission and display the capture
15: if (CaptureDeviceConfiguration.AllowedDeviceAccess CaptureDeviceConfiguration.RequestDeviceAccess())
16: {
17: _captureSource.Start();
18: }
19: }
We also provide a very simple API for enabling “snapshot” images from the webcam:
1: private void TakeSnapshot_Click(object sender, RoutedEventArgs e)
2: {
3: if (_captureSource != null)
4: {
5: // capture the current frame and add it to our observable collection
6: _captureSource.AsyncCaptureImage((snapImage) =>
7: {
8: _images.Add(snapImage);
9: });
10: }
11: }
I am interested to see how these webcam/microphone features are implemented in the wild by developers!

Mouse wheel support
In previous versions of Silverlight, you had to rely on some helper classes from either DeepZoom or other sample sites to implement handling the mouse’s scroll wheel functionality on things like ListBox, etc. We’re now providing APIs for you to handle MouseWheel events. You can attach this event handler to other items as well (not just ListBox).
1: // wire up the event
2: myRectangle.MouseWheel += new MouseWheelEventHandler(RectangleZoom);
3:
4: void RectangleZoom(object sender, MouseWheelEventArgs e)
5: {
6: // do something here like alter the scale
7: // MouseWheelEventArgs.Delta gives you an int
8: // of the amount changed in the scroll event
9: }
So as you can see, you can easily wire-up the event handler for the MouseWheel event on a particular element and respond accordingly.
RichTextArea control
One of the requested features has been to provide an editable text control that enabled rich text editing using common rich text changes like bold, italics, different sizes, etc. Using the RichTextArea, you can now enable these types of editing areas in your application. Here’s an example of implementing the RichTextArea control:


ICommand support on ButtonBase and Hyperlink
To help support development patterns like the popular Model-View-ViewModel pattern, support for commanding infrastructures is now provided on ButtonBase and Hyperlink. These exposed properties, Command and CommandParameter enable binding from a View to a ViewModel approach without the need for click event handlers in code behind files. This helps aide the pattern of separation of concerns for the UI and code layers.

Clipboard API

Prior to now, having a reliable method for providing contents that can be temporarily held in the machine’s “clipboard” memory area involved an IE-only solution or introducing other platforms into your Silverlight application.
With the addition of the Clipboard API, you can now have a cross-platform mechanism in Silverlight to provide this facility for you.
1: Clipboard.SetText("Some text to save in the clipboard area");
This sample above shows setting some simple text to the Clipboard which could then be pasted to the Silverlight application, or to other applications the user is using as this is now in the machine’s clipboard memory.
Video and Accessing the Global Clipboard Programmatically
Host HTML content using WebBrowser control
When you are working in the web world, you likely are dealing with HTML content in some area. Especially if you are creating content-managed systems, sometimes that content is stored as HTML. Enabling hosting HTML content in Silverlight is now possible by providing a simple WebBrowser control that will enable you to provide string-based HTML contents or navigate to a fully interactive URL.
Sample Code (XAML):
1:
Sample Code (C#):
1: MyBrowserControl.NavigateToString(" sdf");
As an example, here’s a Silverlight application hosting an embedded YouTube Flash video:

Hopefully this will be helpful in developing your Silverlight applications. Additionally, you can also use the HtmlBrush to fill elements using HTML content.

Elevated trust applications
One thing users have been asking for is to enable Silverlight out-of-browser (OOB) applications to have more privileges. You can now alter the OOB manifest to request more elevated permissions for your application. Using Visual Studio you can look at the project properties and enable the checkbox to add this request:

The result is that the OOB install dialog now looks a little different and warns the user of these elevated privileges:

See the next sections for things that you can do in OOB mode now while in a trusted application (aka elevated mode). It is important to note that this trusted application request still does not involve installing any additional runtime for the user…it is a part of the Silverlight 4 runtime – no additional download/framework would be required.
Access local files on user’s machine
In order to read/write data to the user’s machine, you normally have to do it through a mechanism like OpenFileDialog (read) and SaveFileDialog (write). In Silverlight 4 you can now have direct local file access to the users’ "My” folders in their profile. These are things like MyDocuments, MyVideos, MyMusic, etc. On OSX platform these map to the same user-level profile folders like /users/timheuer/Videos.
You use the Environment namespace to get the path locations for the operation you are wishing to do.
1: private void EnumerateFiles(object sender, RoutedEventArgs e)
2: {
3: // create a collection to hold the file enumeration
4: List videosInFolder = new List();
5:
6: // using the file api to enumerate
7: // use the SpecialFolder API to get the users low trust "My Document" type folders
8: var videos = Directory.EnumerateFiles(Environment.GetFolderPath(Environment.SpecialFolder.MyVideos));
9:
10: // enumerate the folder
11: foreach (var item in videos)
12: {
13: videosInFolder.Add(item);
14: }
15:
16: // bind the data
17: VideoFileListing.ItemsSource = videosInFolder;
18: }
This feature requires a trusted application (elevated permissions).

COM interoperability
Have you had the need to interoperate with device peripherals that only expose a COM interface? What about having your Silverlight application talk with Office applications? Using the ComAutomationFactory API, you can now have your Silverlight application instantiate and interact with COM applications on the Windows client.
Sample Code (interacting with Excel):
1: // create an instance of excel
2: dynamic excel = ComAutomationFactory.CreateObject("Excel.Application");
3:
4: excel.Visible = true; // make it visible to the user.
5:
6: // add a workbook to the instance
7: dynamic workbook = excel.workbooks;
8: workbook.Add();
9:
10: dynamic sheet = excel.ActiveSheet; // get the active sheet
This feature requires a trusted application (elevated permissions). Notice that this is done via the dynamic keyword in C# 4.0. One thing to also note that in the tooling you will not get IntelliSense support for your COM created objects. Keep that documentation for that API handy!

Notification (aka “toast”) API
Ever want your application to provide a notification mechanism to the user? This is often referred to as “toast” where a subtle notification temporarily displays in the user’s screen providing some information provided by the application. Perhaps one of the more common uses of this is in mail applications, like Outlook, where new mail notifications pop-up message notification windows near the system tray in Windows.
By using the NotificationWindow in Silverlight, you can provide a simple or customized notification mechanism for your application.
1: private void CustomNotificationButton_Click(object sender, RoutedEventArgs e)
2: {
3: // create the nofitication window API
4: NotificationWindow notify = new NotificationWindow();
5: notify.Height = 74;
6: notify.Width = 329;
7:
8: // creating the content to be in the window
9: CustomNotification custom = new CustomNotification();
10: custom.Header = "Sample Header";
11: custom.Text = "Hey this is a better looking notification!";
12: custom.Width = notify.Width;
13: custom.Height = notify.Height;
14:
15: // set the window content
16: notify.Content = custom;
17:
18: // displaying the notification
19: notify.Show(4000);
20: }
Here’s an example of a styled NotificationWindow content:

Notifications can only be done in Silverlight out-of-browser applications, and are simple to implement in few lines of code.

Network authentication in web requests
At times, you may be interacting with 3rd party (or perhaps your own) services that require authentication information to be passed into the service call. This authentication information may be different than the logged-on user’s current information.
We have enabled providing NetworkCredential information via the ClientHttp networking stack that was introduced in Silverlight 3. For example, to pass a username/password (basic auth) to a service call using this method would be something like this:
1: // NetworkCredential passing is available in ClientHttp networking stack
2: WebRequest.RegisterPrefix("http://", System.Net.Browser.WebRequestCreator.ClientHttp);
3:
4: WebClient myService = new WebClient();
5: myService.Credentials = new NetworkCredential("someusername", "somepassword");
6: myService.UseDefaultCredentials = false; // must be set to false if providing your own credentials
7: myService.DownloadStringCompleted += new DownloadStringCompletedEventHandler(OnResultCompleted);
8: myService.DownloadStringAsync(new Uri(http://somewebsite.com/authenticatedservice));
Note that we first register the prefix to use the ClientHttp networking stack. The second thing to note is that in WebClient, you still must specify UseDefaultCredentials=”false” even though you are providing new credentials. If you don’t, the default credentials will still be used.

Cross-domain Networking changes
One of the more significant changes to cross-domain networking comes when you have a trusted application. For services that have a closed cross-domain policy file (via clientaccesspolicy.xml or crossdomain.xml), if your application is a trusted application (elevated permissions), then the requirement for a cross-domain policy file is no longer required.
This only applies to trusted applications.

Full keyboard access in full screen
If you are developing kiosk applications or other Silverlight applications that run in full-screen mode (IsFullScreen=”true”), you have noticed that only a limited set of keyboard input was enabled. In Silverlight 4 trusted applications, any application in full-screen mode can have full keyboard input for things like TextBox or other input controls.
This only applies to trusted applications.
TextTrimming
The TextBlock control has a new property called TextTrimming that enables you to use the WordElipse trimming value. When the property is set, any text exceeding the visible limit of the control will be truncated and an ellipsis will be displayed to the user indicating more content.

As items in the Silverlight Toolkit mature in the codebase, these controls move into the core for Silverlight. In this release, ViewBox has reached that level and is now provided in the core. A ViewBox is a container control that aims to help constrain the contents of the ViewBox to a specific size or area and automatically handle scaling, etc.

Bi-directional and complext text, Right-to-left support in controls
If you are writing an application that requires right-to-left (RTL) support in either text and/or controls, a new attribute for UIElement is now provided for you. The FlowDirection attribute can be applied to represent the element in RTL format.
Offline DRM for media playback
The next major wave of PlayReady innovation being built into Silverlight focuses on meeting the top media customer ask for the Silverlight DRM client – support for Offline scenarios. The three key business models targeted for this release of the Silverlight DRM client are Rental, Subscription, and Purchase. The Silverlight PlayReady ecosystem has several features that are valuable for these business models.
H.264 protected content via PlayReady
PlayReady content protection for Silverlight and VC-1 encoded media has already proven to be a reliable and seamless experience to the user. With Silverlight 4, this content protection is extended to H.264 encoded media assets.
Using Silverlight application as a drop target from your desktop
For some scenarios, you may have wanted to be able to drag a file from your desktop or file explorer on to your Silverlight application. By enabling the AllowDrop attribute on UIElement in this release, you can now accommodate those scenarios.
1: public MainPage()
2: {
3: InitializeComponent();
4: Loaded += new RoutedEventHandler(MainPage_Loaded);
5:
6: // wire up the various Drop events
7: InstallButton.Drop += new DragEventHandler(InstallButton_Drop);
8: InstallButton.DragOver += new DragEventHandler(InstallButton_DragOver);
9: InstallButton.DragEnter += new DragEventHandler(InstallButton_DragEnter);
10: InstallButton.DragLeave += new DragEventHandler(InstallButton_DragLeave);
11: }
12:
13:
14: void InstallButton_Drop(object sender, DragEventArgs e)
15: {
16: IDataObject foo = e.Data; // do something with data
17: }
This will be most helpful in file upload applications.

IDataErrorInfo and asynchronous validation
Silverlight adds the IDataErrorInfo interface enables the reporting of validation errors that a user interface can bind to. When an entity implements this interface and the entity is involved in a binding operation, it invokes the indexer to validate the properties. The bound target properties in the UI will receive the error messages and display the validation states if the ValidatesOnDataErrors property is set to true.
IDataErrorInfo is limited to validating on a per property basis. However, Silverlight 4 also adds the INotifyDataErrorInfo interface that allows validation across properties of an entity. It also allows entity objects to enable notification of data errors in the UI. INotifyDataErrorInfo allows developers to provide custom, asynchronous validation support to access server-side validation logic. It exposes a HasErrors property to indicate if there are any errors and has a GetErrors method to retrieve the errors. The ErrorsChanged event is raised when new errors are added. If the binding property ValidatesOnNotifyDataErrors is set to true and the source object implements the interface, the binding engine in Silverlight will listen for the ErrorsChanged event.
DependencyObject Binding
Silverlight introduces the ability to bind properties on a DependencyObject (DO) and not just on FrameworkElements. For example, in Silverlight you can bind the rotation angle of a RotateTransform to a Slider control.

This is a highly requested data binding enhancement that should be useful to designers and developers.
StringFormat, TargetNullValue, FallbackValue
If you’ve ever done databinding in XAML using simple things like currency, dates, etc. then you have likely created a ValueConverter. While for simple things it is not difficult, it was often a tedious and repetitive task.
StringFormat is now available to you for a simpler solution for XAML databinding and formatting the output.

1: <TextBox Text="{Binding Path=PublishedDate, Mode=OneWay, StringFormat='MM-dd-yyyy'}"/>
Additionally, you can also specify Fallback and TargetNull values in your binding syntax:
1: <TextBox Text="{Binding Path=SomeBindingValue, Mode=TwoWay, FallbackValue=N/A}" />
2: <TextBox Text="{Binding Path=QuantityOnHand, Mode=TwoWay, TargetNullValue=0}" />


The FallbackValue displays a value when the binding operation is unsuccessful, where the TargetNullValue helps provide a value when the result of the binding value is NULL.
Managed Extensibility Framework (MEF)
This release of Silverlight 4 brings support for the Managed Extensibility Framework (MEF) in the SDK. This is far to important of a topic (and too broad of a topic) to cover in a simple paragraph. Take a look at Glenn Block’s session at PDC (when available) for an in-depth look at this support for MEF in Silverlight.
DataGrid enhancements
DataGrid is a commonly used control for building line-of-business applications. Over time, the DataGrid has continually undergone improvement and this release is no different. Take a look at the video for the improvements in the DataGrid control.

Fluid user interface support
In order to support more fluid user interface experiences, new states have been added to ItemsControl. These new states: BeforeLoaded, Loaded and Unloaded help animate the transition of contents between states in an ItemsControl and provide a more interactive and “fluid” experience to the user.
Implicit theming for controls
Silverlight 4 introduces new styling features that allow you to create a style as a resource that can be used implicitly by all elements of a target type. This allows application developers to customize the look across multiple instances of a control and modify the appearance of these control instances by changing the implicit style.

1: <UserControl.Resources>
2: <Style TargetType="Button">
3: <Setter Property="Foreground" Value="Red" />
4: <Setter Property="FontSize" Value="24" />
5: </Style>
6: </UserControl.Resources>

Would result in any Button element having a FontSize of 24 and red foreground text.
Google Chrome support
As browser markets evolve, so must we. During this release cycle we will be officially providing support for the Google Chrome browser. To date, Silverlight has generally worked in Chrome, but we’ll be adding Chrome to our official test/support matrix with this release. We’ve had a working communication group with Chrome to ensure that any questions we’ve had to make sure Silverlight runs well within Chrome are answered.
Summary and Feedback
So there you have it. Some new toys to play around with. What do you think? Please be sure that if you find any issues or compatibility with existing compiled Silverlight applications that you report them in the forum for Silverlight 4 beta.
There are a few other items in the build, so be sure to read the Silverlight 4 Beta information as well as the what’s new documentation and breaking changes documentation provided.

.Net 2.0 New Features

Assembly

The use of the AssemblyKeyFile attribute to sign an assembly is to be avoided. It is now preferred that you use the /keycontainer and /keyfile options of csc.exe, or the new project properties of Visual Studio 2005.

The new System.Runtime.CompilerServices.InternalsVisibleToAttribute attribute allows you to specify assemblies which have access to non-public types within the assembly to which you apply the attribute (kind of 'assemblies friendship').

The ildasm.exe 2.0 tool offers, by default, the possibility of obtaining statistics in regards to the byte size of each section of an assembly and the display of its metadata. With ildasm.exe 1.x, you needed to use the /adv command line option.

Application localization
The resgen.exe tool can now generate C# or VB.NET code which encapsulates access to resources in a strongly typed manner.

Application build process
The .NET platform is now delivered with a new tool called msbuild.exe. This tool is used to build .NET applications and is used by Visual Studio 2005, but you can use it to launch your own build scripts.

Application configuration
The .NET 2.0 platform features a new, strong typed management of your configuration parameters. Visual Studio 2005 also contains a configuration parameter editor which generates the code needed to take advantage of this feature.

Application deployment
The new deployment technology named ClickOnce allows a fine management of the security, updates, as well as on-demand installation of applications. Visual Studio 2005 offers some practical facilities to take advantage of this technology.

CLR
A major bug with version 1.x of the CLR which made it possible to modify signed assemblies has been addressed in version 2.

The System.GC class offers two new methods named AddMemoryPressure() and RemoveMemoryPressure() which allow you to give the GC an indication in regards to the amount of unmanaged memory held. Another method CollectionCount(int generation) allows you to know the number of collections applied to the specified generation.

New features have been added to the ngen.exe tool to support assemblies using reflection, and to automate the update of the compiled version of an assembly when one of its dependencies has changed.

The ICLRRuntimeHost interface used from unmanaged code to host the CLR replaces the ICorRuntimeHost interface. It allows access to a new API permitting the CLR to delegate a certain number of core responsibilities such as the loading of assemblies, thread management, or the management of memory allocations. This API is currently only used by the runtime host for SQL Server 2005.

Three new mechanisms named Constrained Execution Region (CER), Critical Finalizer, and Critical Region (CR) allow advanced developers to increase the reliability of applications such SQL Server 2005 which are likely to deal with a shortage of system resources.

A memory gate mechanism can be used to evaluate, before an operation, if sufficient memory is available.

You can now quickly terminate a process by calling the FailFast() static method which is part of the System.Environment class. This method bypasses certain precautions such as the execution of finalizers or the pending finally blocks.

Delegate
A delegate can now reference a generic method or a method that is part of a generic type. We then see appearing the notion of generic delegates.

With the new overloads of the Delegate.CreateDelegate(Type, Object, MethodInfo) method, it is now possible to reference a static method and its first argument from a delegate. The calls to the delegates then do not need this first argument and is similar to the use of instance method calls.

In addition, the invocation of methods through the use of delegates is now more efficient.

Threading/Synchronization
You can easily pass information to a new thread that you created by using the new ParametrizedThreadStart delegate. Also, new constructors of the Thread class allow you to set the maximum size of the thread stack in bytes.

The Interlocked class offers new methods and allows to deal with more types such as IntPtr or double.

The WaitHandle class offers a new static method named SignalAndWait(). In addition, all classes deriving from WaitHandle offer a new static method named OpenExisting().

The EventWaitHandle can be used instead of its subclasses AutoResetEvent and ManualResetEvent. In addition, it allows to name an event and thus share it amongst multiple processes.

The new class Semaphore allows you take advantage of Win32 semaphores from your managed code.

The new method SetMaxThreads() of the ThreadPool class allows to modify the maximal number of threads within the CLR thread pool from managed code.

The .NET 2.0 framework offers new classes which allow to capture and propagate the execution context of the current thread to another thread.

Security
The System.Security.Policy.Gac class allows the representation of a new type of evidence based on the presence of an assembly in the GAC.

The following new permission classes have been added: System.Security.Permissions.KeyContainerPermission, System.Net.NetworkInformation.NetworkInformationPermission, System.Security.Permissions.DataProtectionPermission, System.Net.Mail.SmtpPermission, System.Data.SqlClient.SqlNotificationPermission, System.Security.Permissions.StorePermission, System.Configuration.UserSettingsPermission, System.Transactions.DistributedTransactionPermission, and System.Security.Permissions.GacIdentityPermission.

The IsolatedStorageFile class presents the following new methods: GetUserStoreForApplication(), GetMachineStoreForAssembly(), GetMachineStoreForDomain(), and GetMachineStoreForApplication().

The .NET 2.0 framework allows to launch a child process within a different security context than the parent process.

The .NET 2.0 framework offers new types within the System.Security.Principal namespace allowing the representation and manipulation of Windows security identifiers.

The .NET 2.0 framework presents new types within the System.Security.AccessControl namespace to manipulate Windows access control settings.

The .NET 2.0 framework offers new hashing methods within the System.Security.Cryptography namespace.

The .NET 2.0 framework offers several classes giving access to the functionality offered by the Windows Data Protection API (DAPI).

The System.Configuration.Configuration class allows the easy management of the application configuration file. In particular, you can use it to encrypt your configuration data.

The .NET 2.0 framework offers new types within the System.Security.Cryptography.X509Certificates and System.Security.Cryptography.Pkcs namespaces which are specialized for the manipulation of X.509 and CMS/Pkcs7 certificates.

The new namespace named System.Net.Security offers the new classes SslStream and NegociateStream which allow the use of the SSL, NTLM, and Kerberos security protocols to secure data streams.

Reflection/Attribute
You now have the possibility of loading an assembly in reflection-only mode. Also, the AppDomain class offers a new event named ReflectionOnlyAssemblyResolve triggered when the resolution of an assembly fails in the reflection-only context.

The .NET 2.0 framework introduces the notion of conditional attribute. Such an attribute has the particularity of being taken into consideration by the C# 2 compiler only when a certain symbol is defined.

Interoperability
The notion of function pointers and delegates are now interchangeable using the new GetDelegateForFunctionPointer() and GetFunctionPointerForDelegate() methods of the Marshal class.

The HandleCollector class allows you to supply to the garbage collector an estimate on the number of Windows handles currently held.

The new SafeHandle and CriticalHandle classes allow to harness Windows handles more safely than with the IntPtr class.

The tlbimp.exe and tlbexp.exe tools present a new option named /tlbreference which allow the explicit definition of a type library without having to go through the registry. This allows the creation of compilation environments which are less fragile.

Visual Studio 2005 offers features to take advantage of the reg-free COM technology of Windows XP within a .NET application. This technology allows the use of a COM class without needing to register it into the registry.

Structures related to COM technology such as BINDPTR, ELEMDESC, and STATDATA have been moved from the System.Runtime.InteropServices namespace to the new System.Runtime.InteropServices.ComTypes namespace. This namespace contains new interfaces which redefine certain standard COM interfaces such as IAdviseSink or IConnectionPoint.

The new namespace named System.Runtime.InteropServices contains new interfaces such as _Type, _MemberInfo, or _ConstructorInfo which allow unmanaged code to have access to reflection services. Of course, the related managed classes (Type, MemberInfo, ConstructorInfo...) implement these interfaces.

C# 2.0
Undoubtedly, the highlight feature in .NET 2.0 and C# 2.0 is generics.

C# 2.0 allows the declaration of anonymous methods (which can be seen as closures).

C# 2.0 presents a new syntax to define iterators.

The csc.exe compiler offers the following new options /keycontainer, /keyfile, /delaysign, /errorreport and /langversion.

C# 2.0 brings forth the notions of namespace alias qualifier, of global:: qualifier, and of external alias to avoid certain identifier conflicts.

C# 2.0 introduces the new compiler directives #pragma warning disable and #pragma warning restore.

The C# 2.0 compiler is now capable of inferring a delegation type during the creation of a delegate object. This makes source code more readable.

The .NET 2.0 framework introduces the notion of nullable types which can be exploited through a special C# 2.0 syntax.

C# 2.0 now allows you to spread the definition of a type across multiple source files within the same module. This new feature is called partial type.

C# 2.0 allows the assignment of a different visibility to the accessor of a property or indexer.

C# 2.0 allows the definition of static classes.

C# 2.0 now allows the definition of a table field with a fixed number of primitive elements within a structure.

Visual Studio 2005 intellisense feature now uses the XML information contained within /// comments.

Visual Studio 2005 allows you to build UML-like class diagrams in-sync with your code.

Exceptions
The SecurityException class and Visual Studio 2005 have been improved to allow you to more easily test and debug your mobile code.

The Visual Studio 2005 debugger offers a practical wizard to obtain a complete set of information relating to an exception.

Visual Studio 2005 allows you to be notified when a problematic event known by the CLR occurs. These events sometime provoke managed exceptions.

Collections
The whole set of collection types within the .NET framework have been revised in order to account for generic types. Here is a comparison chart between the System.Collections and System.Collections.Generic namespaces.

System.Collections.Generics
System.Collections

Comparer
Comparer

Dictionary
HashTable

List LinkedList
ArrayList

Queue
Queue

SortedDictionary SortedList
SortedList

Stack
Stack

ICollection
ICollection

IComparable
System.IComparable

IComparer
IComparer

IDictionary
IDictionary

IEnumerable
IEnumerable

IEnumerator
IEnumerator

IList
IList


The System.Array class has no generic equivalent and is still current. Indeed, since the beginning of .NET, the collection model proposed by this class supports a certain level of genericity. It presents new methods such as void Resize(ref T[] array, int newSize), void ConstrainedCopy(...), and IList AsReadOnly(T[] array).

Debugging
The System.Diagnostics namespace provides new attributes DebuggerDisplayAttribute, DebuggerBrowsable, DebuggerTypeProxyAttribute, and DebuggerVisualizerAttribute which allow you to customize the display of the state of your objects while debugging.

.NET 2.0 allows indicating through attributes the assemblies, modules, or zones of code that you do not wish to debug. This feature is known as Just My Code.

C# 2.0 programmers now have access to the Edit and Continue feature allowing them to modify their code while debugging it.

.NET 2.0 presents the new enumeration named DebuggableAttribute.DebuggingModes which is a set of binary flags on the debugging modes we wish to use.

Base classes
The primitive types (integer, boolean, floating point numbers) now expose a method named TryParse() which allows to parse a value within a string without raising an exception in the case of failure.

The .NET 2.0 framework offers several implementations derived from the System.StringComparer abstract class which allows to compare strings in a culture and case sensitive manner.

The new Sytem.Diagnostics.Stopwatch class is provided especially to accurately measure elapsed time.

The new DriveInfo class allows the representation and manipulation of volumes.

The .NET 2.0 framework introduces the notion of trace source allowing a better management of traces. Also, the following trace listener classes have been added: ConsoleTraceListener, DelimitedListTraceListener, XmlWriterTraceListener, and WebPageTraceListener.

Several new functionalities have been added to the System.Console class in order to improve data display.

IO
The .NET 2.0 framework offers the new class System.Net.HttpListener which allows to take advantage of the HTTP.SYS component of Windows XP SP2 and Windows Server 2003 to develop a HTTP server.

In .NET 2.0, the classes that are part of the System.Web.Mail namespace are now obsolete. To send mail, you must use the classes within the System.Net.Mail namespace. This new namespace now contains classes to support the MIME standard.

New methods now allow you to read and write a file in a single call.

New classes are now available to compress/decompress a data stream.

A new unmanaged version System.IO.UnmanagedMemoryStream of the MemoryStream class allows you to avoid copying of data onto the CLR�s object heap and is thus more efficient.

The new System.Net.FtpWebRequest class implements a FTP client.

The new namespace System.Net.NetworkInformation contains types which allow to query the network interfaces available on a machine in order to know their states, their traffic statistics, and to be notified on state changes.

Web resource caching services are now available in the new System.Net.Cache namespace.

The new System.IO.Ports.SerialPort class allows the use of a serial port in a synchronous or event based manner.

Windows Forms 2.0
Visual Studio 2005 takes advantage of the notion of partial classes in the management of Windows Forms. Hence, it will not mix anymore the generated code with our own code in the same file.

Windows Forms 2.0 offers the BackgroundWorker class which standardizes the development of asynchronous operations within a form.

The appearance (i.e. the visual style) of controls is better managed by Windows Forms 2.0 as it does not need to use the comctl32.dll DLL to obtain a Windows XP style.

Windows Forms 2.0 and Visual Studio 2005 contain the framework and development tools for a quick and easy development of presentation and edition windows for data.

Windows Forms 2.0 presents the new classes BufferedGraphicsContext and BufferedGraphics which allow a fine control on a double buffering mechanism.

The ToolStrip, MenuStrip, StatusStrip, and ContextMenuStrip controls: these controls, respectively, replace the ToolBar, MainMenu, StatusBar, and ContextMenu controls (which are still present for backward compatibility reasons). In addition to nicer visual style, these new controls are particularly easy to manipulate during the design of a window, thanks to a consistent API. New functionality has been added such as the possibility of sharing a render between controls, the support for animated GIFs, opacity, transparency, and the facility of saving the current state (position, size�) in the configuration file. The hierarchy of the classes derived from the class System.Windows.Forms.ToolStripItem constitutes as many elements which can be inserted in this type of control.

The DataGridView and BindingNavigator controls: these controls are part of a new framework to develop data driven forms. This framework is the subject of the Viewing and editing data section a little later in this chapter. Know that it is now preferable to use a DataGridView for the display of any data table or list of objects instead of the Windows Forms 1.0 DataGrid control.

The FlowLayoutPanel and TableLayout controls: these controls allow the dynamic positioning of the child controls that it contains when the user modifies its size. The layout philosophy of the FlowLayoutPanel control is to list the child controls horizontally or vertically in a way where they are moved when the control is resized. This approach is similar to what we see when we resize an HTML document displayed by a browser. The layout philosophy of the TablePanel control is comparable to the anchoring mechanism where the child controls are resized based on the size of the parent control. However, here the child controls are found in the cells of a table.

The SplitterPanel and SplitContainer controls: the combined use of these controls allows the easy implementation of splitting of a window in a way that it can be resized, as we had with version 1.1 using the Splitter control.

The WebBrowser control: this control allows the insertion of a web browser directly in a Windows Forms form.

The MaskedTextBox control: this control displays a TextBox in which the format of the text to insert is constrained. Several types of masks are offered by default, such as dates or US telephone number. Of course, you can also provide your own masks.

The SoundPlayer and SystemSounds controls: the SoundPlayer class allows you to play sounds in .wav format while the SystemSounds class allows you to retrieve the system sounds associated with the current user of the operating system.

ADO.NET 2.0
ADO.NET 2.0 presents new abstract classes such as DbConnection or DbCommand in the new namespace System.Data.Common which implements the IDbConnection or IDbCommand interfaces. The use of these new classes is now preferred to the use of the interfaces.

ADO.NET 2.0 offers an evolved architecture of abstract factory classes which allow decoupling the data access code from the underlying data provider.

ADO.NET 2.0 presents new features to construct connection strings independently of the underlying data provider.

ADO.NET 2.0 offers a framework allowing the programmatic traversal of a RDBMS schema.

The indexing engine used internally by the framework when you use instances of the DataSet and DataTable classes have been revised in order to be more efficient during the loading and manipulation of data.

Instances of the DataSet and DataTable classes are now serializable into a binary form using the new SerializationFormat RemotingFormat{get;set;} property. You can achieve a gain of 3 to 8 times in relation to the use of XML serialization.

The DataTable class is now less dependant on the DataSet class as the XML features of this one have been added.

The new method DataTable DataView.ToTable() allows the construction of a DataTable containing a copy of a view.

ADO.NET 2.0 now offers a bridge between the connected and disconnected modes which allow the DataSet/DataTable and DataReader classes to work together.

Typed DataSets directly take into account the notion of relationships between tables. Now, thanks to partial types, the generated code is separated from your own code. Finally, the new notion of TableAdapter allows you to create some sort of typed SQL requests directly usable from your code.

ADO.NET 2.0 allows to store data updates in a more efficient manner, thanks to batch updates.

ADO.NET 2.0: SQL Server data provider (SqlClient)
You now have the possibility of enumerating SQL Server data sources.

You have more control on connection pooling.

The SqlClient data provider of ADO.NET 2.0 allows the execution of commands in an asynchronous way.

You can harness the bulk copy services of the SQL Server tool bcp.exe using the SqlBulkCopy class.

You can obtain statistics about the activity of a connection.

There is a simplified and freely distributed version of SQL Server 2005 which offers several advantages over the previous MSDE and Jet products.

Transaction
The new namespace named System.Transactions (contained in the Systems.Transactions.dll) offers, at the same time, a unified transactional programming model and a new transactional engine which has the advantage of being extremely efficient on certain types of lightweight transactions.

XML
The performance of all classes involved in XML data handling have been significantly improved (by a factor of 2 to 4 in classic use scenarios according to Microsoft).

The new System.Xml.XmlReaderSettings class allows to specify the type of verifications which must be done when using a subclass of XmlReader to read XML data.

It is now possible to partially validate a DOM tree loaded within an instance of XmlDocument.

It is now possible to modify a DOM tree stored in an XmlDocument instance through the XPathNavigator cursor API.

The XslCompiledTransform class replaces the XslTransform class which is now obsolete. Its main advantage is in compiling XSLT programs into MSIL code before applying a transformation. According to Microsoft, this new implementation improves performance by a factor of 3 to 4. Moreover, Visual Studio 2005 can now debug XSLT programs.

Support for the XML DataSet class has been improved. You can now load XSD schemas with names repeated in different namespaces, and load XML data containing multiple schemas. Also, XML load and save methods have been added to the DataTable class.

The 2005 version of SQL Server brings forth new features in regards to the integration of XML data inside a relational database.

XML serialization can now serialize nullable information and generic instances. Also, a new tool named sgen.exe allows the pre-generation of an assembly containing the code to serialize a type.

.NET Remoting
The new IpcChannel channel is dedicated to the communication between different processes on a same machine. Its implementation is based on the notion of Windows named pipe.

If you use a channel of type TCP, you now have the possibility of using the NTLM and Kerberos protocols to authenticate the Windows user under which the client executes, to encrypt the exchanged data and impersonate your requests.

New attributes of the System.Runtime.Serialization namespace allow the management of problems inherent to the evolution of a serializable class.

It is possible to consume an instance of a closed generic type, with the .NET Remoting technology, whether you are in CAO or WKO mode.

ASP.NET 2.0
Visual Studio .NET 2005 is now supplied with a web server which allows the testing and debugging of your web applications during development.

It is now easy to use the HTTP.SYS component to build a web server which hosts ASP.NET without needing to use IIS.

ASP.NET 2.0 presents a new model for the construction of classes representing web pages. This model is based on partial classes, and is different than the one offered in ASP.NET 1.x.

The CodeBehind directive of ASP.NET v1.x is no longer supported.

In ASP.NET 2.0, the model used for dynamic compilation of your web application has significantly improved, and is now based on several new standard folders. In addition, ASP.NET 2.0 offers two new pre-compilation modes: the in-place pre-compilation, and the deployment pre-compilation.

To counter the effects of large viewstates in ASP.NET 1.x, ASP.NET 2.0 stores information in a base64 string, more efficiently, and introduces the notion of control-state.

ASP.NET 2.0 introduces a new technique which allows to postback a page to another page.

Certain events have been added to the lifecycle of a page.

ASP.NET 2.0 offers an infrastructure to allow the process of the same request across multiple threads of a pool. This allows us to avoid running out of threads within the pool when several long requests are executed at the same time.

New events have been added to the HttpApplication class.

The manipulation of configuration files has been simplified because of the Visual Studio 2005 intellisense, a new web interface, a new UI integrated in IIS, and because of new base classes.

ASP.NET 2.0 offers a framework allowing the standard management of events occurring during the life of a web application.

You can now configure ASP.NET 2.0 so that it can detect whether it is possible to store a session identifier in a client-side cookie, or if it should automatically switch over to the URI mode if cookies are not supported.

ASP.NET 2.0 now allows you to supply your own session or session ID management mechanism.

The cache engine of ASP.NET 2.0 offers interesting new features. You can now use the VaryByControl sub-directive in your pages. You can substitute dynamic fragments within your cached pages. You can associate your cached data dependencies towards tables and rows of a SQL Server data source. Finally, you can create your own types of dependencies.

ASP.NET 2.0 offers new server controls allowing declarative binding to a data source.

ASP.NET 2.0 offers a new hierarchy of server-side controls for the presentation and the edition of data. These controls have the peculiarity of being able to use a data source control to read and write data.

ASP.NET 2.0 offers a simplified template syntax.

ASP.NET 2.0 adds the notion of master pages which allows the easy reuse of a page design across all pages of a website.

ASP.NET 2.0 now offers an extensible architecture to allow insertion of navigational controls within your site.

With ASP.NET 2.0, you can use the Forms authentication mode without being forced to use cookies.

ASP.NET 2.0 allow the management of user authentication data as well of the roles to which they may belong, through the use of a database. Hence, several new server-side controls have been added to greatly simplify the development of ASP.NET applications which support authentication.

ASP.NET 2.0 presents a new framework allowing the storage and access of users' profiles.

ASP.NET 2.0 offers a framework facilitating the management and maintenance of the overall appearance of a site, thanks to the notions of themes and skins.

ASP.NET 2.0 also offers a framework dedicated to the creation of web portals through the use of what is called WebParts.

ASP.NET 2.0 offers a framework allowing the modification of rendered HTML code if the initiating HTTP request comes from a system with a small screen such as a mobile phone. Concretely, the rendering of each server control is done in a way to use less screen space. This modification is done through the use of adapter objects which are requested automatically and implicitly by ASP.NET during the rendering of the page. The "Inside the ASP.NET Mobile Controls" article on MSDN offers a good starting point on this new ASP.NET 2.0 feature.

Web Services
The proxy classes generated by wsdl.exe now offers a new asynchronous model which allows cancellation.

Asp.Net 2.0 Features

What's New in ASP.NET 2.0?

Some of the new features in ASP.NET 2.0 are:
•Master Pages, Themes, and Web Parts
•Standard controls for navigation
•Standard controls for security
•Roles, personalization, and internationalization services
•Improved and simplified data access controls
•Full support for XML standards like, XHTML, XML, and WSDL
•Improved compilation and deployment (installation)
•Improved site management
•New and improved development tools

The new features are described below.

--------------------------------------------------------------------------------

Master Pages

ASP.NET didn't have a method for applying a consistent look and feel for a whole web site.

Master pages in ASP.NET 2.0 solves this problem.

A master page is a template for other pages, with shared layout and functionality. The master page defines placeholders for content pages. The result page is a combination (merge) of the master page and the content page.


--------------------------------------------------------------------------------

Themes

Themes is another feature of ASP.NET 2.0. Themes, or skins, allow developers to create a customized look for web applications.

Design goals for ASP.NET 2.0 themes:
•Make it simple to customize the appearance of a site
•Allow themes to be applied to controls, pages, and entire sites
•Allow all visual elements to be customized

--------------------------------------------------------------------------------

Web Parts

ASP.NET 2.0 Web Parts can provide a consistent look for a site, while still allowing user customization of style and content.

New controls:
•Zone controls - areas on a page where the content is consistent
•Web part controls - content areas for each zone

--------------------------------------------------------------------------------

Navigation

ASP.NET 2.0 has built-in navigation controls like
•Site Maps
•Dynamic HTML menus
•Tree Views

--------------------------------------------------------------------------------

Security

Security is very important for protecting confidential and personal information.

In ASP.NET 2.0 the following controls has been added:
•A Login control, which provides login functionality
•A LoginStatus control, to control the login status
•A LoginName control to display the current user name
•A LoginView control, to provide different views depending on login status
•A CreateUser wizard, to allow creation of user accounts
•A PasswordRecovery control, to provide the "I forgot my password" functionality

--------------------------------------------------------------------------------

Roles and Personalization

Internet communities are growing very popular.

ASP.NET 2.0 has personalization features for storing user details. This provides an easy way to customize user (and user group) properties.

--------------------------------------------------------------------------------

Internationalization

Reaching people with different languages is important if you want to reach a larger audience.

ASP.NET 2.0 has improved support for multiple languages.

--------------------------------------------------------------------------------

Data Access

Many web sites are data driven, using databases or XML files as data sources.

With ASP.NET this involved code, and often the same code had to be used over and over in different web pages.

A key goal of ASP.NET 2.0 was to ease the use of data sources.

ASP.NET 2.0 has new data controls, removing much of the need for programming and in-depth knowledge of data connections.

--------------------------------------------------------------------------------

Mobility Support

The problem with Mobile devices is screen size and display capabilities.

In ASP.NET, the Microsoft Mobile Internet Toolkit (MMIT) provided this support.

In ASP.NET 2.0, MMIT is no longer needed because mobile support is built into all controls.

--------------------------------------------------------------------------------

Images

ASP.NET 2.0 has new controls for handling images:
•The ImageMap control - image map support
•The DynamicImage control - image support for different browsers

These controls are important for better image display on mobile devices, like hand-held computers and cell phones.

--------------------------------------------------------------------------------

Automatic Compilation

ASP.NET 2.0 provides automatic compilation. All files within a directory will be compiled on the first run, including support for WSDL, and XSD files.

--------------------------------------------------------------------------------

Compiled Deployment (Installation) and Source Protection

ASP.NET 2.0 also provides pre-compilation. An entire web site can be pre-compiled. This provides an easy way to deploy (upload to a server) compiled applications, and because only compiled files are deployed, the source code is protected.

--------------------------------------------------------------------------------

Site Management

ASP.NET 2.0 has three new features for web site configuration and management:
•New local management console
•New programmable management functions (API)
•New web-based management tool