CA2522510A1 - Application programming interface for text mining and search - Google Patents

Abstract

Systems and methods are described that allow programmatic access to search engine results and query logs in a structured form. The search results can be retrieved from the search engine in an intermediary form that contains the information that is in the HTML pages provided to web browsers (potentially with additional information). This intermediary form can then be broken down on the client machine, using local resources, to assemble the structured objects. The library also provides for caching of the search results. This can be provided both on the local machine and on a remote database. When the results for a query exist in the caches, they can be retrieved from such location instead of querying the search engine. Documents and/or web pages can also be cached. The library can also be directed to operate only from the cache, effectively exposing a local data set instead of the remote search engine.

Description

APPLICATION PROGRAMMING INTERFACE FOR TEXT MINING AND SEARCH
CROSS-REFERENCE TO RELATED APPLICATIONS
This application claims benefit under 35 U.S.C.
~ 119(e) from U.S. Provisional Patent Application Serial No. 60/626,790 entitled, ~~APPLICATION PROGRAMMING INTERFACE
FOR TEXT MINING AND SEARCH" and filed November 11, 2004, the entirety of which is hereby incorporated by reference.
TECHNICAL FIELD
The present invention relates to a system and method that provide data to a user.
BACKGROUND
In today's information age, the location and collection of data has been simplified by various tools available to consumers. One method of such data collection can be facilitated via an interface to a network of computers (e. g., Internet, intranet, LAN, WAN, etc.), where a user can enter desired information into a search engine and retrieve a set of results that correspond to entered search elements. In addition, the user can repeat search efforts to refine and/or modify the data the user wishes to retrieve. Such additional searches can be conducted manually or automatically based on the user's desires.
There exists a number of various search engines that perform searches employing unique algorithms and/or techniques to locate and return data to a user. For example, one search engine can provide a tool that allows a user to request data utilizing a Boolean string whereas another search engine can employ a natural language interface to the user. By way of further example, the 5'1331-303 search engine can restrict its search to documents that meet predetermined criteria, whereas a second search engine can search every available resource to retrieve requested information.
Typically, the search engine acts as a service wherein the service makes a call to desired potential data sources and then receives a set of information such as text or extensible mark-up language (XML), for example. Such data results can be returned in an unorganized manner wherein the user must sort through all returned information to determine if one or more results contain the information the user wished to retrieve. In this manner, the search for information can be inefficient and/or incomplete if the user fails to locate desired information from the returned set.
Moreover, if the user is repeatedly performing searches for data, it can be inefficient for the user to continuously enter search elements into the search engine. What is needed are systems and/or methods that allow more efficient searching and locating of data desired by a user.
SUMMARY
The following presents a simplified summary of various aspects described herein in order to provide a basic understanding of such aspects. This summary is not an extensive overview of the invention. It is intended neither to identify key or critical elements of the invention nor to delineate the scope of the invention. Its sole purpose is to present some concepts of the invention in a simplified form as a prelude to the more detailed description that is presented later.
Systems and methods are described that allow programmatic access to search engine results and query logs in a structured form. The search results can be retrieved for example from the search engine in an intermediary XML
form that is similar to what is used to prepare the hypertext mark-up language (HTML) pages for web browsers.
This intermediary form can then be broken down on the client machine, using local resources, to assemble the structured objects. The intermediary form can contain more information than what would typically be contained in the HTML result pages prepared for web browsers (such as, but not limited to, debugging statistics or ranking data).
The library also provides caching of the search results. This can be provided both on the local machine and on a remote database. When the results for a query exist in the caches, they can be retrieved from such location instead of querying the search engine, for example. Documents (web pages) can also be cached. The library can also be directed to operate only from the cache, effectively exposing a local data set instead of the remote search engine. The cached data can be edited or completely constructed. Multiple caches can be supported, in that if the cache is changed over time, search results can be compared for different timeframes by switching caches.
The library can target multiple search engines utilizing the same API component. This allows applications using the API component to instantly switch between search engines without changing their code. The library handles the transformations needed to make all search interaction appear the same. Additionally, the library can fabricate web pages that appear to be result pages of a particular search engine, even if the query and results came from a different search engine or were entirely constructed.

Other embodiments of the invention provide computer readable media having computer executable instructions stored thereon for execution by one or more computers, that when executed implement a method as summarized above or as detailed below.
To the accomplishment of the foregoing and related ends, the invention, then, comprises the features hereinafter fully described. The following description and the annexed drawings set forth in detail certain illustrative aspects of the invention. However, these aspects are indicative of but a few of the various ways in which the principles of the invention can be employed.
Other aspects, advantages and novel features of the invention will become apparent from the following detailed description of the invention when considered in conjunction with the drawings.
BRIEF DESCRIPTION OF THE DRAWINGS
Fig. 1 illustrates an exemplary data retrieval system in accordance with an aspect.
Fig. 2 illustrates an exemplary data retrieval system with an extraction component and a results component in accordance with an aspect.
Fig. 3 illustrates an exemplary data retrieval system with a query log and a results cache in accordance with an aspect.
Fig. 4 illustrates a library and application program interface in accordance with an aspect.

5"1331-303 Fig. 5 illustrates an exemplary system that employs a library and an application program interface with a plurality of search engines in accordance with an aspect.
Fig. 6 illustrates a data assembly system employed with a page fabricator in accordance with an aspect.
Fig. 7 illustrates an exemplary methodology that optimizes development via utilizing results from a search engine in accordance with an aspect.
Fig. 8 illustrates an exemplary methodology that retrieves and assembles data for consumption from offline data sources in accordance with an aspect.
Fig. 9 illustrates an exemplary methodology that utilizes an API to locate and implement data in accordance with an aspect.
Fig. 10 illustrates an exemplary computing environment in accordance with various aspects.
Fig. 11 illustrates an exemplary network that can be employed in accordance with various aspects.
Appendix A describes various class libraries and application program interfaces, and this document is considered part of the subject specification.
DETAILED DESCRIPTION
The various aspects of the subject invention will now be described with reference to the drawings, wherein like reference numerals are used to refer to like elements throughout. The invention relates to systems and methods that can allow developers to utilize an application programming interface (API) component that provides access to search engine results and query logs. Search engine results can be cached and query logs can utilized so that a developer can use such API components to interface with a library of search results and query logs to be able to more easily design programs and/or websites that would leverage off of the cached search results and query logs. In this manner, an application utilizing such search results can be rendered more efficient and can limit the processing load to the search engine by utilizing a cache of results in lieu of employing the search engine repeatedly. Such caching of data can occur in multiple locations such as on a local disk, in memory or on a pre-configured cache server, for example.
Referring now to Fig. l, which illustrates a system 100 with a library 110 and an API component 120 that interfaces with a search engine 130 and a memory bank 140.
The library 110 can be employed to provide data to one or more users in a structured form via the API component 120.
Such data can be gathered from various sources, such as the search engine 130 and the memory bank 140, for example. In this manner, the structured form of the data can mitigate the need for parsing out desired data and/or creating programmatic objects in order to access such data.
The API component 120 can be employed to assemble and extract parts of information from the search engine 130 and thus, provide such information in a structured format via the library 110. The structure of the data can be configured automatically or manually based on a user's and or application's needs. Moreover, the API component 120 can utilize client resources in order to alleviate loading of the search engine 130, for example. The structure of the data can be defined via a class library (See Appendix A

5'1331-303 which is considered part of this specification). The class library can be employed to determine the structure and content of the data that is returned by the search engine and subsequently presented to the library 110. Thus, according to one approach, a web site developer can employ the API component 120 to interface with data from the search engine 130 and/or the memory bank 140 to be able to more easily design programs and/or websites that by leverage off of data supplied by either data source.
The API component 120 can interface with one or more disparate applications and/or devices (e. g., the memory bank 140) to provide data without actually instantiating the search engine 130 each time data and/or results are desired.
In this manner, requested data can be provided to the requestor more quickly than conventional methods without taxing the actual search engine. Additionally, system resources can be allocated and managed such that overloading conditions can be mitigated. Thus, when data is requested repeatedly, results can be provided more quickly than conventional methods.
The search engine 130 can be any suitable type of application capable of accepting a set of search criteria and utilizing such criteria to search for and provide one or more results that meet the desired search criteria. Search criteria can relate to one or more aspects of information desired such as data length, format, content, date of creation and so on. Additionally, the search engine 130 can employ one or more methods of accepting data elements to employ in a search such as various languages, boolean connectors, content, format and the like. One or more users can access the search engine 130 locally and/or remotely.
Such interfacing can be accomplished utilizing at least one protocol and/or standard that facilitates communication between the API component 120 and the search engine 130.
For instance, the API component 120 can be located on a processing component that employs Ethernet to communicate to a wireless Ethernet server. The wireless server in turn can communicate with the search engine 130 to request at least one search to be conducted.
The search engine 130 can conduct searches based on an event, periodically or continuously as desired. For example, the search engine 130 can employ a set of criteria to perform a search once a week for a period of six months.
In this manner, content that is added to a particular network over time can be accessed on a regular basis to insure the user is receiving current data content. By way of further example, an artificial intelligence (AI) component (not shown) can be connected to the search engine 130 to determine a best manner in which to perform a search of the data. For example, the data criteria of the user can be modified to provide an ideal set of data results.
Similarly, the AI component can be employed to determine when searches are performed based on events and/or additional information available to the search engine 130.
In one aspect of the invention, the appropriate location to provide requested search elements to the accessing component can be determined by machine learning where one or more training sets of data with examples of desired results and/or undesired results for searches can be utilized to train the system. In another aspect, initial conditions, based on one or more features that indicate desired results, can be utilized. Such initial conditions can be adjusted over time and in response to user actions associated with returned results in order to improve discrimination. For example, results utilized by the user can be employed to train the system to learn desired results for the associated query. In addition, knowledge of which results are most often requested for a particular data item can be used to configure the appropriate interface to expose only such information that a data subscriber is interested in and/or authorized to view. For example, a result that is accessed more times by the user can be deemed more useful to the user. In this manner, if a particular data consumer requests specific properties and/or methods, such data aspects can be utilized in the future.
In addition, as utilized herein, the term "inference" refers generally to the process of reasoning about or inferring states of the system, environment, and/or user from a set of observations as captured via events and/or data. Inference can be employed to identify a specific context or action, or can generate a probability distribution over states, for example. The inference can be probabilistic - that is, the computation of a probability distribution over states of interest based on a consideration of data and events. Inference can refer to techniques employed for composing higher-level events from a set of events and/or data. Such inference can result in the construction of new events or actions from a set of observed events and/or stored event data, whether or not the events are correlated in close temporal proximity, and whether the events and data come from one or several event and data sources. Various classification schemes and/or systems (e. g., support vector machines, neural networks (e. g., back-propagation, feed forward back propagation, radial bases and fuzzy logic), expert systems, Bayesian networks, and data fusion) can be employed in connection with performing '51331-303 automatic and/or inferred action in connection with the subject invention.
In yet another aspect of the invention, a technique can be employed to anticipate the search criteria employed by a user. For example, information such as historical data representing data and attributes associated with such data utilized to provide requested search elements to the accessing component can be employed to predict a preferred location to retrieve requested data within a network. For example, intelligent decisions based on statistics, probabilities, inferences and classifiers (e. g., explicitly and implicitly trained), including Bayesian learning, Bayesian classifiers and other statistical classifiers, such as decision tree learning methods, support vector machines, linear and non-linear regression and/or neural networks can be employed in accordance with an aspect of the subject invention. In this manner, the AI component (not shown) can be employed by the accessing component 110 to provide decision making based on learned actions of a particular data consumer in relation to a particular data source.
The memory bank 140 can be utilized to store parameters related to data and/or to store actual data.
Such data can be structured in the memory bank 140 as desired and further can provide for data to be organized and edited by the user. For example, data related to the search engine 130 such as queries and results be stored in the memory bank 140 and accessed as desired. Further, data from the memory bank 140 can be employed exclusively to alleviate expending resources of the search engine 130.

Fig. 2 illustrates a system 200 where a client is coupled to an API component 220 and a library 230 to access a search engine 240. An assembly component 250 and an extracting component 260 are employed with the client to facilitate consumption of data received from API component 220. The client 210 can be substantially any device, system and/or component that requires data from a disparate source.
For example, the client can be an application running on a processor wherein the application employs data to create and publish web pages to one or more users.
The extraction component 250 can be utilized to accept data from the API component 220 and/or the library 230 in an intermediary form wherein the data can be more easily manipulated and consumed by the client 210. For instance, search results from the search engine 240 can be presented to the client in an XML intermediary form that is substantially close to data employed to prepare HTML pages for web browsers. The extraction component can then parse out desired data using client resources. Once broken down, the assembly component can bring together the extracted data to create an HTML web page, for example.
Fig. 3 illustrates a system 300 wherein a search engine 310 is coupled to a query log 320 and a results cache 330. Both the query log 320 and the results cache 330 interface to a library 340 to allow data to be transferred from the search engine 310. The library 340 can communicate to the assembly component 360 via an API component 350. As discussed above, the search engine 310 can accept data objects as search terms and subsequently perform a search to retrieve data from one or more disparate sources. Such search terms can be stored in the query log 320 and can be organized, edited and retrieved at a later time. Similarly, '51331-303 data gathered by the search engine 310 can be stored in the results cache 330 and organized and structured as desired.
In this manner, the library 340 can interface to both the search engine 310 and to results from the search engine as stored in the results cache 330. The library can structure data from either source to provide to a disparate party. The API component 350 can request desired structure of data from the library to be employed by the assembly component 360. The proper source for requested data can be determined based on one or more factors such as the frequency of the requests, the content and/or type of data desired and/or the age of the data desired. In this manner, more efficient use of system resources can be managed while providing data that meets user expectations. In addition, the results cache 330 can be employed to convert stored data from one format to another format, for example. Moreover, one or internal audits can be conducted to delete redundant search results and to provide clean up of data, as desired.
In addition, the results cache 330 can assemble returned data that the user can interface and use to select desired data. For example, data stored in the results cache 330 can be employed to create a replica web page, for example. In this manner, the assembly component 360 can receive data that appears to be real time data.
Additionally, the results cache 330 can allow the assembly component 360 to retrieve real time data as desired. In this manner, the results cache 330 can be used in place of or in conjunction with the search engine 310 to retrieve desired data.
Data and/or data pointers that reside in the results cache 330 can be organized and edited in order to facilitate efficient access to the data and/or data pointers that populate the results cache 330. For example, data can be grouped according to searches conducted, data content, data format and the like. As another example, the data content can be edited to simplify consumption by a disparate device, such as the assembly component 360. Thus, utilizing the results cache 330 can provide pre-formatted data and mitigate employment of search engine resources to provide a more efficient system architecture.
The library 340 can request and receive data both from real-time sources, such as the search engine 310 and from stored locations such as the query log 320 and the results cache 330. The API can be employed to request data, content, structure and the like from the library in order to provide this information to the assembly component 360. For example, the data delivered to the assembly component 360 can be an XML form that can be parsed and reconstructed as desired. For example, the assembly component can employ both real time and stored data to create an interactive replica web page that can be employed by one or more users.
Thus, the assembly component 360 can receive data from the API 350 and reconstruct data as desired by the user.
Fig. 4 illustrates a system 400 wherein an application 410 employs an API component 420 to interface with a remote database 440 and a local processor 450 via a library 430. The remote database 440 and the local processor 450 contain a results cache 460 and 470. These caches can provide data stores for particular data types, formats, content and so on. Thus, results from a query can be retrieved from one or more results caches (e. g., 460, 470, etc.) as desired by the user. The library 430 can also be directed to operate only from the cache, effectively exposing a local data set instead of the remote search engine, for example. The cached data can be edited or completely constructed via the data editor 480. Further, multiple caches can be supported - that is, if the cache is changed over time, search results can be compared for different time frames by switching caches (e. g. from results cache 460 to results cache 470).
The data editor 480 can be employed by the library 430 to edit, organize and structure data as desired. For example, the application 410 can leverage data from one or more results caches and can structure and/or configure data to conform to requirements of the application 410. The data editor 480 can employ any number of means to communicate with the library 430. For example, the data editor can be a human machine interface that provides tools for making desired changes to data within the library 430.
The remote database 440 can be almost any platform wherein data is stored. Such data can be configured, organized, edited, etc. within the remote database 440. The remote database 440 can interface to the API component 420 via a network connection (e.g., LAN, WAN, CAN, etc.) and utilize various communication protocols and/or standards to interface to the API component 420. For example, the remote database can be located in a disparate network and can accept results after each search for data is performed.
The local processor 450 can be substantially any type of device that can accept and process data in order to achieve a result. Such processing can be done via software and/or hardware that can reside in the local environment.
Maintaining a local cache of search results can alleviate processing time employed with a disparate device such as a search engine for example. The local processor can be a computer, a programmable logic controller, software, firmware, etc. It is to be appreciated that although the processor is local to the API component 420, it can interface to the API component 420 in substantially any location utilizing any number of protocols and/or standards.
Fig. 5 shows a system 500 wherein an application component 510 utilizes an API device 520 to interface to a plurality of search engines 530-536. The API device 520 contains a library 530 that contains search engine results and/or query logs of one or more search engines 530-536.
The application component 510 can be software employed to create and assemble web pages, for example. In one approach, the application component 510 can quickly locate and employ particular data as needed by utilizing the API
device 520. The API device 520 can employ an interface to allow a user to select and configure various data elements returned from one or more search engines 530-536. In addition, the API device 520 can be employed to determine the data desired via search as well as the number and location of particular search engines associated therewith.
The search engines 530-536 can be located remotely or local to the API device 520. For example, search engine 531 can be remote to the API device 520 and accessed via the Internet. In contrast, search engine 534 can be a local application utilized on the same computer as the API device 520, for example. Various protocols can be employed to facilitate communication between the API device 520 and one or more search engines 530-536.
More than one protocol can be employed to provide communication between components within system 500 and such protocols can be employed concurrently with one another.
For example, communication with search engine 530 can utilize a wireless protocol (e. g., wireless Ethernet, infrared, etc.) while search engine 536 concurrently employs Ethernet. In this manner, the API device 520 is not restricted to a specific I/0 interface to request data searches and returns from the search engines 530-536.
Multiple search engines can be targeted utilizing the API device 520. This can allow the application component to utilize the API device 520 to seamlessly switch between the search engines 530-536 without changing their code. In addition, the API device can handle transformations needed to make substantially all search interaction appear the same. Additionally, the API device 520 can fabricate web pages that appear to be the result pages of a particular search engine 530-536, even if the query and results came from a different search engine or were entirely constructed from disparate sets of data.
The search engines 530-536 can employ any number of specific algorithms and/or routines to accept and conduct requested data searches. In addition, each search engine 530-536 can provide specific information as desired by the user. In this manner, the API device 520 can act as a library that is populated by the returns of searches performed by one or more search engines 530-536. Such returned data can be structured in that it can be accessed by the application component 510 to eliminate the need for parsing and creating programmatic objects for the returned data.
Fig. 6 illustrates a system 600 wherein an application 610 communicates with an API component 620 and a library 630. The library 630 interfaces with a query log 640 coupled to search engine 660 and results cache 650 coupled to search engine 670. Search engines 660 and 670 can conduct desired searches for particular data. The results cache 650 can be populated by documents and/or XML
forms returned from one of the search engines 660 and 670, for example. The search results can be retrieved from the search engine in an intermediary XML form similar to the data form employed to prepare HTML pages for web browsers.
The query log 640 can be coupled to the library 630 to provide storage of various data associated with one or more data searches. The query log 640 can contain one or more statements, search elements, descriptors and the like that have been employed to conduct a search for particular data. The query log 640 can employ an editing component (not shown) that can organize and partition data as desired by a user. For example, data can be sorted by session, by search, by keyword and so on.
A page fabricator 680 can be coupled to the library 630 to create replica web pages utilizing disparate data sources. For example, the page fabricator 680 can employ data to fabricate web pages that appear to be the result pages of a particular search engine, even if the query and results came from disparate search engines (e. g., search engines 660 and 670) or were entirely constructed.
By way of further example, a web page or pages can be created utilizing data from the same search engine and a query log and results cache associated therewith.
Figs. 7, 8 and 9 illustrate methodologies 700, 800 and 900 in accordance with the subject invention. For simplicity of explanation, the methodologies are depicted and described as a series of acts. It is to be understood and appreciated that the subject invention is not limited by the acts illustrated and/or by the order of acts, for example acts can occur in various orders and/or concurrently, and with other acts not presented and described herein. Furthermore, not all illustrated acts may be required to implement the methodologies in accordance with the subject invention. In addition, those skilled in the art will understand and appreciate that the methodologies could alternatively be represented as a series of interrelated states via a state diagram or events.
Fig. 7 illustrates a methodology 700 that employs at least one search engine to locate and retrieve particular data to utilize with one or more components. At 710, one or more data elements are sent to a search engine. Such data elements can consist of substantially any desired data length, format, content, packaging and so on. The one or more data elements can be conveyed to the search engine utilizing various protocols and/or standards. In addition, the search engine can employ one or more algorithms to interface with various data sources to locate the requested data. Such search engines can be located locally to the party sending the data elements (e. g., on the same computer) or remotely such as on a disparate network.
At 720, a search is performed based on the at least one data element sent by the requestor. The search conducted can be tailored to a user's needs or requirements.
For example, the search can be limited to only a subset of available resources or limited to data that conforms to one of several predetermined formats. The search can be conducted manually (e. g., user initiated) or automatically (e. g., based on event, periodically or one time). At 730, results from the search engine are stored. Such results can be parsed and organized such that data is available to a user in a more consumable form. Storing the data can be limited based on time and/or other factors to maintain only a set of data that meets a particular time limitation, for example. By way of further example, the data can be grouped such that like data is stored together and/or data that meets certain criteria is stored as a subset, as desired.
At 740, the stored data is interfaced to one or more applications. Such applications can employ the search engine results to create an interactive replica of data.
Communicating with the stored data can involve a plurality of disparate protocols, data structures, and the like in order to properly access desired data. At 750, the results from the search engine are utilized to optimize development.
In one approach, various results are stored in a particular structure (e. g., XML, HTML, etc.) to be utilized to create and/or simulate search engine activity. In this manner, a developer can employ such optimization to access and utilize data for a particular application, for example.
Fig. 8 illustrates a methodology 800 wherein stored data is assembled and utilized by at least one device. At 810, data is located via a search engine in accordance with various parameters as determined by at least one user. At 820, data (e. g., search terms, search instructions, data elements, etc.) associated with each search is stored in a query log. After such search is performed, returned results from each search are stored in a results cache. The results cache can store data returned from one or more searches, as desired. Such returns can include not only data itself, but also metadata that can describe various properties of the data. Such properties can include location of the data, format of the data, conforming standards of the data and the like.
At 840, at least one of the query log and results cache are interrogated. In this manner, desired data can be acquired without the employment of a search engine (or other real time mechanism), for example. The acquisition of such data without taxing system resources (e. g., the search engine) provides a distinct advantage over conventional methods. Such advantages include, but are not limited to efficiency of the system, access to more consumable data, pre-formatting of the data, etc. At 850, data retrieved from at least one of the query log and/or the results cache is assembled for consumption by at least one device.
Fig. 9 illustrates a methodology wherein an API is employed to locate and implement data. At 910, a search for particular data is conducted. As noted above, various aspects of data can be defined and employed to locate and retrieve desired data. At 920, the search results are placed in a returns store. Such data can be available to substantially any disparate device that can interface to the returns store. Additionally, data can include pointers to data sources such that data, which is not actually in the store, can be immediately accessed via one or more data pointers. At 930, an API is utilized to locate particular data within the returns store. Such data can be located based on various factors, as mentioned previously herein.
At 940, search engine results are structured to conform to development needs. Such data structure can include the type, format, class, content, etc. of information to be implemented in development. In this manner, data can be deconstructed and subsequently reassembled efficiently. In addition, such structured data can be sourced from a search engine, returns store and/or query log, for example. At 950, this data is implemented in one or more applications. Such data implementation can take advantage of search engine results by optimizing the utilizing of such data per the requirements of the developer and/or application with which such data is implemented.
With reference to Fig. 10, an exemplary environment 1000 for implementing various aspects of the invention includes a computer 1012 is depicted. The computer 1012 includes a processing unit 1014, a system memory 1016, and a system bus 1018. The system bus 1018 couples system components including, but not limited to, the system memory 1016 to the processing unit 1014. The processing unit 1014 can be any of various available processors. Dual microprocessors and other multiprocessor architectures also can be employed as the processing unit 1014.
The system bus 1018 can be any of several types of bus structures) including the memory bus or memory controller, a peripheral bus or external bus, and/or a local bus using any variety of available bus architectures including, but not limited to, 8-bit bus, Industrial Standard Architecture (ISA), Micro-Channel Architecture (MSA), Extended ISA (EISA), Intelligent Drive Electronics (IDE), VESA Local Bus (VLB), Peripheral Component Interconnect (PCI), Universal Serial Bus (USB), Advanced Graphics Port (AGP), Personal Computer Memory Card International Association bus (PCMCIA), and Small Computer Systems Interface (SCSI).

'51331-303 The system memory 1016 includes volatile memory 1020 and nonvolatile memory 1022. The basic input/output system (BIOS), containing the basic routines to transfer information between elements within the computer 1012, such as during start-up, is stored in nonvolatile memory 1022.
By way of illustration, and not limitation, nonvolatile memory 1022 can include read only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable ROM (EEPROM), or flash memory.
Volatile memory 1020 includes random access memory (RAM), which acts as external cache memory. By way of illustration and not limitation, RAM is available in many forms such as synchronous RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM
(SDRAM), double data rate SDRAM (DDR SDRAM), enhanced SDRAM
(ESDRAM), Synchlink DRAM (SLDRAM), and direct Rambus RAM
( DRRAM ) .
Computer 1012 also includes removable/non-removable, volatile/non-volatile computer storage media.
Fig. 10 illustrates, for example a disk storage 1024. Disk storage 1024 includes, but is not limited to, devices like a magnetic disk drive, floppy disk drive, tape drive, Jaz drive, Zip drive, LS-100 drive, flash memory card, or memory stick. In addition, disk storage 1024 can include storage media separately or in combination with other storage media including, but not limited to, an optical disk drive such as a compact disk ROM device (CD-ROM), CD recordable drive (CD-R Drive), CD rewritable drive (CD-RW Drive) or a digital versatile disk ROM drive (DVD-ROM). To facilitate connection of the disk storage devices 1024 to the system bus 1018, a removable or non-removable interface is typically used such as ,interface 1026.

It is to be appreciated that Fig. 10 describes software that acts as an intermediary between users and the basic computer resources described in suitable operating environment 1000. Such software includes an operating system 1028. Operating system 1028, which can be stored on disk storage 1024, acts to control and allocate resources of the computer system 1012. System applications 1030 take advantage of the management of resources by operating system 1028 through program modules 1032 and program data 1034 stored either in system memory 1016 or on disk storage 1024.
It is to be appreciated that the subject invention can be implemented with various operating systems or combinations of operating systems.
A user enters commands or information into the computer 1012 through input devices) 1036. Input devices 1036 include, but are not limited to, a pointing device such as a mouse, trackball, stylus, touch pad, keyboard, microphone, joystick, game pad, satellite dish, scanner, TV
tuner card, digital camera, digital video camera, web camera, and the like. These and other input devices connect to the processing unit 1014 through the system bus 1018 via interface ports) 1038. Interface ports) 1038 include, for example, a serial port, a parallel port, a game port, and a universal serial bus (USB). Output devices) 1040 use some of the same type of ports as input devices) 1036. Thus, for example, a USB port can be used to provide input to computer 1012, and to output information from computer 1012 to an output device 1040. Output adapter 1042 is provided to illustrate that there are some output devices 1040 like monitors, speakers, and printers, among other output devices 1040, which require special adapters. The output adapters 1042 include, by way of illustration and not limitation, video and sound cards that provide a means of connection between the output device 1040 and the system bus 1018. It should be noted that other devices and/or systems of devices provide both input and output capabilities such as remote computers) 1044.
Computer 1012 can operate in a networked environment using logical connections to one or more remote computers, such as remote computers) 1044. The remote computers) 1044 can be a personal computer, a server, a router, a network PC, a workstation, a microprocessor based appliance, a peer device or other common network node and the like, and typically includes many or all of the elements described relative to computer 1012. For purposes of brevity, only a memory storage device 1046 is illustrated with remote computers) 1044. Remote computers) 1044 is logically connected to computer 1012 through a network interface 1048 and then physically connected via communication connection 1050. Network interface 1048 encompasses communication networks such as local-area networks (LAN) and wide-area networks (WAN). LAN
technologies include Fiber Distributed Data Interface (FDDI), Copper Distributed Data Interface (CDDI), Ethernet/IEEE 802.3, Token Ring/IEEE 802.5 and the like.
WAN technologies include, but are not limited to, point-to-point links, circuit switching networks like Integrated Services Digital Networks (ISDN) and variations thereon, packet switching networks, and Digital Subscriber Lines (DSL) .
Communication connections) 1050 refers to the hardware/software employed to connect the network interface 1048 to the bus 1018. While communication connection 1050 is shown for illustrative clarity inside computer 1012, it can also be external to computer 1012. The hardware/software necessary for connection to the network interface 1048 includes, for exemplary purposes only, internal and external technologies such as, modems including regular telephone grade modems, cable modems and DSL modems, ISDN adapters, and Ethernet cards.
Fig. 11 illustrates an exemplary computing environment 1100 in which the subject invention can be employed. The system 1100 includes one or more clients) 1110. The clients) 1110 can be hardware and/or software (e. g., threads, processes, computing devices). The system 1100 additionally includes one or more servers) 1130.
Likewise, the servers) 1130 can be hardware and/or software (e. g., threads, processes, computing devices).
One possible communication between a client 1110 and a server 1130 can be in the form of a data packet transmitted between two or more computer processes. The system 1100 further includes a communication framework 1150 that can be employed to facilitate communications between the clients) 1110 and the servers) 1130. The clients) 1110 can interface with one or more client data stores) 1160, which can be employed to store information local to the clients) 1110. Similarly, the servers) 1130 can interface with one or more server data stores) 1140, which can be employed to store information local to the servers 1130.
Appendix A describes various class libraries and application program interfaces (APIs), and is considered part of the subject specification. It will be appreciated that while the class libraries, APIs, etc., described in Appendix A can be utilized in conjunction with various aspects set forth herein, such class libraries and/or APIs are not to be interpreted in a limiting sense or as delineating the scope of the subject invention. Rather, the libraries and APIs described in Appendix A are exemplary in nature, and the subject invention can be utilized in conjunction with these and/or any other suitable class libraries, APIs, etc.
What has been described above includes examples of the subject invention. It is, of course, not possible to describe every conceivable combination of components or methodologies for purposes of describing the subject invention, but one of ordinary skill in the art can recognize that many further combinations and permutations of the subject invention are possible. Accordingly, the subject invention is intended to embrace all such alterations, modifications and variations that fall within the spirit and scope of the appended claims. In this regard, it will also be recognized that the invention includes a system as well as a computer-readable medium having computer-executable instructions for performing the steps of the various methods of the invention. In addition, while a particular feature of the invention may have been disclosed with respect to only one of several aspects or implementations of the invention, such a feature can be combined with one or more other features of the other implementations as may be desired and advantageous for any given or particular application. Furthermore, to the extent that the terms "includes", "including", "has", "having", and variants thereof are used in either the detailed description or the claims, these terms are intended to be inclusive in a manner similar to the term "comprising" and its variants.

Appendix A
Contents 1 Namespace Microsoft.TMSN 2 1.1 lntert'arr~ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . 3 1.3 C:lacses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . 3 1.'2.1 C~~ss AnchorInfo . . . . . . . . . . . . . . . . . . . . . . . 3 1.2.2 C: LASS SearchResult . . . . . . . . . . . . . . . . . . . . . . 7 1.2.3 CLnss Tr~ISNSearch . . . . . . . . . . . . . . . . . . . . . . 16 1.?.9 CiLA$$ WordFloatF~-equencyPair . . . . . . . . . . . . . . 55 1.?.5 Ct:~ss WordF~equencyPair . . . . . . . . . . . . . . . . . 59 Chapter 1 Names-pace Microsoft.TMSN
Namespace Cotxtcnts Page Interfaces Classes A nchorInfo.................................................................3 Information about a hyperln~k and its surmunding content.
Search Result............................................,.....,............r' ~S m.atclx to n search guerre zr~ith relnted informnt:on TMSNSearch ............................................................. 16 t~arcious hits of search functionalitg.
'4VordFloat~equeiicyPair . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . .. . . . . . . . .. 55 A pair of a string axxd a floating-point caumt_ WordFrequencyPair . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . 59 A pair of a string and an integer count.

AlicrasoCd. TA~tSN- .~i nchorLifn 3 I.I rnterfaces 1.2 Classes 1.2.1 CLASS AnchorInfo information about a hyperlink and its surrounding context.
DECLARATtpN
public chss Anchorlnfo Object FIELDS
. CorttextGeft public string ContextLeft The text to the left of t.lris link ~ Conde'si.Right public string ContextRight The text to the right of this link ~ Source public string Source The location where this link occurs ~ Target public string Target The destination of this link Text public string Text The description of this link A~licrasvIt.TA~ISN- Andtorlnfo PROrFrrrtEs ~ G'oritcxtSize public int ContextSize ~ get; set;
Get or Sia the preferred nmnber of characters to search left and right of xn anchor for surrounding context.
CONSTRUCTORS
~ . ctor public AnchorInfo( ) Create an Anchorlnfo with null clest.inat.ion, description, source, and context ~ .ctor public AnchorInfo( ) Create an Anchorlrrfo with the given destination, description, source, and context - Parameters * target - The destination of tits link * text - The description of the link * source - The location where the link occurs * contextLeft - The words to the left of the link r~ contextRi:ght - The words to tha right of the link ~ .ctor public AnchorInfo( ) Create an Anchorlnfo with the given destination, description, and source - Parameters * target - The destination of the link * text - The description of the lirtk * source - The location where the link occurs ~ .ct~r public AnchorInfo( ) Create att Anchorlnfo with thr given destination and description i Adicrn..-ofL. TA~ISN- 4 uchurlnfo 5 - Parameters * target - The destination of the link text - The description of the lick . .Ctor public AnchorInfo( ) Crcate an AnchorInfo with the given destination - Parameters * target - The destination of the link ~~t~THO~s ~ CmnpareTo public int CompareTo( ) Compare two Anchorlnfo objects for ordering.
- Parameters * obj - The other AnchorJnfo ~ Equals public boot EquaIsC ) Compare two Anchorlnfos for equalit~~. Context is not considered in the comparison.
- Parameters * obj - The other Anchorlnfo ~ Finnl'~e protected void Finalize( Allows an to attempt to free resources and perform other cleanup operations before the is reclaimed by garbage collection.
. Gettlash.Code public int GetHashCode( ) Returns a hash code based orjl5 on the Source, Target., and Text Alicr~~oft.Tb~ISN- .-lnchorlrrfu 6 ~ C:etType public System.Type GetType( ) Get.: the of the current instance.
~ Alem6e'rmiseClone protected object h~IemberwiseClone( ) Creates a shallow copy of the current .
To5'trFn~
public string TuString( ) Returns a tlr~t rerne,ents the current .
E\TENC>ED INFORb3ATION
~ As:enihly: THSNSearch ll~IicrosoJ't.TAISN- SearchRes~tlt. r"
1.2.2 C-LASS SearchResult A match to a ~eurch yuery with related inform:~t.ion DECD\ kATION
puk~lic class Sesrchl~sull.
l~k~jec4 PROPERTIES
~ CacheDocumefus public bool CacheDocuments { get; set; }
Get or Set a Hag indicating whether to mempize the return valve for GetDocument. Default is true.
~ D.~buy public string Debug { get; set; }
Gets ~r sets the debug information frorn the se;v.rch.
~ Display(~rt public string DisplayUrl { get; set;
Gets or sets the display version of the URL of the matched document, as a string. This defaults to UrlString, and setting it to null will reset it to tllat.
~ EztrnText public string ExtraText { get; set; }
Gets or sets extra text to be included wlth the match description ~ E:rtrnTes&Light public string ExtraTextLight ~ get ; set ;
gets or sets Nxt.ra text to be included with the match description (with Lighter emphesis than ExtraText) A-licrusott. TdISN- SenrclrResult 8 . Fonnat public Microsoft.TI~ISN.DocumentFormat Fortnat ~ get; set; }
Gets or sets the type of the document . ForrncttSlring public string ForrnatString ; get; set;
Gets or sets the name of the type of the document . Quern public string Query { get; set; }
Gets or sets tire query that generated this result . Rank public int Rank ~ get; set; }
Gets or sets the rank of the document match relative to the query ~ Summary public string Summary ~ get; set; }
Gets or sets the summary of the document relative to the match . T:tie public string Title t get; set;
Gets or sets the title of the matched document ~ Url public Systenr.Uri Url { get; set; }
Gets or sets the URL of the matched document ~ UrlStrarrg public string UrlString ; get; set; }
Gets or sets the URL of the matched document, as a string A~Iicro~oft. TIV1S~V- Scr~rvhR~sult J
COIVSTftiJC'FfIRS
~ .rlor public SearchResult( ) Create ~ new SearchResult with blank fields ~ .ctor public SearchResult( ) Create a new Srlrchltesult with the provided details - Parameters * url - The IJRL of the matched document * title - The title of the matched document * summary - The summary of the document relative to the match * rank - The rank of the document match relative to the query ~ .ctor public SearchResult( ) Create a new SNarchResult with the provided details - Parameters * query - The cluery~ that generated this result * url - The URL of the matched document * title - The title of the matched docuuient * summary - The summary of the docwnent relative to the match * rank - The rank of the document match relative to the query ~ .cloy public Search Result( Create a new SearchResult with the provided details - Parameters * url - The URL of the rttat.ched di>cument * title - The title cEf the matched document * summary - The summary of the document relative to the match * rank - The rank of the document match relative to the query AlicrilsoIt.TRISN- SearclzResuJt l~
. . ctvr public SearchResult( ) Create a new SearchResnlt with the provided details - Parameters * query - The query that generated this result * url - The URL of the matched document * title - The title of the matched document ~ summary - The sttmmary of the document relative to the match * rank - The rank of the document matcls relative to the query ~ . ~t~,~
public SearchResult( ) Create a new ScarchResnlt with the provided details - Parameters * url - The URL of the matched document * title - The title of the matched document * summary - The sununary of the document relative to the match * rank - The rank of the document match relative to the query * format - The type of the document . . ctor public SearchResult( ) C:reat.e a new SearchResnlt with the provided details - Parameters * query - The qnery~ thnt generated this result * url - The UI~.L of the matched document.
w title - The title of the rnatched document * summary - The summar~~ of the docurnent relative to the match * rank - The rack of the document match relative to the query * format - The type of tl~e document . . ctor public SearchResult( ) Create a new SearchResult with the provided details - Paratneters * url - The UR.L of the matched docurnent A~Iicrosaft.TA~ISN- ScarchResult 11 * title - Tlm title of the matched document summary - The summary of the document relative to Lhe match * rank - The rank of the document snatch relative to the query * format - The l.~~pe of the document.
~ .sloe public SearchResult ( ) C'.res~ta a r1r_tv Se:rrchltesult with the provided det.a,ils - Parameters * query - The query that generated this result * url - The URL of the matched document * title - The title of the matched document * summary - The summary of the document relative to the match * rank - The rant: of the document match relative t.o the query' * format - The type of the document ~ .sloe public SearchResult( ) Create a new Searchftasult with the provided details - Parameters * url - The URL of the matched document.
r: title - The title of the matched document * summary - The summary of the document relative to the match * rank - The rank of the document match relative to the query * format - Tlu: type of the document ~ . ctor public SearchResutt( ) Create a new ScarchResult with the provided details - Parameters * query - The query that generated this result.
* url - The UIiL of the matched document * title - The title of the matched document.
* summary - The summary of the document r~:lative to the match * rank - Tlre rank of t.hc document match relative t.o the query :,. format - Tlie type of the document.
~ .clor-Alicrosoft.TAdSN- SevrchRe:nit 12 public SeareltResult( ) Crcate a new SsarchR.esult with the provided detreils - Parameters ~: url - The URL e~f the tnatchcd doctitnent * title - The title of the tnatcited document * summary - The summary of the document relative to the match * rank - The rank of the document snatch relative to the query * format - The type of the document . .ctor public SearchResult( ) Creat.o a new SesrchResult with the provided details - Parameters * query - The query that generated this result * url - The URL of the matched document * title - The title of the matched document * summary - The summary of the document relative to the match ~ rank - The rank of the document match relative to the query * format - The type of the docutnent . .ctor public SearchResult( ) Create a new SearchResult with the provided details - Parameters * url - The URL of the matched document * title - The title of the matched document * summary - The summary of the document relative to the match * rank - The rank of the document match relative to the query * format - The type of the document * debug - The debug infortnation for this result . . ct or public SearchResult( ) Create a new SearchResult with the prow ided details - Paratneters * query - The query that generated this result * url - The URL of the snatched document A~icn~solt.Tn~lSN- Scan;hRPCttlt 13 * title - The title of bite ntatche<i document * summary - The suntntary of the document relative to t.lte match * rank - The rank of the document match relative to the query w format - The type of t.lie document * debug - The debug information for this result ~ .star public SearchResult( ) Create a new SearchResult with tire provided dcl~~ils - Parameters * url - The URL of the matched document * title - The title of the matched ducuntent * summary - The sutnmary of the document relative to the match * rank - The rank of the document match relative to the query * f ormat - The type of the document * debug - The debug information for this result ~ .ctor public SearchResult( ) Create a new SearchResult with the provided details - Parameters * query - The query that generated this result * url - The URL of the matched docutnettt * title - The title of the matched document * summary - The summary of the document relative to the match * rank - The rank of the document snatch relative to the query * format - The type of the document * debug - The debug information for this result ~ .ctor public SearchResult( ) Create a copy of the provided SearchResult instance -- Parameters ». orig - The SearchResult to copy ~ .ctor public SearchResult ( ) Create a copy of the provideql SearchResult instance with the specified query hlicrosi~ft.TR~TSN- Sc~rcLRcsult 14 - Parameters + query - The query that generated this result * orig - The SearchResulc to copy h'lETftoDS
~ Equal:
public bool Equals( ) Compare two $earchRc~sults fir equality. Drily the Url is a~nsidered in the con ~ parison.
- Parameters * obj - The other SearchResult ~ Finalize protected void Finalize( ) Allows an Lo attempt t.o freh resources and perform other cleanup i~pcrations before the is reclaimed by garbage collection.
~ CetDvc,nnent public string GetDocument( ) Retrieve from the network the document. at. L~rl ~ CetDocu,nent public string GetDocurnent( ) Retrieve from the network the document. at. LTrI
- Parameters * cacheDnly - If tree, only return the document if it is cached ~ CetDvcrunerrt public string GetDocument ( ) Retrieve from the uetwc~rk the document at Url - Parameters ~I~Jicrosoft.TA~ISN- Se.~rchl~csulL 15 timeout - h~lillisecofuis t.o wnit fur a response ~ CctDocianentStrcarrc public System.IO.Stream GetDocumentStream( ) Retrieve from thwet.work a strr.am from the Url. This response is never cached.
~ CetUocurnenlStrca~n public System.IO.Stream GetDocumentStrea~n( ) Retrieve from the netH~ork a stream from the Url. This response is never cached.
- Parameters ~ timeout - A~filliseconds to wait fur a response ~ CetHashGat~:
public int GetHashCode( ) Returns a lmsh code based only on the Url ~ Gef7l~ye public Syste~n.Type GetType( ) Gets the of the current instance.
. AletnbenuiseClor:e protected object MemberwiseClone( ) Creates a shallo.v copy of the current .
. ToStrirs9 public string ToString( ) Returns a that represents the current .
E\TENC1GU INFORk1AT10N
~ Assr:nrblv: TMSNSearch Alicrc~cr_~ft.TVISN- TAISNSearch l6 1.2.3 Chess TniSNSearch V;~rii~os Fits ~~f senrch funcaiim;rlitv.
D>;~_ L.w~noN
f>ul~lic cl;rss TA~1SNS~:w;:h Object FIELDS
~ daGabascCortnccfionSEri9tg familyorassembly string databaseConnectionString The connect.ir.~n string for this instance ~ databascComeecfiotrStringClobal familyorassembly string databaseConnectionStringGlobal The basis cannertit~n st.ritog ~ rlatabuse~Scr:~er familyorassembly string databaseServer The default database server ~ dutalN>seTiraeorrl4alue familyorassembly int databaseTimeoutValue The timeout for the database connections ~ Dejautt public h4icrosoft.TMSN.TD~ISNSearch Default A default instance of the TA~ISNSewch class. This is not. t.hreadsafe.
~ 7~'~Je211'>'tttesj~rlrr;
familyorassembly System.Text.RegularExpressions.Regex regex~Vhitespace One or more whitespace chxrrzcters Raicrosolt.T111SN- TAfSNSearch 17 PROPERTIES
~ ~3uloDelet~Temporarv~Fites public boot AutoDeleteTemporaryFiles ; get; set; }
Get or Set whether tc. delete any temporary files when disposed ~ CacheSearchRcsulis public bool CacheSearchResults ~ get; set; }
Get or Set whether to memoize (cache) the return values for any calls to 1~9SN Search. This will return comistent results. IC is only in memory, unless FersistSearchResultCache is also true.
~ CacheSear~chResulIsG'ach~Onfy public boot CacheSearchResultsCachet?nly { get; set; }
Get or Set whether to allow network fetches from R~1SN Search. if true, only results in the cache will be used.
~ CacheSear,chResultsLimRl public int CacheSearchR,esultsLimit { get; set; }
Get or Set the maximum number of queries to cache. If non-positive, caching is unlimited. Results are discarded in least-recently-used order.
~ CacheSear~chResvltsReadOnly public bool CacheSearchResultsReadOnly { get; set; }
Get or Set whether to allow new entries to be inserted into the cache. If true, the cache will be use~j if possible, but it will not be expanded.
~ G'acheSearchResallfsScrc~er public boot CacheSearchResultsServer { get; set; }
Get or Set wheth~:r to use a database server to caclze the return values for any calls to R~ISN Search. This will return consistent results.
~ CaeheSea~r,chResultsServerCache public string CacheSearchResultsServerCache { get; set; ) AlicrnsuIt.TAISN- TlilS~liSc,~r~h 1S
Get c~r Set. the name of t.l~e cache on the server to nsc t.o cache the return values for any calls to A~ISN ~<srch. This wilt h<<ee no effect unless C.:rcheSearchResnlt.Sencr is tree.
~ Cache.SearchRecultsSerUr.rNarne public string CacheSearchResultsServerName { get; set;
Get or Set the name ..f the server to use to cache the mturn values for any calls to l\1SN Search. This will have no effect unless CacheSearchResult.Server is true.
~ GacheSearchresvltsServerPostllltnimumResults public int CacheSearchResultsServerPostMinimumResults { get;
set;
Get. or Set tile minimum number of results nenied to he allowed G~ st~~re the set in the server cache.
~ Check.9llLzrtks public bool CheckAllLinks { get; set; ) Get or Set whether to follow all URLs to check for redirects - this can he very slow!
~ DatabaseTimeout public int DatabaseTimeout { get; set; }
Get or Set the timeout used for database connections. The value indicates the number of seconds to wait Cor the server to rr_~spr~nd. Sel.t.ing to a non-positive number will be ignored.
v DebuglnJo public bool DebugInfo { get; set;
Get or Set whether to retrieve debug and other information from the search provider, when available, and store it in the Debug property c>f each SearchResult.
~ DornainFilter public string DomainFilter { get; set; }

A~Iicrn~auft.. Tn~ISIV- TA1S~~'S~.lrcl~ 1 rJ
Get or Set the filter used for limit.iug tlse domain of results returned for searches. The defmult is to allow all domains. Note that caching is spcx;ific to cacti setting of this propcrt,y.
~ FulluwR~.>d~rcctTimeout public int FoIlowRedirectTimeout { get; set;
Get or Set the timcout used for following redirects (commonly occurring in search results dtie to ad tracking). The Vallle illdiCateS the number of milliseconds to wait for each server to responil. Setting to a non-positive number will disable following redirects.
~ FormatFilter public A~Iicrosoft.TMSN.DocumentFortnat FormatFilter { get;
set; }
Get or Set the filter med for limiting the types of documents returned for searches. The default is to allow all document forrnats. Note that ~ ;aching is specific to each setting of this propert,y~.
~ ~~;zijyStrong public bool FuzzifyStrong { get; set; }
Get or Set whether to search for distant variants on URLs when using fuzzy szlrch.
~ F~t~yUrlAfatches public boot FuzzyUrlMatches { get; set; }
Get or Set whether to search fuzzy ntatch~ to provided URLs when using "Loggc~i...ForUrl" methods (no effect on other methods). If true, look for variations on the given URL, including path-based backoff.
~ ParatlelLargeRequests public boot ParallelLargeRequests t get; set; }
Get or Set whether to use a parallel fetch to retrieve large result sets. In general, leave this true for single-threaded applications.
~ PersistSearcilResultCache public bool PersistSearchResultCache { get; set; }

~~licrnsoIL.TAlSN- TA~fSNScarclt '?0 Get. or Set whNtlter to persist the cached rva.urn values for any calls to Search. This will r~t.urn false on Get and have nir effect ott Set if C'.acheAISNResult.sGlohaI is false. The cache will be perstst.ed in the file naute,i by Persi:LbISNR~_snlLCaeltcFiI~N,rnte, or by the TAISN_C:AC'.HE
environment variable if nut specified.
~ 1'ersistSea~thResuhG'raclrcFrleNarne.
public string PersistSearchResultCacheFileNarne { get; set;
Get. ..r Set the location where to persist the cached return values for any calls to D~ISN Search. This will return null en Get and have no effect on Set if GacheSearchResults ~~r Persist.SearchResultCac:he is false. This will default to the file nanred by the T)\ISN_C'AC'HE environment. variable. If that. is alsr_r n irt spemfierl, it rlefaults t.o tntsncache.bin in the application directory.
~ RankL~i9rtrt public int. RankLintit { get; set; ) C:et or Set the largest rank that will be considered when fetching complex results from the logs. Setting this to a non-positive va.iue (the default) will consider ali ranks.
~ ReqvestBtrn<lleSizc public int ReyuestBundleSize { get; set; ) Get or Set t.lte maximum number of results to retriem: at once when composing a result set. It is best to leave this at the defiult.
~ Relrie~ueTirrreout public int RetrieveTirneout { get; set; ) Get or Set the t.imeout used for ret.rieveing dOCtlttiCIttS IIl the method LinkAnchorlnfos. The value indicates t.hP number of milliseconds to wait. for a server t.o respond. Setting to a non-positive number will wail indefinitely, the default.
~ SuppresshatabaseExceplians public boot SuppressDatabaseExceptions ( get; set; ) Get. or Set whether to silently ignore exceptions Lltat are raised when database cannect.ian prokrlems occur. Defaults t.o false, which means the callar moat by ready for exceptions to be thrown.

AlicrosoR..TR1SN- TAISNSeanh 21 ~ TeztTukcni:er public Microsoft.TMSN.TMSNSearch.TextTokenizer~nction TextTokenizer ~ get; set; ) Gets or Sets the tokenizer used when generating l~~ord~'rcqueney lists;
defaults to TexlTokensFiltered.
CONSTRLTCTORS
~ . ctor public TIVISNSearch( ) Construct a TA~ISNSearch object with the default search provider ~ .clor public TMSNSearch( ) Construct a TR~ISNSenrch oF~ject with the specified search provider - Parameters ~. provider - The search provider to use n~IETrtoos ~ G'acheSearchResultSer~rClear public void CacheSearchResultServerClear( ) Clear the dataU~se server cache of ASSN Search results, if it exists.
~ GacheSearchRestetlSen~erCreate public void CacheSearchResultServerCreate( ) Create the database saver cache of nISN Search results, based on current CacheSearchftesultsServerNatne and CacheSearchResultsServerCache.
~ ClearSecrrehResultCache public void CIearSearchResultCache( ) Clear the cache of A1SN Search re..nlts, if it exists. Will also destroy any persisted cache data.

A-Iicrosoft.Tl4lSN- TA~fSNSc:rrch ~ Uedup public Systeru.String(J Dedup( ) Remove the Juplicat,e entries from the list.
- Parameters * orig - The list with potential duplicates ~ Dedrcp public System.String(J Dedup( ) Remove the duplicate entries from the list. If removeEmptyStrings is true, also remove empty strings.
- Parameters * orig - The list with potential duplicates * removeF.mptyStrings - If true, remove empty strings . Dedup public System.Uri(J Dedup( ) Remove the duplicate entries from the list.
- Parameters * orig - The list with potential duplicates ~ Dedup public Microsoft.TMSN.SearchResult(J Dedup( ) Remove the duplicate entries from the list.
- Parameters * orig - The list with potential duplicates ~ Dedup public Microsoft.Th~ISN.AnchorInfo(J Dedup( ) Remove the duplicate entries from the list.
- Parameters * orig - The list witlr potential duplicates A~Iicro~oft.TD-tSN- TII~IS~;Se.;rch ~ Dedup public Systern.Array Dedup( ) Remove the duplicate entries from tire list.
- Parameters * orig - Tlre list with potential duplicates ~ Dedap public System.Collections.ArrayList Dedup( ) Remove the duplicate entries from the list.
- Pararrreters * orig - The list with potential duplicates ~ Dedup public System.Collections.ArrayList Dedup( ) Remove the duplicate entries from the list. if removeEmptyStrings is true, also remove ernpty strings.
- Parameters * orig - The list with potential duplicates s removeEmptyStrings - If trur., remove empty strings ~ DelcteTempomryFiles public void DeleteTemporaryFiles( ) Delete any temporary files that have been created ~ Equals public bool Equals( ) Determines whether the specified is equal to the current .
- Parameters obj -~ Fef chSqlResuhs familyorassembly Systern.String(~ FetchSqIResults( ) A~licrnsnf6.T~11SN- TAISNScarch 24 - Parameters * sqlQuery-~ Fet~:hSqlResults familyorassembly Systerrr.String~J FetchSqlResults( ) - Parameters ~: cmd ~ FetchSqlRes ultslnt familyorassembly System.Int32~) FetchSqIResultslnt( ) - Parameters :~ sqlQuery -~ FetchS'qlResultshit familyorassembly Systetn.1nt32(J FetchSqIResultsInt( ) - Parameters * cmd ~ FetcItSqlResullslniBatch familyorassembly Systetn.Int33(J FetchSqlResultsInt$atch( ) - Parameters * sqlQuery-~ FetclrSqlResultslntBatch familyorassembly System.Int32(J FetchSqlResultslntBatch( ) - Parameters * cmd -~ FetchSqIRestrltchetSin_qle familyorassembly int FetchSqIResultsIntSingle( ) ilfic'rc~s~nft.T~I~ISN- TAISl~'Scarch - Parameters sqlQuery-. FctchSqtReswllslntSingle familyorassembly irrt FetchSqlResultsIntSingle( ) - Parameters ». cmd . FeichSqlResultsSingle familyorassembly string FetchSqIResultsSingle( ) - Parameters sqlQuery_ ~ FetchSqlResultsSingle familyorassembly string FetchSqlResultsSingle( ) - Parameters * cmd ~ Fet~:hSqlResultsSdrir~glnl familyorassembly Microsoft.TMSN.~VordFl~equencyPair~) FetchSqlResultsStringInt ( ) - Parameters * sqlQuery-. FelchSqlResull sSbzngln!
familyorassembly Microsoft.TMSN.Word~equencyPair() FetchSqIResults$tringInt( ) - Parameters cmd -Alicroso(i..TA~ISN- TRISNSe.~.rcii . Fi~rnli~e protected void Finalize( ) Allows an to attempt to tree resources and perform other cleanup operaticms before the is rcclairncd by garbage collection. ' . C:etl~ashCodc public int GetHashCode( ) Serves :rs a hash function for a particular type, suitable for use in lwshing algorithms arni data structures like a hash table.
. Cet7~t~~e public System.Type GetType( ) Gets the of the current instance.
. HashSet public Systern.String~~ HashSet( ) Get the pu.Ssible hashcode .~alur~ for this URL or enuivalents. A url value that is already a hash code is p.3ssed through unchanged.
- Parameters * url - The URL to look for hashcodes from . 1/tmlDecodc public string HtmlDecode( ) Converts a string that has been HT1LIL-encoded for HTTP transmission into a decoded string. Unlike HttpUtility.HtmlDecode, does not break on odd or hroken encodings.
- Parameters * s - The string to decode . II tnrlEstrnctLinks public IVicrosoft.Th~ISN.AnchorInfo~~ HtmlExtractLinks( ) Extract just the hyperlinks in an HTML document described by a Searchli.esult. as Anchorlnfos.

A~licrosoft.TAISN- TtI~fSNSearch ?i - Parameters * source - The SearchResnlt. to extract the links Pram ~ HtmlExtractLinks public Microsoft.TMSN.AnchorInfoi~ HtmlExtractl,inks( ) Extract just the hy~perlinks in an HTI1~1L dacument described by a SearchResult, as Anchorlnfos.
- Parameters * source - The SearchResnlt to extract the links from * timeout - 1~-Iilliseconds to wait. for a respi»~se ~ HtmlExtractLinICs public Microsoft.TMSN.AnchorInfo~) HtmlExtractLinks( ) Extract just the hyperIinks in an HTM1L docnmrnt, as AnchorInfos.
- Parameters * sourceUrl - The lacation to use as the saurce of the HTA~IL
* html - The IiTh~lL document, as a string ~ IIlmlEztraclLfnks public r~Iicrosoft.TA~SN.Anchorlnfo~~ HtmlExtractLinks( ) Extract just the hyperlinks in an HTA~L document, as Anchorlnfos.
- Parameters * sourceUrl - The lacatian to use as the source of the HTh~IL
* html - The HTA~IL dacument, as a string ~ HhnlExtract Texl public string HtmlExtractText( ) Extr.~.ct just the text from an HTNiL document. Special formatting may muddle the result.
- Parameters * html - The original HTh9L document, as a string 1l~licrasofl..TII~ISN- TA~ISNSearcb 28 . IItmlE:ctrcrct.TextTnkens public System.String(J HtmIExtractTextTokens( ) Extract Lhe tokens of the text from an HTD~1L document. Special f~>rrnat.ting rnay nnrddle the result.
- Parameters * html - The original HTA~1L docurnent, as a string . IltnttE:ctructTeitTo!<errsFilter~d public System.String(J HtmIE~tractTextTokensFiltered( ) Extract the tokens of the text from an HTA9L document. Special forntaLting may nnrddle the result. Skip tokens under 3 characters, tokens not starting ~,~ith ~ letter, and tokens that are stopwords. Tokens are also lotvi:rcased.
- Parameters * html - The original HTA9L document, as a string . IItnrITo t-twrrlF'r-equcncrtPairs public Microsoft.TMSN.WordF~~equencyPair(J
HtmIToWordFrequencyPairs( ) Convert HTi~~iL to a sorted list of word, frec7uency pairs.
- Parameters * html - The original HTA~1L body . GinkAnchorlrtfos public Microsoft.TMSN.AnchorInfo~J LinkAnchorInfos( ) Return the top results linking Lo the given URL, with anchor infurmat.ion.
- Parameters * linkedUrl - The URL that must he linked to * maxResults - The ma-~imum number of restrlLs Lo return . LirtkResults public Microsoft.TMSN.SearchIi.esult(J LinkResults( ) Return the top results linking to the given URL.

.51331-303 L~licrr.~solt. TA~ISN- ThISNSearclt 2'J
- Parameters ~ linkedUrl - The UItL that must L~e linked to * maxResults - Tlre nnLxinnnn nunrher of results to return . Loa~f.SerirchResteltCnchc public void LoadSearchResultCache( ) Load the cache of A~ISN Search results, if it exists, from the file spE:cificd by Persist.AlSNResuItCacln:FileName. This will be automatically called when needed, but it my~ he used to prepare the cache in advance.
~ LoggedComrnonQueriesForUrls public System.String(J LoggedCommonQueriesForUrls( ) Return the queries that returned every URL or URL hash in a given set.
based on the logs.
- Parameters * urls - The URLs to look for * resultLimit - A limit to the number of the results to return -although they are not. selected from any meaningful order LogqedConnnonQuer'iesForUrls public System.String() LoggedCornmonQueriesForUrls( ) Return the queries that returnwl every URL or UR,L hash in a given set, based on the logs.
- Parameters * urls - The URLs to look for ~ LoggedCommon.QueriesFor(lrls public System.String~~ LoggedCommonQueriesForUrls( ) Return the queries that returned every URL or URL hash in a given set., based on the logs.
-- Parameters * urls - The URLs to look for * resultLimit - A limit to the member of the results to return -although they are not selected from any meaningful order Alicro~r~ft..TA~ISN- T11-LSNSearch ~ Lo~~r~ed(_:rnumoftQueriesForl_lrlc public Systern.String(J LoggedConnnonQueriesForUrls( ) Return the ctueries that. returned every L1RL ire URL hash in a given sect., LraserJ an the logs.
- Parameters :~ urls - The URLs to look fi>r ~ LuggeriC.'orrrrno>z ClrlllashesFor~Quer-ies public System.String(~ LoggedCommonUrlHashesForQueries( ) Return the URLs returned fear a set. of dneries, 1»,sed on the lugs - Parameters * queries - Tin: queries t.o look for * resultLimit - A limit to the number of the results to return -althongh they are not selectW from any meaningful order ~ LoggerfCmnmon.UrtHashesForQueries public Systern.String(~ LoggedCommonUrlHashesForQueries( ) ri.eturn the LIRLs returned far all queries in a si..t., tensed on the lugs - Parameters ~~ queries - The queries to look for ~ LoggedEzlerrsionsForQuery public l~~Iicrosoft.TMSN.WordF~-equencyPair(~
LoggedExtensionsForQuery ( ) Find the <tist.irbution of queries starting or ending with the given string in t.lre CLr~gs.
- Parameters * queryStart - The query fragement t.r~ look fur * resultLimit - r\ limit to the rnnnber of the results to return ~ GoyyedExterasio~r: ForQuerr~
public Microsoft.TR~ISN.WordFrequencyPair(~
LoggedExtensionsForC~uery( ) Find the dist.irlml.ion of dueries stnrt.ing with t.lie git~cn string in the CLogs.

Alicro:c~ft..TAiSN- TA1SlVSearch 31 - Parameters * query - Tile query fragentent. t..; look fur ~ LoyycdExlerrsiansFr~rQuerr~Cnzlr~t public int LoggedExtensionsForQueryCount( ) Find the nnrnber of queries starting with the given string in the CLogs.
- Pararneters * queryStart - The query fragement t.o look for ~ Loyye<IFreqtrencyForQuc~y public System.1nt32(~ LoggedF'requencyForQuery( ) Find the cumber of times each ctuery in a set occurred in the CLogs.
- Parameters * queries - The queries to look for ~ LogyedFrequencyForQuery public int LoggedF~-equencyForQuery( ) Find the number of times a particular query occurred in the C'Lu~.
- Parameters * query - The query to look for ~ LogrtedFrrgvencyForQuey Scrluenre public int LoggedF~equencyForQuerySequence( Find the ntnnber of times a particular quen~ sequence occurred in the CLogs.
- Parameters * queryl - The first query t« look for * query2 - The following query t.o Iook for ~ LoggedFrequencyForQuerySequen.ve public int LoggedF~-equertcyForQuerySequence( ) Find the number i~f tlllte5 :l particnl,~r query sequence occurred in the CLogs.

~51331-303 Illicrosoft.TII~LSN- TAISNSearch - Parameters ~: queryl - The first query to look for * query2 - The following query to look for * maximumInterval - The mavirnum number of seconds between the first and second query ~ LoggedQuet-iesForUrl public System.String(J LoggedQueriesForUrl( ) Return the queries that returned a given URL or hash code, based on the logs.
- Parameters * url - The URL to look for . LoggedQueriesForClrl public System.String(J LoggedQueriesForUrl( ) Return the queries that returned a given UR.L or hash code, based on the logs.
- Parameters * url - The URL tip look fur ~ LoggedQueriesForUrl public Systern.String(J LoggedQueriesForUrl( ) Return the queries that returned a given UR.L or hash code, based on the logs.
- Parameters * url - The URL to look for * resultLimit - A limit to the nurnber of the results to return -although they are not sel~~ctrd from any meaningful order ~ LoggedQucriesForUrl public System.String(J I~oggedQueriesForUrl( ) Return t.hn queries that returned a given URL or hash code, based on the logs.
- Parameters ~51331-303 Alicrosc~It.Th~ISN- TIIISNScarcli 33 * url - The URL to look for * resultLimit - A limit to the cumber of the results to return -although they are not sel:cted front tsny meaningful order ~ LoggedQueriesForUrlDtrecl familyorassembly System.String(~ LoggedQueriesForUrlDirect( ) Return the queries that returned a given URL or hash code, based on the logs.
- Parameters * url - The URL to look for * resultLimit - A limit to the number of the results to return -althc~ugh they are not selfsaed from any meaningful order ~ LoggedQueri..PaForUr~DirectB~eighled familyorassembly Microsoft.TMSN.WordFreyuencyPair(( LoggedQueriesForUrIDirectWeighted( ) Return the queries that returned a given URL or hash code, based on the lugs. Al.~o returns the frequency with each query.
- Parameters * url - The URL to look fir * resultLimit - A limit to the number of the results to return ~ LaggedQueriesForUr~l3ForQuery public System.String(j LoggedQueriesForUrIsForQuery( ) Return the queries that returned any of the URLs returned for a query, based on the logs.
- Parameters * query - The query to look for * resultLimit - A limit t.o the number of the results to return -although they are not aelected from any meaningful order ~ LoggedQueriesForUrlsForQuery public System.String(J LoggedQueriesForUrlsForQuery( ) Return the queries that returned any of the URLs returned for a query, based on the logs.

A~ficrosoft..T11L5'N- TrIfSNSearch - Parameters * query - The query' t.o look for ~ LayyeriQuer:esForl~rlsF~w(,~ueyll'eighted public R~Iicrosoft.TA~ISN.WordF~-equencyPair(J
LoggedQueriesForUrlsForQueryWeighted( ) Return the queries that returned any of t.hc URLs returned for a query, along with a cr~unt. of hotv mane URLs are in common, based on the logs.
- Parameters * query - The query to Took for * resultLimit - A~limit t.o the number of the results to return ~ Lo!~gertQueriesForttrlsFur(~~ur:rglt~'eiyletecl public Microsoft.TR-ISN.WordF~equencyPair(~
LoggedQueriesForUrlsForQueryWeighted( ) Return the queries that returned any of the URLs returned far a query, along with a count. of how mama URLs are in conunun, based on the logs.
- Parameters x query - The query to look fur ~ Lc~ggedQueriesForUrltf~eighte~f public n~Iicrosoft.TII~ISN.WordFrequencyPair(J
LoggedQueriesForUrlWeighted ( ) Return the queries that ret.ttrned a given URL or bash code, base. on the logs. Also returns tire frednency with each query.
- Parameters * url - The URL t.o look for ~ LoqgedQuez~:esFor(h~lll'e~i~hted public A~Iicrosoft.TAISN.~i'ordFrequencyPair(~
LoggedQueriesForUrI~Veighted ( ) Return the quNries tlnat returned a given URL or hash code, I»sed on i.he logs. Also returns the frequency with each query.
- Parameters '51331-303 111icrosa~t.TAISN- T~11$NSearcfr 35 * url - The URL to look for . Lngge~ItcueriesForUrl4t'e:ghted public R~Iicrosoft.Tl~~ISN.I~l~ordF1~equencyPair[J
LoggedQueriesForUrlWeighted( ) Return the dncrics that retu~rnc~i a given URL or hash code, based on the lugs. Also returns the frequency with each query.
- Pararneters * url - Th a URL to lock fur * resultLimit - A limit Lo the number of the results to return . Logged(,?eceriesFc~rUrl4VetgJited public Microsoft.ThISN.Word~equencyPair[J
LoggedQueriesForUrIWeighted( ) Return the queries that, returned a given URL or hash code, based on the logs. Also returns the frequency with each query.
- Parameters :~ url - The URL try look for * resultLimit - A limit to the number of the results to return ~ Logged~uer~~SeyuenceFallows public T4icrosoft.Tl~~ISN,WordFcequencyPair[J
LoggedQuerySequenceFallows( ) Find the queries that followed a givfn query, with counts, from the CLogs.
- Parameters * queryl - The first query in the sequence . Logged(,ZuerySeqrcenceFolloms public Microsoft.TA~SN.WordF~equencyPair[J
LoggedQuerySequenceFollows( ) Find the queries that followed a given query, with counts, from the CLogs.
- Parameters * queryl - The first query in tire seciuence * resultLimit - A limit to the nwnber of the results to return A'Iicrosoft.TAISN- TA~f.SNSearch . Loyqc°dQueruScquenceFolloius public r~Iicrosoft.Tl1-ISN.WordFS-equencyPair~~
LoggedQuerySequenceFollows( ) Find the queries that follwved a given query, with counts, from the CLogs.
- Parameters :r queryi - The first. query in the sequence resultLimit - A limit to the number of the results to return * maximumInterval - The maximum time in sr~cunds between the two queues ~ Loyged(~rrerySegrar~nceFrcecdes public n~licrosoft.Tl~rISN.'~'VordF~equencyPair~J
LoggedQuerySequencePrecedes( ) Find the queries that preceded a given qu~:ry, with ci~unts, from the CLogs.
- Parameters * query2 - The secc>nd query in the sequence ~ Loqye,tQue.r'y.Sc'rlur_~nrePrtcerla public A~Iicrosoft.Tr-ISN.1'1'ordFlrequencyPair(~
LoggedQuerySequencePrecedes( ) Find the queries that. preceded a given query, with counts, from the CLogs.
- Parameters * query2 - The second query in the sequence *: resultLimit - A limit to the number of the results to return ~ Loggect~rcerr~ScyuerrceFrr-cedes public l4licrosoft.Tl~~ISN.WordF~equet,cyPairO
LoggedQuerySequencePrecedes( ) Find the queries that preceded a given query, with counts, from the CLogs.
- Parameters * query2 - The second query in the sequence * resultLimit - A limit to the number of the results to return * maximum Interval - The maximum time in seconds between the two citterres '51331-303 A~licro~oft..TlllSN- TlIISNSearclr 3'r ~ LvggedUrltlashesForQueriesForUrl public Systern.String(~ LoggedUrlHashesForQueriesForUr1( ) Return the UI~.Ls returned for the queries that returned a given URL or URL h.LSh, b:~.sed on the logs.
- Parameters * url - The URL to look for ~ GaggedL~r-IHashesFvrQue~sesForUrl public System.String(~ LoggedUrIHashesForQueriesForUrl( ) Return the URLs returned for the queries that returned a given URL or URL hash, based on t.hc logs.
- Parameters * url - The URL to look for ~ Lcx~~ectUrltlu.shesFvrQueriesForUrl public System.String() LoggedUrIHashesForC~ueriesForUrl( ) Return the URLs returned fc;,r the queries that returned a given URL or URL hash, based on the lugs.
- Parameters * url - The URL to look for * resultLimit - A limit to the number of the results to return -although they are nut selected from any meaningful order ~ GoggedUrltlashesForQueriesForUrt public System.String(~ LoggedUrIHashesForQueriesForUrl( ) Return the URLs returned for tire queries that returned a given URL or URL hash, based on the lugs.
- Parameters s url - The U1~L to look for * resultLimit - A limit to the number of the results to return -although they are not selected from any meaningful order '51331-303 Alicrust~ft.TAlSN- TRISNSe:uch ~ L~x~ge~tLrrIIfa;fresFr~rQuericsFor-L~rIDincl familyorassembly System.String(J
LoggedUrlHashesFurQueriesForUrIDirect( ) Return the URLs returned for the queries that returned a given URL or URL hash, based on the lugs.
- Pararneters * url - Thr.- URL to look fur * resultLimit - A limit to the nurnber of the results to return -although they are not selected from any lllelrllllgfrll order ~ Loyged(~r~IHa.~hesForQuer~
public System.String(J LoggedUrIHashesForQuery( ) Return the URLs returned fir a query, based vn the lugs - Pararneters * query - Tire query to look for * resultLimit - A limit, to the number of the results to return -although they are not selected from 1ny meaningful order ~ LoqgedllriHashesForQueuy public System-5tring(J LoggedUrlHashesForQuery( ) Return the URLs returned far a query, based vn the logs - Parameters * query - The query to look for ~ Jl9embereuiseClone protected object MemberwiseClone( ) Creates a shallow copy of the current .
~ AfSNSearrhResultPage public string MSNSearchResultPage( ) Froduce a fake h:ISN Search result page fur the given query and items. The supporting files are loaded from the IIISN Search site.
- Parameters '51331-303 Alicrmoft.TillSN- TAISNSzvrctt 39 * query - TJre quen~ t.l~e saarcli is for ~ results - Tlte set. of results t.o rliaplay . Al~SNSearrlrReszrltPage public string I~~ISNSearchResultPage( ) Prorluce a fake AISN Search result page Gir t.hr- given ~luery~ and items.
- Parameters * query - The query the search is for * results - The set. ref results to display * local - if true, the supporting images and stylesheets are expected to be in the same directory as the HT(49L; if false, the supporting files are loaded from the h~ISN Search site . A.ISNSearchResuttP.nge public string MSNSearehResultPage( ) Produce a fake A~1SN Search result page fur the given query and items. The supporting file-: are loaded from the 1~~ISN Search site.
- Parameters * query - The query the search is fur ~ results - The set of results to display * headerText - The text to include before the results * plainHeaderText - If true, the headerText is assumed to be plain text; if false, the 1 aderText 1s ass1Jr11ed to be an 1-1TA1L fragment ~ AfS'NSen~rhResultPage public string lttSNSearchResuitPage( ) Produce a fake 1~ISN Search result page for the given ~.pery and items.
- Parameters * query - The query the search is for * results - Th~~ tea. of results to display *. local - if true, the supporting image: and st,ylesheets are expected t.o be in the same directory as the HT1~IL; if false, the supporting files are loaded front the h~ISN Search site * headerText - The t.~xt to include before the results * plainHeaderText - if true, the headerText is assumerl to he plain text; if false, the hcaderText is assutned to be an HT141L fragment Alicrosoft.TA-1SN- TlIISNSenrch ~!U
~ AISNSearcIrResultPage.Latench public string 1~~ISNSearchResultPageLattnch( ) Produce ri fdke 111SN search result page for the given quNry and items and launch the page in l.he associat.nd viewer.
- Parameters * query - The query the search is for * results - The set of r~:-salts t.,;~ display ~ hiSN.SeanchResult.PageLaterrch public string R45NSearchResultPageLauneh( ) Produce a fake A~1SN Search result page for the given query and items and launch the page in thN associated viewer.
- Parameters * query - The query t.l~e search is for r~ results - The set of rESUlt.s to display * beaderText - The t.evt to include before the results * plainHeaderText - If true, the headerText. is .~.,sumed to be plain text; if false, the headerText is assumed to be an HTA~tL fragment ~ JlISN,Searc:hRes ultPageLaunch public void h~ISNSearchResuItPageLaunch( ) Produce a fake A~1SN Search result page for the given query and items and launch the page in the associated viewer.
- Parameters » f ileName - The filename to use * query - The ctuery the search is fur * results - The set of results to display ~ A~ISNSearchResultPagr.Latctich.
publzc void MSNSearchResultPageLaunch( ) Produce a fake niSN Search result page fir the given query and items and launch the page in the associated viewer.
- Parameters * fileName - The filerrante to use * query - Th~r query the search is for ll~licrosnf(.. T111SN- TA~ISNSesrclr ~ 1 w results - The seL i~f results Lo display »~ headerText - The text t.o include before the results * plainHeaderText - If trut3, the headerText. is assumed to he plain LcxL: if false, t.hc Ireacler~'ext is assumed Lo be an IiTA-1L Cragment ~ QueryResults public l~licrosoft.TI~ISN.SearchResult() QueryResults( ) Return the top results for tire given set of query terni_s, matching all of them.
- Parameters » queryTerms - The set of query terms * maxResults - The rna-xinrum nurrrb~:r of r-rsulLs t.i~ return ~ QueryRestrlts public lhlicrosoft.Th4SN.SearchResult() QueryResults( ) Return the top results for the given set of query terms, using All or Any matching.
- Parameters * queryTerms - The set of query terms * maxResults - The maximum number of results to return * anyTerms - Perform an All match if false and an Any match if true ~ QueryResuhs public ll~Iicrosoft.TRZSN.SearchResult() QueryResults( ) Return the top results for tine given query phrase. Note that this is an All match, as if typed in the user interface, not a Phrase match!
- Parameters * query - The string to query for * maxResults - The maximum nunrber of results to return ~ QueryResults public R9icrosoft.TI~ISN.SearchResult() QueryResults( ) Return the top results fur the given query.
- Pararneters * query - The set of t.errns or phrzse to query fur * maxResults - The ma.~cimum tnrnrber of results to return '51331-303 ll~Iicromft.TAISN- TA~hSNSe:rrch * matc6Type - The. type of query t.o perform ~ licdirect public string Redirect( ) Retrieve the true U13.L of the resource by following any redirects. The request will wait 30110 rnillis~:conds for each redirect to be resolved.
- Parameters * url - The original URL
~ Redirect public string Redirect( ) Retrieve the true URL of the resource by following lr~y redirects.
- Parameters * url - Tire original IjRL
* timeout - The amount of time to wait for each server, in m ill iseconds ~ Redirect public string Redirect( Retrieve the true URL of the resource by fcdluwing any redirects. The request will wait 3000 milliseconds for each redirect to be resolved.
- Parameters * url - The original URL
~ Redirect public string Redirect( ) Retrieve the true UR,L of the resource by following any redirects.
- Parameters * url - The original URL
* timeout - The amount of time to wait. for each server, in milliseconds Alicrnsoft..TAI.SN- TA-ISN.Senrch -13 ~ Renr.oveNutls public System.String() RemoveNulls( ) Return a copy of the input array with the null elements removed.
- Parameters orig - The original array ~ RerrroveNulls public System.String(~ RemoveNulls( ) Return a copy of the input array with the null elements removed. If removeEmptyStrings is true, also rernove empty strings.
- Parameters * orig - ThP original array * removeEmptyStrings - If true, remove empty strings ~ RemoveNulls public System.Uri(~ RemoveNulls( ) Return a copy of the input array with the null elements rr-.moved.
- Parameters * orig - The original array ~ RemotteNulls public Microsoft.TMSN.SearchResult(~ RemoveNulls( ) Return a copy of the input array with the null elements removed.
- Parameters * orig - The original array ~ RerrroveNulls public A~Iicrosoft.TMSN.Anctiorlnfo(~ RemoveNulls( ) Return a copy of the input array with the null elPnleIlt.s removed.
- Parameters * orig - Tlje original array 1llicrosoft.TAfSN- TDISNScarch ~ RernoucNulls public System.Array RentoveNulls( ) Return a colt. of the input array witlt the null elements retttoved.
- Parameters ~ orig - The original array.
~ RcmoveNulls public System.Coltections.ArrayList RemoveNulls( ) Return a copy of the input array with the mill elements removed.
- Parameters * orig - The original array.
~ RentoreN:ails public Systetn.Collections.ArrayList RemoveNulls( ) Return a copy of the input array with the null elements removed. If rentovcEmptyStrings is true, also remove empty strings.
- Parameters * orig - The original array * removeEmptyStrings - if true, remove empty strings ~ Result.CourrlEsti»rale public int ResultCountEstimate( ) Return an estimate of the number of results for the given set of query t~:rms, matching all of thetn. Nute that this is neither cvaet nor stable.
- Parameters * queryTerms - The set of query terms ~ ResvItG'ountEstirrtale public int ResultCountEstintate( ) Return an ea.intate of the nunther of results for the given set of duery terms, using Al) or Any matching. Note that this is neither enact nor stable.
- Parameters Alicrusutt.TAISN- TA~ISNSearch ~15 * queryTerms - The set of query teens anyTerms - Perform an All match if false and an Any match if true ~ ResuftCoun(.Estimale public int ResultCountEstimate( ) Return an estimate of the number of rwuIts for the given query phr~sv. Note that this is an All match, as if typed in the user interface, not a Phrase match! Note that this is neither exact nor stable.
- Parameters * query - The phrase to query for ~ ResultCountEst:mate public int ResultCountEstimate( ) I~.eturn an estimate of the number of results for the given query. Note that this is neither exact. nor stable.
- Parameters * query - The set of terms or phra'ae to query for * matchType - The type of query to perform ~ Re(rieve public Systern.String~~ Retrieve( ) Retrieve a set of documents corresponding to the urls elements. T>ry to detcrrnine the encoding front the response, defaulting to UTF~.
- Parameters * arts - Addrea~ses of the document to retrieve ~ Retrieve public System.Strir~g(~ Retrieve( ) Retrieve a set of docum~:nts corresponding to the arts elements. 'lly to determine tire encoding from the rr~sponse, defaulting to UTFB. Waits for the specified timeout for a rnaponse, or an unlimited time if timeout is non-positive.
- Parameters * arts - Adctressns of the docnrnent to retrieve '51331-303 lllicrnsolt.TAISN-- TnISNSearrh -its * timeout - A~fillisecc~nds t.o wait lbr each rc~ponse v ReGrr:eve public Systetn.St.ring(~ Retrieve( ) Retrieve a set. of documents corresponding to the urls eiernents. 'ICY t.o determine the encoding from the response, defaulting to UTFS.
- Parameters * urls - Addr«scs of the document to retrieve ~ Retrieve public System.String(J Retrieve( ) Retrieve a set of ducunr~nt.s corresponding to the urls elements. 'I~y to determine the t ncoding from the response, defwlt.rng tc> UTFS. 1'Vaits for the specified timeont fur a response, or ari unlin vited time if timeout is non-pc~itive.
- Parameters * urls - Addres.,es of the document to retrieve * timeout - A~lillis~onds to wait for each response ~ Retrieve public System.String(J Retrieve( Retrieve a set of documents corresponding to the urls elements. Try to determine the encoding from the response, defaulting to UTFS.
- Parameters * urls - Addresses of the document to retrieve. Each must be a Uri object. or a URL string ~ Retrieve public System.String(J Retrieve( Retrieve 3 set. of dcmuments corrr~ponding to t.hc urls elements. 'I~y t.o determine the encoding from the response, defaulting to UTFS. V~ait.s fcrr the specified tirrre,nrt for a response, or an unlimited time if timeout is non-positive.
- Parameters Rlicrcuoft.T11~1SN- T111SNScarclt * urls - Addresses of the document t.o retrieve. Each must be a Uri oh jest or ;t U 1~.L string * timeout - h~illisecunds t.o wait. for each response ~ Retrieve public string l~.etrie~~e{ ) Retrieve a document from url. Try to detertnirre the encoding from the response, defaultin g t.o I~TEw.
- Parameters * url - Addrea i>f the document t.o retrieve v Retrieve public string Retrieve( Retrieve a document from url. Try to determine the encoding from the response, defaulting to UTF8. Waits for the specified timeout far a response, or an unlimited time if timeont is non-positive.
- Paratneters * url - Address of t.h a document. to retrieve * timeout - Alillisrcunds to wait for a response ~ Ref9~ieue public string Retrieve( Retrieve a document frotu urlusing the specified encoding.
- Parameters * url - Address of t.l~e document to retrieve * encoding - The encoding of the document.
~ Relreeve public string Retrieve( Retrieve a document from url using the specified encoding. \'baits fur the specified timeout far a response, or an i.tnlitnired Limn if t.imeout is ntm-positive.
- Parameters * url - Addr~.as of the dscttntent to retrieve tllicrosolt.T~IISA~- ThISNScarch timeout - 1~'III115CCQIIfIC to wait for a response ~r~ encoding - The encoding of the iiocurnen t ~ li'etricve public string Retrieve( ) Retrieve a docunr~:nt from nrl. Try t.o ~let~:rmine the encoding from the response, defaulting to 13TF8_ - Pararneters * url - Address of tln_ document to retri~we ~ lletrieve public string Retrieve( ) Retrieve a docurueut frour nrl. Try to determine the enrnding from the resporrse, fiefaulting t.o UTF8. Waits for the specified tinreout fur a response, or an untimit.efi time if tinrecut is non-positive-- Parameters » url - Address of the document to retrieve * timeout - h~lillisecunils to wait far a response v Retrieve public string Retrieve( ) Retrieve a document from ur1 using the specified encoding. If encoding is null, try to determine the encoding from the response, defaulting to UTF3.
Waits for the specified timeout for a response, or au unlimited time if tinreout is non-positive-- Parameters * url - Address of floe fiucrrrnent to retrieve * timeout - h~iilliseconds to wait for a response encoding - TJre encoding of the docurnent ~ RetrieveS'treana public System.IO.Streanp RetrieveStream( ) Retrieve a Stream fur the given url.
- Parameters '51331-303 A~Iicrasoft.TUI.SN- TAISNS~~arch ~ url - Address of the Stream to retrieve ~ Retr~ieveStream public System.IO.Stream RetrieveStream( ) Retrieve a Stream for the given url. tVaits tar the specified timeout for a response, nr ~u~ unlimited time if t.imeout is non-positive.
- Parameters * url - Address of the Stream to retrieve * timeout - l~-liliisf~:onds to wait for a response ~ RetrieveStrearn public Systern.lO.Stream RetrieveStream( ) Retrieve a Stream for the given url.
- Parameters * url - Address of the Stream to retrieve ~ RetrieveStream public System.IO.Stream RetrieveStream( ) Retrieve a Stream f..r the given url, l~lraits for the specified timeout for a response, or an unlimited time if timeout is non-positive.
- Pararnetcrs * url - Address of the Stream to retrieve * timeout - D~lilliseconds to wait for a response ~ SaueSear~chResuItC~rcke public void SaveSearchR.esuItCache( ) Save the cache of A4SN Search results, if it e~cists, to the file specified by Persisth~lSN ResultCacheFileName.
~ SearchRe: ultcToDocu.~nent:
public Systern.String(~ SearchResultsToDocuments( ) l~~lap a set of S~:archResnlt objects to the corresponding HTML documents.
- Parameters A~licrosolL.TA~ISA'- TAISNSearrch 50 results - Tlre Se~~rchResult pbjects to map ~ ScnrchResuhsToDocuments public System.String(J SearchResultsToDocuments( ) ~~tap a set of Se~u'chResult objects to tire corresponding HTA~1L documents.
- Parameters * results - The SearchResult objects to snap * timeout - Milliseconds to wait for each response ~ SearchResulesToSuirtmaries public System.String(J SearchResultsToSumrnaries( ) A~1ap a set of SearchResult objects to the corresponding summaries.
- Parameters * zesults - The SearchResult objects to map ~ SearchResulLsTuSmnmary6l~ardFrequencyPairs public Microsoft.TMSN.WordF'requencyPair(J(J
SearchResultsToSummaryWordFr~equencyPairs( ) h~lap a set of SearchResult objects to the V'urd-Frequency pairs of tire corresponding summaries.
- Parameters * results - The SearchResult objects to nrap ~ SearchResulisToSurnnearyl~VoniFrequencyPairs,4ggnegate public Microsoft.TMSN.WordF't-equencyPair(J
SearchResultsToSummaryWordFt~equencyPairsAggregate( ) A9ap a set of SearchResult objects to the hford-Frequency pairs of the set of corresponding summaries.
- Parameters * results - The SearchResult objects to map ~ SearchResirllsTuUrls public System.Uri(J SearchResultsToUrls( ) A~fap a set of ScarchResult r.~bjects Lo the corresponding URLs.

'51331-303 D~Iivro: ofd. TA lSnr- TA ISNSvarch - Parameters * results - The SearchResnlt objects to map ~ .ScarchResultsToUrlSt~inys public System.String(~ SearchResultsToUrIStrings( ) A~!ap a set of SelrchResuft objects to the corresponding URLs.
- Parameters * results - The SearchResult objects to map ~ SearrhRcs:~ltsTo ll~ondF'requencyFairs public Microsoft.TMSN.WordF~-equencyPair(~(~
SearchResultsToWordFl~equencyPairs( ) Map a set of SearchResult objects to the VVord-Frequency pairs of the corresponding HT~~1L documents.
- Parameters * results - The Searchftesnlt objects to map ~ b'earchliesultsTvV~nrctFrequerrr_yPairs public A~licrosoft.TMSN.Word~equencyPair(~(~
SearchResultsToWordFrequencyPairs( ) hfap a set of SearchResult objects to the ~lrord-Frequency pairs of the corrc-sponding HTML docunrents.
- Parameters * results - The SearchResult obj~:cts to map * timeout - A~liilisecozids to wait for each resptmse ~ SearchResvltsTo lt~ordFrequerrcyPairsAggreyate public Microsoft.TMSN.WordF'requencyPair(J
SearchResultsToWord)E~equencyPairsAggregate( ) E~1ap a set of SearchResnlt objects to the Word-Frequency pairs of the set of corresponding HTD~1L documents.
- Parameters * results - The SearchResult obj~:cls to map '51331-303 A~lictosoft.TAISN- TlIISNSeatch ~ SenrchresultsToVt'ordFrequertcyt'airs,4ggrcgale public n~Iicrosoft.TII~ISN.WordF~equencyPair[]
SearchResuItsToWordFy-equencyPairsAggregate< ) A~iap a set of ScarcIrResult ohjects to the lVord-Freynency pairs of the set of corresponding IITA~LL documents.
- Parameters * results - The Searci~Result objects t.o map * timeout - k~tillisecoculs to wait for each response ~ S'elDatnGnseCo~mectior~SGirag familyorassembly void SetDatabaseConnectionString( ) Generate the connection string based c>n defaults and the config file ~ SelPnozy public void SetProxy( ) Set the proxy server to use for all reciuests. It is speci6eu as address:port of a proxy, empty string for no pro~cy server, or null for the IE proxy server (the default). Note that the IE proxy server will only reflect the static settings, not any dynamic settings picked up by automatic configuration! The default can also k~e specified by setting the T1~~ISNProry config key.
- Parameters * proxy - The address:port of a proxy, empty string for no proxy server, or null for the 1E proxy server.
~ SqlSlring familyorassembly string SqIString( ) Format a string for use in a SQL conrmvrd.
- Parameters * item - The string to be formatted ~ ShingTo Ur public System.Uri[) StringToUri( ) Convert a set of strings to Uris.

Alfcrosoft.TAI$N- TDISN$earc~r 53 - Parameters * strings - The original string . ~S'lrir~yTuUri public System.Uri StringToUri( ) Com~frt a siring to a Uri.
- Parameters k str - The origin:~l string ~ TerlTokens public System.String(~ TextTokens( ) Return all tokens in a document..
- Parameters * txt - The original document, r~ n string . TextTokensFiltered public System.String~ TextTokensFiltered( ) f(rturn tokens in a document. Skip tokens under 3 cht~racters, tokens not starting with a letter, and tokens that are stopwords. Tokens are also lowercasc.~i.
- Parameters ~ txt - The original document, ac a string . TeTLTnl1-o~FY~equert~:pPairs public rlicrosoft.TlI~ISN.Word)~-equencyPair~
TextToWordF~equencyPairs( ) Com~ert text. t.o a sorted list of word, fre~p.~ency pairs.
- Parameters * doe - The b~dv of text . To$triny public string ToString( ) Returns a that represents the currant .

A~licrux~f6.TA~ISA'- TAISNSearcf~ Sd . Uri Tu.String public System.String(~ UriToString( ) Convert. a set of Uris to strings.
- Parameters ~ uris - The t~riginal Uri . UriToSlriny public string UriToString( ) Convert a Uri to a string.
- Parameters * uri - The original Uri E\TENDED INFORMIATfON
. Asseml.,iy~: ThtSNSearch A~licr~,sott.TltISN- lt'ordFlostFrc~ucncyPzir ..'~5 1.2.4 CLASS WordFloatF~-equencyPair A pair of a string and v Ocmting-I~oint. count..
I~EC:I~Aftr\'t'IUN
~~ _pulalic class 1~'ordFIuatFreduencyPair i ~'Vord FrequencyPair PROt'ERTIEs ~ FloatFt~equency public double FIoatF~equency { get;
The precise count for this pair.
~ Freqz~encr~
public int Frequency { get;
The count for this pair.
~ 4Yot cf public string Word { get;
The string for this pair.
CUNSTRUC'I'ORS
~ .ctor public WordFloatF~equet~cyPair( ) Create a pair with a null word and zero count.
~ .ctor public Z'VordFloatF~equencyPair( ) Create a pair with the given string and count.
- Parameters Rlic rosoft. TAISN- It%ordFJoa t.F~equencyPair 5f * word - The string for this pair * frequency - The count for this pair ~ .clor public WordFloatF~equencyPair( ) Create a pair with the given string and a unit count.
- Pararueters * word - The string fur this pair ~ .ctor public WordFloatF~equencyPair( ) Create a pair with Word and FloatFl-equency of the given pair.
- Parameters * pair - The pair to copy A~IETHODS
~ Clone public Microsoft.T.~~1SN.WordF~equencyPair Clone( ) Creates a new object ti~at is a copy of the current instance. !t is a 14'ordFloatFrequencyPair, but it cannot be defined as such.
~ CornpareTo public int CompareTo( ) Compare to another WordFrequencyPair for ordering.
- Parameters * obj - The other WordFreciuencyPair ~ Equals public boot Equals( ) Determines whether the specified is equal to the current .

A~Iicrosoft.TA~ISN- lVonfFluatFre~luencvPair o7 - Parameters » obj -~ Finalise protected void Finalize( ) Allows an to attempt to free resources and perform other cleanup operations before the is reclaimed by garbage collection.
~ CetHashC~xte public int GetHashCode( ) Serves as a h~ish function for a particular type, suitable for use in hashing algorithms and data structures like a hash table.
~ GetTvpe public System.Type Get'l~~pe( ) Gets the of the current instance.
~ AfemberuriseG'lone protected object 1~'IemberwiseClone( ) Creates a shallow copy of the current .
~ Scale public Microsoft.TMSN.'~WordFloatFrequencyPair Scale( ) Return a new NrordFloatFrequencyPair with the Frequency scaled by the given factor.
- Parameters * scaleFactor - The factor to multiply the Frequency by ~ ToString public string ToString( ) Returns a that represents the current .

A~licrosutt.TAISN- l~l~urJFInatFreqatencvPair 5$
EXTENDED INI'ORA$ATION
~ Assembly: TMSNSearch '51331-303 Alicrosoft.TDISN- 11'ur~fFl~eq~rencyFair 59 1.2.5 Ct,a~ss Word)~equencyPair A pair of a string ,mc! :gin integer count.
DECLA RA'f 10N
public class b~'ordFrequencyPvir-Object PROPERTIES
~ Frequency public int F~eyuency ~ get;
The count for this pour.
~ f~t'ord public string Word { get ;
The string for this pair.

~ .ctor public Word~equencyPair( ) Create a pair with a null word and zero count..
~ .ctor public WordFlrequencyPair( ) Create a pair with tire given string and count..
- Parameters x word - The string Cur this pair * f requency - The count for this pair ~ 51331-303 A~licrosoIt.TAJSn~ 11'ordFrequcncyl'reir ail . .ctor public WordF~equencyPair( ) Create a pair with the given string and a unit count.
- Parameters f cord - Th a smug fur this pair . .clor public WordF~equencyPair( ) Crepe a pair with 4trorJ and Frequency of the given pair.
- Parameters t pair - The pair to copy 11~1 ETFi ODS
~ Clone public Microsoft.TMSN.WordF~equencyPair Clone( ) Creates a new object that is a copy of the current inst~~.nce.
~ Cornpcrr~eTo public int CompareTo( ) Comparc to another VYordFrequencyPair for ordering.
- Parameters * obj - The other WordFrequencyPair ~ Eqtral.R
public boot Equals( ) Determines whether the specified is equll to flue current .
- Parameters * obj Alicrvsc~ft.TlllSN- llimlFrequcncyY.zir GI
. Frrrali:4 protected void Finalize( ) Allows .~ti t.o attempt to free resources anal perform other cleanup operations before the is reclaimed by garbage collection.
~ Cettlu.chCcxte public int GetHashCode( ) Serves as a hash function for a particular type, suitable far use in hashing algorithnus and data structures like a hash table.
. C:elTynt public Systern.Type GetType( ) Gets tha of the current instance.
~ Afe~n(~ermise.Clrane protected object A~IemberwiseClone( ) Creates a shallow copy c~f the current .
~ Tv,Slrin?
public string ToString( ) Return: a that rr:presents the current. .

. As.~emblv_ TMSNSearch

Claims (21)

1. A system that provides data to a user, comprising:
a library component that stores information relating to at least one search engine result, wherein the library component can modify the structure of the at least one search engine result; and an application program interface (API) component that specifies how one or more applications interface to the library component to optimize utilization of at least one search engine result.

2. The system of claim 1, further comprising a results cache that stores at least one data object returned from a query, where the results cache can organize, edit and construct one or more data objects.

3. The system of claim 2, wherein the results cache can fabricate web pages that replicate the results from one or more data searches with or without modifications, additions, and removals.

4. The system of claim 1, further comprising a search engine that can accept a set of search elements and return a set of data objects that satisfy the accepted search elements.

5. The system of claim 4, wherein the API component can interface to more than one search engine, and can switch between search engines without changing the application code.

6. The system of claim 1, wherein the data objects are retrieved in at least one of extensible mark-up language (XML) form, hypertext mark-up language (HTML) form, binary form and plain text.

7. The system of claim 1, further comprising a query log that stores information related to at least one search query employed with the search engine.

8. The system of claim 1, wherein the library component combines at least two search engine result sets to implement with the at least one application.

9. The system of claim 1, further comprising an artificial intelligence (AI) component that determines an appropriate location and notifies the accessing component of the appropriate location to provide requested search elements.

10. The system of claim 9, wherein the AI component makes the determination based at least in part on one of a support vector machine, a neural network, a back-propagation network, a feed forward back propagation network, radial basis network, fuzzy logic network, an expert system, a Bayesian network, and a data fusion network.

11. A computer implemented method to optimize utilization of data received from at least one search engine, comprising:
storing at least two search engine results;
extracting at least one data element from the at least two search engine results;
assembling the at least two search engine results to optimize application development; and implementing the assembled search engine results in at least one application.

12. The method of claim 11, further comprising storing data employed to perform a search in a query log.

13. The method of claim 11, further comprising interrogating the one or more stored search results, the one or more search results contain at least one of a resource and a pointer to a resource.

14. The method of claim 13, wherein the pointer is a uniform resource locator.

15. The method of claim 11, further comprising utilizing an application program interface (API) to locate one or more results and retrieve one or more stored results.

16. The method of claim 11, further comprising structuring the at least two search engine results to conform to application development requirements.

17. The method of claim 11, further comprising caching at least one of query and results on at least one of a local memory, a local storage device, and a remote server.

18. The method of claim 21, further comprising switching between two or more search engines.

19. The method of claim 11, further comprising fabricating replica web pages that simulate result pages of at least one search engine.

20. A system that provides programmatic access to search results, comprising:

means for storing search results from a set of data criteria;
means for constructing the search results to utilize optimally for consumption by at least one device;
and means for providing the results in an assembled format to the at least one device.

21. A computer readable medium having computer executable instructions stored thereon for execution by one or more computers, that when executed implement a method according to any one of claims 11 to 19.