Term
|
Definition
| Language keywords used to specify the visibility of the methods and member variables declared within a class. The five access modifiers in the C# language are public, private, protected, internal, and protected internal. |
|
|
Term
| Active Server Pages (ASP) |
|
Definition
| A Microsoft technology for creating server-side, Web-based applications and services combining HTML pages, script commands, and COM components. ASP applications are typically written using a scripting language, such as JScipt, VBScript, or PerlScript. ASP first appeared as part of Internet Information Server 2.0. |
|
|
Term
| ADO (ActiveX Data Objects) |
|
Definition
| A set of COM components used to access data objects through an OLEDB provider. ADO is commonly used to manipulate data in databases. |
|
|
Term
| ADO.NET (ActiveX Data Objects for .NET) |
|
Definition
| The set of .NET classes and data providers used to manipulate databases. ADO.NET was formerly known as ADO+. ADO.NET can be used by any .NET language. |
|
|
Term
| API (Application Program Interface) |
|
Definition
| A set of programs, code libraries, or interfaces used by developers to interact with a hardware device, network, operating system, software library, or application. Calls to the methods of an API are typically synchronous, but may also be asynchronous through the use of callback methods. |
|
|
Term
|
Definition
| The directory where a .NET application's assembly files are stored. Also called the application folder or application directory. |
|
|
Term
|
Definition
| The logical and physical boundary created around every .NET application by the CLR. The CLR can allow multiple .NET applications to be run in a single process by loading them into separate application domains. The CLR isolates each application domain from all other application domains and prevents the configuration, security, or stability of a running .NET applications from affecting other applications. Objects can only be moved between application domains by the use of remoting. |
|
|
Term
|
Definition
| The part of an application that provides information to describe the components that the application uses. |
|
|
Term
|
Definition
A collection of objects of the same type, all of which are referenced by a single identifier and an indexer. In the .NET Framework, all arrays inherit from the Array class that is located in the System namespace. |
|
|
Term
|
Definition
| Abstract State Machine Language, a functional programming language that describes computer system architectures in a precise way. XASM is an open source implementation of the language. |
|
|
Term
|
Definition
| All of the files that comprise a .NET application, including the available data, security management, versioning, sharing, deployment information, and the actual MSIL code executed by the CLR. An assembly may appear as a single DLL or EXE file, or as multiple files. |
|
|
Term
| Assembly Binding Log Viewer |
|
Definition
| A .NET Framework tool (Fuslogvw.exe) used to view and manipulate the log of binding information that is updated at run-time when an assembly is loaded by the CLR. This log viewer is primarily used to discover why an assembly (or satellite assembly) can't be located at runtime, and to verify that the correct assemblies are being loaded by a .NET application. |
|
|
Term
|
Definition
| A reserved area of memory used to store the assemblies of a .NET applications running on a specific machine. |
|
|
Term
|
Definition
| A .NET Framework tool (Shfusion.dll) used to view, add, remove and configure information in the Global Assembly Cache using Windows Explorer. |
|
|
Term
| Assembly informational version |
|
Definition
| A custom attribute that attaches version information to an assembly in addition to the assembly's version number. The informational version is a string that typically contains marketing information, such as the product's name and release number. |
|
|
Term
|
Definition
| A .NET Framework tool (al.exe) used to create an assembly manifest from the specified MSIL modules or resource files. |
|
|
Term
|
Definition
| A detailed description of the contents of an assembly. A manifest contains metadata describing the name, version, types, and resources in the assembly, and the dependencies upon other assemblies. The manifest allows an assembly to be self-describing, easily deployed, and not bound to a particular system by storing information in the Windows registry. |
|
|
Term
|
Definition
| Describes all classes and class members that are defined in the assembly, and the classes and class members that the current assembly will call from another assembly. |
|
|
Term
| Assembly Registration Tool |
|
Definition
| A .NET Framework tool (RegAsm.exe) used to register an assembly in the Windows registry. Registration is required if COM clients need to call managed methods residing in a .NET assembly. This tool can also be used to generate a registry (.reg) file containing the necessary registration information. Registration typically only occurs once when the assembly is installed. |
|
|
Term
|
Definition
| Part of an assembly's identity, and used to indicate the version, revision, and build of an assembly. The version is expressed in dot notation using four, 32-bit integers in the format "<major version>.<minor version>.<build number>.<revision>". The version number is stored in the assembly manifest and only refers to the contents of a single assembly Two assemblies that have version numbers which differ in any way are considered by the CLR to be completely different assemblies. |
|
|
Term
| Attribute-based programming |
|
Definition
| A programming model that allows flexibility in the behavior of a program not possible in traditional API call-based programming. Custom attributes add metadata to give classes extra information that extend the definition a types' behavior. The attribute's values are determined by programmers at design time, and can be reconfigured at runtime by users and other programs without the need for code changes or recompilation. |
|
|
Term
|
Definition
| Language constructs that are used by programmers to add additional information (i.e.,metadata) to code elements (e.g., assemblies, modules, members, types, return values, and parameters) to extend their functionality. |
|
|
Term
|
Definition
| The parent class of a derived class. Classes may be used to create other classes. A class that is used to create (or derive) another class is called the base class or super class. |
|
|
Term
|
Definition
| A set of Microsoft Server applications that allow the integration, automation, and management of different applications and data within and between business organizations. BizTalk Server is a key B2B component of the .NET Enterprise Server product family. |
|
|
Term
|
Definition
Conversion of a value type to a reference type object (i.e. System.Object). Value types are stored in stack memory and must be converted (i.e., boxed) to a new object in heap memory before they can be manipulated as objects. The methods, functions, and events of the new object are invoked to perform operations on the value (e.g., converting an integer to a string). Boxing is implicitly performed by the CLR at runtime. |
|
|
Term
|
Definition
| An object-oriented and type-safe programming language supported by Microsoft for use with the .NET Framework. C# (pronounced "see-sharp") was created specifically for building enterprise-scale applications using the .NET Framework. It is similar in syntax to both C++ and Java. |
|
|
Term
|
Definition
| A method used to return the results of an asynchronous processing call. Typically, methods are called in a synchronous fashion, where the call does not return until the results (i.e., the output or return value) of the call are available. An asynchronous method call returns prior to the results, and then sometime later a callback method is called to return the actual results. The callback method itself contains program statements that are executed in response to the reception of the results. Also referred to as a callback function under the Win32 API. |
|
|
Term
| Casting (Implicit and Explicit) |
|
Definition
| Conversion of a value from one type to another. Implicit casting is performed silently by the compiler when the casting would not cause any information to be lost (e.g., converting a 16-bit integer to a 32-bit integer value). Explicit casting is coded by the programmer using the particular language's cast operator. This is necessary when the use of a value would cause a possible loss of data (e.g., converting a 32-bit integer to a 16-bit integer value). |
|
|
Term
|
Definition
| Templates used for defining new types. Classes describe both the properties and behaviors of objects. Properties contain the data that are exposed by the class. Behaviors are the functionality of the object, and are defined by the public methods (also calledmember functions) and events of the class. Collectively, the public properties and methods of a class are known as the object interface. Classes themselves are not objects, but instead they are used to instantiate (i.e., create) objects in memory. |
|
|
Term
|
Definition
| The elements of a class which define its behaviors and properties. Class members include events, member variables, methods, constructors, and properties. Also called type members. |
|
|
Term
| Client/Server architecture |
|
Definition
| An application architecture in which the server dispenses (or serves) information that is requested by one or more client applications. In the 2-tier client/server model, the client contains the user interface and business logic, and the server contains the database engine and information storage. In the 3-tier model, the business logic is located on a middle-tier server to reduce the processing load on the database server and to make system maintenance easier. The number of users that can be supported by a client/server system is based on the bandwidth and load of the network and processing power of the server. |
|
|
Term
| Code Access Security (CAS) |
|
Definition
| The CLR's security model for applications. This is the core security model for new features of the Vista Operating System. |
|
|
Term
|
Definition
| A class used to logically organize a group of identical types using a single identifier. Examples include array, arraylist, queue, and stack. |
|
|
Term
| COM (Component Object Model) |
|
Definition
| A software architecture developed by Microsoft to build component-based applications. COM objects are discrete components, each with a unique identity, which expose interfaces that allow applications and other components to access their features. COM objects are more versatile that Win32 DLLs because they are completely language independent, have built-in interprocess communications capability, and easily fit into an Object-Oriented program design. |
|
|
Term
|
Definition
| The "next generation" of the COM and DCOM software architectures. COM+ makes it easier to design and construct distributed, transactional, and component-based applications using a multi-tiered architecture. COM+ also supports the use of many new services, such as Just-in-Time Activation, object pooling, and Microsoft Transaction Server (MTS) 2.0. |
|
|
Term
| COM Callable Wrapper (CCW) |
|
Definition
| A metadata wrapper that allows COM components to access managed .NET objects. The CCW is generated at runtime when a COM client loads a .NET object. The .NET assembly must first be registered using the Assembly Registration Tool. |
|
|
Term
| Microsoft Commerce Server |
|
Definition
| Microsoft's e-commerce server application package for developing and maintaining business Web sites. Commerce Server is a key component to creating B2C solutions using the .NET Enterprise Server product family. |
|
|
Term
| Common Intermediate Language (CIL) |
|
Definition
| The system-independent code generated by a .NET language compiler. CIL defines a file format for storing managed code as both program instructions and metadata in a single file. Either the ILASM assembler or JIT compiler is then used to convert CIL to native machine code. CIL is also referred to as Microsoft Intermediate Language (MSIL). |
|
|
Term
| Common Language Infrastructure (CLI) |
|
Definition
| The .NET infrastructure that allows applications written in multiple programming languages to operate many different environments without the need to modify the program code. The CLI consists of a file format (PE), a common type system (CTS), an extensible metadata system, an intermediate language (CIL), a factored base class library (FCL), and access to the underlying operating system (Win32). |
|
|
Term
| Common Language Runtime (CLR) |
|
Definition
| A runtime environment that manages the execution of .NET program code, and provides services such as memory and exception management, debugging and profiling, and security. The CLR is a major component of the .NET Framework, and provides much of its functionality by following the rules defined in the Common Type System. |
|
|
Term
| Common Language Specification (CLS) |
|
Definition
| A set of common conventions used to promote interoperability between programming languages and the .NET Framework. The CLS specifies a subset of the Common Type System and set of conventions that are adhered to by both programming language designers and framework class library authors. |
|
|
Term
|
Definition
| The specification which defines the rules of how the Common Language Runtime defines, declares, and manages types, regardless of the programming language. All .NET components must comply to the CTS specification. |
|
|
Term
|
Definition
| A method that is automatically called when an object is created. The constructor is used to initialize the object and place it in a valid state (e.g., setting the values of member variables). The constructor method always has the same identifier as the class in which it is defined. |
|
|
Term
|
Definition
| Attributes defined by a programmer to store the instance of any type in metadata. |
|
|
Term
|
Definition
| A set of classes in the .NET Framework that allow access to the information in a data source. The data may be located in a file, in the Windows registry, or any type of database server or network resource. A .NET data provider also allows information in a data source to be accessed as an ADO.NET DataSet. Programmers may also author their own data providers for use with the .NET Framework. |
|
|
Term
| DCOM (Distributed Component Object Model) |
|
Definition
| An extension of the COM that allows COM components to communicate across network boundaries. Traditional COM components can only perform interprocess communication across process boundaries on the same machine. DCOM uses the Remote Procedure Call (RPC) mechanism to transparently send and receive information between COM components (i.e., clients and servers) on the same network. |
|
|
Term
|
Definition
| A mechanism used to implement event handling. A class that needs to raise events must define one delegate per event. Types that use the class must implement one event handler method per event that must be processed. |
|
|
Term
|
Definition
| The process of installing an application, service, or content on to one or more computer systems. In .NET, deployment is performed using XCOPY or the Windows Installer. More complex deployment applications, such as System Management Server, can also be used. |
|
|
Term
|
Definition
| The part of an application that tells the system how to install and maintain an application. |
|
|
Term
|
Definition
Method called when the object is garbage collected by the CLR—which happens at some indeterminate time after an object goes out of scope. In C#, the destructor is actually a syntactic mapping to a Finalize method. |
|
|
Term
| DOM (Document Object Model) |
|
Definition
| A programming interface that allows HTML pages and XML documents to be created and modified as if they were program objects. DOM makes the elements of these documents available to a program as data structures, and supplies methods that may be invoked to perform common operations upon the document's structure and data. DOM is both platform- and language-neutral and is a standard of the World Wide Web Consortium (W3C). |
|
|
Term
|
Definition
A class-only method used to implement an explicit way to release the resources allocated by an object. The dispose method is actually an implementation of the IDisposable interface, and is typically called by the destructor or Finialize method of a class. |
|
|
Term
|
Definition
| An application architecture (sometimes called n-tier) in which the components of an application may be distributed across many computers. Although the client/server architecture is fundamentally distributed in its design, the distributed model is not limited to only two or three tiers in its design. |
|
|
Term
|
Definition
| Part of the assembly cache used to store information downloaded from a private network or the public Internet. Objects in the download cache are effectively isolated from all other assemblies loaded into other assembly caches. See Assembly Cache. |
|
|
Term
| DTD (Document Type Definition) |
|
Definition
| A document defining the format of the contents present between the tags in an HTML, XML, or SGML document, and how the content should be interpreted by the application reading the document. |
|
|
Term
| Microsoft Exchange Server |
|
Definition
| A set of Microsoft server applications used to integrate messaging and data storage technologies. Exchange Server's features include instant messaging, email, calendaring, real-time conferencing, and contact management. Exchange Server can also store documents, Web content, and applications that are accessible via Internet protocols, such as NNTP and HTTP. |
|
|
Term
|
Definition
A class-only method that is automatically called when an object is destroyed by the garbage collector. The Finalize method is primarily used to free up unmanaged resources allocated by the object before the object itself is removed from memory. A Finalize method is not needed when only managed resources are used by the object, which are automatically freed by the garbage collector. In C#, when a destructor is defined in a class it is mapped to a Finalize method. |
|
|
Term
|
Definition
| A block of program statements that will be executed regardless if an exception is thrown or not. A finally block is typically associated with a try/catch block (although a catch block need not be present to use a finally block). This is useful for operations that must be performed regardless if an exception was thrown or not (e.g., closing a file, writing to a database, deallocating unmanaged memory, etc). |
|
|
Term
| Framework Class Library (FCL) |
|
Definition
| The collective name for the thousands of classes that compose the .NET Framework. The services provided by the FCL include runtime core functionality (basic types and collections, file and network I/O, accessing system services, etc.), interaction with databases, consuming and producing XML, and support for building Web-based (Web Form) and desktop-based (Windows Form) client applications, and SOAP-based XML Web services. |
|
|
Term
|
Definition
| The process of implicitly reclaiming unused memory by the CLR. Stack values are collected when the stack frame they are declared within ends (e.g., when a method returns). Heap objects are collected sometime after the final reference to them is destroyed. |
|
|
Term
| GDI+ (Graphics Device Interface Plus) |
|
Definition
| The next generation graphics subsystem for Windows. GDI+ provides a set of APIs for rendering 2D graphics, images, and text, and adds new features and an improved programming model not found in its predecessor GDI. GDI+ is found natively in Windows XP and the Windows Server 2003 family, and as a separate installation for Windows 2000, NT, 98, and ME. GDI+ is the currently the only drawing API used by the .NET Framework. |
|
|
Term
| Global Assembly Cache (GAC) |
|
Definition
| A reserved area of memory used to store the assemblies of all of the .NET applications running on a specific machine. The GAC is necessary for side-by-side execution and for the sharing of assemblies among multiple applications. To reside in the GAC, an assembly must be public (i.e., a shared assembly) and have a strong name. Assemblies are added and removed from the GAC using the Global Assembly Cache Tool. |
|
|
Term
| Global Assembly Cache Tool |
|
Definition
| A .NET programming tool (GACUtil.exe) used to install, uninstall, and list the contents of the Global Assembly Cache. This tool is similar in function to the Assembly Cache Viewer that run on Windows Explorer, but as a separate program it can be called from batch files, makefiles, and scripts. |
|
|
Term
|
Definition
| The practice of designing and developing software that can be adapted to run in multiple locales. Globalized software does not make assumptions about human language, country, regional, or cultural information based on a single locale. Instead, the software is written to change the locale-specific information it uses to process data and display information to the user based on the configured locale of the operating system, or the personal preference of the user. Also called internationalization. |
|
|
Term
|
Definition
| A unique number generated to identify each module in an assembly. The hash is used to insure that only the proper version of a module is loaded at runtime. The hash number is based on the actual code in the module itself. |
|
|
Term
|
Definition
| An area of memory reserved for use by the CLR for a running program. In .NET languages, reference types are allocated on the heap. |
|
|
Term
| Microsoft Host Integration Server |
|
Definition
| A set of Microsoft server applications use to ingrate the .NET platform and applications with non-Microsoft operating systems and hardware (e.g., Unix and AS/400), security systems (e.g., ACF/2 and RACF), data stores (e.g., DB2), and transaction environments (e.g., CICS and IMS). |
|
|
Term
| HTML (HyperText Markup Language) |
|
Definition
| A document-layout and hyperlink-specification language. HTML is used to describe how the contents of a document (e.g., text, images, and graphics) should be displayed on a video monitor or a printed page. HTML also enables a document to become interactive with other documents and resources by using hypertext links embedded into its content. HTML is the standard content display language of the World Wide Web (WWW), and is typically conveyed between network hosts using the HTTP protocol. |
|
|
Term
| HTTP (Hyper Text Transfer Protocol) |
|
Definition
| An Internet protocol used to transport content and control information across the World Wide Web. Web content typically originates from Web servers (also called HTTP servers) that run services which support the HTTP protocol. Web clients (i.e., Web browsers) access the content on the server using the rules of the HTTP protocol. The actual Web content is encoded using the HTML or XHTML languages. |
|
|
Term
| Windows Communication Foundation |
|
Definition
| A framework for building service-oriented applications. Using WCF, you can send data as asynchronous messages from one service endpoint to another. A service endpoint can be part of a continuously available service hosted by IIS, or it can be a service hosted in an application. An endpoint can be a client of a service that requests data from a service endpoint. The messages can be as simple as a single character or word sent as XML, or as complex as a stream of binary data. |
|
|
Term
| Interface Definition Language (IDL) |
|
Definition
| A language used to describe object interfaces by their names, methods, parameters, events, and return types. A compiler uses the IDL information to generate code to pass data between machines. Microsoft's IDL, called COM IDL, is compiled using the Microsoft IDL compiler (MIDL). MIDL generates both type libraries and proxy and stub code for marshaling parameters between COM interfaces. |
|
|
Term
|
Definition
| A CLR language feature that allows array-like access to the properties of an object using getter and setter methods and an index value. |
|
|
Term
|
Definition
| A .NET programming tool (InstallUtil.exe) used to install or uninstall one or more assemblies by executing the installer components contained within an assembly. During installation, all necessary files are saved to the application base folder and the required resources are created, including the uninstallation information. |
|
|
Term
|
Definition
| The set of properties, methods, indexers, and events exposed by an object that allow other objects to access its data and functionality. An object guarantees that it will support all of the elements of its interface by way of an interface contract. |
|
|
Term
|
Definition
The guarantee by an object that it will support all of the elements of its interface. In C#, this contract is created by the use of the Interface keyword, which declares a reference type that encapsulates the contract. |
|
|
Term
|
Definition
| A data storage mechanism used by the CLR to insure isolation and type safety by defining standardized ways of associating code with saved data. Data contained in isolated storage is always identified by user and by assembly, rather than by an address in memory, or the name and path of a file on disk. Other forms of security credentials, such as the application domain, can also be used to identify the isolated data. |
|
|
Term
|
Definition
| CLI language J# is Microsoft's implementation of the Java programming language. Tools are available that allow existing Java and Microsoft J++ code to be migrated to J#. Because J# compiles to MSIL and not Java bytecodes, J# applications are not compatible with the Java Virtual Machine(JVM) or the Java 2 platform. |
|
|
Term
| J2EE (Java 2 Enterprise Edition) |
|
Definition
| A Java-based, runtime platform created by Sun Microsystems used for developing, deploying, and managing multi-tier server-centric applications on an enterprise-wide scale. J2EE builds on the features of J2SE and adds distributed communication, threading control, scalable architecture, and transaction management. J2EE is a competitor to the Microsoft .NET Framework. |
|
|
Term
| J2ME (Java 2 Micro Edition) |
|
Definition
| A Java-based, runtime platform created by Sun Microsystems that allows Java applications to run on embedded devices, such as cellular telephones and Personal Digital Assistants (PDA). J2ME is a competitor to the Microsoft .NET Compact Framework. |
|
|
Term
| J2SE (Java 2 Standard Edition) |
|
Definition
| A Java-based, runtime platform that provides many features for developing Web-based Java applications, including database access (JDBC API), CORBA interface technology, and security for both local network and Internet use. J2SE is the core Java technology platform and is a competitor to the Microsoft .NET Framework. |
|
|
Term
| Java Language Conversion Assistant (JLCA) |
|
Definition
| A tool used to convert Java-language source code into C# or J# code. JLCA aides in the migration of Java 2 applications to the Microsoft .NET Framework, and is one of the .NET Framework Migration Tools created by ArtinSoft for Microsoft. |
|
|
Term
| Java Virtual Machine (JVM) |
|
Definition
| A component of the Java runtime environment that JIT—compiles Java bytecodes, manages memory, schedules threads, and interacts with the host operating environment (e.g., a Web browser running the Java program). The JVM is the Java equivalent of the .NET Framework's CLR. |
|
|
Term
|
Definition
| JScript .NET includes all of the features found in the JScript language, but also provides support for true object-oriented scripting using classes and types, and adds features, such as true compiled code, packages, cross-language support, and access to the .NET Framework. |
|
|
Term
|
Definition
| The concept of only compiling units of code just as they are needed at runtime. The JIT compiler in the CLR compiles MSIL instructions to native machine code as a .NET application is executed. The compilation occurs as each method is called; the JIT-compiled code is cached in memory and is never recompiled more than once during the program's execution. |
|
|
Term
|
Definition
A .NET programming tool (lc.exe) used to produce .licenses files that can be embedded in a CLR executable. |
|
|
Term
|
Definition
| The duration from an objects existence. From the time an object is instantiated to the time it is destroyed by the garbage collector. |
|
|
Term
|
Definition
| The assembly cache that stores the compiled classes and methods specific to an application. Each application directory contains a \bin subdirectory which stores the files of the local assembly cache. Also call the application assembly cache. |
|
|
Term
|
Definition
| A collection of rules and data specific to a spoken and/or written language and/or a geographic area. Locale information includes human languages, date and time formats, numeric and monetary conventions, sorting rules, cultural and regional contexts (semantics), and character classification. See Localization. |
|
|
Term
|
Definition
| The practice of designing and developing software that will properly used all of the conventions defined for a specific locale. |
|
|
Term
|
Definition
| Code that is executed by the CLR. Managed code provides information (i.e.,metadata) to allow the CLR to locate methods encoded in assembly modules, store and retrieve security information, handle exceptions, and walk the program stack. Managed code can access both managed data and unmanaged data. |
|
|
Term
|
Definition
| Memory that is allocated and released by the CLR using Garbage Collection. Managed data can only be accessed by managed code. |
|
|
Term
|
Definition
| The process used by the CLR to execute managed code. Each time a method in an object is called for the first time, its MSIL-encoded instructions are JIT-compiled to the native code of the processor. Each subsequent time the same method is called, the previous JIT-compiled code is executed. Compiling and execution continued until the program terminates. |
|
|
Term
|
Definition
| An object reference that is managed by the CLR. Used to point to unmanaged data, such as COM objects and some parameters of Win32 API functions. |
|
|
Term
|
Definition
| A pointer that directly references the memory of a managed object. Managed pointers may point to the field of an object or value type, an element of an array, or the address where the next element just past the end of an array would be stored. |
|
|
Term
|
Definition
.NET objects that provide managed access to services using a simplified data access architecture. The functionality of a provider is accessed via one or more object interfaces. The most common examples of managed providers are the data providers, such as SQL Server Managed Provider (System.Data.SqlClient), OLE DB .NET Data Provider (System.Data.Odbc), and ADO Managed (System.Data.ADO). .NET managed providers operate completely within the bounds of the CLR and require no interaction with COM interfaces, the Win32 API, or other unmanaged code. |
|
|
Term
|
Definition
| A resource that is part of an assembly. |
|
|
Term
|
Definition
| The process of preparing an object to be moved across a context, process, or application domain boundary. |
|
|
Term
|
Definition
| Typed memory locations used to store values. Also called fields. |
|
|
Term
|
Definition
| All information used by the CLR to describe and reference types and assemblies. Metadata is independent of any programming language, and is an interchange medium for program information between tools (e.g., compilers and debuggers) and execution environments. |
|
|
Term
| MIDL (Microsoft Interface Definition Language) Compiler |
|
Definition
| The program used to compile Interface Definition Language (IDL) files into type libraries. |
|
|
Term
|
Definition
| A subunit of an assembly. Assemblies contain one or more modules, which are DLLs that must be combined into assemblies to be used. The assembly manifest describes all of the modules associated with an assembly. |
|
|
Term
| Microsoft SQL Server Data Engine |
|
Definition
| a relational database management system developed by Microsoft. It is a scaled-down version of Microsoft SQL Server 7.0 or 2000 which is free for non-commercial use as well as certain limited commercial use. |
|
|
Term
| MSIL (Microsoft Intermediate Language) |
|
Definition
| The machine-independent language into which .NET applications are compiled using a high-level .NET language compiler (e.g., C# and VB.NET). The MSIL output is then used as the input of the Just-In-Time (JIT) compiler, which compiles the MSIL instructions to machine language just prior to its execution. MSIL can also be converted to native machine object code using the Native Image Generator utility. |
|
|
Term
|
Definition
A logical grouping of the names (i.e., identifiers) used within a program. A programmer defines multiple namespaces as a way to logically group identifiers based on their use. For example,System.Drawing and System.Windows are two namespaces each containing types used for for different purposes. The name used for any identifier may only appear once in any namespace. A namespace only contains the name of a type and not the type itself. Also called name scope. |
|
|
Term
|
Definition
| Machine-readable instructions that are created for a specific CPU architecture. Native code for a specific family of CPUs is not usable by a computer using different CPU architectures. Also called object code and machine code. |
|
|
Term
| OLE (Object Linking and Embedding) |
|
Definition
| A Microsoft technology that allows an application to link or embed into itself documents created by another type of application, such as embedding an Excel spreadsheet file into a Word document file, or emailing a Power Point file as an attachment in Microsoft Outlook. |
|
|
Term
|
Definition
| A block of memory that is marked as unmovable. Blocks of memory are normally moved at the discretion of the CLR, typically at the time of garbage collection. Pinning is necessary for managed pointer types that will be used to work with unmanaged code and expect the data to always reside at the same location in memory. A common example is when a pointer is used to pass a reference to a buffer to a Win32 API function. If the buffer were to be moved in memory, the pointer reference would become invalid, so it must be pinned to its initial location. |
|
|
Term
|
Definition
| An assembly that is used only by a single application. A private assembly will run only with the application with which it was built and deployed. References to the private assembly will only be resolved locally to the application directory it is installed in. |
|
|
Term
|
Definition
| A variable that contains the address of a location in memory. The location is the starting point of an allocated object, such as an object or value type, or the element of an array. |
|
|
Term
| Portable Executable (PE) file |
|
Definition
| The file format defining the structure that all executable files (EXE) and Dynamic Link Libraries (DLL) must use to allow them to be loaded and executed by Windows. PE is derived from the Microsoft Common Object File Format (COFF). The EXE and DLL files created using the .NET Framework obey the PE/COFF formats and also add additional header and data sections to the files that are only used by the CLR. |
|
|
Term
|
Definition
Types defined by the CLR in the System namespace. The pre-defined values types are integer, floating point, decimal, character, and boolean values. Pre-defined reference types are object and string references. |
|
|
Term
|
Definition
| A CLR language feature that allows the value of a single member variable to be modified using getter and setter methods defined in a class or structure. |
|
|
Term
|
Definition
Two or more identifiers that are connected by a dot character (.). Only namespace declarations use qualified identifiers (e.g., System.Windows.Forms). |
|
|
Term
|
Definition
| A variable that stores a reference to data located elsewhere in memory rather than to the actual data itself. Reference types include array, class, delegate, and interface. |
|
|
Term
|
Definition
A feature that allows an application to query its own metadata. Reflection (System.Reflection) allows an application to discover information about itself so that it may display this information to the user, modify its own behavior by using late-binding and dynamic invocation (i.e., binding to and calling methods at runtime), or create new types at runtime (Reflection Emit). |
|
|
Term
|
Definition
| A .NET technology that allows objects residing in different application domains to communicate. Objects in different application domains are said to be separated by a remoting boundary. Objects using remoting may be on the same computer, or on different computers connected by a network. Remoting is the .NET replacement for Distributed COM (DCOM). |
|
|
Term
|
Definition
| An addressable unit of data that is available for use by an application. Resources include text strings, files, documents, vector drawings, bitmapped images, binary data, data streams, message queues, and query result sets. In some contexts, application services themselves, such as Web services, are referred to as resources. |
|
|
Term
| Runtime Callable Wrapper (RCW) |
|
Definition
| A metadata wrapper that allows COM components to be called from .NET applications. For OLE automation interfaces, an RCW is a managed .NET assembly that is generated from the COM component's type library using the Type Library Importer tool. For non-OLE automation interfaces, a custom RCW must be written that manually maps the types exposed by the COM interface to .NET Framework-compatible types. |
|
|
Term
|
Definition
| A runtime environment used to manage the execution of program code. Examples include the .NET CLR and the Java Virtual Machine (JVM). |
|
|
Term
|
Definition
An assembly that contains only resources and no executable code. Satellite assemblies are typically used by .NET application to store localized data. Satellite assembles can be added, modified, and loaded into a .NET application at runtime without the need to recompile the code. Satellite assemblies are created by compiling .resource files using the Assembly Linking Utility. |
|
|
Term
| Secure Execution Environment (SEE) |
|
Definition
| A secure, managed-code, runtime environment within the Vista Operating System that helps to protected against deviant applications. This is a part of Microsoft's "Trustworthy Computing" initiative. |
|
|
Term
|
Definition
| The conversion of an object instance to a data stream of byte values. Serialization is performed by the CLR and occurs when an object must be converted to a persistent form to be stored in an information retrieval system (e.g., a database), on media (e.g., a file on a disk), or when marshaled across a context, application domain, process, or machine boundary. |
|
|
Term
|
Definition
| An application that provides information and/or functionality to other applications. Services are typically non-human-interactive applications that run on servers and interact with applications via an interface. A service may expose a synchronous, programmatic interface (i.e., an API), allowing it to be tightly-coupled with a consumer, or use asynchronous, message-based communications (e.g., HTTP, XML, and SOAP) to remain very loosely-coupled with consumers. Services are an essential part ofdistributed architecture program design. |
|
|
Term
| SGML (Standard Generalized Markup Language) |
|
Definition
| The standard markup language used by the publishing industry to specify the format and layout of both paper and electronic documents. SGML is very flexible and feature-rich, and it is very difficult to write a full-featured SGML parser. As a result, newer markup languages requiring fewer features (e.g., HTML and XML) are subsets of SGML. SGML is defined by the international standard ISO 8879. |
|
|
Term
|
Definition
| An assembly that can be referenced by more than one application. Shared assemblies must be built with a strong name and are loaded into the Global Assembly Cache. |
|
|
Term
|
Definition
| Running multiple versions of the same assembly simultaneously on the same computer, or even in the same process. Assemblies must be specifically (and carefully) coded to make use of side-by-side execution. |
|
|
Term
|
Definition
| A .NET program in which all components are combined into a single DLL or EXE file. Such an assembly does not require an assembly manifest. |
|
|
Term
| SOAP (Simple Object Access Protocol) |
|
Definition
| A lightweight, XML-based messaging protocol used to encode the information in Web service request and response messages before sending them over a network. SOAP messages are independent of any operating system or protocol, and may be transported using a variety of Internet protocols, including SMTP, MIME, and HTTP. |
|
|
Term
|
Definition
| An area of program memory used to store local program variables, method parameters, and return values. In .NET languages, value types are allocated on the stack. |
|
|
Term
|
Definition
| Types that declare methods which are associated with a type rather than an instance of the type. Static methods may be called without first instantiating their associated type. |
|
|
Term
|
Definition
| An assembly name that is globally unique among all .NET assemblies. A public key encryption scheme is used to create a digital signature to insure that the strong name is truly different than all other names created at anytime and anywhere in the known universe. The digital signature also makes it easy to encrypt the assembly, authenticate who created the assembly, and to validate that the assembly hasn't been corrupted or tampered with. Strong names are created using the Shared name utility. |
|
|
Term
|
Definition
| A programming language is said to be strongly-typed when it pre-defines specific primitive data types, requires that all constants and variables be declared of a specific type, and enforces their proper use by imposing rigorous rules upon the programmer for the sake of creating robust code that is consistent in its execution. |
|
|
Term
|
Definition
In .NET languages, structures are light-weight classes that are simpler, have less overhead, and are less demanding on the CLR. Structures are typically used for creating user-defined types that contain only public fields and no properties. But .NET structures, like classes, also support properties, access modifiers, constructors, methods, operators, nested types, and indexers. Unlike classes, however, structures do not support inheritance, custom constructors, a destructor (or Finalize) method, and no compile-time initialization of instance fields. It is important to note that a structure is a value type, while classes are a reference type. Performance will suffer when using structures in a situation where references are expected (e.g., in collections) and the structure must be boxed and unboxed for it to be used. |
|
|
Term
| System Definition Model (SDM) |
|
Definition
| An XML document that follows a system throughout its life and is kept updated as a system moves from the initial design and development stages through its lifecycle and into maintenance. The SDM defines a system, which includes hardware and software resources. It includes a means for the system to compose other systems and subsystems, expose its endpoints for communication purposes, and document its configuration requirements. When initially created, an SDM document can be a simple, skeletal view of a system. Additional information can be added to flesh out semantics, such as server configuration information, security and connection policies, service level agreements, health models, and other information. |
|
|
Term
|
Definition
| Code that accesses only the memory locations it is authorized to access, and only in well-defined, allowable ways. Type-safe code cannot perform an operation on an object that is invalid for that object. The C# and VB.NET language compilers always produce type-safe code, which is verified to be type-safe during JIT-compilation. The PEVerify tool can also be used to verify if code is type-safe. |
|
|
Term
|
Definition
| A set of data and function members that are combined to form the modular units used to build a .NET applications. Pre-defined types exist within the CLR and user-defined types are created by programmers. Types include enumerations, structures, classes, standard modules, interfaces, and delegates. |
|
|
Term
|
Definition
A compiled file (.tlb) containing metadata that describes interfaces and data types. Type libraries can be used to describe vtable interfaces, regular functions, COM components, and DLL modules. Type libraries are compiled from Interface Definition Language (IDL) files using the MIDLcompiler. |
|
|
Term
| UDDI (Universal Description, Discovery, and Integration) |
|
Definition
| An XML- and SOAP-based lookup service for Web service consumers to locate Web Services and programmable resources available on a network. Also used by Web service providers to advertise the existence of their Web services to consumers. |
|
|
Term
|
Definition
Conversion of a reference type object (i.e. System.Object) to its value type instance. Unboxing must be explicitly performed in code, usually in the form of a cast operation. |
|
|
Term
|
Definition
| Any code that executes outside of the control of the .NET Common Language Runtime. Unmanaged code may perform unsafe operations, such as declare and operate on pointers, take the address of a variable, and perform conversions between pointers and integral types. Uses of unmanaged code include calling operating system APIs, interfacing to COM components, accessing unmanaged areas of memory, and writing performance-critical routines that are not encumbered by the overhead of the CLR. Also called unsafe code. |
|
|
Term
|
Definition
| A variable that stores actual data rather than a reference to data, which is stored elsewhere in memory. Simple value types include the integer, floating point number, decimal, character, and boolean types. Value types have the minimal memory overhead and are the fastest to access. |
|
|
Term
|
Definition
| A typed storage location in memory. The type of the variable determines what kind of data it can store. Examples of variables include local variables, parameters, array elements, static fields and instance fields. |
|
|
Term
|
Definition
| An application hosted on a Web server that provides information and services to other network applications using the HTTP and XML protocols. A Web service is conceptually an URL-addressable library of functionality that is completely independent of the consumer and stateless in its operation. |
|
|
Term
|
Definition
| Open communication standards that are key technologies in the .NET Web Services architecture. These protocols include WSDL, HTTP, XML, SOAP, and UDDI. |
|
|
Term
| Web Services Description Language (WSDL) |
|
Definition
| An XML-based contract language for describing the network services offered by a Web service provider via UDDI. WSDL describes a Web service to Web service consumers by its public methods, data types of all parameters, return value, and bindings. WSDL will eventually replace Microsoft's earlier Web Services discovery protocol, DISCO. See the document Web Services Description Language (WSDL) 1.1. |
|
|
Term
| Windows Communication Foundation (WCF) |
|
Definition
| This communications technology focuses on providing spanning transports, security, messaging patterns, encoding, networking and hosting, and more. WCF brings together technologies ranging from Web Services to .NET Remoting to Windows Services — for building connected systems. |
|
|
Term
| Windows Presentation Foundation (WPF) |
|
Definition
| WPF is often referred to as the graphical subsystem of Windows Vista. More correctly stated, it is the way Windows creates, displays, and manipulates documents, media, and user interfaces. |
|
|
Term
|
Definition
| Extensible Application Markup Language, pronounced "zammel", is the declarative markup language for MS Expression Blend that allows an interface to be defined. These applications can be created by using XAML for the interface definition and managed procedure code for other logic. |
|
|
Term
| XML (eXtensible Markup Language) |
|
Definition
| A meta-markup language that provides a format for describing almost any type of structured data. XML is a subset of SGML and has become the standard language for storing, viewing, and manipulation Web-based data. XML allows the creation of custom tags to describe both proprietary data and business logic. |
|
|
Term
|
Definition
| Web-based .NET applications that provide services (i.e., data and functionality) to other Web-based applications (i.e. Web service consumers). XML Web services are accessed via standard Web protocols and data formats such as HTTP, XML, and SOAP. |
|
|
Term
| XPath (XML Path Language) |
|
Definition
| A language that uses path expressions to specify the locations of structures and data within an XML document. XPath information is processed using XSLT or XPointer. |
|
|
Term
| XSD (XML Schema Definition) |
|
Definition
| A language used to describe the structure of an XML document. XSD is used to defined classes that are in turn used to create instances of XML documents which conform to the schema. |
|
|
Term
| XSL (eXtensible Stylesheet Language) |
|
Definition
| A language used for creating stylesheets for XML documents. XSL consists of languages for transforming XML documents (XPath and XSLT) and an XML vocabulary for specifying formatting semantics. |
|
|
Term
| XSLT (eXtensible Stylesheet Language Transformation) |
|
Definition
| A language for transforming XML documents into other XML documents based of a set of well-defined rules. XSLT is designed for use as part ofXSL. |
|
|
Term
|
Definition
| A query language used to extract data from XML documents. XQL uses XML as a data model and is very similar to the pattern matching semantics of XSL. See the documentXML Query Language (XQL). |
|
|
Term
|
Definition
Methods, Variables and Constructors that are declared private can only be accessed within the declared class itself. Private access modifier is the most restrictive access level. Class and interfaces cannot be private.
Variables that are declared private can be accessed outside the class if public getter methods are present in the class. Using the private modifier is the main way that an object encapsulates itself and hide data from the outside world. |
|
|
Term
|
Definition
Variables, methods and constructors which are declared protected in a superclass can be accessed only by the subclasses in other package or any class within the package of the protected members' class.
The protected access modifier cannot be applied to class and interfaces. Methods, fields can be declared protected, however methods and fields in a interface cannot be declared protected.
Protected access gives the subclass a chance to use the helper method or variable, while preventing a nonrelated class from trying to use it. |
|
|
Term
|
Definition
| Internal types or members are accessible only within files in the same assembly. |
|
|
Term
|
Definition
| Visible only to classes that derive from the class that declares that member *and* are declared in a file in the same assembly. |
|
|
Term
|
Definition
| A task that must be executed before control is passed to the next step. |
|
|
Term
|
Definition
| Used when a successful update is required prior to control being passed to the next step. The task does not end when it is executed. The task ends when a terminating event is received. The terminating event requires a COMMIT WORK before it is triggered. |
|
|
