摘要:
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.g., DOM).
摘要:
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.
摘要:
The subject invention pertains to a system and method of incorporating collation information into data types. In particular, the subject invention provides for parameterizing data types with collation information such that a comparison between two different collations generates a static-type error rather than a run-time error. Additionally, the invention affords for conveniently working with localized data types to allow generic parameterization over collations as well as ordinary types. In the context of strings, the present invention enables concurrent use of strings in multiple languages and facilitates the correct handling thereof.
摘要:
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.
摘要:
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.
摘要:
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.
摘要:
The present invention discloses an improved system and method for specifying and compiling computer programs. Type aliases are introduced whose binding is inferred by a type inference component during compilation. Once declared, type aliases can be utilized just like regular types thereby providing added efficiency in coding, among other things. Additionally, a mechanism for specifying the introduction of a new variable whose type is to be inferred is disclosed. This mechanism clears up an ambiguity during type inference concerning whether to infer a new variable type or utilize a variable in scope. Further yet, an efficient type inference system and method is disclosed to effectively deal with overloading among other things.
摘要:
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. In another aspect, code inferencing is disclosed whereby given a type, the corresponding code can be inferred by the compiler and inserted for compiling by a compiler.
摘要:
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.
摘要:
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.