Microsoft Technology Licensing, LLC

David S Ebbo

Scott David Guthrie

Mark T Anders

Stephen James Millet

Gary Steven Burd

Ted Andrew Peters

Kenneth Bruce Cooper

Erik B Olson

Adam Wade Smith

Erik B Christensen

Stefan Harrington Pharies

Anthony J Moore

Yann Christensen

Fabio A Yeon

Suzanne Maurine Cook

Jayanth V Rajan

Jonathan C Hawkins

Christopher L Anderson

Robert Michael Howard

Ting-Hao Yang

Anders Hejlsberg

Gopala Krishna R Kakivaya

Christopher Wellington Brumme

Michael M Magruder

Nikhil Kothari

Raja Krishnaswamy

David Bau

Brian LaMacchia

Lance Olson

Henry L Sanders

Julie D Bennett

Sean Edwin Trowbridge

James S Miller

Travis Muhlestein

Krzysztof J Cwalina

Seth Mitchell Demsey

Brian M Grunkemeyer

Shawn Patrick Burke

Loren Kohnfelder

Yung-Shin Lin

Jeffrey M Cooperstein

James H Hogg

Craig T Sinclair

Corina Eva Feuerstein

David S Mortenson

Shajan Dasan

Caleb L Doise

Alan Geoffrey Boshier

Radu Rares Palanca

Manish S Prabhu

John I McConnell

Tarun Anand

Joseph L Roxe

Hany E Ramadan

Jesus Ruiz-Scougall

Joe Dennis Long

Ramasamy Krishnaswamy

Daniel Takacs

Gregory Darrell Fee

Keith W Ballinger

Shanku Shivabrata Niyogi

Susan M Warren

Manu Vasandani

David Owen Driver

Mark A Boulter

Satoshi Nakajima

Srinivasa R Koppolu

Richard J Wolf

Benjamin W Slivka

Simon Calvert

Dmitry Robsman

Victor A Stone

Joseph Keith Croney

Clarence Glasse

Yan Valerie Leshinsky

Giovanni Moises Della-Libera

Luca Bolognese

Brian Keith Pepin

Jun Fang

Susan Chory

Andres Sanabria

Nicholas M Kramer

Chad W Royal

Mark W Fussell

Eilon J Lipton

Roger F Grambihler

Sreeram Nivarthi

Omri Gazitt

Michael Joseph Morton

Nithyalakshmi Sampathkumar

Andrew Cheng-min Lin

Daniel Dedu-Constantin

Neetu Rajpal

Blaine J Dockter

William A Adams

Mark P Ashton

Subhag P Oak

Samudra Sengupta

George D Fee

Qing Ye

The described systems and methods are directed at persisting data between web pages. A server receives object-related data associated with a first web page and a request for posting to a second web page from a client. The object-related data includes information about the objects in the first web page. Instances of the objects associated with the first web page are reconstructed based, at least in part, on the object-related data. The server generates rendering data of the second web page based, at least in part, on the reconstructed object instances. In this manner, the object-related data is allowed to persist from the first web page to the second web page.

Systems and methods for persisting data between web pages

A web page generator dynamically and implicitly generates localized web content. A web developer can mark the content of a page (including controls and literal content) with resource keys, and can dynamically process this request by dynamically substituting the marked content with localized content. Multiple properties of the controls within a page may be localized.

Dynamic implicit localization of web content

In a distributed computing system containing multiple entities such as servers and clients, an object passed between the entities is attached with metadata identifying the type of the object and/or types and values of properties associated with the object. Before the object is passed to an entity in the distributed computing system, the object may be serialized into a data format that the receiving entity can understand.

Preservation of type information between a client and a server

An application program interface (API) provides a set of functions for application developers who build Web applications on Microsoft Corporation's .NET&#x2122; platform.

Application program interface for network software platform

In a first exemplary media implementation, one or more processor-accessible media include a build provider that is tailored for a particular file type, the build provider adapted to generate code from files corresponding to the particular file type and to contribute the generated code to a compilation. In a second exemplary media implementation, one or more processor-accessible media include processor-executable instructions that, when executed, direct a device to perform actions including: accepting multiple files, each file of the multiple files corresponding to a respective file type and including source code; associating a build provider with each file of the multiple files in accordance with the corresponding respective file type; ascertaining the source code of each file of the multiple files via the associated build provider; and compiling the ascertained source code of each file of the multiple files into an assembly.

Software build extensibility

A method provides for output caching of a portion of a web page, and thereby allows the cached portion to be used in web pages for a predetermined period of time without the need to regenerate that portion of the web page. A server computing system receives a request for information from a client computer system. The server computing system creates, in response to the received request, a page having portions. When an output cache contains a portion of the page, the portion of the page contained in the output cache is retrieved from the output cache and when the output cache does not contain a portion of the page, the portion of the page not contained in the output cache is retrieved from another source. The contents of the page are then sent to the client computing system.

Partial page output caching

Computing system and method for allowing plurality of applications written in different programming languages to communicate and request resources or services via a common language runtime layer

An application program interface (API) provides a set of functions, including a set of base classes and types that are used in substantially all applications accessing the API, for application developers who build Web applications on Microsoft Corporation's .NET&#x2122; platform.

A virtual path provider allows a Web application to access content source that is maintained by a file system, and/or content source that is maintained separately from a file system. When the Web application receives a request for processed content from a requesting computer system, the Web application access the processed content in cache if there is a valid cache entry, or accesses the corresponding content source through a virtual path provider. If appropriate for the content source, the virtual path provider streams the content source to the Web application through a virtual path. In one implementation, the virtual path provider provides a hash value of the content source, which can be compared to a cache entry. Implementations of the present invention, therefore, allow content source from any virtual store at any location to be processed or compiled by a Web application.

Accessing Web content from any virtualized store

A concept for providing a process for parsing at least one code object comprising determining when a page associated with the at least one code object has been previously processed; parsing the page when the page is determined not to have been previously processed; and evaluating a value for a compilation attribute for the page, is described.

Non-compile pages

One or more server-side control objects provide server-side processing of postback input received from client-side user interface elements in a request from a client. Such input may include without limitation postback data and postback events generated from a web page on a client and received by a server in an HTTP request. A hierarchy of server-side control objects can cooperate to process the postback input and to generate the resulting authoring language code, such as HTML. Server-side events can also result from the server-side processing of postback input. In addition to processing postback input, server-side processing may include, without limitation, state management of server-side control objects and binding data to and from server-side database. After the processing and generating operations, the server-side control object hierarchy is terminated until a subsequent request is received from the client.

Postback input handling by server-side control objects

Web pages that share a common layout and/or functionality are associated with at least one master page and at least one endpoint page. Each master page specifies a common layout and/or functionality that are intended to be shared between the web pages. The master pages also include content place holders that identify content segments that are intended to be replaced by content that is obtained from the at least one endpoint page. When a client system requests one of the web pages, the server system merges the appropriate master page and endpoint page into a resulting page that can be rendered as the requested web page by the client system. This enables web pages sharing common features to be created automatically, in real-time, and transparently to the client system, and without having to redundantly store duplicative content for each of the web pages at the server system.

Utilizing common layout and functionality of multiple web pages

A server-side control object processes and generates a client-side user interface element for display on a web page. Multiple server-side control objects may be combined into a hierarchy of server-side control objects that cooperate to generate the resulting authoring language code, such as HTML, for display of a web page on a client. The operation of processing the client-side user interface element may include at least one of an event handling operation, a postback data handling operation, a data binding operation, and a state management operation. The state management operation relates to the state of a server-side control object.

Server-side control objects for processing client-side user interface elements

A language-neutral model is employed to represent a compile unit to facilitate transformation of a representation of the compile unit to one or more other languages or to language implementations. The model provides a plurality of elements arranged according to a hierarchy in which each of the elements represents different programmatic constructs of a compile unit represented by the model. In one aspect, a code generator interface may be employed to facilitate generation of a high-level language from the language-neutral representation. In another aspect, a code parser may be employed to generate from source code a language neutral representation according to the model. In yet another aspect, a compiler interface may be utilized to transform the language-neutral representation into a low-level language, such as an executable assembly or an intermediate language.

Language-neutral representation of software code elements

A web page rendering mechanism in which a computing system generating a web page from a web page definition. A web page class is compiled from the web page definition. The theme-specific properties are described separate from the web page definition in theme-oriented text documents that are compiled into a theme class. The web page is rendered by executing an instance of the web page class in conjunction with an instance of the theme class. The web page object may include an object for each control element to be rendered. In addition, the theme object may include an object for control elements of each control element type. When rendering a control element of a particular type, the object corresponding to that control element is executed from the web page object. In addition, the object corresponding to the control element type is executed from the theme object.

Web page rendering mechanism using external programmatic themes

Growing community of inventors

Redmond, WA, United States of America

David S Ebbo