Home
Patent Search
IMT Blog
REGISTER
|
SIGN IN
United States Patent Application
20030167356
Kind Code
A1
Smith, Adam W. ; et al.
September 4, 2003
Application program interface for network software platform
Abstract
An application program interface (API) provides a set of functions, including a set of base classes and types that are used in substantially all applications accessing the API, for application developers who build Web applications on Microsoft Corporation's .NET.TM. platform.
Inventors:
Smith; Adam W.
(Redmond, WA)
, Moore; Anthony J.
(Seattle, WA
)
, LaMacchia; Brian A.
(Bellevue, WA
)
, Hejlsberg; Anders
(Seattle, WA
)
, Grunkemeyer; Brian M.
(Issaquah, WA
)
, Doise; Caleb L.
(Bellevue, WA
)
, Brumme; Christopher W.
(Mercer Island, WA
)
, Anderson; Christopher L.
(Issaquah, WA
)
, Feuerstein; Corina E.
(Redmond, WA
)
, Sinclair; Craig T.
(Sammamish, WA
)
, Takacs; Daniel
(Bellevue, WA
)
, Ebbo; David S.
(Redmond, WA
)
, Driver; David O.
(Seattle, WA
)
, Mortenson; David S.
(Redmond, WA
)
, Christensen; Erik B.
(Seattle, WA
)
, Olson; Erik B.
(Sammamish, WA
)
, Yeon; Fabio A.
(Mill Creek, WA
)
, Kakivaya; Gopala Krishna R.
(Sammamish, WA
)
, Fee; Gregory D.
(Seattle, WA
)
, Ramadan; Hany E.
(Kirkland, WA
)
, Sanders; Henry L.
(Kirkland, WA
)
, Rajan; Jayanth V.
(Bellevue, WA
)
, Cooperstein; Jeffrey M.
(Bellevue, WA
)
, Hawkins; Jonathan C.
(Seattle, WA
)
, Hogg; James H.
(Bellevue, WA
)
, Long; Joe D.
(Woodinville, WA
)
, McConnell; John I.
(Kirkland, WA
)
, Ruiz-Scougall; Jesus
(Redmond, WA
)
, Miller; James S.
(Bellevue, WA
)
, Bennett; Julie D.
(Medina, WA
)
, Cwalina; Krzysztof J.
(Redmond, WA
)
, Olson; Lance E.
(Sammamish, WA
)
, Kohnfelder; Loren M.
(Bellevue, WA
)
, Magruder; Michael M.
(Sammamish, WA
)
, Prabhu; Manish S.
(Redmond, WA
)
, Palanca; Radu Rares
(Redmond, WA
)
, Krishnaswamy; Raja
(Bellevue, WA
)
, Burke; Shawn P.
(Kirkland, WA
)
, Trowbridge; Sean E.
(Sammamish, WA
)
, Demsey; Seth M.
(Kirkland, WA
)
, Dasan; Shajan
(Sammamish, WA
)
, Pharies; Stefan H.
(Seattle, WA
)
, Cook; Suzanne M.
(Redmond, WA
)
, Anand; Tarun
(New Dehli, IN
)
, Muhlestein; Travis J.
(Redmond, WA
)
, Christensen; Yann E.
(Seattle, WA
)
, Lin; Yung-shin
(Sammamish, WA
)
, Krishnaswamy; Ramasamy
(Redmond, WA
)
, Roxe; Joseph
(Hanover, NH
)
, Boshier; Alan
(Redmond, WA
)
, Bau; David
(Gladwyne, PA
)
Correspondence Name and Address:
421 W RIVERSIDE AVENUE SUITE 500
LEE & HAYES PLLC
SPOKANE
WA
99201
Series Code:
902811
Filed:
July 10, 2001
U.S. Current Class:
709/328;
708/318
U.S. Class at Publication:
709/328;
708/318
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 applications executing on remote devices over a network; and an application program interface to present functions used by the applications to access network and computing resources of the distributed computing system, wherein the application program interface comprises a set of base classes and types that are used in substantially all applications executing on the remote devices submitting requests.
2. A software architecture as recited in claim 1, wherein the set of base types comprises: an AsyncCallback delegate supplied to an application, wherein the AsyncCallback delegate references a callback method to be called when a corresponding asynchronous operation is completed; and an IAsyncResult interface that enables determination of the status of an asynchronous operation.
3. A software architecture as recited in claim 2, wherein the IAsyncResult interface includes: an AsyncState property that returns the object that was provided as the last parameter as part of a Begin call corresponding to the asynchronous operation; an AsyncWaitHandle property that returns a WaitHandle that can be used to allow the application to wait for a call to be completed without needing to poll; a CompletedSynchronously property that is set to true if the Begin call corresponding to the asynchronous operation completed synchronously; and an IsCompleted property that is set to true after processing of the asynchronous operation is completed.
4. A software architecture as recited in claim 1, wherein the set of types support an event model including an event delegate that connects an event with a handler of the event, the set of base classes and types further comprising: one or more classes that hold event data; and one or more delegates that identify a method to provide a response to an event.
5. A software architecture as recited in claim 1, wherein the application program interface further comprises a collections namespace that includes a plurality of classes and interfaces for in-memory data storage and manipulation.
6. A software architecture as recited in claim 5, wherein the collections namespace includes, as at least part of the plurality of types: a first set of types including commonly used collection classes; a second set of types including interfaces to define a formal contract between developers creating new collections and developers consuming collections; and a third set of types that support creating strongly typed collections.
7. A software architecture as recited in claim 1, wherein the application program interface further comprises a globalization namespace that includes a plurality of classes that define culture-related information, wherein the plurality of classes include a first set of types representing information about a user's culture and a second set of types representing information about a user's region.
8. A software architecture as recited in claim 1, wherein the application program interface further comprises a net namespace that includes a plurality of Classes that enables use of network resources without details of one or more protocols used to access the network resources.
9. A software architecture as recited in claim 1, wherein the application program interface further comprises a security namespace that includes a plurality of classes and interfaces that make available an underlying structure of a security system including one or more cryptographic services, code access security and role based security infrastructure.
10. A software architecture as recited in claim 1, wherein the application program interface further comprises a service process namespace that includes a plurality of classes that allow installation and running of services.
11. A software architecture as recited in claim 1, wherein the application program interface further comprises a serialization namespace that includes a plurality of classes that enable serializing and deserializing of instance data.
12. A software architecture as recited in claim 1, wherein the application program interface further comprises a diagnostics namespace that includes a plurality of classes that enable debugging of applications, trace code execution, reading event logs, writing event logs, and monitoring system performance.
13. A software architecture as recited in claim 1, wherein the application program interface further comprises a messaging namespace that includes a plurality of classes that enable connecting to message queues on the network, sending messages to message queues, receiving messages from message queues, and peeking at messages from message queues.
14. An application program interface, embodied on one or more computer readable media, comprising: an AsyncCallback delegate supplied to an application, wherein the AsyncCallback delegate references a callback method to be called when a corresponding asynchronous operation is completed; and an lAsyncResult interface that enables determination of the status of an asynchronous operation.
15. An application program interface as recited in claim 14, wherein the IAsyncResult interface includes: an AsyncState property that returns the object that was provided as the last parameter as part of a Begin call corresponding to the asynchronous operation; an AsyncWaitHandle property that returns a WaitHandle that can be used to allow the application to wait for a call to be completed without needing to poll; a CompletedSynchronously property that is set to true if the Begin call corresponding to the asynchronous operation completed synchronously; and an IsCompleted property that is set to true after processing of the asynchronous operation is completed.
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 types that are used in each of the one or more applications.
17. A distributed computer software architecture as recited in claim 16, wherein the set of base classes and types comprises: an AsyncCallback delegate supplied to an application, wherein the AsyncCallback delegate references a callback method to be called when a corresponding asynchronous operation is completed; and an IAsyncResult interface that enables determination of the status of an asynchronous operation.
18. A method comprising: receiving one or more application program interface (API) calls from one or more remote devices over a network, wherein the one or more calls are to one or more functions that include a set of base classes and types that are used in substantially all applications executing on the one or more remote devices; and performing the function requested in each of the one or more calls.
19. A method as recited in claim 18, wherein the set of base classes and types comprises: an AsyncCallback delegate supplied to an application, wherein the AsyncCallback delegate references a callback method to be called when a corresponding asynchronous operation is completed; and an lAsyncResult interface that enables determination of the status of an asynchronous operation.
20. A method as recited in claim 18, wherein the set of base classes and types support an event model including an event delegate that connects an event with a handler of the event, the set of base classes and types further comprising: one or more classes that hold event data; and one or more delegates that identify a method to provide a response to an event.
21. A method as recited in claim 18, wherein the application program interface further comprises a collections namespace that includes a plurality of classes and interfaces for in-memory data storage and manipulation.
22. A method as recited in claim 18, wherein the application program interface further comprises a globalization namespace that includes a plurality of classes that define culture-related information, wherein the plurality of classes include a first set of types representing information about a user's culture and a second set of types representing information about a user's region.
23. A method as recited in claim 18, wherein the application program interface further comprises a net namespace that includes a plurality of classes that enables use of Internet resources without details of one or more protocols used to access the Internet resources.
24. A method comprising: calling, to one or more remote devices over a network, one or more functions via an application program interface (API) that make available a set of base classes and types that are used in substantially all applications calling the one or more functions; receiving, from the one or more remote devices, a response to the calling.
25. A method as recited in claim 24, wherein the set of base classes and types comprises: an AsyncCallback delegate supplied to an application, wherein the AsyncCallback delegate references a callback method to be called when a corresponding asynchronous operation is completed; and an IAsyncResult interface that enables determination of the status of an asynchronous operation.
26. A method as recited in claim 24, wherein the set of types support an event model including an event delegate that connects an event with a handler of the event, the set of base classes and types further comprising: one or more classes that hold event data; and one or more delegates that identify a method to provide a response to an event.
27. A method as recited in claim 24, wherein the application program interface further comprises a collections namespace that includes a plurality of classes and interfaces for in-memory data storage and manipulation.
28. A method as recited in claim 24, wherein the application program interface further comprises a globalization namespace that includes a plurality of classes that define culture-related information, wherein the plurality of classes include a first set of types representing information about a user's culture and a second set of types representing information about a user's region.
29. A method as recited in claim 24, wherein the application program interface further comprises a net namespace that includes a plurality of classes that enables use of Internet resources without details of one or more protocols used to access the Internet resources.
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, including a set of base classes and types that are used in substantially all applications accessing the API, 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' 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.Fortns") 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 base class library namespace 206 ("System") are discussed in additional detail below.
[0071] System Namespace
[0072] The System namespace is the root namespace; it offers common functionality that is needed by a wide variety of application types. The System namespace includes common base classes, types and utility classes that will be needed in substantially all applications (that is, in nearly every application).
[0073] The System namespace provides commonly used base types. It includes Object, which is the ultimate base class for all types in the system. Object defines the base set of services that any type in the system is able to provide. Not surprisingly, Object provides default implementations for all of these services. The ValueType class is a reference type that serves as the base class for all value types. It customizes the implementations of the virtual methods on Object so that is they are more appropriate for value types. Enum is a reference type that derives from ValueType and is the base class for all enums in the system. It further customizes the virtual methods from ValueType to make them specific to deal with exactly one integral field of instance data. Enum also offers utility methods for formatting and parsing of enum values. The ultimate base class for all exceptions in the system, the Exception class, is also in the System namespace. All custom attributes derive from the Attribute base class that contains utility methods for reading custom attribute off of reflection elements.
[0074] In addition, the base data types are also found in the system namespace. These are types that are so commonly used that languages typically use key words as aliases for them. These classes represent those types and provide formatting and parsing, comparing and coercion support.
[0075] NET Framework built-in value types
1
NET Framework built-in value types Managed Extensions Class Visual Basic C# for C++ Category name Description data type data type data type Integer Byte An 8-bit Byte byte char unsigned integer. Sbyte An 8-bit signed Sbyte sbyte signed char integer. No built-in Not CLS type. compliant. Int16 A 16-bit signed Short short short integer. Int32 A 32-bit signed Integer int int -or- integer. long Int64 A 64-bit signed Long long _int64
integer. UInt16 A 16-bit UInt16 ushort unsigned unsigned No built-in short integer. type. Not CLS compliant. UInt32 A 32-bit UInt32 uint unsigned int unsigned No built-in -or- integer. type. unsigned Not CLS long compliant. UInt64 A 64-bit UInt64 ulong unsigned unsigned No built-in _int64
integer. type. Not CLS compliant. Floating Single A single- Single float float point precision (32- bit) floating- point number. Double A double- Double double double precision (64- bit) floating- point number. Logical Boolean A Boolean value Boolean bool bool (true or false). Other Char A Unicode (16- Char char _wchar_t bit) character. Decimal A 96-bit Decimal decimal Decimal decimal value. Single A signed IntPtr IntPtr IntPtr integer, that is, No built-in No built-in No built-in a 32 bit value type. type. type. on a 32-bit platform and a 64 bit value on a 64-bit platform. Double A native-sized UIntPtr UIntPtr UIntPtr unsigned No built-in No built-in No built-in integer. type. type. type. Not CLS compliant.
[0076] Other classes provide services including supervision of managed and unmanaged applications, mathematics, remote and local program invocation, data type conversion, and application environment management.
[0077] The following is a more detailed description of the System namespace, identifying various classes, interfaces, enumerations, and so forth contained in the System namespace.
[0078] System
[0079] This namespace contains fundamental classes and base classes that define commonly-used value and reference data types, events and event handlers, interfaces, attributes, and processing exceptions.
[0080] Description
[0081] This namespace contains fundamental classes and base classes that define commonly-used value and reference data types, events and event handlers, interfaces, attributes, and processing exceptions. _AppDomain interface (System)
[0082] Description
[0083] Properties:
[0084] BaseDirectory
[0085] [C#] string BaseDirectory {get;}
[0086] [C++] String* get_BaseDirectory( );
[0087] [VB] ReadOnly Property BaseDirectory As String
[0088] [JScript] abstract function get BaseDirectory( ): String;
[0089] Description
[0090] DynamicDirectory
[0091] [C#] string DynamicDirectory {get;}
[0092] [C++] String* get_DynamicDirectory( );
[0093] [VB] ReadOnly Property DynamicDirectory As String
[0094] [JScript] abstract function get DynamicDirectory( ): String;
[0095] Description
[0096] Evidence
[0097] [C#] Evidence Evidence {get;}
[0098] [C++] Evidence* get_Evidence( );
[0099] [VB] ReadOnly Property Evidence As Evidence
[0100] [JScript] abstract function get Evidence( ): Evidence;
[0101] Description
[0102] FriendlyName
[0103] [C#] string FriendlyName {get;}
[0104] [C++] String* get_FriendlyName( );
[0105] [VB] ReadOnly Property FriendlyName As String
[0106] [JScript] abstract function get FriendlyName( ): String;
[0107] Description
[0108] RelativeSearchPath
[0109] [C#] string RelativeSearchPath {get;}
[0110] [C++] String* get_RelativeSearchPath( );
[0111] [VB] ReadOnly Property RelativeSearchPath As String
[0112] [JScript] abstract function get RelativeSearchPath( ): String;
[0113] Description
[0114] ShadowCopyFiles
[0115] [C#] bool ShadowCopyFiles {get;}
[0116] [C++] bool get_ShadowCopyFiles( );
[0117] [VB] ReadOnly Property ShadowCopyFiles As Boolean
[0118] [JScript] abstract function get ShadowCopyFiles( ): Boolean;
[0119] Description
[0120] [C#] event AssemblyLoadEventHandler AssemblyLoad;
[0121] [C++]_event AssemblyLoadEventHandler* AssemblyLoad;
[0122] [VB] Event AssemblyLoad As AssemblyLoadEventHandler
[0123] Description
[0124] [C#] event ResolveEventHandler AssemblyResolve;
[0125] [C++]_event ResolveEventHandler* AssemblyResolve;
[0126] [VB] Event AssemblyResolve As ResolveEventHandler
[0127] Description
[0128] [C#] event EventHandler DomainUnload;
[0129] [C++]_event EventHandler* DomainUnload;
[0130] [VB] Event DomainUnload As EventHandler
[0131] Description
[0132] [C#] event EventHandler ProcessExit;
[0133] [C++]_event EventHandler* ProcessExit;
[0134] [VB] Event ProcessExit As EventHandler
[0135] Description
[0136] [C#] event ResolveEventHandler ResourceResolve;
[0137] [C++]_event ResolveEventHandler* ResourceResolve;
[0138] [VB] Event ResourceResolve As ResolveEventHandler
[0139] Description
[0140] [C#] event ResolveEventHand TypeResolve;
[0141] [C++]_event ResolveEventHandler* TypeResolve;
[0142] [VB] Event TypeResolve As ResolveEventHandler
[0143] Description
[0144] [C#] event UnhandledExceptionEventHandler UnhandledException;
[0145] [C++]_event UnhandledExceptionEventHandler* UnhandledException;
[0146] [VB] Event UnhandledException As UnhandledExceptionEventHandler
[0147] Description
[0148] Methods:
[0149] AppendPrivatePath
[0150] [C#] void AppendPrivatePath(string path);
[0151] [C++] void AppendPrivatePath(String* path);
[0152] [VB] Sub AppendPrivatePath(ByVal path As String)
[0153] [JScript] function AppendPrivatePath(path: String);
[0154] Description
[0155] ClearPrivatePath
[0156] [C#] void ClearPrivatePath( );
[0157] [C++] void ClearPrivatePath( );
[0158] [VB] Sub ClearPrivatePath( )
[0159] [JScript] function ClearPrivatePath( );
[0160] Description
[0161] ClearShadowCopyPath
[0162] [C#] void ClearShadowCopyPath( );
[0163] [C++] void ClearShadowCopyPath( );
[0164] [VB] Sub ClearShadowCopyPath( )
[0165] [JScript] function ClearShadowCopyPath( );
[0166] Description
[0167] CreateInstance
[0168] [C#] ObjectHandle CreateInstance(string assemblyName, string typeName);
[0169] [C++] ObjectHandle* CreateInstance(String* assemblyName, String* typeName);
[0170] [VB] Function CreateInstance(ByVal assemblyName As String, ByVal typeName
[0171] As String) As ObjectHandle
[0172] [JScript] function CreateInstance(assemblyName: String, typeName: String):
[0173] ObjectHandle;
[0174] Description
[0175] CreateInstance
[0176] [C#] ObjectHandle CreateInstance(string assemblyName, string typeName, object[ ] activationAttributes);
[0177] [C++] ObjectHandle* CreateInstance(String* assemblyName, String* typeName, Object* activationAttributes_gc[ ]);
[0178] [VB] Function CreateInstance(ByVal assemblyName As String, ByVal typeName As String, ByVal activationAttributes( ) As Object) As ObjectHandle [JScript] function CreateInstance(assemblyName: String, typeName: String, activationAttributes: Object[ ]): ObjectHandle;
[0179] Description
[0180] CreateInstance
[0181] [C#] ObjectHandle CreateInstance(string assemblyName, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[ ] args, CultureInfo culture, object[ ] activationAttributes, Evidence securityAttributes);
[0182] [C++] ObjectHandle* CreateInstance(String* assemblyName, String* typeName, bool ignoreCase, BindingFlags bindingAttr, Binder* binder, Object* args_gc[ ], CultureInfo* culture, Object* activationAttributes_gc- [ ], Evidence* securityAttributes);
[0183] [VB] Function CreateInstance(ByVal assemblyName As String, ByVal typeName As String, ByVal ignoreCase As Boolean, ByVal bindingAttr As BindingFlags, ByVal binder As Binder, ByVal args( ) As Object, ByVal culture As CultureInfo, ByVal activationAttributes( ) As Object, ByVal securityAttributes As Evidence) As ObjectHandle
[0184] [JScript] function CreateInstance(assemblyName: String, typeName: String, ignoreCase: Boolean, bindingAttr: BindingFlags, binder: Binder, args: Object[ ], culture: CultureInfo, activationAttributes: Object[ ], securityAttributes Evidence): ObjectHandle;
[0185] Description
[0186] CreateInstanceFrom
[0187] [C#] ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName);
[0188] [C++] ObjectHandle* CreateInstanceFrom(String* assemblyFile, String* typeName);
[0189] [VB] Function CreateInstanceFrom(ByVal assemblyFile As String, ByVal typeName As String) As ObjectHandle
[0190] [JScript] function CreateInstanceFrom(assemblyFile: String, typeName: String) ObjectHandle;
[0191] Description
[0192] CreateInstanceFrom
[0193] [C#] ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName, object[ ] activationAttributes);
[0194] [C++] ObjectHandle* CreateInstanceFrom(String* assemblyFile, String* typeName, Object* activationAttributes_gc[ ]);
[0195] [VB] Function CreateInstanceFrom(ByVal assemblyFile As String, ByVal typeName As String, ByVal activationAttributes As Object) As ObjectHandle [JScript] function CreateInstanceFrom(assemblyFile: String, typeName: String, activationAttributes: Object[ ]): ObjectHandle;
[0196] Description
[0197] CreateInstanceFrom
[0198] [C#] ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[ ] args, CultureInfo culture, object[ ] activationAttributes, Evidence securityAttributes); [C++] ObjectHandle* CreateInstanceFrom(Stri- ng* assemblyFile, String* typeName, bool ignoreCase, BindingFlags bindingAttr, Binder* binder, Object* args_gc[ ], CultureInfo* culture, Object* activationAttributes_gc[ ], Evidence* securityAttributes);
[0199] [VB] Function CreateInstanceFrom(ByVal assemblyFile As String, ByVal typeName As String, ByVal ignoreCase As Boolean, ByVal bindingAttr As BindingFlags, ByVal binder As Binder, ByVal args( ) As Object, ByVal culture As CultureInfo, ByVal activationAttributes( ) As Object, ByVal securityAttributes As Evidence) As ObjectHandle
[0200] [JScript] function CreateInstanceFrom(assemblyFile: String, typeName: String, ignoreCase: Boolean, bindingAttr: BindingFlags, binder: Binder, args: Object[ ], culture: CultureInfo, activationAttributes: Object[ ], securityAttributes: Evidence): ObjectHandle;
[0201] Description
[0202] DefineDynamicAssembly
[0203] [C#] AssemblyBuilder DefineDynamicAssembly(AssemblyName name, AssemblyBuilderAccess access);
[0204] [C++] AssemblyBuilder* DefineDynamicAssembly(AssemblyName* name, AssemblyBuilderAccess access);
[0205] [VB] Function DefineDynamicAssembly(ByVal name As AssemblyName, ByVal access As AssemblyBuilderAccess) As AssemblyBuilder
[0206] [JScript] function DefineDynamicAssembly(name: AssemblyName, access: AssemblyBuilderAccess): AssemblyBuilder;
[0207] Description
[0208] DefineDynamicAssembly
[0209] [C#] AssemblyBuilder DefineDynamicAssembly(AssemblyName name, AssemblyBuilderAccess access, Evidence evidence);
[0210] [C++] AssemblyBuilder* DefineDynamicAssembly(AssemblyName* name, AssemblyBuilderAccess access, Evidence* evidence);
[0211] [VB] Function DefineDynamicAssembly(ByVal name As AssemblyName, ByVal access As AssemblyBuilderAccess, ByVal evidence As Evidence) As AssemblyBuilder
[0212] [JScript] function DefineDynamicAssembly(name: AssemblyName, access: AssemblyBuilderAccess, evidence: Evidence): AssemblyBuilder;
[0213] Description
[0214] DefineDynamicAssembly
[0215] [C#] AssemblyBuilder DefineDynamicAssembly(AssemblyName name, AssemblyBuilderAccess access, string dir);
[0216] [C++] AssemblyBuilder* DefineDynamicAssembly(AssemblyName* name, AssemblyBuilderAccess access, String* dir);
[0217] [VB] Function DefineDynamicAssembly(ByVal name As AssemblyName, ByVal access As AssemblyBuilderAccess, ByVal dir As String) As AssemblyBuilder
[0218] [JScript] function DefineDynamicAssembly(name: AssemblyName, access: AssemblyBuilderAccess, dir: String): AssemblyBuilder;
[0219] Description
[0220] DefineDynamicAssembly
[0221] [C#] AssemblyBuilder DefineDynamicAssembly(AssemblyName name, AssemblyBuilderAccess access, string dir, Evidence evidence);
[0222] [C++] AssemblyBuilder* DefineDynamicAssembly(AssemblyName* name, AssemblyBuilderAccess access, String* dir, Evidence* evidence);
[0223] [VB] Function DefineDynamicAssembly(ByVal name As AssemblyName, ByVal access As AssemblyBuilderAccess, ByVal dir As String, ByVal evidence As Evidence) As AssemblyBuilder
[0224] [JScript] function DefineDynamicAssembly(name: AssemblyName, access: AssemblyBuilderAccess, dir: String, evidence: Evidence): AssemblyBuilder;
[0225] Description
[0226] DefineDynamicAssembly
[0227] [C#] AssemblyBuilder DefineDynamicAssembly(AssemblyName name, AssemblyBuilderAccess access, PermissionSet requiredPermissions, PermissionSet optionalPermissions, PermissionSet refusedPermissions);
[0228] [C++] AssemblyBuilder* DefineDynamicAssembly(AssemblyName* name, AssemblyBuilderAccess access, PermissionSet* requiredPermissions, PermissionSet* optionalPermissions, PermissionSet* refusedPermissions);
[0229] [VB] Function DefineDynamicAssembly(ByVal name As AssemblyName, ByVal access As AssemblyBuilderAccess, ByVal requiredPermissions As PermissionSet, ByVal optionalPermissions As PermissionSet, ByVal refusedPermissions As PermissionSet) As AssemblyBuilder
[0230] [JScript] function DefineDynamicAssembly(name: AssemblyName, access: AssemblyBuilderAccess, requiredPermissions: PermissionSet, optionalPermissions: PermissionSet, refusedPermissions: PermissionSet): AssemblyBuilder;
[0231] Description
[0232] DefineDynamicAssembly
[0233] [C#] AssemblyBuilder DefineDynamicAssembly(AssemblyName name, AssemblyBuilderAccess access, Evidence evidence, PermissionSet requiredPermissions, PermissionSet optionalPermissions, PermissionSet refusedPermissions);
[0234] [C++] AssemblyBuilder* DefineDynamicAssembly(AssemblyName* name, AssemblyBuilderAccess access, Evidence* evidence, PermissionSet* requiredPermissions, PermissionSet* optionalPermissions, PermissionSet* refusedPermissions);
[0235] [VB] Function DefineDynamicAssembly(ByVal name As AssemblyName, ByVal access As AssemblyBuilderAccess, ByVal evidence As Evidence, ByVal requiredPermissions As PermissionSet, ByVal optionalPermissions As PennissionSet, ByVal refusedpermissions As PermissionSet) As AssemblyBuilder
[0236] [JScript] function DefineDynamicAssembly(name: AssemblyName, access:
[0237] AssemblyBuilderAccess, evidence: Evidence, requiredPermissions:
[0238] PermissionSet, optionalPermissions: PermissionSet, refusedPermissions:
[0239] PermissionSet): AssemblyBuilder;
[0240] Description
[0241] DefineDynamicAssembly
[0242] [C#] AssemblyBuilder DefineDynamicAssembly(AssemblyName name, AssemblyBuilderAccess access, string dir, PermissionSet requiredPermissions, PermissionSet optionalPermissions, PermissionSet refusedPermissions);
[0243] [C++] AssemblyBuilder* DefineDynamicAssembly(AssemblyName* name, AssemblyBuilderAccess access, String* dir, PermissionSet* requiredPermissions, PermissionSet* optionalPermissions, PermissionSet* refusedPermissions);
[0244] [VB] Function DefineDynamicAssembly(ByVal name As AssemblyName, ByVal access As AssemblyBuilderAccess, ByVal dir As String, ByVal requiredPermissions As PermissionSet, ByVal optionalPermissions As PermissionSet, ByVal refusedPermissions As PermissionSet) As AssemblyBuilder
[0245] [JScript] function DefineDynamicAssembly(name: AssemblyName, access:
[0246] AssemblyBuilderAccess, dir: String, requiredPermissions: PermissionSet,
[0247] optionalPermissions: PermissionSet, refusedPermissions: PermissionSet)
[0248] AssemblyBuilder;
[0249] Description
[0250] DefineDynamicAssembly
[0251] [C#] AssemblyBuilder DefineDynamicAssembly(AssemblyName name, AssemblyBuilderAccess access, string dir, Evidence evidence, PermissionSet requiredPermissions, PermissionSet optionalPermissions, PermissionSet refusedPermissions);
[0252] [C++] AssemblyBuilder* DefineDynamicAssembly(AssemblyName* name, AssemblyBuilderAccess access, String* dir, Evidence* evidence, PermissionSet* requiredPerminssions, PermissionSet* optionalPermissions, PermissionSet* refusedPermissions);
[0253] [VB] Function DefineDynamicAssembly(ByVal name As AssemblyName, ByVal access As AssemblyBuilderAccess, ByVal dir As String, ByVal evidence As Evidence, ByVal requiredPermissions As PermissionSet, ByVal optionalPermissions As PermissionSet, ByVal refusedPermissions As PermissionSet) As AssemblyBuilder
[0254] [JScript] function DefineDynamicAssembly(name: AssemblyName, access:
[0255] AssemblyBuilderAccess, dir: String, evidence: Evidence, requiredPermissions:
[0256] PermissionSet, optionalPermissions: PermissionSet, refusedPermissions:
[0257] PermissionSet): AssemblyBuilder;
[0258] Description
[0259] DefineDynamicAssembly
[0260] [C#] AssemblyBuilder DefineDynamicAssembly(AssemblyName name, AssemblyBuilderAccess access, string dir, Evidence evidence, PermissionSet requiredPermissions, PermissionSet optionalPermissions, PermissionSet refisedPermissions, bool isSynchronized);
[0261] [C++] AssemblyBuilder* DefineDynamicAssembly(AssemblyName* name, AssemblyBuilderAccess access, String* dir, Evidence* evidence, PermissionSet* requiredPermissions, PermissionSet* optionalPermissions, PermissionSet* reffusedPermissions, bool isSynchronized);
[0262] [VB] Function DefineDynamicAssembly(ByVal name As AssemblyName, ByVal access As AssemblyBuilderAccess, ByVal dir As String, ByVal evidence As Evidence, ByVal requiredPermissions As PermissionSet, ByVal optionalPermissions As PermissionSet, ByVal refusedpermissions As PermissionSet, ByVal isSynchronized As Boolean) As AssemblyBuilder
[0263] [JScript] function DefineDynamicAssembly(name: AssemblyName, access:
[0264] AssemblyBuilderAccess, dir: String, evidence: Evidence, requiredPermissions:
[0265] PermissionSet, optionalPermissions: PermissionSet, refusedPermissions:
[0266] PermissionSet, isSynchronized: Boolean): AssemblyBuilder;
[0267] Description
[0268] DoCallBack
[0269] [C#] void DoCallBack(CrossAppDomainDelegate theDelegate);
[0270] [C++] void DoCallBack(CrossAppDomainDelegate* theDelegate);
[0271] [VB] Sub DoCallBack(ByVal theDelegate As CrossAppDomainDelegate)
[0272] [JScript] function DoCallBack(theDelegate: CrossAppDomainDelegate);
[0273] Description
[0274] Equals
[0275] [C#] bool Equals(object other);
[0276] [C++] bool Equals(Object* other);
[0277] [VB] Function Equals(ByVal other As Object) As Boolean
[0278] [JScript] function Equals(other: Object): Boolean;
[0279] Description
[0280] ExecuteAssembly
[0281] [C#] int ExecuteAssembly(string assemblyFile);
[0282] [C++] int ExecuteAssembly(String* assemblyFile);
[0283] [VB] Function ExecuteAssembly(ByVal assemblyFile As String) As Integer
[0284] [JScript] function ExecuteAssembly(assemblyFile: String): int;
[0285] Description
[0286] ExecuteAssembly
[0287] [C#] int ExecuteAssembly(string assemblyFile, Evidence assemblySecurity);
[0288] [C++] int ExecuteAssembly(String* assemblyFile, Evidence* assemblySecurity);
[0289] [VB] Function ExecuteAssembly(ByVal assemblyFile As String, ByVal assemblySecurity As Evidence) As Integer
[0290] [JScript] function ExecuteAssembly(assemblyFile: String, assemblySecurity: Evidence): int;
[0291] Description
[0292] ExecuteAssembly
[0293] [C#] int ExecuteAssembly(string assemblyFile, Evidence assemblySecurity, string[ ] args);
[0294] [C++] int ExecuteAssembly(String* assemblyFile, Evidence* assemblySecurity, String* args_gc[ ]);
[0295] [VB] Function ExecuteAssembly(ByVal assemblyFile As String, ByVal assemblySecurity As Evidence, ByVal args( ) As String) As Integer
[0296] [JScript] function ExecuteAssembly(assemblyFile String, assemblySecurity: Evidence, args: String[ ]): int;
[0297] Description
[0298] GetAssemblies
[0299] [C#] Assembly[ ] GetAssemblies( );
[0300] [C++] Assembly* GetAssemblies( )[ ];
[0301] [VB] Function GetAssemblies( ) As Assembly( )
[0302] [JScript] function GetAssemblies( ): Assembly[ ];
[0303] Description
[0304] GetData
[0305] [C#] object GetData(string name);
[0306] [C++] Object* GetData(String* name);
[0307] [VB] Function GetData(ByVal name As String) As Object
[0308] [JScript] function GetData(name: String): Object;
[0309] Description
[0310] GetHashCode
[0311] [C#] int GetHashCode( );
[0312] [C++] int GetHashCode( );
[0313] [VB] Function GetHashCode( ) As Integer
[0314] [JScript] function GetHashCode( ): int;
[0315] Description
[0316] GetLifetimeService
[0317] [C+] object GetLifetimeService( );
[0318] [C++] Object* GetLifetimeService( );
[0319] [VB] Function GetLifetimeService( ) As Object
[0320] [JScript] function GetLifetimeService( ) Object;
[0321] Description
[0322] GetType
[0323] [C#] Type GetType( );
[0324] [C++] Type* GetType( );
[0325] [VB] Function GetType( ) As Type
[0326] [JScript] function GetType( ): Type;
[0327] Description
[0328] InitializeLifetimeService
[0329] [C#] object InitializeLifetimeService( );
[0330] [C++] Object* InitializeLifetimeService( );
[0331] [VB] Function InitializeLifetimeService( ) As Object
[0332] [JScript] function InitializeLifetimeService( ): Object;
[0333] Description
[0334] Load
[0335] [C#] Assembly Load(AssemblyName assemblyRef);
[0336] [C++] Assembly* Load(AssemblyName* assemblyRef);
[0337] [VB] Function Load(ByVal assemblyRef As AssemblyName) As Assembly
[0338] [JScript] function Load(assemblyRef: AssemblyName): Assembly;
[0339] Description
[0340] Load
[0341] [C#] Assembly Load(byte[ ] rawAssembly);
[0342] [C++] Assembly* Load(unsigned char rawAssembly_gc[ ]);
[0343] [VB] Function Load(ByVal rawAssembly( ) As Byte) As Assembly
[0344] [JScript] function Load(rawAssembly: Byte[ ]): Assembly;
[0345] Description
[0346] Load
[0347] [C#] Assembly Load(string assemblyString);
[0348] [C++] Assembly* Load(String* assemblyString);
[0349] [VB] Function Load(ByVal assemblyString As String) As Assembly
[0350] [JScript] function Load(assemblyString: String): Assembly;
[0351] Description
[0352] Load
[0353] [C#] Assembly Load(AssemblyName assemblyRef, Evidence assemblySecurity);
[0354] [C++] Assembly* Load(AssemblyName* assemblyRef, Evidence* assemblySecurity);
[0355] [VB] Function Load(ByVal assemblyRef As AssemblyName, ByVal assemblySecurity As Evidence) As Assembly
[0356] [JScript] function Load(assemblyRef: AssemblyName, assemblySecurity: Evidence): Assembly;
[0357] Description
[0358] Load
[0359] [C#] Assembly Load(byte[ ] rawAssembly, byte[ ] rawSymbolStore);
[0360] [C++] Assembly* Load(unsigned char rawAssembly_gc[ ], unsigned char rawSymbolStore_gc[ ]);
[0361] [VB] Function Load(ByVal rawAssembly( ) As Byte, ByVal rawSymbolStore( ) As Byte) As Assembly
[0362] [JScript] function Load(rawAssembly: Byte[ ], rawSymbolStore: Byte[ ]) Assembly;
[0363] Description
[0364] Load
[0365] [C#] Assembly Load(string assemblyString, Evidence assemblySecurity);
[0366] [C++] Assembly* Load(String* assemblyString, Evidence* assemblySecurity);
[0367] [VB] Function Load(ByVal assemblyString As String, ByVal assemblySecurity As Evidence) As Assembly
[0368] [JScript] function Load(assemblyString: String, assemblySecurity: Evidence): Assembly;
[0369] Description
[0370] Load
[0371] [C#] Assembly Load(AssemblyName assemblyRef, Evidence assemblySecurity, string callerLocation);
[0372] [C++] Assembly* Load(AssemblyName* assemblyRef, Evidence* assemblySecurity, String* callerLocation);
[0373] [VB] Function Load(ByVal assemblyRef As AssemblyName, ByVal assemblySecurity As Evidence, ByVal callerLocation As String) As Assembly
[0374] [JScript] function Load(assemblyRef: AssemblyName, assemblySecurity: Evidence, callerLocation: String): Assembly;
[0375] Description
[0376] Load
[0377] [C#] Assembly Load(byte[ ] rawAssembly, byte[ ] rawSymbolStore, Evidence securityEvidence);
[0378] [C++] Assembly* Load(unsigned char rawAssembly_gc[ ], unsigned char rawSymbolStore_gc[ ], Evidence* securityEvidence);
[0379] [VB] Function Load(ByVal rawAssembly( ) As Byte, ByVal rawSymbolStore( ) As Byte, ByVal securityEvidence As Evidence) As Assembly
[0380] [JScript] function Load(rawAssembly: Byte[ ], rawSymbolStore: Byte[ ], securityEvidence: Evidence): Assembly;
[0381] Description
[0382] Load
[0383] [C#] Assembly Load(string assemblyString, Evidence assemblySecurity, string callerLocation);
[0384] [C++] Assembly* Load(String* assemblyString, Evidence* assemblySecurity, String* callerLocation);
[0385] [VB] Function Load(ByVal assemblyString As String, ByVal assemblySecurity As Evidence, ByVal callerLocation As String) As Assembly
[0386] [JScript] function Load(assemblyString: String, assemblySecurity: Evidence, callerLocation: String): Assembly;
[0387] Description
[0388] SetAppDomainPolicy
[0389] [C#] void SetAppDomainPolicy(PolicyLevel domainPolicy);
[0390] [C++] void SetAppDomainPolicy(PolicyLevel* domainPolicy);
[0391] [VB] Sub SetAppDomainPolicy(ByVal domainPolicy As PolicyLevel)
[0392] [JScript] function SetAppDomainPolicy(domainPolicy: PolicyLevel);
[0393] Description
[0394] SetCachePath
[0395] [C#] void SetCachePath(string s);
[0396] [C++] void SetCachePath(String* s);
[0397] [VB] Sub SetCachePath(ByVal s As String)
[0398] [JScript] fuinction SetCachePath(s: String);
[0399] Description
[0400] SetData
[0401] [C#] void SetData(string name, object data);
[0402] [C++] void SetData(String* name, Object* data);
[0403] [VB] Sub SetData(ByVal name As String, ByVal data As Object)
[0404] [JScript] function SetData(name: String, data: Object);
[0405] Description
[0406] SetPrincipalPolicy
[0407] [C#] void SetPrincipalPolicy(PrincipalPolicy policy);
[0408] [C++] void SetPrincipalPolicy(PrincipalPolicy policy);
[0409] [VB] Sub SetPrincipalPolicy(ByVal policy As PrincipalPolicy)
[0410] [JScript] function SetPrincipalPolicy(policy: PrincipalPolicy);
[0411] Description
[0412] SetShadowCopyPath
[0413] [C#] void SetShadowCopyPath(string s);
[0414] [C++] void SetShadowCopyPath(String* s);
[0415] [VB] Sub SetShadowCopyPath(ByVal s As String)
[0416] [JScript] function SetShadowCopyPath(s: String);
[0417] Description
[0418] SetThreadPrincipal
[0419] [C#] void SetThreadPrincipal(IPrincipal principal);
[0420] [C++] void SetThreadPrincipal(IPrincipal* principal);
[0421] [VB] Sub SetThreadPrincipal(ByVal principal As IPrincipal)
[0422] [JScript] function SetThreadPrincipal(principal: IPrincipal);
[0423] Description
[0424] ToString
[0425] [C#] string ToString( );
[0426] [C++] String* ToString( );
[0427] [VB] Function ToString( ) As String
[0428] [JScript] function ToString( ): String;
[0429] Description
[0430] Activator class (System)
[0431] ToString
[0432] Description
[0433] Contains methods to create types of objects locally or remotely, or obtain references to existing remote objects.
[0434] The
[0435] System.Activator.CreateInstance(System.Type,System.Reflection.Bindi- ngFla gs,System.Reflection.Binder,System.Object[ ],System.Globalization.Cu- ltureln fo) method creates an instance of a type defined in an assembly by invoking the constructor that best matches the specified arguments. If no arguments are specified, the constructor that takes no parameters, that is, the default constructor, is invoked.
[0436] CreateComInstanceFrom
[0437] [C#] public static ObjectHandle CreateComInstanceFrom(string assemblyName, string typeName);
[0438] [C++] public: static ObjectHandle* CreateComInstanceFrom(String* assemblyName, String* typeName);
[0439] [VB] Public Shared Function CreateComInstanceFrom(ByVal assemblyName As String, ByVal typeName As String) As ObjectHandle
[0440] [JScript] public static function CreateComInstanceFrom(assemblyName- : String, typeName: String): ObjectHandle;
[0441] Description
[0442] Creates an instance of the COM object whose name is specified, using the named assembly file and the constructor that best matches the specified parameters.
[0443] Return Value: A handle, which must be unwrapped to access the newly created instance.
[0444] This method allows types to be created remotely without having to load the type locally. The name of a file that contains an assembly where the type named typeName is sought. The name of the desired type.
[0445] CreateInstance
[0446] [C#] public static object CreateInstance(Type type);
[0447] [C++] public: static Object* CreateInstance(Type* type);
[0448] [VB] Public Shared Function CreateInstance(ByVal type As Type) As Object
[0449] [JScript] public static function CreateInstance(type: Type): Object;
[0450] Description
[0451] Creates an instance of the specified type using the constructor that best matches the specified parameter.
[0452] Return Value: A reference to the newly created object.
[0453] The constructor to be invoked must be accessible. The type of object to create.
[0454] CreateInstance
[0455] [C#] public static ObjectHandle CreateInstance(string assemblyName, string typeName);
[0456] [C++] public: static ObjectHandle* CreateInstance(String* assemblyName, String* typeName);
[0457] [VB] Public Shared Function CreateInstance(ByVal assemblyName As String, ByVal typeName As String) As ObjectHandle
[0458] [JScript] public static function CreateInstance(assemblyName: String, typeName: String): ObjectHandle;
[0459] Description
[0460] Creates an instance of the type whose name is specified, using the named assembly and the constructor that best matches the specified parameters.
[0461] Return Value: A handle, which must be unwrapped to access the newly created instance.
[0462] This method allows types to be created remotely without having to load the type locally. The name of the assembly where the type named typeName is sought. If assemblyName is null, the executing assembly is searched. The name of the desired type.
[0463] CreateInstance
[0464] [C#] public static object CreateInstance(Type type, object[ ] args);
[0465] [C++] public: static Object* CreateInstance(Type* type, Object* args_gc[ ]); [VB] Public Shared Function CreateInstance(ByVal type As Type, ByVal args( ) As Object) As Object
[0466] [JScript] public static function CreateInstance(type: Type, args: Object[ ]) Object;
[0467] Description
[0468] Creates an instance of the specified type using the constructor that best matches the specified parameters.
[0469] Return Value: A reference to the newly created object.
[0470] The constructor to be invoked must be accessible and provide the most specific match with the specified argument list. The type of object to create. An array of arguments that match in number, order, and type the parameters of the constructor to invoke. If args is an empty array or null, the constructor that takes no parameters (the default constructor) is invoked.
[0471] CreateInstance
[0472] [C#] public static ObjectHandle CreateInstance(string assemblyName, string typeName, object[ ] activationAttributes);
[0473] [C++] public: static ObjectHandle* CreateInstance(String* assemblyName, String* typeName, Object* activationAttributes_gc[ ]);
[0474] [VB] Public Shared Function CreateInstance(ByVal assemblyName As String, ByVal typeName As String, ByVal activationattributes( ) As Object) As ObjectHandle
[0475] [JScript] public static function CreateInstance(assemblyName: String, typeName: String, activationAttributes: Object[ ]): ObjectHandle;
[0476] Description
[0477] Creates an instance of the type whose name is specified, using the named assembly and the constructor that best matches the specified parameters.
[0478] Return Value: A handle, which must be unwrapped to access the newly created instance.
[0479] This method allows types to be created remotely without having to load the type locally. The name of the assembly where the type named typeName is sought. If assemblyName is null, the executing assembly is searched. The name of the desired type. An array of one or more attributes that can participate in activation.
[0480] CreateInstance
[0481] [C#] public static object CreateInstance(Type type, object[ ] args, object[0 ] activationAttributes);
[0482] [C++] public: static Object* CreateInstance(Type* type, Object* args_gc[ ], Object* activationAttributes_gc[ ]);
[0483] [VB] Public Shared Function CreateInstance(ByVal type As Type, ByVal args( ) As Object, ByVal activationAttributes( ) As Object) As Object
[0484] [JScript] public static function CreateInstance(type: Type, args: Object[ ], activationAttributes: Object [ ]): Object;
[0485] Description
[0486] Creates an instance of the specified type using the constructor that best matches the specified parameters.
[0487] Return Value: A reference to the newly created object.
[0488] The constructor to be invoked must be accessible and provide the most specific match with the specified argument list. The type of object to create. An array of arguments that match in number, order, and type the parameters of the constructor to invoke. If args is an empty array or null, the constructor that takes no parameters (the default constructor) is invoked. An array of one or more attributes that can participate in activation.
[0489] CreateInstance
[0490] [C#] public static object CreateInstance(Type type, BindingFlags bindingAttr, Binder binder, object[ ] args, CultureInfo culture);
[0491] [C++] public: static Object* CreateInstance(Type* type, BindingFlags bindingAttr, Binder* binder, Object* args_gc[ ], CultureInfo* culture);
[0492] [VB] Public Shared Function CreateInstance(ByVal type As Type, ByVal bindingAttr As BindingFlags, ByVal binder As Binder, ByVal args( ) As Object, ByVal culture As CultureInfo) As Object
[0493] [JScipt] public static function CreateInstance(type: Type, bindingAttr: BindingFlags, binder: Binder, args: Object [ ], culture: CultureInfo): Object; Creates an instance of the specified type using the constructor that best matches the specified parameters.
[0494] Description
[0495] Creates an instance of the specified type using the constructor that best matches the specified parameters.
[0496] Return Value: A reference to the newly created object.
[0497] The constructor to be invoked must be accessible and provide the most specific match with the specified argument list under the constraints of the specified binder and binding attributes. The type of object to create. A combination of zero or more bit flags that affect the search for the type constructor. If bindingAttr is zero, a case-sensitive search for public properties is conducted. An object that uses bindingAttr and args to seek and identify the type constructor. If binder is null, the default binder is used. An array of arguments that match in number, order, and type the parameters of the constructor to invoke. If args is an empty array or null, the constructor that takes no parameters (the default constructor) is invoked. Culture-specific information that governs the coercion of args to the formal types declared for the type constructor. If culture is null, the System.Globalization.CultureInfo for the current thread is used.
[0498] CreateInstance
[0499] [C#] public static object CreateInstance(Type type, BindingFlags bindingAttr, Binder binder, object [ ] args, CultureInfo culture, object [ ] activationAttributes);
[0500] [C++] public: static Object* CreateInstance(Type* type, BindingFlags bindingAttr, Binder* binder, Object* args_gc[ ], CultureInfo* culture, Object* activationAttributes_gc[ ]);
[0501] [VB] Public Shared Function CreateInstance(ByVal type As Type, ByVal bindingAttr As BindingFlags, ByVal binder As Binder, ByVal args( ) As Object, ByVal culture As CultureInfo, ByVal activationAttributes( ) As Object) As Object
[0502] [JScript] public static function CreateInstance(type: Type, bindingAttr: BindingFlags, binder: Binder, args: Object [ ], culture: CultureInfo, activationAttributes: Object [ ]): Object;
[0503] Description
[0504] Creates an instance of the specified type using the constructor that best matches the specified parameters.
[0505] Return Value: A reference to the newly created object.
[0506] The constructor to be invoked must be accessible and provide the most specific match with the specified argument list under the constraints of the specified binder and binding attributes. The type of object to create. A combination of zero or more bit flags that affect the search for the type constructor. If bindingAttr is zero, a case-sensitive search for public properties is conducted. An object that uses bindingAttr and args to seek and identify the type constructor. If binder is null, the default binder is used. An array of arguments that match in number, order, and type the parameters of the constructor to invoke. If args is an empty array or null, the constructor that takes no parameters (the default constructor) is invoked. Culture-specific information that governs the coercion of args to the formal types declared for the type constructor. If culture is null, the System.Globalization.CultureInfo for the current thread is used. An array of one or more attributes that can participate in activation.
[0507] CreateInstance
[0508] [C#] public static ObjectHandle CreateInstance(string assemblyName, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object [ ] args, CultureInfo culture, object [ ] activationAttributes, Evidence securityInfo);
[0509] [C++] public: static ObjectHandle* CreateInstance(String* assemblyName, String* typeName, bool ignoreCase, BindingFlags bindingAttr, Binder* binder, Object* args_gc[ ], CultureInfo* culture, Object* activationAttributes_gc[ ], Evidence* securityInfo);
[0510] [VB] Public Shared Function CreateInstance(ByVal assemblyName As String, ByVal typeName As String, ByVal ignoreCase As Boolean, ByVal bindingAttr As BindingFlags, ByVal binder As Binder, ByVal args( ) As Object, ByVal culture As CultureInfo, ByVal activationAttributes( ) As Object, ByVal securityInfo As Evidence) As ObjectHandle
[0511] [JScript] public static function CreateInstance(assemblyName: String, typeName: String, ignoreCase: Boolean, bindingAttr: BindingFlags, binder: Binder, args: Object [ ], culture: CultureInfo, activationAttributes: Object [ ], securityInfo: Evidence): ObjectHandle;
[0512] Description
[0513] Creates an instance of the type whose name is specified, using the named assembly and the constructor that best matches the specified parameters.
[0514] Return Value: A handle, which must be unwrapped to access the newly created instance.
[0515] This method allows types to be created remotely without having to load the type locally. The name of the assembly where the type named typeName is sought. If assemblyName is null, the executing assembly is searched. The name of the desired type. A Boolean that specifies whether the search for typeName is case-sensitive. If ignoreCase is true, the search is not case-sensitive. A combination of zero or more bit flags that affect the search for the typeName constructor. If bindingattr is zero, a case-sensitive search for public properties is conducted. An object that uses bindingAttr and args to seek and identify the typeName constructor. If binder is null, the default binder is used. An array of arguments that match in number, order, and type the parameters of the constructor to invoke. If args is an empty array or null, the constructor that takes no parameters (the default constructor) is invoked. Culture-specific information that governs the coercion of args to the formal types declared for the typeName constructor. If culture is null, the System.Globalization.CultureInfo for the current thread is used. An array of one or more attributes that can participate in activation. Information used to make security policy decisions and grant code permissions.
[0516] CreateInstanceFrom
[0517] [C#] public static ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName);
[0518] 2 [C++] public: static ObjectHandle* CreateInstanceFrom(String* assemblyFile, String* typeName);
[0519] [VB] Public Shared Function CreateInstanceFrom(ByVal assemblyFile As String, ByVal typeName As String) As ObjectHandle
[0520] [JScript] public static function CreateInstanceFrom(assemblyFile: String, typeName: String): ObjectHandle; Creates an instance of the type whose name is specified, using the named assembly file and the constructor that best matches the specified parameters.
[0521] Description
[0522] Creates an instance of the type whose name is specified, using the named assembly file and the constructor that best matches the specified parameters.
[0523] Return Value: A handle, which must be unwrapped to access the newly created instance.
[0524] This method allows types to be created remotely without having to load the type locally. The name of a file that contains an assembly where the type named typeName is sought. The name of the desired type.
[0525] CreateInstanceFrom
[0526] [C#] public static ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName, object [ ] activationAttributes);
[0527] [C++] public: static ObjectHandle* CreateInstanceFrom(String* assemblyFile, String* typeName, Object* activationAttributes_gc[ ]);
[0528] [VB] Public Shared Function CreateInstanceFrom(ByVal assemblyFile As String, ByVal typeName As String, ByVal activationAttributes( ) As Object) As ObjectHandle
[0529] [JScript] public static function CreateInstanceFrom(assemblyFile: String, typeName: String, activationAttributes: Object [ ]): ObjectHandle;
[0530] Description
[0531] Creates an instance of the type whose name is specified, using the named assembly file and the constructor that best matches the specified parameters.
[0532] Return Value: A handle, which must be unwrapped to access the newly created instance.
[0533] This method allows types to be created remotely without having to load the type locally. The name of a file that contains an assembly where the type named typeName is sought. The name of the desired type. An array of one or more attributes that can participate in activation.
[0534] CreateInstanceFrom
[0535] [C#] public static ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object [ ] args, CultureInfo culture, object [ ] activationAttributes, Evidence securityInfo);
[0536] [C++] public: static ObjectHandle* CreateInstanceFrom(String* assemblyFile, String* typeName, bool ignoreCase, BindingFlags bindingAttr, Binder* binder, Object* args_gc[ ], CultureInfo* culture, Object* activationAttributes_gc[ ], Evidence* securityInfo);
[0537] [VB] Public Shared Function CreateInstanceFrom(ByVal assemblyFile As String, ByVal typename As String, ByVal ignoreCase As Boolean, ByVal bindingAttr As BindingFlags, ByVal binder As Binder, ByVal args( ) As Object, ByVal culture As CultureInfo, ByVal activationAttributes( ) As Object, ByVal securityInfo As Evidence) As ObjectHandle
[0538] [JScript] public static function CreateInstanceFrom(assemblyFile: String, typeName: String, ignoreCase: Boolean, bindingAttr: BindingFlags, binder: Binder, args: Object [ ], culture: CultureInfo, activationAttributes: Object [ ], securityInfo: Evidence): ObjectHandle;
[0539] Description
[0540] Creates an instance of the type whose name is specified, using the named assembly file and the constructor that best matches the specified parameters.
[0541] Return Value: A handle, which must be unwrapped to access the newly created instance.
[0542] This method allows types to be created remotely without having to load the type locally. The name of a file that contains an assembly where the type named typeName is sought. The name of the desired type. A Boolean that specifies whether the search for typeName is case-sensitive. If ignoreCase is true, the search is not case-sensitive. A combination of zero or more bit flags that affect the search for the typeName constructor. If bindingAttr is zero, a case-sensitive search for public properties is conducted. An object that uses bindingAttr and args to seek and identify the typeName constructor. If binder is null, the default binder is used. An array of arguments that match in number, order, and type the parameters of the constructor to invoke. If args is an empty array or null, the constructor that takes no parameters (the default constructor) is invoked. Culture-specific information that governs the coercion of args to the formal types declared for the typeName constructor. If culture is null, the System.Globalization.CultureInfo for the current thread is used. An array of one or more attributes that can participate in activation. Information used to make security policy decisions and grant code permissions.
[0543] GetObject
[0544] [C#] public static object GetObject(Type type, string url);
[0545] [C++] public: static Object* GetObject(Type* type, String* url);
[0546] [VB] Public Shared Function GetObject(ByVal type As Type, ByVal url As String) As Object
[0547] [JScript] public static function GetObject(type: Type, url: String): Object; Creates a proxy for a currently running remote object, server-activated well-known object, or web service.
[0548] Description
[0549] Creates a proxy for the well-known object indicated by the specified type and URL.
[0550] Return Value: A proxy that points to an endpoint served by the requested well-known object.
[0551] Call the proxy to send messages to the remote object. No messages are sent over the network until a method is called on the proxy. The type of the well-known object to which you want to connect. The URL of the well-known object.
[0552] GetObject
[0553] [C#] public static object GetObject(Type type, string url, object state);
[0554] [C++] public: static Object* GetObject(Type* type, String* url, Object* state);
[0555] [VB] Public Shared Function GetObject(ByVal type As Type, ByVal url As String, ByVal state As Object) As Object
[0556] [JScript] public static function GetObject(type: Type, url: String, state: Object) Object;
[0557] Description
[0558] Creates a proxy for the well-known object indicated by the specified type, URL, and channel data.
[0559] Return Value: A proxy that points to an endpoint served by the requested well-known object.
[0560] Call the proxy to send messages to the remote object. No messages are sent over the network until a method is called on the proxy. The type of the well-known object to which you want to connect. The URL of the well-known object. Channel-specific data or null.
[0561] AppDomain class (System)
[0562] ToString
[0563] Description
[0564] Represents an application domain, which is an isolated environment where applications execute. This class cannot be inherited.
[0565] Application domains isolate executing applications from one another. One or more applications can run in a single application domain.
[0566] BaseDirectory
[0567] ToString
[0568] [C#] public string BaseDirectory {get;}
[0569] [C++] public: _property String* get_BaseDirectory( );
[0570] [VB] Public ReadOnly Property BaseDirectory As String
[0571] [JScript] public function get BaseDirectory( ): String;
[0572] Description
[0573] Gets the base directory that the assembly resolver used to probe for assemblies.
[0574] This property corresponds to the assembly resolver's APPBASE.
[0575] CurrentDomain
[0576] ToString
[0577] [C#] public static AppDomain CurrentDomain {get;}
[0578] [C++] public: _property static AppDomain* get_CurrentDomain( );
[0579] [VB] Public Shared ReadOnly Property CurrentDomain As AppDomain
[0580] [JScript] public static function get CurrentDomain( ): AppDomain;
[0581] Description
[0582] Gets the current application domain for the current System.Threading.Thread.
[0583] DynamicDirectory
[0584] ToString
[0585] [C#] public string DynamicDirectory {get;}
[0586] [C++] public: _property String* get_DynamicDirectory( );
[0587] [VB] Public ReadOnly Property DynamicDirectory As String
[0588] [JScript] public function get DynamicDirectory( ): String;
[0589] Description
[0590] Gets the directory that the assembly resolver used to probe for dynamically-created assemblies.
[0591] Only available once an attempt has been made to load an assembly into this domain.
[0592] Evidence
[0593] ToString
[0594] [C#] public Evidence Evidence {get;}
[0595] [C++] public: Property Evidence* get_Evidence( );
[0596] [VB] Public ReadOnly Property Evidence As Evidence
[0597] [JScript] public function get Evidence( ): Evidence;
[0598] Description
[0599] Gets the System.Security.Policy.Evidence associated with this application domain that is used as input to security policy.
[0600] FriendlyName
[0601] ToString
[0602] [C#] public string FriendlyName {get;}
[0603] [C++] public: _property String* get_FriendlyName( );
[0604] [VB] Public ReadOnly Property FriendlyName As String
[0605] [JScript] public function get FriendlyName( ): String;
[0606] Description
[0607] Gets the friendly name of this application domain.
[0608] The friendly name of the default application domain is the name of the assembly file loaded in the application domain. The friendly name is formed by stripping the directory specification from the assembly's codebase. For example, if an assembly with the file name "c:.backslash.MyAppDirectory.backslash.MyAssembly.exe" is loaded in the default application domain, the friendly name of that application domain is "MyAssembly.exe".
[0609] RelativeSearchPath
[0610] ToString
[0611] [C#] public string RelativeSearchPath {get;}
[0612] [C++] public: _property String* get_RelativeSearchPath( );
[0613] [VB] Public ReadOnly Property RelativeSearchPath As String
[0614] [JScript] public function get RelativeSearchPath( ): String;
[0615] Description
[0616] Gets the path relative to the base directory where the assembly resolver should probe for private assemblies.
[0617] Private assemblies are deployed in the same directory structure as the application.
[0618] SetupInformation
[0619] ToString
[0620] [C#] public AppDomainSetup SetupInformation {get; }
[0621] [C++] public: _property AppDomainSetup* get_SetupInformation( );
[0622] [VB] Public ReadOnly Property SetupInformation As AppDomainSetup
[0623] [JScript] public function get SetupInformation( ): AppDomainSetup;
[0624] Description
[0625] Gets the application domain configuration information for this instance.
[0626] ShadowCopyFiles
[0627] ToString
[0628] [C#] public bool ShadowCopyFiles {get; }
[0629] [C++] public: _property bool get_ShadowCopyFiles( );
[0630] [VB] Public ReadOnly Property ShadowCopyFiles As Boolean
[0631] [JScript] public function get ShadowCopyFiles( ): Boolean;
[0632] Description
[0633] Gets an indication whether all assemblies that are loaded in the application domain are shadow copied.
[0634] This method sets the System.AppDomainSetup.ShadowCopyFiles property of the internal System.AppDomainSetup object associated with this instance.
[0635] ToString
[0636] [C#] public event AssemblyLoadEventHandler AssemblyLoad;
[0637] [C++] public: _sealed_event AssemblyLoadEventHandler* AssemblyLoad;
[0638] [VB] NotOverridable Public Event AssemblyLoad As AssemblyLoadEventHandler
[0639] Description
[0640] Occurs when an assembly is loaded.
[0641] The System.AssemblyLoadEventHandler for this event can attempt to locate the assembly and load it.
[0642] ToSting
[0643] [C#] public event ResolveEventHandler AssemblyResolve;
[0644] [C++] public: _sealed_event ResolveEventHandler* AssemblyResolve;
[0645] [VB] NotOverridable Public Event AssemblyResolve As ResolveEventHandler
[0646] Description
[0647] Occurs when the resolution of an assembly fails.
[0648] The System.ResolveEventHandler for this event can attempt to locate the assembly and load it.
[0649] ToString
[0650] [C#] public event EventHandler DomainUnload;
[0651] [C++] public: _sealed_event EventHandler* DomainUnload;
[0652] [VB] NotOverridable Public Event DomainUnload As EventHandler
[0653] Description
[0654] Occurs when an System.AppDomain is about to be unloaded. The System.EventHandler for this event can attempt to locate the assembly and load it.
[0655] ToString
[0656] [C#] public event EventHandler ProcessExit;
[0657] [C++] public: _sealed_event EventHandler* ProcessExit;
[0658] [VB] NotOverridable Public Event ProcessExit As EventHandler
[0659] Description
[0660] Occurs when a process is about to exit.
[0661] The System.EventHandler for this event can perform termination activities, such as closing files, releasing storage and so on, before the process ends.
[0662] ToString
[0663] [C#] public event ResolveEventHandler ResourceResolve;
[0664] [C++] public: _sealed_event ResolveEventHandler* ResourceResolve;
[0665] [VB] NotOverridable Public Event ResourceResolve As ResolveEventHandler
[0666] Description
[0667] Occurs when the resolution of a resource fails.
[0668] The System.ResolveEventHandler for this event can attempt to locate the resource and load it.
[0669] ToString
[0670] [C#] public event ResolveEventHandler TypeResolve;
[0671] [C++] public: .sub.13 sealed_event ResolveEventHandler* TypeResolve;
[0672] [VB] NotOverridable Public Event TypeResolve As ResolveEventHandler
[0673] Description
[0674] Occurs when the resolution of a type fails.
[0675] The System.ResolveEventHandler for this event can attempt to locate the type and load it.
[0676] ToString
[0677] [C#] public event UnhandledExceptionEventHandler UnhandledException;
[0678] [C++] public: .sub.13 sealed_event UnhandledExceptionEventHandler* UnhandledException;
[0679] [VB] NotOverridable Public Event UnhandledException As UnhandledExceptionEventHandler
[0680] Description
[0681] Occurs when an exception is not caught by an event handler.
[0682] For more information about handling events, see.
[0683] AppendPrivatePath
[0684] [C#] public void AppendPrivatePath(string path);
[0685] [C++] public: _sealed void AppendPrivatePath(String* path);
[0686] [VB] NotOverridable Public Sub AppendPrivatePath(ByVal path As String)
[0687] [JScript] public function AppendPrivatePath(path: String);
[0688] Description
[0689] Appends the specified name of the directory to the private path.
[0690] The private path, or relative search path, is the path relative to the base directory where the assembly resolver probes for private assemblies. The name of the directory to be appended to the private path.
[0691] ClearPrivatePath
[0692] [C#] public void ClearPrivatePath( );
[0693] [C++] public: _sealed void ClearPrivatePath( );
[0694] [VB] NotOverridable Public Sub ClearPrivatePath( )
[0695] [JScript] public function ClearPrivatePath( );
[0696] Description
[0697] Resets the System.AppDomainSetup.PrivateBinPath for this instance to null.
[0698] ClearShadowCopyPath
[0699] [C#] public void ClearShadowCopyPath( );
[0700] [C++] public: _sealed void ClearShadowCopyPath( );
[0701] [VB+] NotOverridable Public Sub ClearShadowCopyPath( )
[0702] [JScript] public function ClearShadowCopyPath( );
[0703] Description
[0704] Resets the System.AppDomainSetup.ShadowCopyDirectories property for this instance to null.
[0705] CreateInstanceFrom
[0706] [C#] public ObjectHandle CreateComInstanceFrom(string assemblyName, string typeName);
[0707] [C++] public: ObjectHandle* CreateComInstanceFrom(String* assemblyName, String* typeName);
[0708] [VB] Public Function CreateComInstanceFrom(ByVal assemblyName As String, ByVal typeName As String) As ObjectHandle
[0709] [JScript] public function CreateComInstanceFrom(assemblyName: String, typeName: String): ObjectHandle;
[0710] Description
[0711] Creates an instance of a COM object. Parameters specify the name of the assembly that can create the object and the name of the type of the object.
[0712] Return Value: An object that is a wrapper for the new instance.
[0713] Use this method to create types remotely without having to load the type locally. The return value must to be unwrapped in order to access the real object. The name of the assembly in which this object type resides. The type name of the desired object.
[0714] CreateDomain
[0715] [C#] public static AppDomain CreateDomain(string friendlyName);
[0716] [C++] public: static AppDomain* CreateDomain(String* friendlyName);
[0717] [VB] Public Shared Function CreateDomain(ByVal friendlyName As String) As AppDomain
[0718] [JScript] public static function CreateDomain(friendlyName: String): AppDomain;
[0719] Description
[0720] Creates a new application domain with the specified name.
[0721] Return Value: The newly created application domain. friendlyName can be displayed in user interfaces to identify the domain. The friendly name of the domain.
[0722] CreateDomain
[0723] [C#] public static AppDomain CreateDomain(string friendlyName, Evidence securityInfo);
[0724] [C++] public: static AppDomain* CreateDomain(String* friendlyName, Evidence* securityInfo);
[0725] [VB] Public Shared Function CreateDomain(ByVal friendlyName As String, ByVal securityInfo As Evidence) As AppDomain
[0726] [JScript] public static function CreateDomain(friendlyName: String, securityInfo: Evidence): AppDomain; Creates a new application domain.
[0727] De