Microsoft Technology Licensing, LLC

Brian Keith Pepin

Shawn Patrick Burke

Nikhil Kothari

James S Miller

Mark A Boulter

Fred W Balsiger

Anders Hejlsberg

Giovanni Moises Della-Libera

Simon Calvert

Christopher L Anderson

Nicholas M Kramer

Michael R Harsh

Chad W Royal

Jeffrey Marc Richter

Sreeram Nivarthi

Andrew Cheng-min Lin

Subhag P Oak

Erik B Christensen

Gopala Krishna R Kakivaya

Yan Valerie Leshinsky

Christopher Wellington Brumme

Stephen James Millet

Michael M Magruder

Raja Krishnaswamy

David Bau

Brian LaMacchia

Gregory Darrell Fee

Lance Olson

Scott David Guthrie

Henry L Sanders

David S Ebbo

Julie D Bennett

Travis Muhlestein

Sean Edwin Trowbridge

Jonathan C Hawkins

Krzysztof J Cwalina

Seth Mitchell Demsey

Luca Bolognese

Brian M Grunkemeyer

Stefan Harrington Pharies

Loren Kohnfelder

Keith W Ballinger

Yung-Shin Lin

Mark T Anders

Anthony J Moore

Charles P Jazdzewski

Jun Fang

Erik B Olson

Yann Christensen

Jeffrey M Cooperstein

Fabio A Yeon

Susan M Warren

James H Hogg

Adam Wade Smith

Craig T Sinclair

Robert Michael Howard

Anson Michael Horton

Corina Eva Feuerstein

Manu Vasandani

Shajan Dasan

David S Mortenson

Caleb L Doise

Alan Geoffrey Boshier

Manish S Prabhu

Radu Rares Palanca

Thomas E Quinn

Paul Yuknewicz

Bulusu Krishna Mohan

John I McConnell

Suzanne Maurine Cook

Tarun Anand

Mark W Fussell

Joseph L Roxe

Antoine Cote

Hany E Ramadan

Jesus Ruiz-Scougall

Thomas Edward Quinn, Jr

Joe Dennis Long

Omri Gazitt

Ramasamy Krishnaswamy

Daniel Takacs

Nithyalakshmi Sampathkumar

Jayanth V Rajan

Jeffrey Thomas Chrisope

Neetu Rajpal

Daniel Dedu-Constantin

Blaine J Dockter

Gary Linscott

James Nakashima

Julien Jacques Nicolas Ellie

James Roy Schmelzer, Jr

Unnikrishnan Ravindranathan

William A Adams

Mark P Ashton

Meghan Rae Perez

Donna Wallace

Jeffrey Walter Kelly

Juraj Hlavac

Graeme Mott

Christopher Dias

The present invention provides technologies for forming an editing interface for editing arbitrary objects. In particular, the present invention provides system and methods for enumerating object properties, selecting a suitable pre-existing object editor and, if no such pre-existing editor is available, constructing an object editor on the fly suitable for editing the properties of the object where the object may include properties and/or collections of objects. Construction of a suitable editor is based on enumeration of object properties and on the serialization of the object using a descriptive language such as extensible markup language ('XML') or the like. Property values specified by a user via the object interface and editors are stored in a descriptive format such as XML and generally specify the initial characteristics of the object.

Arbitrary object editing

An Integrated Development Environment (IDE) is provided which comprises a visual designer that supports at least two avenues of extension. First, the visual designer may be extended with entirely new features by adding a visual designer extension. The visual designer extension is a deriving class of an extension server object. The extension server object may be provided along with the IDE. The visual designer extension manages a list of extension objects, and exposes a service provider to such extension objects. The visual designer extension can request and publish services through the service provider. Second, the visual designer may be extended with new variations of existing features by adding additional extension objects that derive from, and are managed by, an existing visual designer extension. These two modes of extension are supported by a novel visual designer framework described herein.

Dynamic design-time extensions support in an integrated development environment

A system and method for discovering the design time attributes of a component are provided. The invention includes a type descriptor that can access metadata associated with a component and report the metadata to a development tool. The invention further includes a custom type descriptor interface that can be implemented on a component in order to dynamically provide information regarding the component to the type descriptor. The invention further includes a type descriptor filter service interface that can be implemented by the development tool to facilitate filtering of design time information regarding components in order to simulate a run time environment. The invention further comprises methodologies and tools for facilitating application development.

System and method to facilitate design-time component discovery

A 'virtual type' that, to the reflection system, looks and acts like a fully compiled type&#x2014;in reality, the 'virtual type' does not exist and has been fabricated based on another API such as CodeDOM. Essentially, the &#x201c;virtual type&#x201d; allows code to be implemented using a single code path and therefore can remain ignorant that it is dealing with uncompiled source code. A &#x201c;virtual type&#x201d; is an object that looks just like a compiled type, provided that it is viewed through a reflection application program interface (API).

Virtual types

The present invention relates to systems and methods that provide automatic generation of user interfaces via creation of a class-based model. A system is provided that facilitates generating a user interface. The system includes a class component to generally define properties and methods associated with one or more interface actions. A service component parses the class to automatically generate all or a portion of a user interface from the interface actions. Push and Pull-type models can be provided to facilitate merging of actions from various classes such as provided by third parties or from existing component developments.

Explicitly defining user interface through class definition

Dynamic metadata allows for metadata that can be configured for an application programming interface (API) after the API has shipped. Multiple entities can provide metadata for the same API or portions of an API. The metadata provided for an API can be set up for each application domain, allowing customization within a single process. Metadata can be provided in several ways, including traditional compiled code and declarative markup as well as databases and other more dynamic approaches. Metadata is separated from its runtime components, so that the metadata that is used by the runtime components can be changed. For example, metadata may be declared on the objects separately. The metadata is then tied back to the runtime components.

Dynamic mechanism for providing metadata

The present invention extends to methods, systems, and computer program products for discovering, qualifying, and activating software add-in components. An add-in components manager discovers one or more add-in components at the computer system are of a specified type of add-in component requested by an application. The add-in component manager qualifies at least one discovered add-in component based on the at least one discovered add-in component satisfying one or more qualification constraints. The one or more qualification constraints are representative of functionality that is to be associated with an add-in component for the add-in component to interoperate with the application in a desired manner. The add-in component manager activates a qualified add-in component in accordance with the one or more qualification constraints for use with the application.

Discovery, qualification, and activation of software add-in components

The invention includes an architecture in which components associate their design time functionality independent of a design tool. The design time functionality includes code generators, compilers, parsers and editors. The architecture includes interfaces for components and designers to communicate. The architecture includes attributes in metadata that describe the functionality associated with the instance of a component.

Component based design time architecture

Node-to-node communication pipelines may include code modules that are configured and assembled across a protocol according to dynamically input module-specific parameters. The parameters may be input to a service into which the modules are registered, and one or more appropriate pipelines may be dynamically assembled.

Node-to-node communication pipelines

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

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

Application program interface for network software platform

Methods, systems, and computer program products for centrally managing user interface state information for a visual user interface development tool. Component and development tool behavior is centralized in a behavior service that allows behaviors to be defined at development time. The behavior service catches messages that are generated within the visual user interface development tool and routes the message to determine behaviors available within the development tool. If a suitable behavior is available, the behavior is used to process the message. Similar to behaviors, during development time the behavior service may store one or more glyphs with corresponding glyph behavior for a component within the development tool. These glyphs are capable of hit testing and painting themselves, and may be organized into one or more adorner layers that can be independently disabled and enabled.

Behavior architecture for component designers

A user interface is provided that exposes items such as developer tasks, commands, property settings, and other related information to a user. The user interface may be invoked in a number of development interfaces such as, for example, a designer or an editor. The user interface may be either an object bound interface or an action triggered interface. An object bound interface exposes a set of items that are associated with a corresponding object. An action triggered interface exposes a set of items that are associated with a corresponding triggering action. In addition to enumerating developer tasks, the user interface may provide a direct link to other interfaces that facilitate task execution.

System and method for exposing tasks in a development environment

A system and/or methodology to publish and share global objects in a visual designer is provided. A global object is an object that is available anywhere in the development project, rather than being local to a class or user interface element. Aspects of the invention are directed to a mechanism where global objects can be published, queried and/or used by individual visual designers. Additionally, aspects are directed to systems and/or methodologies where changes to those global objects can be made in such a way that they can be automatically updated in the designer. An alternate aspect of this mechanism can integrate with visual designers such that the designer itself does not need to be modified to accommodate the presence of a global object.

Global object system

Methods, systems, and computer program products to serialize user interface objects having custom object types and serialization formats. A serialization manager may coordinate standard serialization providers to identify standard serializers for standard object types or serialization formats, and as needed, may be extended by loading custom serialization providers to identify custom serializers for custom object types or serialization formats, which may not be covered by the standard serialization providers. From available serialization providers, the serialization manager identifies a serializer for a particular serialization format and object type. The object, custom or standard, is serialized using the identified serializer to a custom or standard format, including source code representations, XML representations, etc. Certain serialization formats produce a snippet of code without producing a class representation of an object; to help coordinate and enhance modularity among serializers and their providers; the serialization manager may maintain and share context information.

Modular object serialization architecture

Growing community of inventors

Seattle, WA, United States of America

Brian Keith Pepin