Abstract: A development system is provided. The system includes a workspace component to visually display one or more stored procedures and one or more class components. A manipulation component locates the stored procedures onto the class components in order to automatically create methods for the class components.

Abstract: An architecture that leverages support for markup language operations, e.g., extensible markup language (XML) queries, via a lightweight application program interface (API). The API defines an object model that can simplify construction of XML values in languages that do not natively support XML. The novel aspects of the described innovation can enable query languages to be factored into general operations (e.g., mapping, filtering, sorting, and/or projection of functions) on collections on one hand, and a set of domain specific operations (e.g., navigation, construction and modification) on the elements of these collections on another hand. The subject API can support creation of XML data that is node centric (e.g., context-free). Accordingly, nodes do not have to be constructed within the context of a document. Additionally, aspects can enable expression-oriented interface mechanisms as opposed to the imperative statement-oriented style interfaces used in connection with traditional interface mechanisms (e.

Abstract: The subject disclosure pertains to systems and methods that facilitate retrieval of data. In particular, an application defined data shape can regulate loading of data for use in an object relational mapping system, enabling the object-oriented application to access data in a relational data base system. Data shapes define policies that control data retrieval, enabling efficient data loading. A data shape allows users to declaratively specify a set of policies to be applied to all queries associated with the data shape. In particular, data shapes can include policies that control eager loading.

Abstract: A special syntax is developed to differentiate between accesses to a primary and one or more secondary object protocols in a programming language. The syntax allows the compiler to differentiate between the primary and secondary object model based on syntax, rather than type. The syntax is created in such a way as to approximate the syntax of the secondary object model, and allows the user to dynamically generate member names.

Abstract: Object instance annotation technology is disclosed. This technology is capable of annotating any number of instances for any number of objects. Object instance annotations can be of various types, and annotations can serve as data extensions. Objects are enabled for annotation either by developers, or, alternatively, automatically by a programming language or framework. Furthermore, an interface is provided for annotations. This interface has a variety of operations, some of which allow for adding, retrieving, or removing annotations. Annotations can be reference types or even value types. They may also be private class types. Once object instances are enabled for annotating, and the interface is set up, this interface can annotate a multitude of different kinds of objects. For example, it can annotate generic objects, XML trees, CodeDom trees, and so on.

Abstract: The claimed subject matter provides a system and/or a method that facilitates querying data utilizing an explicit representation of an embedded language. An IEnumberable component can receive a data operation that can be employed on a collection of data utilizing at least one of an IEnumerable interface and an IEnumerable<T> interface. A mirror component can provide a generic interface to query the collection of data by representing the collection of data as an expression tree utilizing at least one function that mirrors the at least one IEnumerable interface and the IEnumerable<T> interface.

Abstract: A system for managing data element names, comprises a parent table for listing names of data elements that is constrained such that the parent table cannot grow beyond a first predetermined size. The system also includes a child table for listing names of data elements that is derived from the parent table and that is constrained such that the child table cannot grow beyond a second predetermined size. Methods for using the system are also provided.

Abstract: The subject disclosure pertains to interaction with one or more collections of data. Queries and domains are presented as separate entities. A number of compositional operators are provided to manipulate a generic collection of data at a low level. Query comprehensions can specify interactions with one or more collections at a higher or more intuitive level. The query comprehensions can be translated or mapped to operators that can be employed to interact with one or more data collections and return results where applicable.

Abstract: The subject disclosure pertains to lambda expressions and the employment of such expressions in imperative and/or object-oriented computer programming languages. Lambda expressions can be employed in conjunction with methods (e.g., arguments, assignment . . . ) to provide a more concise and functional manner of code specification. Further, lambda expressions can participate in type inference and checking as well as overload resolution, among other things.

Abstract: An architecture that leverages support for markup language operations, e.g., extensible markup language (XML) queries, via a lightweight application program interface (API). The API defines an object model that can simplify construction of XML values in languages that do not natively support XML. The novel aspects of the described innovation can enable query languages to be factored into general operations (e.g., mapping, filtering, sorting, and/or projection of functions) on collections on one hand, and a set of domain specific operations (e.g., navigation, construction and modification) on the elements of these collections on another hand. The subject API can support creation of XML data that is node centric (e.g., context-free). Accordingly, nodes do not have to be constructed within the context of a document. Additionally, aspects can enable expression-oriented interface mechanisms as opposed to the imperative statement-oriented style interfaces used in connection with traditional interface mechanisms (e.

Abstract: This disclosure concerns various manners and mechanisms to capture and interact with free/outer variables or parameters. The capture of such variables, among other things, enables the code to become mobile to facilitate transmission to and execution by various systems or sub-systems. Transmission can be accomplished, for instance, by generation of code objects or data packets that include substituted values of the free variables and/or references to the location of the values.

Abstract: A program execution engine that facilitates generic type variance verification is provided. The execution engine receives a program executable in the form of intermediate language (IL). The program executable can be based on code that includes expression(s) with generic type(s) which have been identified as requiring variance verification (e.g., covariance and/or contra-variance). The execution engine includes a variance verification component that dynamically determines whether value(s) associated with the generic type(s) identified as requiring variance verification comply with the particular variance verification requirement. The variance verification component can provide error information (e.g., throw an exception), if the specified variance is not safely compliant Variance verification can be based on static checking which places the burden on a source language compiler to emit the run-time checks in intermediate language (IL), if run-time checked variance is required.

Abstract: Architecture that extends existing types including constructed and sealed types using extension methods. Extension methods are static methods that can be invoked using instance method syntax. Extension methods are declared by specifying the keyword “this” as a modifier on the first parameter of the methods. Extension methods have all the capabilities of regular static methods. In addition, once imported, extension methods can be invoked using instance method syntax. Also disclosed are rules for importing extension methods, and extension method invocations. Extension methods are imported through using-namespace-directives. In addition to importing the types contained in a namespace, a using-namespace-directive imports all extension methods in all static classes in the namespace. In effect, imported extension methods appear as additional methods on the types that are given by their first parameter and have lower precedence than regular instance methods.

Abstract: A compiler supporting a language in which selected semantic objects are represented as data objects. The data objects may be used in multiple ways to expand the capabilities of the programming language. Data objects may be passed to applications and used to create executable instructions for that application. In this way, instructions written in the native language of the compiler may be used to control applications that accept programs in a language inconsistent with the native language of the compiler. The syntax checking and variable binding capabilities of the compiler may be used for those instructions that will be executed by an application separate from the object code generated by the compiler. The semantic objects represented as data objects may be selected based on express operations included in the source code or may be based on implicit type conversion.

Abstract: Syntax for creating object instances utilizing expressions instead of statements. A syntax component facilitates extension of conventional object-creation-expression syntax. An initializer component provides for initialization of a newly-created entity via object and collection initializers. The initializer component provides initialization of the newly-created entity utilizing an object initializer where the object initializer specifies values for one or more fields or properties of the newly-created entity which is an object, and consists of a sequence of member initializers enclosed by tokens and separated by commas. The initializer component can also provides initialization of the newly-created entity utilizing a collection initializer when the underlying object implements a certain interface or implements a certain pattern. An overloading constructor can be called as part of the initialization process.

Abstract: Systems and methods that enable consistent navigation (for a database and memory environment) in object relational mapping. This typically ensures fidelity of object graph via restrictions on collections of persistent objects (e.g., entity sets, entity refs . . . ). Moreover, a tracking component can detect changes as they occur, and only a copy of the objects that have changed can be created, to optimize operation.

Abstract: Anonymous types for a programming language. Non-denotable anonymous types are types that a compiler generates on behalf of a programmer and can then be used as nominal types. Insofar as anonymous types do not have a name, they can be used only inside a method in which they are created. Additionally, an anonymous type cannot be exposed in any way outside of the method. Syntax to create an anonymous type is useful when employed with a Select operator to generate a result with a particular shape, without the need of having a regular type for it. Anonymous types are expressible such that an expression of that type can be written. Translation of an anonymous type by a compiler generates a nominal class that implements Equals and GetHashCode methods. There is equivalence of anonymous types within the same method, and conversion of an unrealized structural type into structurally compatible nominal type.

Abstract: A system for converting a query from a representation in a first computing language to an equivalent query in a representation in a second computing language that is different from the first computing language, comprises a query module that accepts a query in an object-oriented representation for translation to an equivalent query in a target query language. The system also includes a translation module that uses the object-oriented representation of the query to create a first version of the query in an idealized version of a target query language and uses the first version of the query to create a second version of the query in an implemented version of the target query language. Methods of using the system are also provided.

Abstract: The subject disclosure pertains to code generation patterns for use in object relational mapping. The code patterns may be used to manage bidirectional relationships and ensure consistency. The code patterns may support on-demand or deferred loading of relational data. Change detection and tracking are also provided. In addition, a default member modifier allows developers to override tool generated source code without directly modifying the generated source code.

Abstract: A general-purpose programming language having language extensions for strongly typed, compile-time checked query and set operations that can be applied to arbitrary data structures, be they object-relational (O-R) mappings or just regular objects. As is appropriate for a general purpose programming language, the extensions do not mandate a particular object-relational layer; rather, they are introduced as abstractions that can be implemented in multiple environments. Accordingly, there is provided a system that facilitates data querying in accordance with an innovative aspect. The system include a program component that provides embedded query and set operations in a programming language, and an application component that facilitates application of the query and set operations over a data structure of data. The data can be any kind of data such as that found in a database, a document (e.g., XML), and data sources in a programming language (e.g., C#), for example.