Microsoft Technology Licensing, LLC

Microsoft Corporation

James S Miller

Christopher Wellington Brumme

Sean Edwin Trowbridge

James H Hogg

Patrick Henri Dussud

Gopala Krishna R Kakivaya

Vance Palmer Morrison

Anthony J Moore

David S Mortenson

Michael M Magruder

Raja Krishnaswamy

Brian M Grunkemeyer

George Harold Bosworth

Erik B Christensen

Anders Hejlsberg

David Bau

Brian LaMacchia

Lance Olson

Henry L Sanders

David S Ebbo

Julie D Bennett

Travis Muhlestein

Jonathan C Hawkins

Krzysztof J Cwalina

Seth Mitchell Demsey

Christopher L Anderson

Shawn Patrick Burke

Stefan Harrington Pharies

Loren Kohnfelder

Yung-Shin Lin

Erik B Olson

Yann Christensen

Fabio A Yeon

Jeffrey M Cooperstein

Corina Eva Feuerstein

Craig T Sinclair

Adam Wade Smith

Shajan Dasan

Caleb L Doise

Alan Geoffrey Boshier

Manish S Prabhu

Radu Rares Palanca

John I McConnell

Tarun Anand

Suzanne Maurine Cook

Joseph L Roxe

Hany E Ramadan

Jesus Ruiz-Scougall

Joe Dennis Long

Ramasamy Krishnaswamy

Jayanth V Rajan

Daniel Takacs

Gregory Darrell Fee

Brian Keith Pepin

Brian D Harry

Daryl B Olander

David Owen Driver

Jesse Daniel Kaplan

William G Evans

Bradley Moore Abrams

Thomas E Quinn

Jeffrey Marc Richter

Li Zhang

Charles W Kaufman

Yan Valerie Leshinsky

Stephen James Millet

Giovanni Moises Della-Libera

Nicholas P Wilt

Nikhil Kothari

Scott David Guthrie

Luca Bolognese

Brian Robert Crawford

John Lawrence Hamby

Keith W Ballinger

Peter A Hallam

Mark T Anders

Jun Fang

Susan M Warren

Jason L Zander

Robert Michael Howard

Manu Vasandani

Sam Spencer

Nicholas M Kramer

Thottam Sriram

Chad W Royal

John Joseph Rivard

Douglas Jay Rosen

Mark W Fussell

Mark A Boulter

Ian H Carmichael

Stephen Alan Fisher

Steven J Steiner

Thomas Edward Quinn, Jr

Omri Gazitt

Sreeram Nivarthi

Nithyalakshmi Sampathkumar

Neetu Rajpal

Jennifer A Hamilton

Mario Chenier

Peter Kukol

A type system includes a dual representation for basic data types. One representation is the basic data type representation common to such basic built-in data types, known as an unboxed value type or simply as a value type. Each of the basic data types also has a boxed representation that can be stored in the object hierarchy of the type system. This dual representation can also be extended to user-defined types, so that user-defined types may exist both as an unboxed value type and as an object within the object hierarchy of the type system. This dual representation allows the compiler and/or runtime environment to select the most effective and efficient representation for the data type depending on the particular need at the moment.

Unified data type system and method

Various technologies and techniques are disclosed for generating add-in bridges that allow hosts to be extended using a dynamic language. The system programmatically determines static requirements that an add-in is required to implement in order to integrate with a particular host. The system programmatically generates the add-in bridge to conform to the requirements of the particular host and to operate like a compiled add-in while actually calling dynamic language script files that are executed by a scripting engine. The add-in bridge is generated by generating a component for the add-in that contains at least one class to conform to the host requirements. A constructor is then generated for the class. For each method the add-in is required to implement, a respective method is generated in the class that provides a stub implementation but that calls dynamic-language script files to perform a desired functionality.

Static extensibility models with dynamic languages and scripts

In a managed execution environment, an error may be deferred until execution of the application, program, function, or other assemblage of code reaches a point at which calling the reference to a module associated with a missing type or type member becomes inevitable.

Adaptive compiled code

Various technologies and techniques are disclosed for providing a common generic interface for numeric types in statically typed languages. The common generic interface defines basic arithmetic operations, thereby allowing basic arithmetic operations to be performed on the numeric types. The common generic interface provides support for overflow detection when a result of an operation being performed on a particular numeric type will result in an overflow situation when the operation does not fit within a range supported by the particular numeric types. The common generic interface provides support for one or more mathematical properties to be retrieved for a particular one of the numeric types being used in a particular circumstance.

Generic interface for numeric types

Various technologies and techniques are disclosed for providing host control of partial trust accessibility. A framework allows libraries to be identified as partial trust callers allowed to indicate that the libraries are allowed to be called from partially trusted code by default. The framework allows libraries to be identified as partial trust callers enabled to indicate the libraries could be called from partially trusted code, but not by default. A hosting application is notified that a particular library has been loaded. If the particular library has been identified as partial trust callers allowed, then a determination is received from the hosting application on whether to remove or keep partial trust accessibility for the particular library. If the particular library has been identified as partial trust callers enabled, then a determination is received from the hosting application on whether or not to enable partial trust accessibility for the particular library.

Host control of partial trust accessibility

A requirement for a versioned resource is fulfilled, particularly in light of compatibility constraints of the requirement. Versions of the versioned resource are associated with compatibility information, such as a feature version and a service version, for example. In fulfilling the requirement, compatibility logic may be applied to identify versions that are compatible with the requirement, and selection logic may be applied to select a preferred version from the compatible versions.

Selection of versioned resource among multiple compatible versions

A system and method for mitigating problems associated with automatic execution of initialization code is provided. The system includes an initialization method activator that can call a class initialization method at a pre-determined execution point. The system also includes a deadlock analyzer that can determine whether calling the initialization method will create a deadlock, and, if a deadlock is detected that can resolve such a deadlock. The system also includes a semantic analyzing component that can analyze a semantic type associated with the initialization method and a domain uniqueness analyzer that can analyze the uniqueness of the domain with which the class will interact, to facilitate determining where to place code that will check whether a class is initialized, and if the class is not initialized that will invoke the class initializing method.

Class initialization method semantics

Various technologies and techniques are disclosed for using annotations in contracts to generate views and adapters. A framework is provided that supports annotations that can be used in a contract to allow a user to express how one or more members of the contract should be represented in at least one view, and to express how to adapt the members in at least one adapter. Annotations can also be used to indicate which of the components should be programmatically generated. The contract is accessed and at least a portion of the at least one view and the at least one adapter are generated based on the annotations and other information contained in the contract. For example, source code can programmatically be generated for a host side view, an add-in side view, a host side adapter, and an add-in side adapter using the various contract details and the annotations.

Using a system of annotations to generate views and adapters

Various technologies and techniques are disclosed for providing a numeric tower that represents a structure supporting statically defined numeric data types. The numeric data types each are operable to implement a different but accurate representation of a particular value. Numeric operations are supported for the numeric tower that can be performed with any of the statically defined numeric data types. The numeric tower is extensible, and allows for additional statically defined numeric data types to be added, as well as operations. The numeric tower is also operable to detect overflow situations. For example, suppose a result of an operation will result in an overflow situation because the operation does not fit within a range supported by the particular numeric type. The system converts the numeric type to a different one of the numeric data types when the result does not fit within a range supported by the first one.

Tower of numeric types

Meta-data of compiled code may have a corresponding description of the schema for meta-data, to allow for deviations from a schema standard.

Extensible meta-data

A method and system for compiling multiple source language files that share a common library. The common library is represented in a common language that can be used by multiple different source languages. Font end compiler systems read the common language files that make up the common library and the source language files that use the library. Additionally, the front end systems produce common language files. The common language files produced by the front end systems can be used in the common library. The common language files may also be supplied to a back end system or runtime environment that further compiles the common language file to an executable form and executes the file. At runtime, the common language file is used by the runtime environment to layout the objects and methods used during execution.

Method and system for compiling multiple languages

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

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

Managed code, including applications, runtime, and driver, have a priori knowledge of the client's exact hardware configuration, just as the JIT compiler has a priori knowledge of the microprocessor type on the target computer system. At compile time, the compiler knows the effective version various system drivers, so that the compiler can emit an executable tuned for a particular driver version and target system.

Systems and methods for managing drivers in a computing system

Growing community of inventors

Bellevue, WA, United States of America

James S Miller