Microsoft Technology Licensing, LLC

Stefan Harrington Pharies

Erik B Christensen

Keith W Ballinger

Yann Christensen

Douglas M Purdy

Natasha Harish Jethanandani

Anders Hejlsberg

Gopala Krishna R Kakivaya

David S Ebbo

Anthony J Moore

Erik B Olson

Fabio A Yeon

Adam Wade Smith

Suzanne Maurine Cook

Stephen James Millet

Lance Olson

Kenneth David Wolf

Christopher Wellington Brumme

David Wortendyke

Michael M Magruder

Raja Krishnaswamy

David Bau

Brian LaMacchia

Henry L Sanders

Julie D Bennett

James S Miller

Sean Edwin Trowbridge

Travis Muhlestein

Jonathan C Hawkins

Krzysztof J Cwalina

Seth Mitchell Demsey

Brian M Grunkemeyer

Shawn Patrick Burke

Christopher L Anderson

Yung-Shin Lin

Loren Kohnfelder

Jeffrey M Cooperstein

Michael Steven Vernal

James H Hogg

Craig T Sinclair

Corina Eva Feuerstein

David S Mortenson

Caleb L Doise

Alan Geoffrey Boshier

Shajan Dasan

David Owen Driver

Manish S Prabhu

Radu Rares Palanca

Joseph L Roxe

Tarun Anand

John I McConnell

Ramasamy Krishnaswamy

Yan Valerie Leshinsky

Giovanni Moises Della-Libera

Nikhil Kothari

Gregory Darrell Fee

Scott David Guthrie

Mark T Anders

Stephen T Swartz

Susan M Warren

Shy Cohen

Manu Vasandani

Robert Michael Howard

Sowmy Srinivasan

Mark W Fussell

Donald F Box

Bradford H Lovering

Christopher Lovett

Michael James Coulson

Craig Andrew Critchley

Michael Marucheck

Uday Sooryakant Hegde

Elliot Lee Waingold

Tomasz Janczuk

Chia-Hsun Chen

Christopher G Kaler

Steven E Lucco

James Ernest Johnson

Tirunelveli R Vishwanath

Richard Douglas Hill

Umesh Madan

Stefan R Batres

Luca Bolognese

John David Doty

Brian Keith Pepin

Jun Fang

Vijay Gajjala

Krishnan Srinivasan

Geary L Eppley

Matthew Thomas Tavis

David Edwin Levin

Max A Feingold

Nicholas M Kramer

Richard Dievendorff

Eric Kenneth Zinda

Chad W Royal

Aaron Stern

Siddhartha Puri

Saurab Nog

Douglas A Walter

The present invention extends to using Simple Object Access Protocol ('SOAP') to exchange typed objects, such as, for example, parameters for invoking methods. A computer system accesses typed object parameters corresponding to a typed object. The typed object is annotated with one or more message contract attributes of a message contract model defining a mapping between typed object parameters and corresponding SOAP elements. The computer system utilizes the message contract attributes to map the typed object parameters into a SOAP element and inserts the SOAP element into a SOAP envelope. A receiving computer system accessing the SOAP element and utilizes the message contract attributes to map the SOAP element back into the typed object parameters.

Flexibly transferring typed application data

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

Application program interface for network software platform

The present invention provides for an automated, user friendly way of constructing and using a binding object. A developer is presented with and selects binding elements that will ultimately be used to create a runtime communication channel for transporting a message between a client and service endpoint. After receiving the user input, metadata, a channel factory and listener factory are created. The metadata describes binding elements and provides an abstract representation of a protocol stack that implements communication aspects at runtime. The channel factory is configured to use the collection of metadata at runtime to generate the runtime communication channel. Further, the listener factory is configured to accept the runtime communication channel for de-multiplexing the communication aspects in order to process the message at a service endpoint. The present invention also provides for groupings of binding elements and standardized binding objects organized based on industry need.

System and method for building and using communication binding objects

The present invention provides for a channel model capable of generating a runtime communication channel with pluggable modular channel components. These channel components implement one of a set of standard interfaces that allow processing details of communication semantics between components to be represented in a polymorphic way. A message and corresponding communication semantics are recursively passed through the channel components using the standard interface, thereby abstracting other modules and components from specific implementation details of how the communication semantics are performed. The message may then be sent to the next appropriate module for further processing, or the processing may be completed at that particular component or module. Note also that the message can also be de-multiplexed on the service side in a similar fashion as that described above.

Communication channel model

Serialization and deserialization using data contracts. The data contract specifies data types that are serialized and deserialized for data objects that are associated with the data contract. During serialization, the data contract associated with the data object is identified. Then, the data fields that correspond to those specified data field types are extracted from the data object and serialized into a serialization format. During deserialization, the serialization mechanism receives a serialized data structure having a particular serialization format. A data contract is then identified as being associated with the serialized data structure. After deserialization of the serialized data structure into abstract data, a corresponding data object is populated with data fields that correspond only with those data field types specified in the data contract. Accordingly, data abstraction is enabled while serializing and deserializing.

Data abstraction based serialization

An object instance is serialized to a serial format, such as an eXtensible Markup Language (XML) document, based on a mapping between an arbitrary annotated source code file and a schema. The arbitrary annotated source code contains at least one programming type that describes a shape of an object instance and the schema describes a format of a document having a serial format. The mapping defines a correspondence between the shape of the object instance and the format of the document having the serial format. Subsequently, an object instance is converted to the serial format by converting public properties, public fields and method parameters of the object instance to a document having the serial format based on the mapping. Once the mapping is defined, an XML document can also be converted to an object instance based on the mapping.

XML serialization and deserialization

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

A data structure includes means for representing a programming type and means for representing an attribute. The specified attribute indicates that an instance of the programming type is to be serialized with XML.

Methods, systems, and computer program products for converting an object of one type to an object of another type that allow for the runtime operation of the conversion process to be altered or customized. The conversion may occur within an extensible serialization engine that serializes, deserializes, and transforms objects of various types. The runtime operation of the serialization engine is altered by one or more extension routines that implement the desired customizations or extensions, without requiring replacement of other existing routines. Based on type information, identified for an initial object, the object is converted to an intermediate representation which permits runtime modification, including modification of object names, object types, and object data. The intermediate representation of the initial object is modified in accordance with extension routines that alter the runtime operation of the serialization engine, and the intermediate representation is converted to a final object and type.

Type bridges

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

The transfer of raw data from a source data structure to a target data structure that represent the same item. During the data transfer, if there is a given field in the target data structure that does not correspond to a field supplied by the source data structure, the transfer mechanism determines whether or not it is mandatory that the source data structure supply the field. If it is mandatory, the transfer fails. Otherwise, the transfer continues. If there is field of the source data structure that does not correspond to a field of the target data structure, the transfer mechanism determines whether or not it is mandatory that the target data structure have the field. If it is mandatory, the transfer fails. Otherwise, the corresponding data may be provided to a residual field of the target data structure dedicated for unknown data.

Mechanisms for transferring raw data from one data structure to another representing the same item

A versionable schema is both backward-compatible and forward-compatible. Such a schema is able to receive data expected by multiple versions of the schema; tolerates the absence of optional data, in accordance with other versions, and accept wildcard data in accordance with still further versions. Thus, a message or message may be validated by the versionable schema.

Type evolution

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 web services namespace pertains to an infrastructure for enabling creation of a wide variety of applications. The infrastructure provides a foundation for building message-based applications of various scale and complexity. The infrastructure or framework provides APIs for basic messaging, secure messaging, reliable messaging and transacted messaging. In some embodiments, the associated APIs are factored into a hierarchy of namespaces in a manner that balances utility, usability, extensibility and versionability.

Interface infrastructure for creating and interacting with web services

Growing community of inventors

Seattle, WA, United States of America

Stefan Harrington Pharies