Home
Patent Search
IMT Blog
REGISTER
|
SIGN IN
United States Patent Application
20030172196
Kind Code
A1
Hejlsberg, Anders ; et al.
September 11, 2003
Application program interface for network software platform
Abstract
An application program interface (API) provides a set of functions that make available support for processing XML documents for application developers who build Web applications on Microsoft Corporation's .NET.TM. platform.
Inventors:
Hejlsberg; Anders
(Seattle, WA)
, Dedu-Constantin; Daniel
(Redmond, WA
)
, Christensen; Erik B.
(Seattle, WA
)
, Ballinger; Keith W.
(North Bend, WA
)
, Fussell; Mark W.
(Sammamish, WA
)
, Rajpal; Neetu
(Redmond, WA
)
, Sampathkumar; Nithyalakshmi
(Bellevue, WA
)
, Gazitt; Omri
(Redmond, WA
)
, Pharies; Stefan H.
(Seattle, WA
)
, Adams; William A.
(Bellevue, WA
)
, Leshinsky; Yan
(Bellevue, WA
)
, Chen; Chia-Hsun
(Redmond, WA
)
Correspondence Name and Address:
421 W RIVERSIDE AVENUE SUITE 500
LEE & HAYES PLLC
SPOKANE
WA
99201
Series Code:
902810
Filed:
July 10, 2001
U.S. Current Class:
709/328
U.S. Class at Publication:
709/328
Intern'l Class:
G06F 009/00
Claims
1. A software architecture for a distributed computing system comprising: an application configured to handle requests submitted by remote devices over a network; and an application program interface to present functions used by the application to access network and computing resources of the distributed computing system, wherein the application program interface comprises a set of classes that make available standards-based support for processing XML documents.
2. A software architecture as recited in claim 1, wherein the set of classes comprises: an XmlReader class that enables non-cached forward only access to XML data; an XPathNavigator class that enables read-only random access to a data store; an XslTransform class that enables transforming of XML data using an XSLT stylesheet; a plurality of Xml Schema classes that enable constructing and editing of schemas; an XmlResolver class that enables resolving of external XML resources named by a Uniform Resource Identifier (URI); an XmlDataDocument class that enables structured data to be stored, retrieved, and manipulated through a relational dataset; and an XmlWriter class that enables a non-cached forward only way of generating streams and files containing XML data.
3. A software architecture as recited in claim 2, wherein the set of classes further comprises: an XmlValidatingReader class that enables DTD, XDR and XSD schema validation.
4. An XmlReader class of an application program interface, embodied on one or more computer readable media that enables non-cached forward only access to XML data, the XmlReader class comprising: an XmlReader constructor that enables initialization of a new instance of the XmlReader class; and a Read method that enables reading of nodes of the XML data via the XmlReader class instance.
5. An XmlReader class of an application program interface as recited in claim 4, wherein the XmlReader class further comprises: a BaseURI property that identifies a base URI of a current node of the XML data; and a NodeType property that identifies the type of the current node.
6. An XPathNavigator class of an application program interface, embodied on one or more computer readable media, that enables read-only random access to a data store, the XPathNavigator class comprising: an XPathNavigator constructor that enables initialization of a new instance of the XPathNavigator class; a MoveToFirst method that enables moving to a first sibling of a current node of XML data; a MoveToNext method that enables moving to a next sibling of the current node; a MoveToPrevious method that enables moving to a previous sibling of the current node; a MoveToFirstChild method that enables moving to a first child of the current node; a MoveToParent method that enables moving to a parent of the current node; and a NodeType property that enables obtaining the type of the node that is moved to.
7. An XslTransform class of an application program interface, embodied on one or more computer readable media, that enables transforming of XML data using an XSLT stylesheet, the XslTransform class comprising: an XslTransform constructor that enables initialization of a new instance of the XslTransform class; a Load method that enables loading of the XSLT stylesheet; and a Transform method that enables transforming of the specified XML data using the loaded XSLT stylesheet and outputs the results.
8. A set of XmlSchema classes of an application program interface, embodied on one or more computer readable media, that enable constructing and editing of schemas, the set of XmlSchema classes comprising: a Schema class that contains a definition of a schema; a SchemaObject class that enables creating of an empty schema; and a SchemaCollection class that contains a cache of defined XML Schema Definition language (XSD) and XML-Data Reduced Language (XDR) schemas.
9. An XmlResolver class of an application program interface, embodied on one or more computer readable media, that enables resolving of external XML resources named by a Uniform Resource Identifier (URI), the XmlResolver class comprising: a ResolveURI method that enables resolving the absolute URI from a base URI and a relative URI; and a GetEntity method that enables mapping of the resolved URI to an object containing identified resource.
10. An XmlDataDocument class of an application program interface, embodied on one or more computer readable media, that enables structured data to be stored, retrieved, and manipulated through a relational dataset, the XmlDataDocument class comprising: a DataSet property that enables obtaining of a dataset that provides a relational representation of the data in a document; a Load method that enables loading of the document using a specified data source and synchronizing the dataset with the loaded data.
11. An XmlWriter class of an application program interface, embodied on one or more computer readable media, that enables a non-cached forward only way of generating streams and files containing XML data, the XmlWriter class comprising: an XmlWriter constructor that enables initialization of a new instance of the XmlWriter class; and an WriteState property that enables obtaining of the state of an instance of the XmlWriter class; and a plurality of Write methods that enable writing XML data via the instance of the XmlWriter class.
12. An XmlValidatingReader class of an application program interface, embodied on one or more computer readable media, that enables DTD, XDR and XSD schema validation, the XmlValidatingReader class comprising: a ValidationType property that enables obtaining an indication of what type of validation to perform on a document; a Read method that enables reading of nodes of the document so that validation of the document can be performed.
13. An XmlValidatingReader class of an application program interface as recited in claim 12, where the type of validation to perform is validation according to DTD.
14. An XmlValidatingReader class of an application program interface as recited in claim 12, where the type of validation to perform is validation according to XSD schemas.
15. An XmlValidatingReader class of an application program interface as recited in claim 12, where the type of validation to perform is validation according to XDR schemas.
16. A distributed computer software architecture, comprising: one or more applications configured to be executed on one or more computing devices, the applications handling requests submitted from remote computing devices; a networking platform to support the one or more applications; and an application programming interface to interface the one or more applications with the networking platform, wherein the application program interface comprises a set of classes that make available standards-based support for processing documents written in a markup language.
17. A software architecture as recited in claim 16, wherein the set of classes comprises: an XmlReader class that enables non-cached forward only access to XML data; an XPathNavigator class that enables read-only random access to a data store; an XslTransform class that enables transforming of XML data using an XSLT stylesheet; a plurality of Xml Schema classes that enable constructing and editing of schemas; an XmlResolver class that enables resolving of external XML resources named by a Uniform Resource Identifier (URI); an XmlDataDocument class that enables structured data to be stored, retrieved, and manipulated through a relational dataset; and an XmlWriter class that enables a non-cached forward only way of generating streams and files containing XML data.
18. A software architecture as recited in claim 17, wherein the set of classes further comprises: an XmlValidatingReader class that enables DTD, XDR and XSD schema validation.
19. A computer system including one or more microprocessors and one or more software programs, the one or more software programs utilizing an application program interface to request services from an operating system, the application program interface including separate commands to request services that make available support for processing XML documents.
20. A software architecture as recited in claim 19, wherein the commands include: non-cached forward only access to XML data; read-only random access to a data store; transforming of XML data using an XSLT stylesheet; constructing and editing of schemas; resolving of external XML resources named by a Uniform Resource Identifier (URI); storage, retrieval, and manipulation of structured data through a relational dataset; and non-cached forward only generation of streams and files containing XML data.
21. A software architecture as recited in claim 20, wherein the commands further include: validating DTD, XDR and XSD schemas.
22. A method comprising: receiving one or more calls from one or more remote devices over a network, wherein the one or more calls are to one or more functions that make available support for processing XML documents; and performing the requested XML document processing.
23. A software architecture as recited in claim 22, wherein the one or more functions comprises: an XmlReader function that enables non-cached forward only access to XML data; an XPathNavigator function that enables read-only random access to a data store; an XslTransform function that enables transforming of XML data using an XSLT stylesheet; a plurality of Xml Schema functions that enable constructing and editing of schemas; an XmlResolver function that enables resolving of external XML resources named by a Uniform Resource Identifier (URI); an XmlDataDocument function that enables structured data to be stored, retrieved, and manipulated through a relational dataset; and an XmlWriter function that enables a non-cached forward only way of generating streams and files containing XML data.
24. A software architecture as recited in claim 23, wherein the one or more functions further comprises: an XmlValidatingReader function that enables DTD, XDR and XSD schema validation.
25. A method comprising: calling, to one or more remote devices over a network, one or more functions that make available support for processing XML documents; receiving, from the one or more remote devices, a response to the calling.
26. A software architecture as recited in claim 25, wherein the one or more functions comprises: an XmlReader function that enables non-cached forward only access to XML data; an XPathNavigator function that enables read-only random access to a data store; an XslTransform function that enables transforming of XML data using an XSLT stylesheet; a plurality of Xml Schema functions that enable constructing and editing of schemas; an XmlResolver function that enables resolving of external XML resources named by a Uniform Resource Identifier (URI); an XmlDataDocument function that enables structured data to be stored, retrieved, and manipulated through a relational dataset; and an XmlWriter function that enables a non-cached forward only way of generating streams and files containing XML data.
27. A software architecture as recited in claim 26, wherein the one or more functions further comprises: an XmlValidatingReader function that enables DTD, XDR and XSD schema validation.
Description
TECHNICAL FIELD
[0001] This invention relates to network software, such as Web applications, and to computer software development of such network software. More particularly, this invention relates to an application program interface (API) that facilitates use of a network software platform by application programs and computer hardware.
BACKGROUND
[0002] Very early on, computer software came to be categorized as "operating system" software or "application" software. Broadly speaking, an application is software meant to perform a specific task for the computer user such as solving a mathematical equation or supporting word processing. The operating system is the software that manages and controls the computer hardware. The goal of the operating system is to make the computer resources available to the application programmer while at the same time, hiding the complexity necessary to actually control the hardware.
[0003] The operating system makes the resources available via functions that are collectively known as the Application Program Interface or API. The term API is also used in reference to a single one of these functions. The functions are often grouped in terms of what resource or service they provide to the application programmer. Application software requests resources by calling individual API functions. API functions also serve as the means by which messages and information provided by the operating system are relayed back to the application software.
[0004] In addition to changes in hardware, another factor driving the evolution of operating system software has been the desire to simplify and speed application software development. Application software development can be a daunting task, sometimes requiring years of developer time to create a sophisticated program with millions of lines of code. For a popular operating system such as Microsoft Windows.RTM., application software developers write thousands of different applications each year that utilize the operating system. A coherent and usable operating system base is required to support so many diverse application developers.
[0005] Often, development of application software can be made simpler by making the operating system more complex. That is, if a function may be useful to several different application programs, it may be better to write it once for inclusion in the operating system, than requiring dozens of software developers to write it dozens of times for inclusion in dozens of different applications. In this manner, if the operating system supports a wide range of common functionality required by a number of applications, significant savings in applications software development costs and time can be achieved.
[0006] Regardless of where the line between operating system and application software is drawn, it is clear that for a useful operating system, the API between the operating system and the computer hardware and application software is as important as efficient internal operation of the operating system itself.
[0007] Over the past few years, the universal adoption of the Internet, and networking technology in general, has changed the landscape for computer software developers. Traditionally, software developers focused on single-site software applications for standalone desktop computers, or LAN-based computers that were connected to a limited number of other computers via a local area network (LAN). Such software applications were typically referred to as "shrink wrapped" products because the software was marketed and sold in a shrink-wrapped package. The applications utilized well-defined APIs to access the underlying operating system of the computer.
[0008] As the Internet evolved and gained widespread acceptance, the industry began to recognize the power of hosting applications at various sites on the World Wide Web (or simply the "Web"). In the networked world, clients from anywhere could submit requests to server-based applications hosted at diverse locations and receive responses back in fractions of a second. These Web applications, however, were typically developed using the same operating system platform that was originally developed for standalone computing machines or locally networked computers. Unfortunately, in some instances, these applications do not adequately transfer to the distributed computing regime. The underlying platform was simply not constructed with the idea of supporting limitless numbers of interconnected computers.
[0009] To accommodate the shift to the distributed computing environment being ushered in by the Internet, Microsoft Corporation is developing a network software platform known as the ".NET" platform (read as "Dot Net"). The platform allows developers to create Web services that will execute over the Internet. Such a dynamic shift requires a new ground-up design of an entirely new API.
[0010] In response to this challenge, the inventors developed a unique set of API functions for Microsoft's .NET.TM. platform.
SUMMARY
[0011] An application program interface (API) provides a set of functions that make available support for processing XML documents for application developers who build Web applications on a network platform, such as Microsoft Corporation's .NET.TM. platform.
BRIEF DESCRIPTION OF THE DRAWINGS
[0012] The same numbers are used throughout the drawings to reference like features.
[0013] FIG. 1 illustrates a network architecture in which clients access Web services over the Internet using conventional protocols.
[0014] FIG. 2 is a block diagram of a software architecture for Microsoft's .NET.TM. platform, which includes an application program interface (API).
[0015] FIG. 3 is a block diagram of unique namespaces supported by the API, as well as function classes of the various API functions.
[0016] FIG. 4 is a block diagram of an exemplary computer that may execute all or part of the software architecture.
BRIEF DESCRIPTION OF ACCOMPANYING COMPACT DISC
[0017] Accompanying this specification is a compact disc that stores a compiled HTML help file identifying the API (application program interface) for Microsoft's .NET.TM. network platform. The file is named "cpref.chm" and was created on Jun. 8, 2001. It is 30.81 Mbytes in size. The file can be executed on a Windows.RTM.-based computing device (e.g., IBM-PC, or equivalent) that executes a Windows.RTM.-brand operating system (e.g., Windows.RTM. NT, Windows.RTM. 98, Windows.RTM. 2000, etc.). The compiled HTML help file stored on the compact disk is hereby incorporated by reference.
[0018] Additionally, the APIs contained in the compiled HTML help file are also provided in approximately 100 separate text files named "NamespaceName.txt". The text files comply with the ASCII format.
[0019] The compact disc itself is a CD-ROM, and conforms to the ISO 9660
standard.
DETAILED DESCRIPTION
[0020] This disclosure addresses an application program interface (API) for a network platform upon which developers can build Web applications and services. More particularly, an exemplary API is described for the .NET.TM. platform created by Microsoft Corporation. The .NET.TM. platform is a software platform for Web services and Web applications implemented in the distributed computing environment. It represents the next generation of Internet computing, using open communication standards to communicate among loosely coupled Web services that are collaborating to perform a particular task.
[0021] In the described implementation, the .NET.TM. platform utilizes XML (extensible markup language), an open standard for describing data. XML is managed by the World Wide Web Consortium (W3C). XML is used for defining data elements on a Web page and business-to-business documents. XML uses a similar tag structure as HTML; however, whereas HTML defines how elements are displayed, XML defines what those elements contain. HTML uses predefined tags, but XML allows tags to be defined by the developer of the page. Thus, virtually any data items can be identified, allowing Web pages to function like database records. Through the use of XML and other open protocols, such as Simple Object Access Protocol (SOAP), the .NET.TM. platform allows integration of a wide range of services that can be tailored to the needs of the user. Although the embodiments described herein are described in conjunction with XML and other open standards, such are not required for the operation of the claimed invention. Other equally viable technologies will suffice to implement the inventions described herein.
[0022] Exemplary Network Environment
[0023] FIG. 1 shows a network environment 100 in which a network platform, such as the .NET.TM. platform, may be implemented. The network environment 100 includes representative Web services 102(1), . . . , 102(N), which provide services that can be accessed over a network 104
(e.g., Internet). The Web services, referenced generally as number 102, are programmable application components that are reusable and interact programmatically over the network 104, typically through industry standard Web protocols, such as XML, SOAP, WAP (wireless application protocol), HTTP (hypertext transport protocol), and SMTP (simple mail transfer protocol) although other means of interacting with the Web services over the network may also be used, such as Remote Procedure Call (RPC) or object broker type technology. A Web service can be self-describing and is often defined in terms of formats and ordering of messages.
[0024] Web services 102 are accessible directly by other services (as represented by communication link 106) or a software application, such as Web application 110 (as represented by communication links 112 and 114). Each Web service 102 is illustrated as including one or more servers that execute software to handle requests for particular services. Such services often maintain databases that store information to be served back to requesters. Web services may be configured to perform any one of a variety of different services. Examples of Web services include login verification, notification, database storage, stock quoting, location directories, mapping, music, electronic wallet, calendar/scheduler, telephone listings, news and information, games, ticketing, and so on. The Web services can be combined with each other and with other applications to build intelligent interactive experiences.
[0025] The network environment 100 also includes representative client devices 120(1), 120(2), 120(3), 120(4), . . . , 120(M) that utilize the Web services 102 (as represented by communication link 122) and/or the Web application 110 (as represented by communication links 124, 126, and 128). The clients may communicate with one another using standard protocols as well, as represented by an exemplary XML link 130 between clients 120(3) and 120(4).
[0026] The client devices, referenced generally as number 120, can be implemented many different ways. Examples of possible client implementations include, without limitation, portable computers, stationary computers, tablet PCs, televisions/set-top boxes, wireless communication devices, personal digital assistants, gaming consoles, printers, photocopiers, and other smart devices.
[0027] The Web application 110 is an application designed to run on the network platform and may utilize the Web services 102 when handling and servicing requests from clients 120. The Web application 110 is composed of one or more software applications 130 that run atop a programming framework 132, which are executing on one or more servers 134 or other computer systems. Note that a portion of Web application 110 may actually reside on one or more of clients 120. Alternatively, Web application 110
may coordinate with other software on clients 120 to actually accomplish its tasks.
[0028] The programming framework 132 is the structure that supports the applications and services developed by application developers. It permits multi-language development and seamless integration by supporting multiple languages. It supports open protocols, such as SOAP, and encapsulates the underlying operating system and object model services. The framework provides a robust and secure execution environment for the multiple programming languages and offers secure, integrated class libraries.
[0029] The framework 132 is a multi-tiered architecture that includes an application program interface (API) layer 142, a common language runtime (CLR) layer 144, and an operating system/services layer 146. This layered architecture allows updates and modifications to various layers without impacting other portions of the framework. A common language specification (CLS) 140 allows designers of various languages to write code that is able to access underlying library functionality. The specification 140 functions as a contract between language designers and library designers. By adhering to the CLS, libraries written in one language can be directly accessible to code modules written in other languages to achieve seamless integration between code modules written in one language and code modules written in another language.
[0030] The API layer 142 presents groups of functions that the applications 130 can call to access the resources and services provided by layer 146. By exposing the API functions for a network platform, application developers can create Web applications for distributed computing systems that make full use of the network resources and other Web services, without needing to understand the complex interworkings of how those network resources actually operate or are made available. Moreover, the Web applications can be written in any number of programming languages, and translated into an intermediate language supported by the common language runtime 144 and included as part of the common language specification 140. . In this way, the API layer 142 can provide methods for a wide and diverse variety of applications.
[0031] Additionally, the framework 132 can be configured to support API calls placed by remote applications executing remotely from the servers 134 that host the framework. Representative applications 148(1) and 148(2) residing on clients 120(3) and 120(M), respectively, can use the API functions by making calls directly, or indirectly, to the API layer 142 over the network 104.
[0032] The framework may also be implemented at the clients. Client 120(3) represents the situation where a framework 150 is implemented at the client. This framework may be identical to server-based framework 132, or modified for client purposes. Alternatively, the client-based framework may be condensed in the event that the client is a limited or dedicated function device, such as a cellular phone, personal digital assistant, handheld computer, or other communication/computing device.
[0033] Developers's Programming Framework
[0034] FIG. 2 shows the programming framework 132 in more detail. The common language specification (CLS) layer 140 supports applications written in a variety of languages 130(1), 130(2), 130(3), 130(4), . . . , 130(K). Such application languages include Visual Basic, C++, C#, COBOL, Jscript, Perl, Eiffel, Python, and so on. The common language specification 140 specifies a subset of features or rules about features that, if followed, allow the various languages to communicate. For example, some languages do not support a given type (e.g., an "int*" type) that might otherwise be supported by the common language runtime 144. In this case, the common language specification 140 does not include the type. On the other hand, types that are supported by all or most languages (e.g., the "int[ ]" type) is included in common language specification 140 so library developers are free to use it and are assured that the languages can handle it. This ability to communicate results in seamless integration between code modules written in one language and code modules written in another language. Since different languages are particularly well suited to particular tasks, the seamless integration between languages allows a developer to select a particular language for a particular code module with the ability to use that code module with modules written in different languages. The common language runtime 144 allow seamless multi-language development, with cross language inheritance, and provide a robust and secure execution environment for the multiple programming languages. For more information on the common language specification 140 and the common language runtime 144, the reader is directed to co-pending applications entitled "Method and System for Compiling Multiple Languages", filed Jun. 21, 2000 (Ser. No. 09/598,105) and "Unified Data Type System and Method" filed Jul. 10, 2000 (Ser. No. 09/613,289), which are incorporated by reference.
[0035] The framework 132 encapsulates the operating system 146(1) (e.g., Windows.RTM.-brand operating systems) and object model services 146(2) (e.g., Component Object Model (COM) or Distributed COM). The operating system 146(1) provides conventional functions, such as file management, notification, event handling, user interfaces (e.g., windowing, menus, dialogs, etc.), security, authentication, verification, processes and threads, memory management, and so on. The object model services 146(2) provide interfacing with other objects to perform various tasks. Calls made to the API layer 142 are handed to the common language runtime layer 144 for local execution by the operating system 146(1) and/or object model services 146(2).
[0036] The API 142 groups API functions into multiple namespaces. Namespaces essentially define a collection of classes, interfaces, delegates, enumerations, and structures, which are collectively called "types", that provide a specific set of related functionality. A class represents managed heap allocated data that has reference assignment semantics. A delegate is an object oriented function pointer. An enumeration is a special kind of value type that represents named constants. A structure represents static allocated data that has value assignment semantics. An interface defines a contract that other types can implement.
[0037] By using namespaces, a designer can organize a set of types into a hierarchical namespace. The designer is able to create multiple groups from the set of types, with each group containing at least one type that exposes logically related functionality. In the exemplary implementation, the API 142 is organized into four root namespaces: a first namespace 200
for Web applications, a second namespace 202 for client applications, a third namespace 204 for data and XML, and a fourth namespace 206 for base class libraries (BCLs). Each group can then be assigned a name. For instance, types in the Web applications namespace 200 are assigned the name "Web", and types in the data and XML namespace 204 can be assigned names "Data" and "XML" respectively. The named groups can be organized under a single "global root" namespace for system level APIs, such as an overall System namespace. By selecting and prefixing a top level identifier, the types in each group can be easily referenced by a hierarchical name that includes the selected top level identifier prefixed to the name of the group containing the type. For instance, types in the Web applications namespace 200 can be referenced using the hierarchical name "System.Web". In this way, the individual namespaces 200, 202, 204, and 206 become major branches off of the System namespace and can carry a designation where the individual namespaces are prefixed with a designator, such as a "System." prefix.
[0038] The Web applications namespace 200 pertains to Web based functionality, such as dynamically generated Web pages (e.g., Microsoft's Active Server Pages (ASP)). It supplies types that enable browser/server communication. The client applications namespace 202 pertains to drawing and client side UI functionality. It supplies types that enable drawing of two-dimensional (2D) and three-dimensional (3D) drawings, imaging, and printing, as well as the ability to construct window forms, menus, boxes, and so on.
[0039] The data and XML namespace 204 relates to connectivity to data sources and XML functionality. It supplies classes, interfaces, delegates, and enumerations that enable security, specify data types, and serialize objects into XML format documents or streams. The base class libraries (BCL) namespace 206 pertains to basic system and runtime functionality. It contains the fundamental types and base classes that define commonly-used value and reference data types, events and event handlers, interfaces, attributes, and processing exceptions.
[0040] In addition to the framework 132, programming tools 210 are provided to assist the developer in building Web services and/or applications. One example of the programming tools 200 is Visual Studio.TM., a multi-language suite of programming tools offered by Microsoft Corporation.
[0041] Root API Namespaces
[0042] FIG. 3 shows the API 142 and its four root namespaces in more detail. In one embodiment, the namespaces are identified according to a hierarchical naming convention in which strings of names are concatenated with periods. For instance, the Web applications namespace 200 is identified by the root name "System.Web". Within the "Sytem.Web" namespace is another namespace for Web services, identified as "System.Web.Services", which further identifies another namespace for a description known as "System.Web.Services.Description". With this naming convention in mind, the following provides a general overview of selected namespaces of the API 142, although other naming conventions could be used with equal effect.
[0043] The Web applications namespace 200 ("System.Web") defines additional namespaces, including:
[0044] A services namespace 300 ("System.Web.Services") containing classes that enable a developer to build and use Web services. The services namespace 300 defines additional namespaces, including a description namespace 302 ("System.Web.Services.Description") containing classes that enable a developer to publicly describe a Web service via a service description language (such as WSDL, a specification available from the W3C), a discovery namespace 304 ("System.Web.Services.Discovery") containing classes that allow Web service consumers to locate available Web Services on a Web server, and a protocols namespace 306
("System.Web.Services.Protocols") containing classes that define the protocols used to transmit data across a network during communication between Web service clients and the Web service itself.
[0045] A caching namespace 308 ("System.Web.Caching") containing classes that enable developers to decrease Web application response time through temporarily caching frequently used resources on the server. This includes ASP.NET pages, web services, and user controls. (ASP.NET is the updated version of Microsoft's ASP technology.) Additionally, a cache dictionary is available for developers to store frequently used resources, such as hash tables and other data structures.
[0046] A configuration namespace 310 ("System.Web.Configuration") containing classes that are used to read configuration data in for an application.
[0047] A UI namespace 312 ("System.Web.UI") containing types that allow developers to create controls and pages that will appear in Web applications as user interfaces on a Web page. This namespace includes the control class, which provides all web based controls, whether those encapsulating HTML elements, higher level Web controls, or even custom User controls, with a common set of functionality. Also provided are classes which provide the web forms server controls data binding functionality, the ability to save the view state of a given control or page, as well as parsing functionality for both programmable and literal controls. Within the UI namespace 312 are two additional namespaces: an HTML controls namespace 314 ("System.Web.UI.HtmlControls") containing classes that permit developers to interact with types that encapsulates html 3.2 elemtents create HTML controls, and a Web controls namespace 316
("System.Web.UI.WeblControls") containing classes that allow developers to create higher level Web controls.
[0048] A security namespace 318 ("System.Web.Security") containing classes used to implement security in web server applications, such as basic authentication, challenge response authentication, and role based authentication.
[0049] A session state namespace 320 ("System.Web.SessionState") containing classes used to access session state values (i.e., data that lives across requests for the lifetime of the session) as well as session-level settings and lifetime management methods.
[0050] The client applications namespace 202 is composed of two namespaces:
[0051] A windows forms namespace 322 ("System.Windows.Forms") containing classes for creating Windows.RTM.-based client applications that take full advantage of the rich user interface features available in the Microsoft Windows.RTM. operating system, such as the ability to drag and drop screen elements. Such classes may include wrapped APIs available in the Microsoft Windows.RTM. operating system that are used in a windowing UI environment. Within this namespace are a design namespace 324
("System.Windows.Forms.Design") that contains classes to extend design-time support for Windows forms and a component model namespace 326
("System.Windows.Forms.ComponentModel") that contains the windows form implementation of the general component model defined in System.ComponentModel. This namespace contains designer tools, such as Visual Studio, which offer a rich experience for developers at design time.
[0052] A drawing namespace 328 ("System.Drawing") containing classes for graphics functionality. The drawing namespace 328 includes a 2D drawing namespace 330 ("System.Drawing.Drawing2D") that contains classes and enumerations to provide advanced 2-dimmensional and vector graphics functionality, an imaging namespace 332 ("System.Drawing.Imaging") that contains classes for advanced imaging functionality, a printing namespace 334 ("System.Drawing.Printing") that contains classes to permit developers to customize printing, and a text namespace 336
("System.Drawing.Text") that contains classes for advanced typography functionality.
[0053] The data and XML namespace 204 is composed of two namespaces:
[0054] A data namespace 340 ("System.Data") containing classes that enable developers to build components that efficiently manage data from multiple data sources. It implements an architecture that, in a disconnected scenario (such as the Internet), provides tools to request, update, and reconcile data in multiple tier systems. The data namespace 340 includes a common namespace 342 that contains types shared by data providers. A data provider describes a collection of types used to access a data source, such as a database, in the managed space. The data namespace 340
also includes an OLE DB namespace 344 that contains types pertaining to data used in object-oriented databases (e.g., Microsoft's SQL Server), and a SQL client namespace 346 that contains types pertaining to data used by SQL clients. The data namespace also includes a SQL types namespace 348 ("System.Data.SqlTypes") that contains classes for native data types within Microsoft's SQL Server. The classes provide a safer, faster alternative to other data types. Using the objects within this namespace helps prevent type conversion errors caused in situations where loss of precision could occur. Because other data types are converted to and from SQL types behind the scenes, explicitly creating and using objects within this namespace results in faster code as well.
[0055] An XML namespace 350 ("System.XML") containing classes that provide standards-based support for processing XML. The supported standards include XML (e.g., version 1.0), XML Namespaces (both stream level and DOM), XML Schemas, XPath expressions, XSL/T transformations, DOM Level 2
Core, and SOAP (e.g., version 1.1). The XML namespace 350 includes an XSLT namespace 352 ("System.XML.Xsl") that contains classes and enumerations to support XSLT (Extensible Stylesheet Language Transformations), an Xpath namespace 354 ("System.XML.Xpath") that contains an XPath parser and evaluation engine, and a serialization namespace 356 ("System.XML.Serialization") that contains classes used to serialize objects into XML format documents or streams.
[0056] The base class library namespace 206 ("System") includes the following namespaces:
[0057] A collections namespace 360 ("System.Collections") containing interfaces and classes that define various collections of objects, such as lists, queues, arrays, hash tables and dictionaries.
[0058] A configuration namespace 362 ("System.Configuration") containing classes and interfaces that allow developers to programmatically access configuration settings and handle errors in configuration files.
[0059] A diagnostics namespace 364 ("System.Diagnostics") containing classes that are used to debug applications and to trace code execution. The namespace allows developers to start system processes, read and write to event logs, and monitor system performance using performance counters.
[0060] A globalization namespace 366 ("System.Globalization") containing classes that define culture-related information, including the language, the country/region, the calendars in use, the format patterns for dates, currency and numbers, and the sort order for strings.
[0061] An I/O namespace 368 ("System.IO") containing the infrastructure pieces to operate with the intput/output of data streams, files, and directories. This namespace includes a model for working with streams of bytes, higher level readers and writers which consume those bytes, various constructions or implementations of the streams (e.g., FileStream and MemoryStream) and, a set of utility classes for working with files and directories.
[0062] A net namespace 370 ("System.Net") providing an extensive set of classes for building network-enabled application, referred to as the Net Class Libraries (NCL). One element to the design of the Net Class Libraries is an extensible, layered approach to exposing networking functionality. The NCL stack contains three basic layers. A base layer (System.Net.Socket) provides access to an interface to TCP/IP, the communications protocol of UNIX networks and the Internet. One example of such an interface is the "WinSock API" from Microsoft Corporation. The next layer is the Transport Protocol classes, which support such transport protocols as TCP and UDP. Developers may write their own protocol classes to provide support for protocols such as IGMP and ICMP. The third layer is the Web request, which provides an abstract factory pattern for the creation of other protocol classes. The NCL provides implementations for Hyper Text Transport Protocol (HTTP).
[0063] A reflection namespace ("System.Reflection") 372 containing types that provide a managed view of loaded types, methods, and fields, with the ability to dynamically create and invoke types.
[0064] A resources namespace 374 ("System.Resources") containing classes and interfaces that allow developers to create, store and manage various culture-specific resources used in an application.
[0065] A security namespace 376 ("System.Security") supporting the underlying structure of the security system, including interfaces, attributes, exceptions, and base classes for permissions.
[0066] A service process namespace 378 ("System.ServiceProcess") containing classes that allow developers to install and run services. Services are long-running executables that run without a user interface. They can be installed to run under a system account that enables them to be started at computer reboot. Services whose implementation is derived from processing in one class can define specific behavior for start, stop, pause, and continue commands, as well as behavior to take when the system shuts down.
[0067] A text namespace 380 ("System.Text") containing classes representing various types of encodings (e.g., ASCII, Unicode, UTF-7, and UTF-8), abstract base classes for converting blocks of characters to and from blocks of bytes, and a helper class that manipulates and formats string objects without creating intermediate instances.
[0068] A threading namespace 382 ("System.Threading") containing classes and interfaces that enable multi-threaded programming. The threading namespace includes a ThreadPool class that manages groups of threads, a Timer class that enables a delegate to be called after a specified amount of time, and a Mutex class for synchronizing mutually-exclusive threads. This namespace also provides classes for thread scheduling, wait notification, and deadlock resolution.
[0069] A runtime namespace 384 ("System.Runtime") containing multiple namespaces concerning runtime features, including an interoperation services namespace 386 ("System.Runtime.InteropServices") that contains a collection of classes useful for accessing COM objects. The types in the InteropServices namespace fall into the following areas of functionality: attributes, exceptions, managed definitions of COM types, wrappers, type converters, and the Marshal class. The runtime namespace 384 further includes a remoting namespace 388 ("System.Runtime.Remoting") that contains classes and interfaces allowing developers to create and configure distributed applications. Another namespace within the runtime namespace 384 is a serialization namespace 390 ("System.Runtime.Serializa- tion") that contains classes used for serializing and deserializing objects. Serialization is the process of converting an object or a graph of objects into a linear sequence of bytes for either storage or transmission to another location.
[0070] Portions of the XML namespace 350 ("System.XML") are discussed in additional detail below.
[0071] System.XML Namespace
[0072] This is the overall namespace for the XML classes that provide standards-based support for processing XML. Various functionality for processing XML documents can be invoked via the XML namespace, such as non-cached forward only access to XML data, read-only random access to a data store, transforming of XML data using an XSLT stylesheet, constructing and editing of schemas, resolving of external XML resources named by a Uniform Resource Identifier (URI), storage and retrieval (as well as manipulation) of structured data through a relational dataset, non-cached forward only generation of streams and files containing XML data, DTD and XDR (as well as XSD) schema validation, and so forth. In one exemplary implementation, the standards supported by the namespace are:
[0073] XML 1.0--http://www.w3.org/TR/1998/REC-xml-19980210--including DTD support (XmlTextReader);
[0074] XML Namespaces--http://www.w3.org/TR/REC-xml-names/--both stream level and DOM;
[0075] XML Schemas--http://www.w3.org/TR/xmlschema-1/--supported for schema mapping and serialization. (see also XmlSchemaCollection which provides XDR schema validation);
[0076] XPath expressions--http://www.w3.org/TR/xpath (XmlNavigator);
[0077] XSL/T transformations--http://www.w3.org/TR/xslt (XslTransform);
[0078] DOM Level 2 Core--http://www.w3.org/TR/DOM-Level-2/--for (XmlDocument);
[0079] SOAP 1.1--http://msdn.microsoft.com/xml/general/soapspec.asp (including the Soap Contract Language and Soap Discovery) used in XML object serialization.
[0080] The System.Xml namespace also includes a System.Xml.Schema namespace that contains XML classes that provide standards-based support for XML schemas. In one exemplary implementation, the supported standards are:
[0081] XML Schemas for Structures--http://www.w3.org/TR/xmlschema-1/--supp- orts for schema mapping and for validation. (see also XmlSchemaCollection which provides XSD and XDR schema validation); and
[0082] XML Schemas for Data Types--http://www.w3.org/TR/xmlschema-2/--supp- orts data types for XML schema definitions. (see also XmlSchemaCollection which provides XSD and XDR schema validation).
[0083] The following is a more detailed description of the System.Xml namespace, identifying various classes, interfaces, enumerations, and so forth contained in the System.Xml namespace (as well as the System.Xml.Schema, System.Xml.Serialization, System.Xml.Xpath, and System.Xml.Xsl namespaces contained therein).
[0084] System.Xml
[0085] This is the overall namespace for the XML classes that provide standards-based support for processing XML. The supported standards are: XML 1.0--http://www.w3.org/TR/1998/REC-xml-19980210--including DTD support (XmlTextReader) XML Namespaces--http://www.w3.org/TR/REC-xml-name- s/--both stream level and DOM.
[0086] Description
[0087] This is the overall namespace for the XML classes that provide standards-based support for processing XML. The supported standards are: XML 1.0--http://www.w3.org/TR/1998/REC-xml-19980210--including DTD support (XmlTextReader)XML Namespaces--http://www.w3.org/TR/REC-xml-names- /--both stream level and DOM.
[0088] XmlDataDocument class (System.Xml)
[0089] Description
[0090] Allows structured data to be stored, retrieved, and manipulated through a relational System.Data.DataSet
[0091] This class extends System.Xml.XmlDocument. It enables you to load either relational data or XML data and manipulate that data using the W3C Document Object Model (DOM). The DOM presents data as a hierarchy of node objects. Because XmlDataDocument implements the System.Xml.XPath.IXPathNa- vigable interface it can also be used as the source document for the System.Xml.Xsl.XslTransform class.
[0092] Constructors:
[0093] XmlDataDocument
[0094] Example Syntax:
[0095] [C#] public XmlDataDocument( );
[0096] [C++] public: XmlDataDocument( );
[0097] [VB] Public Sub New( )
[0098] [JScript] public function XmlDataDocument( ); Initializes a new instance of the XmlDataDocument class.
[0099] Description
[0100] Initializes a new instance of the XmlDataDocument class.
[0101] The first time the System.Xml.XmlDataDocument.DataSet property is used, a new DataSet is created an associated with the XmlDataDocument.
[0102] XmlDataDocument
[0103] Example Syntax:
[0104] [C#] public XmlDataDocument(DataSet dataset);
[0105] [C++] public: XmlDataDocument(DataSet* dataset);
[0106] [VB] Public Sub New(ByVal dataset As DataSet)
[0107] [JScript] public function XmlDataDocument(dataset : DataSet);
[0108] Description
[0109] Initializes a new instance of the XmlDataDocument class with the specified System.Data.DataSet.
[0110] The XmlDataDocument is synchronized with the specified DataSet. Any data in the DataSet is immediately available through the XmlDataDocument. Any changes in the DataSet are propogated in the XmlDataDocument. Any changes made in the XmlDataDocument, provided they match the DataSet schema, are propogated in the DataSet. The DataSet to load into the XmlDataDocument.
[0111] Properties:
[0112] Attributes
[0113] BaseURI
[0114] ChildNodes
[0115] DataSet
[0116] Description
[0117] Gets a System.Data.DataSet that provides a relational representation of the data in the XmlDataDocument.
[0118] The DataSet enables you to access the data in the XmlDataDocument using a relational model. This means that you can handle the data as tables and views, rows and columns, relations, and so on.
[0119] DocumentElement
[0120] DocumentType
[0121] FirstChild
[0122] HasChildNodes
[0123] Implementation
[0124] InnerText
[0125] InnerXml
[0126] IsReadOnly
[0127] Item
[0128] Item
[0129] LastChild
[0130] LocalName
[0131] Name
[0132] NamespaceURI
[0133] NameTable
[0134] NextSibling
[0135] NodeType
[0136] OuterXml
[0137] OwnerDocument
[0138] ParentNode
[0139] Prefix
[0140] PreserveWhitespace
[0141] PreviousSibling
[0142] Value
[0143] XmlResolver
[0144] Methods:
[0145] CloneNode
[0146] [C#] public override XmlNode CloneNode(bool deep);
[0147] [C++] public: XmlNode* CloneNode(bool deep);
[0148] [VB] Overrides Public Function CloneNode(ByVal deep As Boolean) As XmlNode
[0149] [JScript] public override function CloneNode(deep : Boolean) : XmlNode;
[0150] Description
[0151] Creates a duplicate of the current node.
[0152] Return Value: The cloned node.
[0153] Cloning the XmlDataDocument also clones the System.Data.DataSet schema. true to recursively clone the subtree under the specified node; false to clone only the node itself.
[0154] CreateElement
[0155] [C#] public override XmlElement CreateElement(string prefix, string localName, string namespaceURI);
[0156] [C++] public: XmlElement* CreateElement(String* prefix, String* localName, String* namespaceURI);
[0157] [VB] Overrides Public Function CreateElement(ByVal prefix As String, ByVal localName As String, ByVal namespaceURI As String) As XmlElement
[0158] [JScript] public override function CreateElement(prefix : String, localName : String, namespaceURI : String) : XmlElement; Creates an System.Xml.XmlElement.
[0159] Description
[0160] Creates an element with the specified System.Xml.XmlNode.Prefix, System.Xml.XmlDocument.LocalName, and System.Xml.XmlNode.NamespaceURI.
[0161] Return Value: A new System.Xml.XmlElement.
[0162] Notes to Inheritors If you overload this function, it should not be used for extensibility. Instead, you should return an element created by the base class, XmlDataDocument in this case. See the following example. The prefix of the new element; if String.Empty or null there is no prefix. The local name of the new element. The namespace URI of the new element; if String.Empty or null there is no namespaceURI.
[0163] CreateEntityReference
[0164] [C#] public override XmlEntityReference CreateEntityReference(strin- g name);
[0165] [C++] public: XmlEntityReference* CreateEntityReference(String* name);
[0166] [VB] Overrides Public Function CreateEntityReference(ByVal name As String) As XmlEntityReference
[0167] [JScript] public override function CreateEntityReference(name : String) : XmlEntityReference;
[0168] Description
[0169] Creates an System.Xml.XmlEntityReference with the specified name. Name of the entity reference.
[0170] CreateNavigator
[0171] [C#] protected override XPathNavigator CreateNavigator(XmlNode node);
[0172] [C++] protected: XPathNavigator* CreateNavigator(XmlNode* node);
[0173] [VB] Overrides Protected Function CreateNavigator(ByVal node As XmlNode) As XPathNavigator
[0174] [JScript] protected override function CreateNavigator(node : XmlNode) : XPathNavigator; Creates a new System.Xml.XPath.XPathNavigator object for navigating this document.
[0175] Description
[0176] Creates a new System.Xml.XPath.XPathNavigator object for navigating this document.
[0177] Return Value: An XPathNavigator.
[0178] The XPathNavigator provides read-only, random access to data. Because it is optimized for XSLT transformations, it provides performance benefits when used as an input mechanism to the System.Xml.Xsl.XslTransfo- rm.Transform(System.Xml.XPath.IXPathNaviga ble,System.Xml.Xsl.XsltArgument- List) method. The System.Xml.XmlNode you want to navigate.
[0179] GetElementById
[0180] [C#] public override XmlElement GetElementById(string elemId);
[0181] [C++] public: XmlElement* GetElementById(String* elemId);
[0182] [VB] Overrides Public Function GetElementById(ByVal elemId As String) As XmlElement
[0183] [JScript] public override function GetElementById(elemId : String) : XmlElement;
[0184] Description
[0185] Gets the System.Xml.XmlElement with the specified ID. The attribute ID to match.
[0186] GetElementFromRow
[0187] [C#] public XmlElement GetElementFromRow(DataRow r);
[0188] [C++] public: XmlElement* GetElementFromRow(DataRow* r);
[0189] [VB] Public Function GetElementFromRow(ByVal r As DataRow) As XmlElement
[0190] [JScript] public function GetElementFromRow(r : DataRow) : XmlElement;
[0191] Description
[0192] Retrieves the System.Xml.XmlElement associated with the specified System.Data.DataRow.
[0193] Return Value: The XmlElement containing a representation of the specified DataRow. The DataRow whose associated XmlElement you wish to retrieve.
[0194] GetRowFromElement
[0195] [C#] public DataRow GetRowFromElement(XmlElement e);
[0196] [C++] public: DataRow* GetRowFromElement(XmlElement* e);
[0197] [VB] Public Function GetRowFromElement(ByVal e As XmlElement) As DataRow
[0198] [JScript] public function GetRowFromElement(e : XmlElement) : DataRow;
[0199] Description
[0200] Retrieves the System.Data.DataRow associated with the specified System.Xml.XmlElement.
[0201] Return Value: The DataRow containing a representation of the XmlElement. The XmlElement whose associated DataRow you wish to retrieve.
[0202] Load
[0203] [C#] public override void Load(XmlReader reader);
[0204] [C++] public: void Load(XmlReader* reader);
[0205] [VB] Overrides Public Sub Load(ByVal reader As XmlReader)
[0206] [JScript] public override function Load(reader : XmlReader); Loads the XmlDataDocument using the specified data source and synchronizes the System.Data.DataSet with the loaded data.
[0207] Description
[0208] Loads the XmlDataDocument from the specified System.Xml.XmlReader.
[0209] System.Xml.XmlWhitespace nodes are not created unless System.Xml.XmlDocument.PreserveWhitespace is set to true. Also, if the reader has been configured to not return whitespace, then no whitespace nodes will be created. In other words Load does not change the whitespace handling of the given reader. XmlReader containing the XML document to load.
[0210] WriteTo
[0211] [C#] public override void WriteTo(XmlWriter writer);
[0212] [C++] public: void WriteTo(XmlWriter* writer);
[0213] [VB] Overrides Public Sub WriteTo(ByVal writer As XmlWriter)
[0214] [JScript] public override function WriteTo(writer : XmlWriter);
[0215] Description
[0216] Saves the current node to the specified System.Xml.XmlWriter. The XmlWriter to which you want to save.
[0217] EntityHandling enumeration (System.Xml)
[0218] WriteTo
[0219] Description
[0220] Specifies how entities are handled.
[0221] WriteTo
[0222] [C#] public const EntityHandling ExpandCharEntities;
[0223] [C++] public: const EntityHandling ExpandCharEntities;
[0224] [VB] Public Const ExpandCharEntities As EntityHandling
[0225] [JScript] public var ExpandCharEntities : EntityHandling;
[0226] Description
[0227] Expands character entities and returns general entities as nodes (System.Xml.XmlValidatingReader.NodeType=XmlNodeType.EntityReference, System.Xml.XmlValidatingReader.Name=the name of the entity, System.Xml.XmlValidatingReader.HasValue=false).
[0228] WriteTo
[0229] [C#] public const EntityHandling ExpandEntities;
[0230] [C++] public: const EntityHandling ExpandEntities;
[0231] [VB] Public Const ExpandEntities As EntityHandling
[0232] [JScript] public var ExpandEntities : EntityHandling;
[0233] Description
[0234] Expands all entities. This is the default.
[0235] Formatting enumeration (System.Xml)
[0236] ToString
[0237] Description
[0238] Specifies formatting options for the System.Xml.XmlTextWriter.
[0239] ToString
[0240] [C#] public const Formatting Indented;
[0241] [C++] public: const Formatting Indented;
[0242] [VB] Public Const Indented As Formatting
[0243] [JScript] public var Indented : Formatting;
[0244] Description
[0245] Causes child elements to be indented according to the System.Xml.XmlTextWriter.Indentation and System.Xml.XmlTextWriter.IndentC- har settings. This option indents element content only; mixed content is not affected. For the XML 1.0 definitions of these terms, see the W3C documentation (http://www.w3.org/TR/1998/REC-xml-19980210#sec-element-con- tent and http://www.w3.org/TR/1998/REC-xml-19980210#sec-mixed-content).
[0246] ToString
[0247] [C#] public const Formatting None;
[0248] [C++] public: const Formatting None;
[0249] [VB] Public Const None As Formatting
[0250] [JScript] public var None : Formatting;
[0251] Description
[0252] No special formatting is applied. This is the default.
[0253] IHasXmlNode interface (System.Xml)
[0254] ToString
[0255] Description
[0256] Enables a class to return an System.Xml.XmlNode from the current context or position.
[0257] This interface is implemented by classes which operate over classes that have System.Xml.XmlNode nodes. For example, if an System.Xml.XPath.XPathNavigator is implemented over an System.Xml.XmlDocument you can use the System.Xml.IHasXmlNode.GetNode method to access the node representing the current position of the navigator.
[0258] GetNode
[0259] [C#] XmlNode GetNode( );
[0260] [C++] XmlNode* GetNode( );
[0261] [VB] Function GetNode( ) As XmlNode
[0262] [JScript] function GetNode( ) : XmlNode;
[0263] Description
[0264] Returns the System.Xml.XmlNode for the current position.
[0265] Return Value: The XmlNode for the current position.
[0266] The following C# code uses GetNode to access a node the System.Xml.XPath.XPathNavigator is currently positioned on.
[0267] IXmlLineInfo interface (System.Xml)
[0268] GetNode
[0269] Description
[0270] Provides an interface to enable a class to return line and position information.
[0271] LineNumber
[0272] GetNode
[0273] [C#] int LineNumber {get;}
[0274] [C++] int get_LineNumber( );
[0275] [VB] ReadOnly Property LineNumber As Integer
[0276] [JScript] abstract function get LineNumber( ) : int;
[0277] Description
[0278] Gets the current line number.
[0279] This property is used primarily for error reporting, but can be called at any time. The starting value is b 1. Combined with System.Xml.IXmlLineInfo.LinePosition, a value of 1,1 indicates the start of a document.
[0280] LinePosition
[0281] GetNode
[0282] [C#] int LinePosition {get;}
[0283] [C++] int get_LinePosition( );
[0284] [VB] ReadOnly Property LinePosition As Integer
[0285] [JScript] abstract function get LinePosition( ) : int;
[0286] Description
[0287] Gets the current line position.
[0288] This property is used primarily for error reporting, but can be called at any time. The starting value is 1. Combined with System.Xml.IXmlLineInfo.LineNumber, a value of 1,1 indicates the start of a document.
[0289] HasLineInfo
[0290] [C#] bool HasLineInfo( );
[0291] [C++] bool HasLineInfo( );
[0292] [VB] Function HasLineInfo( ) As Boolean
[0293] [JScript] function HasLineInfo( ) : Boolean;
[0294] Description
[0295] Gets a value indicating whether the class can return line information.
[0296] Return Value: true if System.Xml.IXmlLineInfo.LineNumber and System.Xml.IXmlLineInfo.LinePosition can be provided; otherwise, false.
[0297] NameTable class (System.Xml)
[0298] HasLineInfo
[0299] Description
[0300] Implements a single-threaded System.Xml.XmlNameTable.
[0301] Several classes, such as System.Xml.XmlDocument and System.Xml.XmlReader use the NameTable class internally, to store attribute and element names. When an element or attribute name occurs multiple times in an XML document it is stored only once in the NameTable. This allows you to do object comparisons on these strings rather than a more expensive string comparison.
[0302] NameTable
[0303] Example Syntax:
[0304] HasLineInfo
[0305] [C#] public NameTable( );
[0306] [C++] public: NameTable( );
[0307] [VB] Public Sub New( )
[0308] [JScript] public function NameTable( );
[0309] Description
[0310] Initializes a new instance of the NameTable class.
[0311] Constructs an empty NameTable.
[0312] Add
[0313] [C#] public override string Add(string key);
[0314] [C++] public: String* Add(String* key);
[0315] [VB] Overrides Public Function Add(ByVal key As String) As String
[0316] [JScript] public override function Add(key : String) : String; Atomizes the specified string and adds it to the NameTable.
[0317] Description
[0318] Atomizes the specified string and adds it to the NameTable.
[0319] Return Value: The atomized string or the existing string if it already exists in the NameTable. The string to add.
[0320] Add
[0321] [C#] public override string Add(char[ ] key, int start, int len);
[0322] [C++] public: String* Add(_wchar_t key_gc[ ], int start, int len);
[0323] [VB] Overrides Public Function Add(ByVal key( ) As Char, ByVal start As Integer, ByVal len As Integer) As String
[0324] [JScript] public override function Add(key : Char[ ], start : int, len : int) : String;
[0325] Description
[0326] Atomizes the specified string and adds it to the NameTable.
[0327] Return Value: The atomized string or the existing atom if one already exists in the NameTable. If len is zero, String.Empty is returned. The character array containing the string to add. The zero-based index into the array specifying the first character of the string. The number of characters in the string.
[0328] Get
[0329] [C#] public override string Get(string value);
[0330] [C++] public: String* Get(String* value);
[0331] [VB] Overrides Public Function Get(ByVal value As String) As String
[0332] [JScript] public override function Get(value : String) : String; Gets the atomized string object.
[0333] Description
[0334] Gets the atomized string object with the specified value.
[0335] Return Value: The atomized string object or null if the string has not already been atomized. The name to find.
[0336] Get
[0337] [C#] public override string Get(char[ ] key, int start, int len);
[0338] [C++] public: String* Get(_wchar_t key_gc[ ], int start, int len);
[0339] [VB] Overrides Public Function Get(ByVal key( ) As Char, ByVal start As Integer, ByVal len As Integer) As String
[0340] [JScript] public override function Get(key : Char[ ], start : int, len : int) : String;
[0341] Description
[0342] Gets the atomized String object containing the same characters as the specified range of characters in the given array.
[0343] Return Value: The atomized string or null if the string has not already been atomized. If len is zero, String.Empty is returned. The character array containing the name to find. The zero-based index into the array specifying the first character of the name. The number of characters in the name.
[0344] ReadState enumeration (System.Xml)
[0345] ToString
[0346] Description
[0347] Specifies the state of the reader.
[0348] ToString
[0349] [C#] public const ReadState Closed;
[0350] [C++] public: const ReadState Closed;
[0351] [VB] Public Const Closed As ReadState
[0352] [JScript] public var Closed : ReadState;
[0353] Description
[0354] The System.Xml.XmlReader.Close method has been called.
[0355] ToString
[0356] [C#] public const ReadState EndOfFile;
[0357] [C++] public: const ReadState EndOfFile;
[0358] [VB] Public Const EndOfFile As ReadState
[0359] [JScript] public var EndOfFile : ReadState;
[0360] Description
[0361] The end of the file has been reached successfully.
[0362] ToString
[0363] [C#] public const ReadState Error;
[0364] [C++] public: const ReadState Error;
[0365] [VB] Public Const Error As ReadState
[0366] [JScript] public var Error : ReadState;
[0367] Description
[0368] An error occurred that prevents the read operation from continuing.
[0369] ToString
[0370] [C#] public const ReadState Initial;
[0371] [C++] public: const ReadState Initial;
[0372] [VB] Public Const Initial As ReadState
[0373] [JScript] public var Initial : ReadState;
[0374] Description
[0375] The Read method has not been called.
[0376] ToString
[0377] [C#] public const ReadState Interactive;
[0378] [C++] public: coust ReadState Interactive;
[0379] [VB] Public Const Interactive As ReadState
[0380] [JScript] public var Interactive : ReadState;
[0381] Description
[0382] The Read method has been called. Additional methods may be called on the reader.
[0383] ValidationType enumeration (System.Xml)
[0384] ToString
[0385] Description
[0386] Specifies the type of validation to perform.
[0387] The validation model has three characteristics, strict, informative, and status. Strict, does not allow the mixing of validation types, informative provides a warning if the schema or DTD cannot be found, and status provides warnings if validation cannot be performed for elements and attributes from schemas.
[0388] ToString
[0389] [C#] public const ValidationType Auto;
[0390] [C++] public: const ValidationType Auto;
[0391] [VB] Public Const Auto As ValidationType
[0392] [JScript] public var Auto : ValidationType;
[0393] Description
[0394] System.Xml.XmlValidatingReader validates if DTD or schema information is found.
[0395] ToString
[0396] [C#] public const ValidationType DTD;
[0397] [C++] public: const ValidationType DTD;
[0398] [VB] Public Const DTD As ValidationType
[0399] [JScript] public var DTD : ValidationType;
[0400] Description
[0401] Validates according to the DTD.
[0402] ToString
[0403] [C#] public const ValidationType None;
[0404] [C++] public: const ValidationType None;
[0405] [VB] Public Const None As ValidationType
[0406] [JScript] public var None : ValidationType;
[0407] Description
[0408] Creates an XML 1.0 compliant non-validating parser. Default attributes are reported and general entities can be resolved by calling System.Xml.XmlValidatingReader.ResolveEntity. The DOCTYPE is not used for validation purposes.
[0409] ToString
[0410] [C#] public const ValidationType Schema;
[0411] [C++] public: const ValidationType Schema;
[0412] [VB] Public Const Schema As ValidationType
[0413] [JScript] public var Schema : ValidationType;
[0414] Description
[0415] Validate according to XSD schemas; including inline schemas. XSD schemas are associated with namespace URIs either by using the schemaLocation attribute or the provided System.Xml.XmlValidatingReader.S- chemas property.
[0416] ToString
[0417] [C#] public const ValidationType XDR;
[0418] [C++] public: const ValidationType XDR;
[0419] [VB] Public Const XDR As ValidationType
[0420] [JScript] public var XDR : ValidationType;
[0421] Description
[0422] Validate according to XDR schemas; including inline schemas. XDR schemas are recognized using the x-schema namespace prefix or the System.Xml.XmlValidatingReader.Schemas property.
[0423] WhitespaceHandling enumeration (System.Xml)
[0424] ToString
[0425] Description
[0426] Specifies how whitespace is handled.
[0427] ToString
[0428] [C#] public const WhitespaceHandling All;
[0429] [C++] public: const WhitespaceHandling All;
[0430] [VB] Public Const All As WhitespaceHandling
[0431] [JScript] public var All : WhitespaceHandling;
[0432] Description
[0433] Return Whitespace and SignificantWhitespace nodes. This is the default.
[0434] ToString
[0435] [C#] public const WhitespaceHandling None;
[0436] [C++] public: const WhitespaceHandling None;
[0437] [VB] Public Const None As WhitespaceHandling
[0438] [JScript] public var None : WhitespaceHandling;
[0439] Description
[0440] Return no Whitespace and no SignificantWhitespace nodes.
[0441] ToString
[0442] [C#] public const WhitespaceHandling Significant;
[0443] [C++] public: const WhitespaceHandling Significant;
[0444] [VB] Public Const Significant As WhitespaceHandling
[0445] [JScript] public var Significant : WhitespaceHandling;
[0446] Description
[0447] Return SignificantWhitespace nodes only.
[0448] WriteState enumeration (System.Xml)
[0449] ToString
[0450] Description
[0451] Specifies the state of the System.Xml.XmlWriter.
[0452] ToString
[0453] [C#] public const WriteState Attribute;
[0454] [C++] public: const WriteState Attribute;
[0455] [VB] Public Const Attribute As WriteState
[0456] [JScript] public var Attribute : WriteState;
[0457] Description
[0458] An attribute value is being written.
[0459] ToString
[0460] [C#] public const WriteState Closed;
[0461] [C++] public: const WriteState Closed;
[0462] [VB] Public Const Closed As WriteState
[0463] [JScript] public var Closed : WriteState;
[0464] Description
[0465] The System.Xml.XmlWriter.Close method has been called.
[0466] ToString
[0467] [C#] public const WriteState Content;
[0468] [C++] public: const WriteState Content;
[0469] [VB] Public Const Content As WriteState
[0470] [JScript] public var Content : WriteState;
[0471] Description
[0472] The element content is being written.
[0473] ToString
[0474] [C#] public const WriteState Element;
[0475] [C++] public: const WriteState Element;
[0476] [VB] Public Const Element As WriteState
[0477] [JScript] public var Element : WriteState;
[0478] Description
[0479] An element start tag is being written.
[0480] ToString
[0481] [C#] public const WriteState Prolog;
[0482] [C++] public: const WriteState Prolog;
[0483] [VB] Public Const Prolog As WriteState
[0484] [JScript] public var Prolog : WriteState;
[0485] Description
[0486] The prolog is being written.
[0487] ToString
[0488] [C#] public const WriteState Start;
[0489] [C++] public: const WriteState Start;
[0490] [VB] Public Const Start As WriteState
[0491] [JScript] public var Start : WriteState;
[0492] Description
[0493] A Write method has not been called.
[0494] XmlAttribute class (System.Xml)
[0495] ToString
[0496] Description
[0497] Represents an attribute. Valid and default values for the attribute are defined in a DTD or schema.
[0498] XmlAttribute
[0499] Example Syntax:
[0500] ToString
[0501] [C#] protected internal XmlAttribute(string prefix, string localName, string namespaceURI, XmlDocument doc);
[0502] [C++] internal: XmlAttribute(String* prefix, String* localName, String* namespaceURI, XmlDocument* doc);
[0503] [VB] Protected Friend Sub New(ByVal prefix As String, ByVal localName As String, ByVal namespaceURI As String, ByVal doc As XmlDocument)
[0504] [JScript] package function XmlAttribute(prefix : String, localName : String, namespaceURI : String, doc : XmlDocument);
[0505] Description
[0506] Attributes
[0507] BaseURI
[0508] ToString
[0509] Description
[0510] Gets the base URI of the node.
[0511] A networked XML document is comprised of chunks of data aggregated using various W3C standard inclusion mechanisms and therefore contains nodes that come from different places. The BaseURI tells you where these nodes came from.
[0512] ChildNodes
[0513] FirstChild
[0514] HasChildNodes
[0515] InnerText
[0516] ToString
[0517] Description
[0518] Gets or sets the concatenated values of the node and all its children.
[0519] Setting this property replaces all the children with the parsed contents of the given string.
[0520] InnerXml
[0521] ToString
[0522] [C#] public override string InnerXml {get; set;}
[0523] [C++] public: _property virtual String* get_InnerXml( );public: _property virtual void set_InnerXml(String*);
[0524] [VB] Overrides Public Property InnerXml As String
[0525] [JScript] public function get InnerXml( ) : String;public function set InnerXml(String);
[0526] Description
[0527] Gets or sets the markup representing just the children of this node.
[0528] This is also settable which replaces the children of the node with the parsed contents of the given string. The parsing is done in the current namespace context.
[0529] IsReadOnly
[0530] Item
[0531] Item
[0532] LastChild
[0533] LocalName
[0534] ToString
[0535] Description
[0536] Gets the local name of the node.
[0537] If the node does not have a prefix, LocalName is the same as System.Xml.XmlAttribute.Name.
[0538] Name
[0539] ToString
[0540] [C#] public override string Name {get;}
[0541] [C++] public: _property virtual String* get_Name( );
[0542] [VB] Overrides Public ReadOnly Property Name As String
[0543] [JScript] public function get Name( ) : String;
[0544] Description
[0545] Gets the qualified name of the node.
[0546] NamespaceURI
[0547] ToString
[0548] [C#] public override string NamespaceURI {get;}
[0549] [C++] public: _property virtual String* get_NamespaceURI( );
[0550] [VB] Overrides Public ReadOnly Property NamespaceURI As String
[0551] [JScript] public function get NamespaceURI( ) : String;
[0552] Description
[0553] Gets the namespace URI of this node.
[0554] An attribute does not inherit its namespace from the element it is attached to. If an attribute is not explicitly given a namespace, the namespace URI is considered to be String.Empty.
[0555] NextSibling
[0556] NodeType
[0557] ToString
[0558] Description
[0559] Gets the type of the current node.
[0560] OuterXml
[0561] OwnerDocument
[0562] ToString
[0563] Description
[0564] Gets the System.Xml.XmlDocument to which this node belongs.
[0565] OwnerElement
[0566] ToString
[0567] [C#] public virtual XmlElement OwnerElement {get;}
[0568] [C++] public: _property virtual XmlElement* get_OwnerElement( );
[0569] [VB] Overridable Public ReadOnly Property OwnerElement As XmlElement
[0570] [JScript] public function get OwnerElement( ) : XmlElement;
[0571] Description
[0572] Gets the System.Xml.XmlElement that contains this attribute.
[0573] ParentNode
[0574] ToString
[0575] [C#] public override XmlNode ParentNode {get;}
[0576] [C++] public: _property virtual XmlNode* get_ParentNode( );
[0577] [VB] Overrides Public ReadOnly Property ParentNode As XmlNode
[0578] [JScript] public function get ParentNode( ) : XmlNode;
[0579] Description
[0580] Gets the parent of this node. For XmlAttribute nodes, this property always returns null.
[0581] Prefix
[0582] ToString
[0583] [C#] public override string Prefix {get; set;}
[0584] [C++] public: _property virtual String* get_Prefix( );public: _property virtual void set_Prefix(String*);
[0585] [VB] Overrides Public Property Prefix As String
[0586] [JScript] public function get Prefix( ) : String;public function set Prefix(String);
[0587] Description
[0588] Gets or sets the namespace prefix of this node.
[0589] Changing the prefix of an attribute that is known to have a default value does not create a new attribute with the default value and the original prefix.
[0590] PreviousSibling
[0591] Specified
[0592] ToString
[0593] Description
[0594] Gets a value indicating whether the attribute value was explicitly set.
[0595] The implementation is in charge of this property, not the user. If the user changes the value of the attribute (even if it ends up having the same value as the default/fixed value) then the specified flag is automatically flipped to true. To respecify the attribute as the default/fixed value from the DTD, the user must delete the attribute. The implementation then makes a new attribute available with specified set to false and the default/fixed value (if one exists).
[0596] Value
[0597] ToString
[0598] [C#] public override string Value {get; set;}
[0599] [C++] public: _property virtual String* get_Value( );public: _property virtual void set_Value(String*);
[0600] [VB] Overrides Public Property Value As String
[0601] [JScript] public function get Value( ) : String;public function set Value(String);
[0602] Description
[0603] Gets or sets the value of the node.
[0604] CloneNode
[0605] [C#] public override XmlNode CloneNode(bool deep);
[0606] [C++] public: XmlNode* CloneNode(bool deep);
[0607] [VB] Overrides Public Function CloneNode(ByVal deep As Boolean) As XmlNode
[0608] [JScript] public override function CloneNode(deep : Boolean) : XmlNode;
[0609] Description
[0610] Creates a duplicate of this node.
[0611] Return Value: The duplicate node.
[0612] This method serves as a copy constructor for nodes. The cloned node has no parent (System.Xml.XmlAttribute.ParentNode returns null). true to recursively clone the subtree under the specified node; false to clone only the node itself
[0613] WriteContentTo
[0614] [C#] public override void WriteContentTo(XmlWriter w);
[0615] [C++] public: void WriteContentTo(XmlWriter* w);
[0616] [VB] Overrides Public Sub WriteContentTo(ByVal w As XmlWriter)
[0617] [JScript] public override function WriteContentTo(w : XmlWriter);
[0618] Description
[0619] Saves all the children of the node to the specified XmlWriter. The XmlWriter where you want to save the current node.
[0620] WriteTo
[0621] [C#] public override void WriteTo(XmlWriter w);
[0622] [C++] public: void WriteTo(XmlWriter* w);
[0623] [VB] Overrides Public Sub WriteTo(ByVal w As XmlWriter)
[0624] [JScript] public override function WriteTo(w : XmlWriter);
[0625] Description
[0626] Saves the node to the specified XmlWriter. The XmlWriter where you want to save the node.
[0627] XmlAttributeCollection class (System.Xml)
[0628] WriteTo
[0629] Description
[0630] Represents a collection of attributes that can be accessed by name or index.
[0631] Count
[0632] ItemOf
[0633] WriteTo
[0634] Description
[0635] Gets the attribute with the specified name.
[0636] This method is the same as calling System.Xml.XmlNamedNodeMap.GetNa- medItem(System.String). The qualified name of the attribute.
[0637] ItemOf
[0638] WriteTo
[0639] [C#] public virtual XmlAttribute this[int i] {get;}
[0640] [C++] public: _property virtual XmlAttribute* get_ItemOf(int i);
[0641] [VB] Overridable Public Default ReadOnly Property ItemOf(ByVal i As Integer) As XmlAttribute
[0642] [JScript] returnValue=XmlAttributeCollectionObject.ItemOf(i); Gets the attribute with the specified name or index.
[0643] Description
[0644] Gets the attribute with the specified index.
[0645] This method is the same as calling System.Xml.XmlNamedNodeMap.Item(- System.Int32). The index of the attribute.
[0646] ItemOf
[0647] WriteTo
[0648] [C#] public virtual XmlAttribute this[string localName, string namespaceURI] {get;}
[0649] [C++] public: _property virtual XmlAttribute* get_ItemOf(String* localName, String* namespaceURI);
[0650] [VB] Overridable Public Default ReadOnly Property ItemOf(ByVal localName As String, ByVal namespaceURI As String) As XmlAttribute
[0651] [JScript] returnValue=XmlAttributeCollectionObject.ItemOf(localName- , namespaceURI);
[0652] Description
[0653] Gets the attribute with the specified local name and namespace URI.
[0654] This method is the same as calling System.Xml.XmlNamedNodeMap.GetNa- medItem(System.String). The local name of the attribute. The namespace URI of the attribute.
[0655] Append
[0656] [C#] public virtual XmlAttribute Append(XmlAttribute node);
[0657] [C++] public: virtual XmlAttribute* Append(XmlAttribute* node);
[0658] [VB] Overridable Public Function Append(ByVal node As XmlAttribute) As XmlAttribute
[0659] [JScript] public function Append(node : XmlAttribute) : XmlAttribute;
[0660] Description
[0661] Inserts the specified attribute as the last node in the collection.
[0662] If node is already in the collection, it is moved to the last position. If an attribute with the same name is already present in the collection, the original attribute is removed from the collection and node is added to the end of the collection. The System.Xml.XmlAttribute to insert.
[0663] CopyTo
[0664] [C#] public void CopyTo(XmlAttribute[ ] array, int index);
[0665] [C++] public: void CopyTo(XmlAttribute* array[ ], int index);
[0666] [VB] Public Sub CopyTo(ByVal array( ) As XmlAttribute, ByVal index As Integer)
[0667] [JScript] public function CopyTo(array : XmlAttribute[ ], index : int);
[0668] Description
[0669] Copies all the System.Xml.XmlAttribute objects from this collection into the given array. The array that is the destination of the objects copied from this collection. The index in array where copying begins.
[0670] InsertAfter
[0671] [C#] public virtual XmlAttribute InsertAfter(XmlAttribute newNode, XmlAttribute refNode);
[0672] [C++] public: virtual XmlAttribute* InsertAfter(XmlAttribute* newNode, XmlAttribute* refNode);
[0673] [VB] Overridable Public Function InsertAfter(ByVal newNode As XmlAttribute, ByVal refNode As XmlAttribute) As XmlAttribute
[0674] [JScript] public function InsertAfter(newNode : XmlAttribute, refNode : XmlAttribute) : XmlAttribute;
[0675] Description
[0676] Inserts the specified attribute immediately after the specified reference attribute.
[0677] If an attribute with the same name is already present in the collection, the original attribute is removed from the collection and newNode is inserted into the collection. The System.Xml.XmlAttribute to insert. The System.Xml.XmlAttribute that is the reference attribute.
[0678] InsertBefore
[0679] [C#] public virtual XmlAttribute InsertBefore(XmlAttribute newNode, XmlAttribute refNode);
[0680] [C++] public: virtual XmlAttribute* InsertBefore(XmlAttribute* newNode, XmlAttribute* refNode);
[0681] [VB] Overridable Public Function InsertBefore(ByVal newNode As XmlAttribute, ByVal refNode As XmlAttribute) As XmlAttribute
[0682] [JScript] public function InsertBefore(newNode : XmlAttribute, refNode : XmlAttribute) : XmlAttribute;
[0683] Description
[0684] Inserts the specified attribute immediately before the specified reference attribute.
[0685] If an attribute with the same name is already present in the collection, the original attribute is removed from the collection and newNode is inserted into the collection. The System.Xml.XmlAttribute to insert. The System.Xml.XmlAttribute that is the reference attribute.
[0686] Prepend
[0687] [C#] public virtual XmlAttribute Prepend(XmlAttribute node);
[0688] [C++] public: virtual XmlAttribute* Prepend(XmlAttribute* node);
[0689] [VB] Overridable Public Function Prepend(ByVal node As XmlAttribute) As XmlAttribute
[0690] [JScript] public function Prepend(node : XmlAttribute) : XmlAttribute;
[0691] Description
[0692] Inserts the specified attribute as the first node in the collection.
[0693] If node is already in the collection, it is moved to the first position. If an attribute with the same name is already present in the collection, the original attribute is removed from the collection and node is added to the beginning of the collection. The System.Xml.XmlAttribute to insert.
[0694] Remove
[0695] [C#] public virtual XmlAttribute Remove(XmlAttribute node);
[0696] [C++] public: virtual XmlAttribute* Remove(XmlAttribute* node);
[0697] [VB] Overridable Public Function Remove(ByVal node As XmlAttribute) As XmlAttribute
[0698] [JScript] public function Remove(node : XmlAttribute) : XmlAttribute;
[0699] Description
[0700] Removes the specified attribute from the collection.
[0701] Return Value: The node removed or null if it is not found in the collection. The System.Xml.XmlAttribute to remove.
[0702] RemoveAll
[0703] [C#] public virtual void RemoveAll( );
[0704] [C++] public: virtual void RemoveAll( );
[0705] [VB] Overridable Public Sub RemoveAll( )
[0706] [JScript] public function RemoveAll( );
[0707] Description
[0708] Removes all attributes from the collection.
[0709] RemoveAt
[0710] [C#] public virtual XmlAttribute RemoveAt(int i);
[0711] [C++] public: virtual XmlAttribute* RemoveAt(int i);
[0712] [VB] Overridable Public Function RemoveAt(ByVal i As Integer) As XmlAttribute
[0713] [JScript] public function RemoveAt(i : int) : XmlAttribute;
[0714] Description
[0715] Removes the attribute corresponding to the specified index from the collection.
[0716] Return Value: Returns null if there is no attribute at the specified index. The index of the node to remove. The first node has index 0.
[0717] SetNamedItem
[0718] [C#] public override XmlNode SetNamedItem(XmlNode node);
[0719] [C++] public: XmlNode* SetNamedItem(XmlNode* node);
[0720] [VB] Overrides Public Function SetNamedItem(ByVal node As XmlNode) As XmlNode
[0721] [JScript] public override function SetNamedItem(node : XmlNode) : XmlNode;
[0722] Description
[0723] Adds a System.Xml.XmlNode using its System.Xml.XmlNode.Name property
[0724] Return Value: If the node replaces an existing node with the same name, the old node is returned; otherwise, null is returned. An attribute node to store in this collection. The node will later be accessible using the name of the node. If a node with that name is already present in the collection, it is replaced by the new one.
[0725] ICollection.CopyTo
[0726] [C#] void ICollection.CopyTo(Array array, int index);
[0727] [C++] void ICollection::CopyTo(Array* array, int index);
[0728] [VB] Sub CopyTo(ByVal array As Array, ByVal index As Integer) Implements ICollection.CopyTo
[0729] [JScript] function ICollection.CopyTo(array : Array, index : int);
[0730] XmlCDataSection class (System.Xml)
[0731] ToString
[0732] Description
[0733] Represents a CDATA section.
[0734] CDATA sections are used to quote or escape blocks of text to keep that text from being interpreted as markup language.
[0735] XmlCDataSection
[0736] Example Syntax:
[0737] ToString
[0738] [C#] protected internal XmlCDataSection(string data, XmlDocument doc);
[0739] [C++] internal: XmlCDataSection(String* data, XmlDocument* doc);
[0740] [VB] Protected Friend Sub New(ByVal data As String, ByVal doc As XmlDocument)
[0741] [JScript] package function XmlCDataSection(data : String, doc : XmlDocument);
[0742] Description
[0743] Attributes
[0744] BaseURI
[0745] ChildNodes
[0746] Data
[0747] FirstChild
[0748] HasChildNodes
[0749] InnerText
[0750] InnerXml
[0751] IsReadOnly
[0752] Item
[0753] Item
[0754] LastChild
[0755] Length
[0756] LocalName
[0757] ToString
[0758] Description
[0759] Gets the local name of the node.
[0760] Name
[0761] ToString
[0762] [C#] public override string Name {get;}
[0763] [C++] public: _property virtual String* get_Name( );
[0764] [VB] Overrides Public ReadOnly Property Name As String
[0765] [JScript] public function get Name( ) : String;
[0766] Description
[0767] Gets the qualified name of the node.
[0768] NamespaceURI
[0769] NextSibling
[0770] NodeType
[0771] ToString
[0772] Description
[0773] Gets the type of the current node.
[0774] OuterXml
[0775] OwnerDocument
[0776] ParentNode
[0777] Prefix
[0778] PreviousSibling
[0779] Value
[0780] CloneNode
[0781] [C#] public override XmlNode CloneNode(bool deep);
[0782] [C++] public: XmlNode* CloneNode(bool deep);
[0783] [VB] Overrides Public Function CloneNode(ByVal deep As Boolean) As XmlNode
[0784] [JScript] public override function CloneNode(deep : Boolean) : XmlNode;
[0785] Description
[0786] Creates a duplicate of this node.
[0787] Return Value: The cloned node.
[0788] CloneNode serves as a copy constructor for nodes. For CDATA nodes, the cloned node always includes the data content. To see how this method behaves with other node types, see System.Xml.XmlNode.CloneNode(System.Bo- olean) method in the XmlNode class. true to recursively clone the subtree under the specified node; false to clone only the node itself.
[0789] WriteContentTo
[0790] [C#] public override void WriteContentTo(XmlWriter w);
[0791] [C++] public: void WriteContentTo(XmlWriter* w);
[0792] [VB] Overrides Public Sub WriteContentTo(ByVal w As XmlWriter)
[0793] [JScript] public override function WriteContentTo(w : XmlWriter);
[0794] Description
[0795] Saves the node to the specified System.Xml.XmlWriter. The XmlWriter to which you want to save.
[0796] WriteTo
[0797] [C#] public override void WriteTo(XmlWriter w);
[0798] [C++] public: void WriteTo(XmlWriter* w);
[0799] [VB] Overrides Public Sub WriteTo(ByVal w As XmlWriter)
[0800] [JScript] public override function WriteTo(w : XmlWriter);
[0801] Description
[0802] Saves the node to the specified System.Xml.XmlWriter. The XmlWriter to which you want to save.
[0803] XmlCharacterData class (System.Xml)
[0804] WriteTo
[0805] Description
[0806] Provides text-manipulation methods that are used by several classes. This class is abstract.
[0807] XmlCharacterData
[0808] Example Syntax:
[0809] WriteTo
[0810] [C#] protected internal XmlCharacterData(string data, XmlDocument doc);
[0811] [C++] internal: XmlCharacterData(String* data, XmlDocument* doc);
[0812] [VB] Protected Friend Sub New(ByVal data As String, ByVal doc As XmlDocument)
[0813] [JScript] package function XmlCharacterData(data : String, doc : XmlDocument);
[0814] Description
[0815] Attributes
[0816] BaseURI
[0817] ChildNodes
[0818] Data
[0819] WriteTo
[0820] Description
[0821] Contains this node's data.
[0822] FirstChild
[0823] HasChildNodes
[0824] InnerText
[0825] WriteTo
[0826] Description
[0827] Gets or sets the concatenated values of the node and all its children.
[0828] InnerXml
[0829] IsReadOnly
[0830] Item
[0831] Item
[0832] LastChild
[0833] Length
[0834] WriteTo
[0835] Description
[0836] Gets the length of the data, in characters.
[0837] LocalName
[0838] Name
[0839] NamespaceURI
[0840] NextSibling
[0841] NodeType
[0842] OuterXml
[0843] OwnerDocument
[0844] ParentNode
[0845] Prefix
[0846] PreviousSibling
[0847] Value
[0848] WriteTo
[0849] Description
[0850] Gets or sets the value of the node.
[0851] AppendData
[0852] [C#] public virtual void AppendData(string strData);
[0853] [C++] public: virtual void AppendData(String* strData);
[0854] [VB] Overridable Public Sub AppendData(ByVal strData As String)
[0855] [JScript] public function AppendData(strData : String);
[0856] Description
[0857] Appends the specified string to the end of the character data of the node.
[0858] When overriding AppendData in a derived class, in order for events to be fired correctly, you must call the base class's AppendData method. String data that is to be inserted into the existing string.
[0859] DecideXPNodeTypeForTextNodes
[0860] [C#] protected internal bool DecideXPNodeTypeForTextNodes(XmlNode node, ref XPathNodeType xnt);
[0861] [C++] protected public: bool DecideXPNodeTypeForTextNodes(XmlNode* node, XPathNodeType* xnt);
[0862] [VB] Protected Friend Dim Function DecideXPNodeTypeForTextNodes(ByV- al node As XmlNode, ByRef xnt As XPathNodeType) As Boolean
[0863] [JScript] package function DecideXPNodeTypeForTextNodes(node : XmlNode, xnt : XPathNodeType) : Boolean;
[0864] Description
[0865] DeleteData
[0866] [C#] public virtual void DeleteData(int offset, int count);
[0867] [C++] public: virtual void DeleteData(int offset, int count);
[0868] [VB] Overridable Public Sub DeleteData(ByVal offset As Integer, ByVal count As Integer)
[0869] [JScript] public function DeleteData(offset : int, count : int);
[0870] Description
[0871] Remove a range of characters from the node.
[0872] When overriding DeleteData in a derived class, in order for events to be fired correctly, you must call the base class's DeleteData method. Offset, in characters, at which to start deleting string data. Number of characters to delete.
[0873] InsertData
[0874] [C#] public virtual void InsertData(int offset, string strData);
[0875] [C++] public: virtual void InsertData(int offset, String* strdata);
[0876] [VB] Overridable Public Sub InsertData(ByVal offset As Integer, ByVal strData As String)
[0877] [JScript] public function InsertData(offset : int, strData : String);
[0878] Description
[0879] Insert the specified string at the specified character offset.
[0880] When overriding InsertData in a derived class, in order for events to be fired correctly, you must call the base class's InsertData method. Offset, in characters, at which to insert the supplied string data. String data that is to be inserted into the existing string.
[0881] ReplaceData
[0882] [C+] public virtual void ReplaceData(int offset, int count, string strData);
[0883] [C++] public: virtual void ReplaceData(int offset, int count, String* strdata);
[0884] [VB] Overridable Public Sub ReplaceData(ByVal offset As Integer, ByVal count As Integer, ByVal strData As String)
[0885] [JScript] public function ReplaceData(offset : int, count : int, strData : String);
[0886] Description
[0887] Replace the specified number of characters starting at the specified offset with the specified string.
[0888] When overriding ReplaceData in a derived class, in order for events to be fired correctly, you must call the base class's ReplaceData method. Offset, in characters, at which to start replacing string data. Number of characters to replace. New data that replaces the old string data.
[0889] Substring
[0890] [C#] public virtual string Substring(int offset, int count);
[0891] [C++] public: virtual String* Substring(int offset, int count);
[0892] [VB] Overridable Public Function Substring(ByVal offset As Integer, ByVal count As Integer) As String
[0893] [JScript] public function Substring(offset : int, count : int) : String;
[0894] Description
[0895] Retrieves a substring of the full string from the specified range. Offset, in characters, from the beginning of the string. An offset of zero indicates copying from the start of the data. Number of characters to retrieve from the specified offset.
[0896] XmlComment class (System.Xml)
[0897] WriteTo
[0898] Description
[0899] Represents the content of an XML comment.
[0900] XmlComment
[0901] Example Syntax:
[0902] WriteTo
[0903] [C#] protected internal XmlComment(string comment, XmlDocument doc);
[0904] [C++] internal: XmlComment(String* comment, XmlDocument* doc);
[0905] [VB] Protected Friend Sub New(ByVal comment As String, ByVal doc As XmlDocument)
[0906] [JScript] package function XmlComment(comment : String, doc : XmlDocument);
[0907] Description
[0908] Attributes
[0909] BaseURI
[0910] ChildNodes
[0911] Data
[0912] FirstChild
[0913] HasChildNodes
[0914] InnerText
[0915] InnerXml
[0916] IsReadOnly
[0917] Item
[0918] Item
[0919] LastChild
[0920] Length
[0921] LocalName
[0922] WriteTo
[0923] Description
[0924] Gets the local name of the node.
[0925] Name
[0926] WriteTo
[0927] [C#] public override string Name {get;}
[0928] [C++] public: _property virtual String* get_Name( );
[0929] [VB] Overrides Public ReadOnly Property Name As String
[0930] [JScript] public function get Name( ) : String;
[0931] Description
[0932] Gets the qualified name of the node.
[0933] NamespaceURI
[0934] NextSibling
[0935] NodeType
[0936] WriteTo
[0937] Description
[0938] Gets the type of the current node.
[0939] OuterXml
[0940] OwnerDocument
[0941] ParentNode
[0942] Prefix
[0943] PreviousSibling
[0944] Value
[0945] CloneNode
[0946] [C#] public override XmlNode CloneNode(bool deep);
[0947] [C+] public: Xml Node* CloneNode(bool deep);
[0948] [VB] Overrides Public Function CloneNode(ByVal deep As Boolean) As XmlNode
[0949] [JScript] public override function CloneNode(deep : Boolean) : XmlNode;
[0950] Description
[0951] Creates a duplicate of this node.
[0952] Return Value: The cloned node.
[0953] CloneNode serves as a copy constructor for nodes. For comment nodes, the cloned node always includes the text content. To see how this method behaves with other node types, see System.Xml.XmlNode.CloneNode(Sy- stem.Boolean) method in the XmlNode class. true to recursively clone the subtree under the specified node; false to clone only the node itself.
[0954] WriteContentTo
[0955] [C#] public override void WriteContentTo(XmlWriter w);
[0956] [C++] public: void WriteContentTo(XmlWriter* w);
[0957] [VB] Overrides Public Sub WriteContentTo(ByVal w As XmlWriter)
[0958] [JScript] public override function WriteContentTo(w : XmlWriter);
[0959] Description
[0960] Saves all the children of the node to the specified System.Xml.XmlWriter. The XmlWriter to which you want to save.
[0961] WriteTo
[0962] [C#] public override void WriteTo(XmlWriter w);
[0963] [C++] public: void WriteTo(XmlWriter* w);
[0964] [VB] Overrides Public Sub WriteTo(ByVal w As XmlWriter)
[0965] [JScript] public override function WriteTo(w : XmlWriter);
[0966] Description
[0967] Saves the node to the specified System.Xml.XmlWriter. The XmlWriter to which you want to save.
[0968] XmlConvert class (System.Xml)
[0969] WriteTo
[0970] Description
[0971] Encodes and decodes XML names and provides methods for converting between CLR types and XSD types.
[0972] XmlConvert
[0973] Example Syntax:
[0974] WriteTo
[0975] [C#] public XmlConvert( );
[0976] [C++] public: XmlConvert( );
[0977] [VB] Public Sub New( )
[0978] [JScript] public function XmlConvert( );
[0979] DecodeName
[0980] [C#] public static string DecodeName(string name);
[0981] [C++] public: static String* DecodeName(String* name);
[0982] [VB] Public Shared Function DecodeName(ByVal name As String) As String
[0983] [JScript] public static function DecodeName(name : String) : String;
[0984] Description
[0985] Transforms an XML name into an ADO.NET object name (such as DataTable or DataColumn).
[0986] Decoding: When the method transforms an XML name into an ADO.NET object name, the decoding step follows the following rules: Names are decoded from left to right. The name to be transformed.
[0987] EncodeLocalName
[0988] [C#] public static string EncodeLocalName(string name);
[0989] [C++] public: static String* EncodeLocalName(String* name);
[0990] [VB] Public Shared Function EncodeLocalName(ByVal name As String) As String
[0991] [JScript] public static function EncodeLocalName(name : String) : String;
[0992] Description
[0993] Converts names, such as DataTable or DataColumn names, that contain characters that are not permitted in XML names to valid names.
[0994] Return Value: The encoded name.
[0995] This method is the same as System.Xml.XmlConvert.EncodeName(System.- String) except it also encodes the colon character, guaranteeing that this can be used as the LocalName part of a namespace qualified name. The name to be encoded.
[0996] EncodeName
[0997] [C+] public static string EncodeName(string name);
[0998] [C++] public: static String* EncodeName(String* name);
[0999] [VB] Public Shared Function EncodeName(ByVal name As String) As String
[1000] [JScript] public static function EncodeName(name : String) : String;
[1001] Description
[1002] Converts names, such as DataTable or DataColumn names, that contain characters that are not permitted in XML names to valid names.
[1003] Return Value: Returns the name with any invalid characters replaced by an escape string.
[1004] This method translates invalid characters, such as spaces or half-width Katakana, that need to be mapped to XML names without the support or presence of schemas. The invalid characters are translated into escaped numeric entity encodings. A name to be translated.
[1005] EncodeNmToken
[1006] [C#] public static string EncodeNmToken(string name);
[1007] [C++] public: static String* EncodeNmToken(String* name);
[1008] [VB] Public Shared Function EncodeNmToken(ByVal name As String) As String
[1009] [JScript] public static function EncodeNmToken(name : String) : String;
[1010] Description
[1011] Verifies the name is valid according to the XML spec.
[1012] Return Value: The encoded name.
[1013] This method guarantees the name is valid according to the XML spec. For example, if you passed this method the invalid name "70+", it would return "a_x003a_b" which is a valid XML name. The name to be encoded.
[1014] ToBoolean
[1015] [C#] public static bool ToBoolean(string s);
[1016] [C++] public: static bool ToBoolean(String* s);
[1017] [VB] Public Shared Function ToBoolean(ByVal s As String) As Boolean
[1018] [JScript] public static function ToBoolean(s : String) : Boolean;
[1019] Description
[1020] Converts the System.String to a System.Boolean equivalent.
[1021] Return Value: A Boolean value (i.e true or false).
[1022] Valid strings are "1" or "true" for true and "0" or "false" for false. The string to convert.
[1023] ToByte
[1024] [C#] public static byte ToByte(string s);
[1025] [C++] public: static unsigned char ToByte(String* s);
[1026] [VB] Public Shared Function ToByte(ByVal s As String) As Byte
[1027] [JScript] public static function ToByte(s : String) : Byte;
[1028] Description
[1029] Converts the System.String to a System.Byte equivalent.
[1030] Return Value: A Byte equivalent of the string. The string to convert.
[1031] ToChar
[1032] [C#] public static char ToChar(string s);
[1033] [C++] public: static _wchar_t ToChar(String* s);
[1034] [VB] Public Shared Function ToChar(ByVal s As String) As Char
[1035] [JScript] public static function ToChar(s : String) : Char;
[1036] Description
[1037] Converts the System.String to a System.Char equivalent.
[1038] Return Value: A Char representing the first character in the string. The string to convert.
[1039] ToDateTime
[1040] [C#] public static DateTime ToDateTime(string s);
[1041] [C++] public: static DateTime ToDateTime(String* s);
[1042] [VB] Public Shared Function ToDateTime(ByVal s As String) As DateTime
[1043] [JScript] public static function ToDateTime(s : String) : DateTime; Converts the System.String to a System.DateTime equivalent.
[1044] Description
[1045] Converts the System.String to a System.DateTime equivalent.
[1046] Return Value: A DateTime equivalent of the string. The string to convert.
[1047] ToDateTime
[1048] [C#] public static DateTime ToDateTime(string s, string format);
[1049] [C++] public: static DateTime ToDateTime(String* s, String* format);
[1050] [VB] Public Shared Function ToDateTime(ByVal s As String, ByVal format As String) As DateTime
[1051] [JScript] public static function ToDateTime(s : String, format : String) : DateTime;
[1052] Description
[1053] Converts the System.String to a System.DateTime equivalent.
[1054] Return Value: A DateTime equivalent of the string. The string to convert. The format structure to apply to the converted DateTime. Valid formats include "yyyy-MM-ddTHH:mm:sszzzzzz" and its subsets. The string is validated against this format.
[1055] ToDateTime
[1056] [C#] public static DateTime ToDateTime(string s, string[ ] formats);
[1057] [C++] public: static DateTime ToDateTime(String* s, String* formats _gc[ ]);
[1058] [VB] Public Shared Function ToDateTime(ByVal S As String, ByVal formats( ) As String) As DateTime
[1059] [JScript] public static function ToDateTime(s : String, formats : String[ ]) : DateTime;
[1060] Description
[1061] Converts t