Microsoft Technology Licensing, LLC

Michael Steven Vernal

Erik B Christensen

Kenneth David Wolf

David Wortendyke

Elliot Lee Waingold

Michael James Coulson

Stefan Harrington Pharies

Stephen T Swartz

Donald F Box

Stephen James Millet

Michael Marucheck

Shy Cohen

Douglas M Purdy

Aaron Stern

Ryan Thomas Sturgell

Yaniv Pessach

Christopher G Kaler

Raymond Edward Ozzie

Giovanni Moises Della-Libera

Jack E Ozzie

Akash Jeevan Sagar

George P Moromisato

Lance Olson

Jeffrey C Schlimmer

David Richard Reed

Craig Andrew Critchley

Uday Sooryakant Hegde

Tomasz Janczuk

Martin James Gudgin

Muthukaruppan Annamalai

Eric Kenneth Zinda

Natasha Harish Jethanandani

Stefan H Pharies

Siddhartha Puri

Anastasios Kasiolas

Richard Yiu-Sai Chung

Vladimir Dmitri Fedorov

Michael Thomas Dice

Mauro Ottaviani

Alfred M Lee, Iv

Luis Felipe Cabrera

Bradford H Lovering

James Ernest Johnson

Tirunelveli R Vishwanath

David E Langworthy

Richard Douglas Hill

Umesh Madan

Stefan R Batres

John Raymond Justice

John David Doty

Vijay Gajjala

Krishnan Srinivasan

Geary L Eppley

Matthew Thomas Tavis

David Edwin Levin

Max A Feingold

Richard Dievendorff

David Owen Driver

Saurab Nog

Douglas A Walter

Gopal Kakivaya

Jesus Ruiz-Scougall

Kapil Gupta

Vipul A Modi

Mohammad Makarechian

Evgeny Osovetsky

Alexander Martin DeJarnatt

Sowmyanarayanan K Srinivasan

Scott Christopher Seely

Jonathan T Wheeler

Erin Honeycutt

Chaitanya Dutt Upadhyay

Eugene Shvets

Jesus Ruiz Scougall

Alex DeJarnett

Eugene Osovetsky

Yasser Shohoud

Vaithialingam B Balayogan

Luis Filipe Cabrera

Vaithiakingam B Balayoghan

Waingold L Elliot

Anand Rjagopalan

Mohamed-Hany Essam Ramadan

Serge Sverdlov

A mechanism for sending structured data using a corresponding byte stream. Upon accessing structured data such as a Simple Object Access Protocol (SOAP) envelope, a byte stream is generated. The byte stream includes bytes that represent the structured data, as well as a collection of bytes that represents properties about the byte stream such as, for example, a mode of communication. The byte stream may then be passed to a communication module (e.g., a TCP or Named Pipes module) capable of receiving and transmitting the byte stream.

Mechanism for binding a structured data protocol to a protocol offering up byte streams

Systems and methods for synchronizing data between endpoints using elements of centralized and decentralized synchronization systems and communication topologies are disclosed. Such systems and methods may in some cases synchronize some subset of data with a centralized endpoint while another subset of data is synchronized in a decentralized fashion directly with other endpoints. Such systems and methods may include a variety of cooperative functionality to assist in the synchronization of data between endpoints.

Server-assisted and peer-to-peer synchronization

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

Embodiments described herein provide for an overall object mode that allows for a single message object to represent multiple messaging formats. A general message object is populated with fields for multiple available messaging formats, which can be appropriately filled with information with fields for both versions 1.1 and 1.2. Depending on which version is being used or desired, the appropriate fields can be populated when creating an instance of the message object. The other fields that do not correspond to that version, however, are left blank.

Message object model

The present invention extends utilizing abstract descriptions to generate, exchange, and configure service and client runtimes. A computer system parses compiled code and potentially optional configuration information for implementing a service and converts the compiled code and any configuration information into an abstract service description. The abstract service description can then be converted into code document object model and service configuration information or exported as metadata. A corresponding service runtime can be initiated by calling a service initializer included in the abstract service description. The code document object model and configuration information and/or metadata can be transferred to another computer system. The other computer system can utilize the code document object model and configuration information and/or import the metadata to facilitate initialization of a compatible channel for communicating with the service runtime.

Utilizing abstract descriptions to generate, exchange, and configure service and client runtimes

Embodiments described herein provide for a message object that simultaneously exposes an XML view and Type view for a message infoset. In this embodiment, interaction with a message can occur using either an XML or Type application program interface (API), which are synced. More specifically, embodiments herein provide or expose a common set of headers (e.g., SOAP headers) as 'typed' properties (e.g., CLR properties), which allow for getting and/or setting a value thereof. In other words, the Type API reads/writes values for typed properties without regard to how the message is encoded with XML. Moreover, the two APIs are synced such that a value can be set using one API and retrieved using the other. For example, an XML API may be used as a writing mechanism for interacting with a value, while the Type API can read that same value, and vise-versa.

Simultaneous API exposure for messages

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

Embodiments described herein provide a user with the ability to vary the encoding of a message object rather than being bound to a specific one, e.g., the text encoding for SOAP messaging. Accordingly, a message encoding factory is provided that is responsible for mapping a message object (e.g., SOAP Infoset) into raw octets suitable for wire transmission. By encapsulating the notion of a message encoder factory abstractly, embodiments allow users to vary the encoding of an Infoset without varying the programming model (or any other aspect of the system that uses message). In other words, embodiments herein separate the transport (e.g., TCP, HTTP, etc.) from the encoding, which allows users to use any number of encoding mechanisms&#x2014;even their own proprietary ones.

Varying of message encoding

Preserving session state correlation in a distributed computing environment in which a service module instance receives messages from a general input buffer. The general input buffer is not accessed by a service module instance once the service module instance is determined to be recycled. After the service module instance receives a session initiation message through the general input buffer, a session-oriented input buffer is associated with the service module instance. Any subsequent session messages are then received by the service module via the session-oriented input buffer. Even if the service module instance was determined to be recycled mid-session, the service module instance would still operate to process all of the remaining session messages from the session input buffer, thereby preserving session continuity.

Mechanism for preserving session state when using an access-limited buffer

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

A sending computer system can identify one or more available network resources at one or more network computers by sending a request for services using Simple Object Access Protocol (SOAP) over User Datagram Protocol (UDP). In particular, the sending computer system prepares a SOAP message that includes a request for available resources. The sending computer system then encapsulates the SOAP message into a user datagram, and sends the user datagram to one or more identifiable computer systems on the network. In one implementation, the sending computer system sends the user datagram to a multi-cast Uniform Resource Identifier (URI). The receiving computer system receives the message through UDP, unpacks the message, and responds to the SOAP message request. Accordingly, the sending computer system can query multiple computer systems in an efficient manner without necessarily incurring the overhead otherwise associated with connection-oriented communication.

Querying for services using soap over UDP

Growing community of inventors

Seattle, WA, United States of America

Michael Steven Vernal