Pro ASP.NET 2.0 In CSharp 2005 (2005) [eng]

598C H A P T E R 1 6 ■ W E B S I T E N AV I G AT I O N

private void SearchNodes(SiteMapNode node, string title)

{

if (node.Title == title)

{

matchingDescription = node.Description; return;

}

else

{

foreach (SiteMapNode child in node.ChildNodes)

{

// Perform recursive search. SearchNodes(child, title);

}

}

}

Now you can use the GetDescriptionFromTitle() method in a template:

<asp:Menu ID="Menu1" runat="server" DataSourceID="SiteMapDataSource1"> <StaticItemTemplate>

<%# Eval("Text") %><br /> <small>

<%# GetDescriptionFromTitle(((MenuItem)Container.DataItem).Text) %> </small>

</StaticItemTemplate>

<DynamicItemTemplate>

<%# Eval("Text") %><br /> <small>

<%# GetDescriptionFromTitle(((MenuItem)Container.DataItem).Text) %> </small>

</DynamicItemTemplate>

</asp:Menu>

Finally, you can declare data bindings for the Menu control that specifically map out what property in the bound object should be used for the MenuItem text. This isn’t much help if you want to display both the title and description, because it accepts only one field. However, it’s fairly easy to show the title as the text and the description as the tooltip text:

<asp:Menu ID="Menu1" runat="server" DataSourceID="SiteMapDataSource1"> <DataBindings>

<asp:MenuItemBinding DataMember="SiteMapNode" TextField="Title" ToolTipField="Description" />

</DataBindings>

</asp:Menu>

Summary

In this chapter you explored a variety of navigation features. You started with the multipane MultiView and Wizard controls. You then delved into the new navigation model and learned how to define site maps, bind the navigation data, and extend the site map provider infrastructure. Finally, you considered two rich controls that are especially suited for navigation data, the TreeView and Menu.

C H A P T E R 1 7

■ ■ ■

Resources and Localization

Because more and more companies are reaching international markets through the Internet, supporting different cultures through your applications is essential for being successful. The .NET Framework comes with an integrated infrastructure for creating international applications.

Basically, the CLR supports a mechanism for packaging and deploying resources with any type of application. The CLR and the base class library of the .NET Framework come with several classes for managing and accessing resources in applications. These classes are located in the System.Resources and System.Globalization namespaces.

In this chapter, you will learn all the necessary details for working with resources in ASP.NET applications and for creating international ASP.NET applications based on embedded resources and the integrated localization support.

Resources in .NET Applications

600 C H A P T E R 1 7 ■ R E S O U R C E S A N D L O C A L I Z AT I O N

The following example shows an excerpt of a sample .resx file. The file contains simple strings as well as a reference to an external image file.

<root>

<resheader name="resmimetype"> <value>text/microsoft-resx</value>

</resheader>

<resheader name="version"> <value>2.0</value>

</resheader>

...

<data name="Binary Code Sm"

type="System.Resources.ResXFileRef, System.Windows.Forms">

<value>

Binary Code Sm.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a

</value>

</data>

<data name="LegendAge">

<value xml:space="preserve">Age</value> </data>

<data name="LegendFirstname">

<value xml:space="preserve">Firstname</value> </data>

<data name="LegendLastname">

<value xml:space="preserve">Lastname</value> </data>

</root>

■Note This is just an excerpt of the .resx file. Visual Studio usually generates a bunch of comments and the XML schema for the resource file in the same XML file automatically.

Another way of compiling files as embedded resources in the application is to add them to the project and select the value Embedded Resource for the BuildAction property in the Properties window for the file. But this works only for Windows projects such as class libraries, Windows services, or Windows Forms applications. For ASP.NET applications, you have to take the approach introduced in this chapter. In any case, you can then access resources programmatically through the ResourceManager class.

■Note You can also add resources as text files to the application. These text files consist of key/value pairs, one per line, in the format key = value. They can be compiled with the resgen.exe tool into a binary format with the file extension .resources. You can then add such .resources files as embedded resources (BuildAction=EmbeddedResource) to your application. But because this is the old way of managing resources, we suggest not using it.

While going through the following web application sample, you will learn how you can use resources both for populating control properties and for getting some other information such as document templates for report generation. The web application requires users to enter their first name, last name, and age. Based on this information, the application generates a simple Microsoft Word document. For this purpose, a template of the Microsoft Word document to be generated is bound to an XML schema, saved in XML format, and added as an embedded resource.

■Note The XML features of Microsoft Office 2003 introduced in this chapter require Microsoft Word 2003 Professional Edition on the client (not on the server). If you don’t have Microsoft Word 2003, you can test the same concepts with your own custom file templates. If you want to learn more details about Microsoft Office 2003 and XML, browse to http://msdn.microsoft.com/office.

All strings as well as the Microsoft Word document used in the application are embedded as resources. After adding an assembly resource file to the project, Visual Studio offers a resource editor for modifying the contents of the .resx file. It enables you to add strings as well as any other type of file to the project, as shown in Figure 17-1.

Figure 17-1. The Visual Studio 2005 resource editor

Through Add Resource Add Existing File, you can add any external file stored in any format on the hard disk to the project. These files are automatically added to one of the resource directories of the ASP.NET website and compiled as embedded resources into the resulting binaries. Visual Studio and ASP.NET distinguish between global resources and local resources. Global resources are accessible from within any page of the application, and local resources exist on a per-page basis and are accessible from within their page only. Further, .resx files added to the App_GlobalResources folder are accessible from within all pages of the application. Figure 17-2 shows the current layout of the application running without using these embedded resources.

resources themselves are just wrappers around calls of one of the GetXxx methods (that is, GetString or GetStream) of this ResourceManager instance. For example, the resource that is accessible through the generated property procedure Resources.MyResourceStrings.LegendAge is also accessible through ResourceManager.GetString("LegendAge"), as shown in Figure 17-3.

Figure 17-3. The ResourceManager class’s methods

The ResourceManager property of the generated class creates an instance of the resource manager automatically, as shown in the following code snippet. Of course, anybody can do this.

ResourceManager ResMgr = new ResourceManager("Resources.MyResourceStrings", Assembly.GetAssembly(typeof(Resources.MyResourceStrings)));

The first parameter specifies the base name for the resources that should be loaded by the ResourceManager class. The second parameter specifies the assembly into which the resources have been compiled. If the resources are compiled into the assembly that executes this code, using the GetExecutingAssembly() method of the System.Reflection.Assembly class is sufficient. Mostly this is true for class libraries or classic Windows applications. ASP.NET is a little bit different, as it generates and compiles the assemblies automatically. Internally, the ASP.NET infrastructure actually creates different assemblies for the page code and global resources. And the name of the dynamically generated assembly is basically unknown, as it is determined by the infrastructure

as well. Therefore, using the GetExecutingAssembly() method won’t work. Alternatively, using the GetAssembly method with the type description of the generated resource class is a possible way of creating a custom instance of the ResourceManager class, because this type resides in the assembly created by ASP.NET for the embedded resources contained in this class.

As you know how to use resources now, you will see some code for generating the Microsoft Word document when the user clicks the button on the page. For this purpose, you can leverage the XML functionality of Microsoft Word 2003 by completing the following steps:

1.First, create a Microsoft Word document as usual and then save it as an XML document instead of the binary DOC format. You can select the format in the File Types list of the Save dialog box in Microsoft Word.

2.Next, create an XML schema. You must connect this XML schema to the Microsoft Word document through the XML Structure task pane. You get the task pane by selecting View Task Pane and then clicking the title of the task pane. From the menu, select XML Structure. This task pane allows you to add an XML schema to the document and attach the XML schema’s elements to sections of the Microsoft Word document. Your application will use the elements defined in this XML schema for finding the appropriate sections in the document for generating contents through System.Xml. (You can find details about System.Xml in Chapter 12.)

604C H A P T E R 1 7 ■ R E S O U R C E S A N D L O C A L I Z AT I O N

3.Finally, add the XML Word document as a resource to your solution with the previously introduced resource editor (refer to Figure 17-1). The XML schema to create your solution is as follows. After you have created the schema, you can create the Word document and bind the schema to the document through the XML Structure task pane. Figure 17-4 shows the Word document with XML elements associated.

<xs:schema id="DocumentSchema" targetNamespace="uri:AspNetPro20/Chapter17/Demo1" elementFormDefault="qualified" xmlns="uri:AspNetPro20/Chapter17/Demo1" xmlns:mstns="uri:AspNetPro20/Chapter17/Demo1" xmlns:xs="http://www.w3.org/2001/XMLSchema">

<xs:element name="MyPersonType"> <xs:complexType mixed="true">

<xs:all>

<xs:element name="Firstname" type="xs:string" /> <xs:element name="Lastname" type="xs:string" /> <xs:element name="Age" type="xs:int" />

</xs:all>

</xs:complexType>

</xs:element>

</xs:schema>

Figure 17-4. The Microsoft Word document connected with the XML schema

Generating the Microsoft Word document based on the XML template created previously requires nothing more than loading it from the embedded resources into an instance of XmlDocument. (You can find more information about XML in Chapter 12.) When taking a closer look at the Microsoft Word document that has been saved as XML, you will see that the XML elements

defined by the schema are directly incorporated into the XML elements that define the Microsoft Word formatting and contents. The following listing shows an excerpt of the Microsoft Word document saved as an XML file (which has been embedded as a resource in your application):

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?> <?mso-application progid="Word.Document"?>

<w:wordDocument xmlns:w="http://schemas.microsoft.com/office/word/2003/wordml"

...

xmlns:ns1="uri:AspNetPro20/Chapter17/Demo1">

<o:DocumentProperties>

<o:Title>This document will automatically be generated:</o:Title> <o:Author>VB.NET Trainings</o:Author>

<o:LastAuthor>VB.NET Trainings</o:LastAuthor> <o:Revision>8</o:Revision> <o:TotalTime>0</o:TotalTime>

...

...

<w:body>

<wx:sect>

<ns1:MyPersonType>

<w:p>

<w:r>

<w:rPr>

<w:rFonts w:ascii="Verdana" w:h-ansi="Verdana" /> <wx:font wx:val="Verdana" />

<w:b />

<w:sz w:val="36" /> <w:sz-cs w:val="36" /> <w:lang w:val="EN-GB" />

</w:rPr>

<w:t>This document will be</w:t> </w:r>

...

...

<ns1:Firstname>

<w:tc>

<w:tcPr>

<w:tcW w:w="4606" w:type="dxa" /> </w:tcPr>

<w:p>

...

</w:p>

</w:tc>

</ns1:Firstname>

...

</ns1:MyPersonType>

</wx:sect>

</w:body>

</w:wordDocument>

As you can see, the elements defined in the previously created XML schema are included directly in the Microsoft Word XML file. All the other tags you can see define the formatting and the other options that make up a complete Microsoft Word document. That means all the things that were encapsulated in the binary format of Microsoft Word documents (the DOC format) are now available as XML as well. This is what makes processing Microsoft Word documents on the server side from within web applications as easy as processing XML files. The XML schema that defines the Microsoft Word XML elements is well documented and can be downloaded (including the

606C H A P T E R 1 7 ■ R E S O U R C E S A N D L O C A L I Z AT I O N

documentation) from http://msdn.microsoft.com/office. You need to know two things about this example; first, you can load this Microsoft Word document into an instance of XmlDocument and then change its contents through simple XML operations such as cloning nodes or adding new nodes. Second, you need to know the meaning of one special XML tag: the <w:r /> tag, which is called word run. A word run is an XML fragment of a Microsoft Word document that encapsulates simple text within a paragraph. Therefore, if you want to programmatically enter text into a specific position within the XML Microsoft Word document, you have to complete the following steps:

1.Open the Microsoft Word document with System.Xml.XmlDocument.

2.Execute an XPath query for finding an element of your custom XML schema, such as the ns1:Firstname element in the document presented earlier.

3.Then execute another XPath query on the node returned from the last XPath query for finding the next word run (<w:r />) below the custom XML node (ns1:Firstname).

4.Finally, within the <w:r> tag, you can add a <w:t> tag (Microsoft Word text) that then contains the text you want to add to the Microsoft Word document.

The following code shows how you can open the Microsoft Word document with the XmlDocument class. It then executes an XPath query for finding the ns1:Firstname element within the document. After it has found this element, it changes the InnerXml to a word run that contains just the text entered by the user into the ASP.NET TextBox control. Afterward, it does the same steps for the ns1:Lastname and ns1:Age sections.

protected void GenerateAction_Click(object sender, EventArgs e)

{

XmlDocument doc = new XmlDocument(); doc.LoadXml(Resources.MyResourceStrings.MyDocument);

XmlNode TextNode;

XmlNamespaceManager NsMgr = new XmlNamespaceManager(doc.NameTable); NsMgr.AddNamespace("ns1", "uri:AspNetPro20/Chapter17/Demo1"); NsMgr.AddNamespace("w",

"http://schemas.microsoft.com/office/word/2003/wordml");

TextNode = doc.SelectSingleNode("//ns1:Firstname//w:p", NsMgr);

TextNode.InnerXml = string.Format("<w:r><w:t>{0}</w:t></w:r>",

TextFirstname.Text);

TextNode = doc.SelectSingleNode("//ns1:Lastname//w:p", NsMgr);

TextNode.InnerXml = string.Format("<w:r><w:t>{0}</w:t></w:r>",

TextLastname.Text);

TextNode = doc.SelectSingleNode("//ns1:Age//w:p", NsMgr);

TextNode.InnerXml = string.Format("<w:r><w:t>{0}</w:t></w:r>",

TextAge.Text);

// Clear the response Response.Clear();

Response.ContentType = "application/msword"; Response.Write(doc.OuterXml); Response.End();

}

Because the XML Microsoft Word document itself has been added as an embedded resource to your application, you can retrieve it through the generated resources class as was done in the previous code sample. Actually, the string template <w:r><w:t>{0}</w:r></w:t> used for adding the text to the Word document is a perfect candidate to be embedded as a resource.

Localization of Web Applications

The infrastructure presented in the first part of this chapter provides the fundamentals for localizing any type of .NET-based application, including Windows applications, class libraries, services, and (of course) web applications.

Before you learn about the technical details for localizing applications, we will discuss the major challenges in doing do. Figure 17-5 shows some challenges of localizing a web application.

Figure 17-5. Sample application showing localization challenges

Although this is a simple example, it demonstrates some of the core challenges for localizing web applications. The simplest challenge, of course, is localizing the strings for the captions of the labels as well as the buttons. Also, you must localize the format for the currency values and for the dates and times. For that purpose, you need to localize the validation expression of the validation control.

Finally, when parsing the information in the code for storing it in a database or for other processing steps, you need to consider the format for dates, times, and currency values. All these values might be different and therefore customized from culture to culture.

Localization and the Common Language Runtime

Usually resources are created for every culture the application should support. In the earlier example, you learned how to create resources for the default culture, because we didn’t specify any culturespecific information. These resources are used by the CLR as a last resort in the localization process. The CLR defines a behavior for finding culture-specific resources. With that said, every set

of resources has to define a base name that is specified through the first part of the name of the resource file. The second part of the name, which has been omitted in the first example of this chapter, defines the culture. If the culture portion in the name is not specified, the resources