Microsoft Technology Licensing, LLC

Stephen T Swartz

Erik B Christensen

Stephen James Millet

Donald James McCrady

Michael Steven Vernal

Gerald L Hinson

Kenneth David Wolf

David Wortendyke

Seth B Pollack

Mohsen M Al-Ghosein

Stefan Harrington Pharies

Igor Sedukhin

Michael Marucheck

Eric Kenneth Zinda

Douglas M Purdy

Donald W Dumitru

Ryan Thomas Sturgell

Donald F Box

Giovanni Moises Della-Libera

Vladimir Pogrebinsky

Girish Mittur Venkataramanappa

Craig Andrew Critchley

Uday Sooryakant Hegde

Elliot Lee Waingold

Amol Kulkarni

Tomasz Janczuk

Shy Cohen

Haoran Andy Wu

Daniel Eshner

Natasha Harish Jethanandani

Sowmyanarayanan K Srinivasan

Yaniv Pessach

Alex DeJarnett

Jesus Ruiz Scougall

Christopher G Kaler

Steven E Lucco

Gopala Krishna R Kakivaya

Bradford H Lovering

James Ernest Johnson

Tirunelveli R Vishwanath

Lance Olson

Richard Douglas Hill

Stefan R Batres

Umesh Madan

Michael James Coulson

John David Doty

Oliver J Sharp

Vijay Gajjala

Krishnan Srinivasan

Geary L Eppley

Matthew Thomas Tavis

David Edwin Levin

Richard Dievendorff

Max A Feingold

David Owen Driver

Nagalinga Durga Prasad Sripathi Panditharadhya

Siddhartha Puri

Prasad Sripathi Panditharadhya

Stefan H Pharies

Aaron Stern

Saurab Nog

Anastasios Kasiolas

Sumit Mohanty

Jesus Ruiz-Scougall

Douglas A Walter

Kapil Gupta

Vipul A Modi

Mohammad Makarechian

Jonathan T Wheeler

Scott Christopher Seely

Alexander Martin DeJarnatt

Sundeep Sahi

Evgeny Osovetsky

Erin Honeycutt

Michael Thomas Dice

Chaitanya Dutt Upadhyay

Mauro Ottaviani

Alfred M Lee, Iv

Eugene Shvets

Uday Bhaskara

Yasser Shohoud

Eugene Osovetsky

Vaithialingam B Balayogan

Serge Sverdlov

Mohamed-Hany Essam Ramadan

Anand Rjagopalan

Dan Eshner

The present invention extends to methods, systems, and computer program products for modeling and managing heterogeneous applications. Application intent can be described in a relatively straight forward manner that abstracts underlying implementation details. Thus, application developers can develop applications without necessarily having to know extensive details of an underlying implementation environment. In any event, an application can be executed in different implementation environments without requiring changes to the corresponding model.

Modeling and managing heterogeneous applications

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

The present invention extends to methods, systems, and computer program products for performing requested commands for model-based applications. Embodiments of the invention permit efficient implementation of operations for model-based applications. Since drivers that are to implement an operation request data for implementing the operation, embodiments significantly reduce the likelihood of superfluous data being exchanged between an executive service and drivers. Further, if an operation is interrupted before implementation is complete, the operation can be resumed without having to re-perform already completed portions of the operation. Additionally, a user can be regularly updated on the progress of their commands.

Performing requested commands for model-based applications

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

Abstracting communication with a plurality of containers. Each container encapsulates or hosts a module (e.g., a web service, a database, etc.) associated with a distributed application. A meta-container communicates with drivers that interface with each of the containers. The meta-container represents an abstraction and a virtualization of the containers in the hierarchy. Each container may also be a meta-container for other containers. The recursion and layered hierarchy provide flexible, extensible, and efficient management of the distributed application.

Meta-container for model-based distributed applications

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

The present invention extends to mapping between object oriented and service oriented representations of a distributed application. A computer system accesses an annotated object oriented representation of a service, which is annotated with service description attributes mapping included objects to corresponding service oriented elements in a service oriented representation of the service. The computer system identifies a service description attribute that annotates an object of the annotated object oriented representation. The computer system maps the object to a corresponding service oriented element in accordance with service description information contained in the identified service description attribute. The computer system outputs a channel object configured to implements behaviors and data formats described in the service oriented representations. The computer system initiates a channel that is compatible with behaviors and data formats of the service.

Mapping between object oriented and service oriented representations of a distributed application

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

An object-based event communications system supplies an event distribution object having an outgoing-from-publisher event interface and associated with unique identifiers defined for a publisher that is programmed to fire events by calling a method on the event distribution object's outgoing-from-publisher event interface. The event communications system stores subscriptions of subscriber objects to methods of the outgoing-from-publisher event interface. On receiving a call from a publisher to its outgoing-from-publisher interface methods, the event distribution object multi-casts calls to counterpart methods of subscriber objects that have stored subscriptions to the respective outgoing-from-publisher interface methods.

Object connectivity through loosely coupled publish and subscribe events

Object connectivity through loosely coupled publish and subscribe events with filtering

Growing community of inventors

Seattle, WA, United States of America

Stephen T Swartz