September 19, 2014
Hot Topics:
RSS RSS feed Download our iPhone app

Microsoft .NET Glossary

  • February 28, 2003
  • By Developer.com Staff, Bradley L. Jones
  • Send Email »
  • More Articles »

Note that terms that the terms "Microsoft" and ".NET" were generally not included when alphabetizing terms.


| A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | Other |


A

A1—The bundle of Microsoft antivirus and antispyware development lines.

Abstract IL (ILX)—A toolkit for accessing the contents of .NET Common IL binaries. Among its features, it lets you transform the binaries into structured abstract syntax trees that can be manipulated.

Acceleration Server 2000—See Internet Security and Acceleration Server 2000.

Access modifiers—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.

Acrylic— Codename for an innovative illustration, painting and graphics tool that provides creative capabilities for designers working in print, web, video, and interactive media.

Active Server Pages (ASP)—A Microsoft technology for creating server-side, Web-based application services. 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 and was code-named Denali.

ADO (ActiveX Data Objects)—A set of COM components used to access data objects through an OLEDB provider. ADO is commonly used to manipulate data in databases, such as Microsoft SQL Server 2000, Oracle, and Microsoft Access.

ADO.NET (ActiveX Data Objects for .NET)—The set of .NET classes and data providers used to manipulate databases, such as Microsoft SQL Server 2000. ADO.NET was formerly known as ADO+. ADO.NET can be used by any .NET language.

Aero—The code name for the user experience provided by Microsoft's Longhorn Operating System.

API (Application Program Interface)—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.

Application assembly cache—See Local assembly cache.

Application base—The directory where a .NET application's assembly files are stored. Also called the application folder or application directory.

Application Center 2000—A deployment and management package for Web sites, Web services, and COM components. Application Center is a key B2B and B2C component of the .NET Enterprise Server product family.

Application domain—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.

Application Manifest—The part of an application that provides information to describe the components that the application uses.

Array—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 inherits from the Array class that is located in the System namespace.

AsmL—An Abstract State Machine Language.

ASP.NET (Active Server Pages for .NET)—A set of .NET classes used to create Web-based, client-side (Web Form) and server-side (Web Service) applications. ASP.NET was derived from the Microsoft Active Server Pages (ASP) Web technology and adapted for use in the .NET Framework. Also called managed ASP and formerly known as ASP+.

Assembly—All of the files that comprise a .NET application, including the resource, 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, and is roughly the equivalent of a COM module. See assembly manifest, private assembly, shared assembly.

Assembly Binding Log Viewer—A .NET programming 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.

Assembly cache—A reserved area of memory used to store the assemblies of a .NET applications running on a specific machine. See Global Assembly Cache, Local assembly cache, Download Cache.

Assembly Cache Viewer—A .NET programming tool (Shfusion.dll) used to view, add, remove and configure information in the Global Assembly Cache using Windows Explorer. This viewer is used by clicking on the %WINDIR\Assembly folder in Windows Explorer. See Global Assembly Cache Utility.

Assembly Dependency List—A .NET programming tool (ADepends.exe) used to display all of the assemblies that a specific assembly is dependent upon.

Assembly informational version—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 (e.g., "Windows 2000 Server" or "FantastiWidget 3.0").

Assembly Linking Utility—A .NET programming tool (al.exe) used to create an assembly manifest from the specified MSIL modules or resource files. Also call the Assembly Linker and Assembly Generation Utility.

Assembly manifest—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.

Assembly metadata—The metadata stored in assembly files.

Assembly Registration Tool—A .NET programming 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.

Assembly version number—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. See Assembly informational version.

"Atlanta"—The code-name of an antivirus product being developed by Microsoft. (Named after the home town of one of the product's developers).

"Asta"—A project investigating algorithms for detecting cloned code.

Attribute-based programming—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. See Reflection.

Attributes—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. See Custom Attributes.

Avalon—The code name for Windows Presentation Foundation (WPF), which is the graphical subsystem (User Interface framework) of Longhorn. It is worth noting that this will be a vector-based system.


B

B2BBusiness-to-Business. The exchange of information between business entities.

B2CBusiness-to-Consumer. The exchange of information between business and consumer (i.e., customer) entities.

BackOffice Server 2000—A suite of Microsoft servers applications used for B2B and B2C services. Included in this suite are Windows 2000 Server, Exchange Server 2000, SQL Server 2000, Internet Security and Acceleration Server 2000, Host Integration Server 2000, and Systems Management Server 2.0. These server applications are now referred to as the .NET Enterprise Server product family.

Base class—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. See Derived Class, Inheritance.

Behave!—A project for building tools to checking things such as deadlock freedom, invariant checking, and message-understood properties in behavior properties of asynchronous, message-passing programs.

BizTalk Server 2000—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.

Boxing—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. See Unboxing.

Built-in Types—See Pre-defined types.

Burton—The codename for Microsoft Visual Studio 2005 Team System.


C

(C-Omega)—An experimental programming language — actually an extension to C# — that focuses on distributed asynchronous concurrency and XML manipulation. This is a combination of research projects that were formally known as polymorphic C# and Xen (and X#).

C# (C-Sharp)—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 and is considered by Microsoft as the natural evolution of the C and C++ languages. C# was created by Anders Hejlsberg (author of Turbo Pascal and architect of Delphi), Scot Wiltamuth, and Peter Golde. C# is defined by the standard ECMA-334.

Callback Method—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. See Event.

Casting—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).

Catching—To trap a program exception. See try/catch block.

Class—In .NET languages, classes are 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 called member 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. See structure.

Class members—The elements of a class which define it behaviors and properties. Class members include events, member variables, methods, constructors, and properties. Also called type members.

ClickOnce—A deployment technology introduced with the release of Whidbey that allows client program to be used and installed as seamless as Web applications. This includes the ability to download files to be installed, versioning, side-by-side installation, and more.

Client—Any application that requests information or services from a server. See Client/Server architecture.

Client-side—An operation or event that occurs on a client system. Examples include client-side scripting, client-side validation, and client-side events. See Server-side.

Client/Server architecture—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 contain 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. See Distributed architecture.

CLR Debugger—A .NET programming tool (DbgClr.exe) used as a Windows-based, source-level debugging utility for MSIL applications. See Runtime Debugger.

CLR Minidump Tool—A .NET programming tool (Mscordmp.exe) used to produce a mini-dump image file (i.e., a core dump) of the CLR at runtime. This tool is used to examine runtime problems by taking a snapshot of the CLR as the problems occurs. Windows automatically invokes the CLR Minidump Tool prior to running the Dr. Watson utility (Drwatson.exe).

Code Access Security (CAS)—The common language runtime's security model for applications. This is the core security model for new features of the Longhorn Operating System.

Collection—A class used to logically organize a group of identical types using a single identifier. Examples of collection types in the .NET Framework include array, arraylist, queue, and stack.

COM (Component Object Model)—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. COM was first released in 1993 with OLE2, largely to replace the interprocess communication mechanism Dynamic Data Exchanged (DDE) used by the initial release of OLE. See COM+.

COM+—The "next generation" of the COM and DCOM software architectures. COM+ (pronounced "COM plus") 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. The use of COM, DCOM, and COM+ in application design will eventually be entirely replaced by the Microsoft .NET Framework.

COM+ 2.0—This was one of the pre-release names for the original Microsoft .NET Framework. See also Web Services Platform.

COM Callable Wrapper (CCW)—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. See Runtime Callable Wrapper (RCW).

Commerce Server 2000—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.

Common Intermediate Language (CIL)—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).

Common Language Infrastructure (CLI)—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). The CLI is defined by the standard ECMA-335.

Common Language Runtime (CLR)—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. Also known as the Virtual Execution System (VES).

Common Language Specification (CLS)—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.

Common Object File Format (COFF)—See Portable Executable file.

Common Type System (CTS)—The .NET Framework 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.

Content Management Server 2001—Microsoft's server package for building, deploying, and maintaining dynamic content for both private or commercial Web sites.

Constructor—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. See Destructor.

Cool—The pre-release code name used for C#.

Cryptyc—A tool in the Microsoft research division for type-checking security protocols. In fact, the name stands for "Cryptographic Protocol Type Checker."

CSC—The .NET C# command line compiler (csc.exe).

Custom AttributesAttributes defined by a programmer to store the instance of any type in metadata. See Attribute-based programming, Reflection.


D

Data provider—A set of classes in the .NET Framework that allow access to the information a data source. The data may be located in a file, in the Windows registry, or any 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. See Managed providers.

DCOM (Distributed Component Object Model)—An extension of the Microsoft Component Object Model (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. DCOM was first made available in 1995 with the initial release of Windows NT 4.

Delegate—A mechanism used to implement event handling in .NET Framework code. 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. Delegates are often described as a managed version of a C++ function pointer. However, delegates can reference both instance and static (also called shared) methods, while function pointers can only reference static methods.

Deployment—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. See Installer Tool.

Deployment Manifest—The part of an application that tells the system how to install and maintain an application.

Derived class—A class that was created based on a previously existing class (i.e., base class). A derived class inherits all of the member variables and methods of the base class it is derived from. Also called a derived type.

Destructor—In traditional Object Oriented Programming, a destructor is a class method that is called when an object goes out of scope. In .NET languages, the destructor method is instead 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. See Constructor, Dispose.

DOM (Document Object Model)—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).

DISCO—An Microsoft-created XML protocol used for discovering Web Services. Much of DISCO is now a subset in the newer, more universal protocol UDDI. It is expected that DISCO will become obsolete in favor of UDDI.

Dispose—A class-only method used to implement an explicit way to release the resources allocated by an object. The dispose method is actually in implementation of the IDisposable interface, and is typically called by the destructor or Finialize method of a class.

Distributed architecture—An application architecture 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. A distributed, n-tier architecture may use many components running on dozens, hundreds or thousands of computers on a network to service a single application. This concept is reflected in Sun Microsystems' visionary phrase, "The network is the computerTM."

Download Cache—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.

DSI—Was Microsoft's Distributed System Initiative. Is also Microsoft's Dynamic System Initiative.

DTD (Document Type 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. Applications will use a document's DTD to properly read and display a document's contents. Changes in the format of the document can be easily made by modifying the DTD.

Dynamic Systems Initiative (DSI)—A 10-year plan to simplify management of software and hardware. It includes assemssment, configuration, monitoriing, management, and development tools. These tools will communicate their status in order improve how they operate.


E

ECMA (European Computer Manufactures Association)—The ECMA (known since 1994 as ECMA International) is an industry association founded in 1961 and dedicated to the standardization of information and communication systems. The C# and CLI specification were ratified by the ECMA on December 31, 2001 as international standards, and assigned to them the ECMA standards designations of ECMA-334 (C#) and ECMA-335 (CLI), and Technical Report TR-84. These standards are available at www.ecma.ch.

Enterprise Instrumentation Framework (EIF)—A feature that expands the program execution tracing capabilities found in the initial release of the .NET Framework. EIF allows the use of configurable event filtering and tracing by integrating .NET applications with the event log and tracing services built into the Windows operating system. Warnings, errors, business events, and diagnostic information can be monitored and reported for immediate, runtime analysis by developers, or collected and stored for later use by technical support personnel. Support for EIF will be included in the next release of Visual Studio.NET.

Event—A notification by a program or operating system that "something has happened." An event may be fired (or raised) in response to the occurrence of a pre-defined action (e.g., a window getting focus, a user clicking a button, a timer indicating a specific interval of time has passed, or a program starting up or shutting down). In response to an event, an event handler is called.

Event Handler—A function or method containing program statements that are executed in response to an event. See Callback method.

Everett—The pre-release code name of Visual Studio .NET 2003. Everett offers increased performance over Visual Studio .NET 1.0, integration with Windows Server 2003 and SQL Server 2003 (Yukon), extended support for XML Web services, MS Office programmability (the Visual Studio Tools for Office Development), improved migration tools for VB6 code, new managed data providers for Oracle and ODBC, and the addition of the Enterprise Instrumentation Framework (EIF) and mobile device support in the form of the .NET Compact Framework.

Exception—A signal that is generated when an unplanned or unexpected event occurs. Exceptions are typically caught by an exception handler and dealt with in an appropriate way. A fatal exception (also called a critical or catastrophic error) is an event that cannot be properly handled to allow the application—or the operating system—to continue running.

Exception Handling—The process of trapping an exception and performing some sort of corrective procedure in response. See try/catch block.

Exchange Server 2000—A set of Microsoft server applications use to ingrate 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.

Executable file—A file containing program instructions that are executed by an operating system or runtime environment. See Portable Executable file.

Extensible Markup Language (XML)—See XML.


F

Fields—Same as member variables.

Finalize—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. Also called a finalizer. See Dispose.

Finally block—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).

Framework Class Library (FCL)—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.

Fugue (FCL)— A tool for helping you write better .NET code. It is a "defect detection" tool. Fugue will do things such as check for fields that shouldn't be null, check for use of objects after they've been disposed, check to verify that methods are used in the proper order, and much more. Using Fugue, you record a set of rules for using a class or interface. Fugue will then verify that the rules are followed.


G

Garbage Collection (GC)—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.

GDI (Graphics Device Interface)—A Win32 API that provides Windows applications the ability to access graphical device drivers for displaying 2D graphics and formatted text on both the video and printer output devices. GDI (pronounced "gee dee eye") is found on all version of Windows. See GDI+.

GDI+ (Graphics Device Interface Plus)—The next generation graphics subsystem for Windows. GDI+ (pronounced "gee dee eye plus") 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.

Global Assembly Cache (GAC)—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.

Global Assembly Cache Tool—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.

Globalization—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. See localization, satellite assembly.


H

Hash Code—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.

"Hatteras"—Codename for Team Foundation Version Control tool. This is the new version control in Visual Studio 2005.

Heap—An area of memory reserved for use by the CLR for a running programming. In .NET languages, reference types are allocated on the heap. See Stack.

Host Integration Server 2000—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).

HTML (HyperText Markup Language)—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. See XHTML.

HTTP (Hyper Text Transfer Protocol)—An Internet protocol used to transport content and control information across the World Wide Web (WWW). 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.


I

Identifiers—The names that programmers choose for namespaces, types, type members, and variables. In C# and VB.NET, identifiers must begin with a letter or underscore and cannot be the same name as a reserved keyword. Microsoft no longer recommends the use of Hungarian Notation (e.g., strMyString, nMyInteger) or delimiting underscores (e.g., Temp_Count) when naming identifiers. See Qualified identifiers.

ILASM—See MSIL Assembler.

ILDASM—See MSIL Disassembler.

Indigo —The code name for for Windows Communication Foundation (WCF), which is the communications portion of Longhorn that is built around Web services. This communications technology focuses on providing spanning transports, security, messaging patterns, encoding, networking and hosting, and more.

"Indy"—The code-name for a capacity Planning tool being developed by Microsoft. This was originally a part of Longhorn, but is speculated to ship earlier.

Interface Definition Language (IDL)—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.

Indexer—A CLR language feature that allows array-like access to the properties of an object using getter and setter methods and an index value. This construct is identical to operator[] in C++. See Property.

Installer Tool—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.

Interface—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.

Interface contract—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.

Intermediate Language (IL)—See MSIL.

Inheritance—The ability of a class to be created from another class. The new class, called a derived class or subclass, is an exact copy of the base class or superclass and may extend the functionality of the base class by both adding additional types and methods and overriding existing ones.

Instant fields—The member variables in an object instance.

Internet Security and Acceleration Server 2000—A set of applications used to provide firewall security and Web caching services to a single Web site or to an enterprise-scale Web farm.

Intrinsic Types—See Built-in Types.

Isolated storage—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.

Isolated storage tool—A .NET programming tool (Storeadm.exe) used to list and remove all existing stores for the current user. See Isolated storage.

Istanbul—The code name for the newest member of the Microsoft Office System — predicted to be out in 2005 — that will provide integrated communications capabilities including instant messaging, extensible presence, PC-based voice and video, and telephony integration.


J

J# (J-Sharp). A Microsoft-supported language for .NET. J# (pronounced "jay sharp") is Microsoft's implementation of the Java programming language. It specifically designed to allow Java-language developers to easily transition to the .NET Framework and to create .NET applications. Tools are also 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. However, J# applications can be written using Visual Studio .NET and then compiled using third-party Java tools. See Java Language Conversion Assistant.

J2EE (Java 2 Enterprise Edition)—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.

J2ME (Java 2 Micro Edition)—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.

J2SE (Java 2 Standard Edition)—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.

Java—A computing platform and programming language released by Sun Microsystems in 1995. A Java application has the ability to run on many different types of computers, devices, operating systems (e.g., Windows, Macintosh, Linux and UNIX), and application environments (e.g., Web browsers) without requiring any changes to its code (this technology is referred to by Sun as "Write Once, Run AnywhereTM" portability). The Java 2 platform and language is a competitor to the Microsoft .NET Framework and the J# language. See the java.sun.comWebsite.

Java Language Conversion Assistant (JLCA)—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.

Java Virtual Machine (JVM)—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.

JScript .NET—A Microsoft-supported language for .NET. JScript .NET (pronounced "jay script dot net") is Microsoft's "next generation" implementation of the JavaScript programming language. 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.

Just In Time (JIT)—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.


K

Keywords—Names that have been reserved for special use in a programming language. The C# language defines about 80 keywords, such as bool, namespace, class, static, and while. The 160 or so keywords reserved in VB.NET include Boolean, Event, Function, Public, and WithEvents. Keywords may not be used as identifiers in program code.


L

"Ladybug"—Code-name for product officially known as the Microsoft Developer Network Product Feedback Center where testers can submit online bug reports and provide product suggestions via the Web.

License Compiler—A .NET programming tool (lc.exe) used to produce .licenses files that can be embedded in a CLR executable.

Lifetime—The duration from an objects existence. From the time an object is instantiated to the time it is destroyed by the garbage collector.

Local assembly cache—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. See Global Assembly Cache.

Local Variable—Same as a member variable.

Locale—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.

Localization—The practice of designing and developing software that will properly used all of the conventions defined for a specific locale. See Globalization.

Lonestar—The codename for Windows XP Tablet PC Edition 2005.

Longhorn—The "next generation" release of Windows Server after Windows Server 2003 and named Microsoft Windows Vista.

Longhorn API—The application programming interface for the Longhorn operating system.


M

"Magneto"—The code-name for Windows Mobile 5.0. This version is to unify the Windows CE, PocketPC, and SmartPhone platforms. This platform includes a new user interface, improved video support, better keyboard support, and more.

Make Utility—A .NET programming tool (nmake.exe) used to interpret script files (i.e., makefiles) that contain instructions that detail how to build applications, resolve file dependency information, and access a source code control system. Microsoft's nmake program has no relation to the nmake program originally created by AT&T Bell Labs and now maintained by Lucent. Although identical in name and purpose these two tools are not compatible. See Lucent nmake Web site.

Managed ASP—Same as ASP.NET.

Managed C++—Same as Visual C++ .NET.

Managed code—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.

Managed data—Memory that is allocated and released by the CLR using Garbage Collection. Managed data can only be accessed by managed code.

Managed execution—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.

Managed Extensions for C++—Language extensions added to the C++ language that enable developers to write code that makes use of the .NET Framework's CLR. See as Visual C++ .NET.

Managed pointer types—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.

Managed pointers—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.

Managed providers—.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.

Managed resources—A resource that is part of an assembly.

Manifest—See Assembly manifest.

Marshaling—The process of preparing an object to be moved across a context, process, or application domain boundary. See Remoting.

Members—See Class members.

Member variablesTyped memory locations used to store values. Also called fields.

Metadata—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. See MSIL.

Method—A function defined within a class. Methods (along with events) defined the behavior of an object.

"Metro"—Code-name for a set of print document specifications along with the set of printer drivers. This is being built as a part of Longhorn. It appears that it could become a competitor to PDF and Adobe's PostScript.

MIDL (Microsoft Interface Definition Language) Compiler—The program used to compile Interface Definition Language (IDL) files into type libraries.

Mobile Information Server 2002—A set of applications used for extending Microsoft .NET applications, enterprise data, and intranet content to mobile client devices such as cell phones and Personal Digital Assistants (PDA). Features include network gateway, notification routing, security (SSL, IPSec, VPN), mobile device support (WAP, SMS) and integration with Windows 2000.

Module—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 (sometimes called a module manifest) describes all of the modules associated with an assembly.

MSDE 2000 (Microsoft Data Engine)—A light weight release of the SQL Server 7.0 data engine. The MSDE is used as a relational data store on many Microsoft products, including BizTalk Server 2000, Host Integration Server 2000, SQL Server 2000, Visual Studio.NET, and the .NET Framework. The MSDE a modern replacement for the older Microsoft Jet database technology.

MSIL (Microsoft Intermediate Language)—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.

MSBuild—The build tool (MSBuild.exe) for Longhorn applications.

MSIL Assembler—A .NET programming tool (ILAsm.exe) used to create MSIL portable executable (PE) files directly from MSIL code.

MSIL Disassembler—A .NET programming tool (ILDAsm.exe) used to translate a portable executable (PE) file containing MSIL code to an an MSIL file that can be used as input to MSIL Assembler.

Multi-module Assembly—A .NET program which is contained in many modules and resource files. The use of an assembly manifest to identify all of the files in a multi-module assembly is required.


N

Namespace—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 containing 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.

Native code—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 (c.f., Intel x86 and Sun UltraSPARC). Also called object code and machine code.

Native Image Generator—A .NET programming tool (Ngen.exe) used to compile a managed assembly to native machine code and install it in the local assembly cache. During execution the native image will be used each time the assembly is accessed rather than the MSIL assembly itself. If the native image is removed, the CLR reverts to using the original MSIL assembly by default. Native images are faster to load and execute than MSIL assemblies, which must be Just-In-Time (JIT) compiled by the CLR. Using Ngen to create a native image file is often referred to as pre-JITting, because it makes JIT-compiling the assembly unnecessary.

.NET Compact Framework—A port of the .NET Framework to Windows CE, allowing embedded and mobile devices to run .NET applications. See Smart Device Extensions.

.NET Data Provider—See Data provider.

.NET Enterprise Server product family—These products include Application Center, BizTalk Server, Commerce Server, Content Management Server, Exchange Server, Host Integration Server, Internet Security and Acceleration Server, SQL Server 2000 , and Windows 2000 Server. Formerly known as BackOffice Server 2000.

.NET Framework—A programming infrastructure created by Microsoft for building, deploying, and running applications and services that use .NET technologies, such as desktop applications and Web services. The .NET Framework contains three major parts: the Common Language Runtime (CLR), the Framework Class Library, and ASP.NET. See .NET Compact Framework.

.NET Framework Class Library (FCL)—The foundation of classes, interfaces, value types, services and providers that are used to construct .NET Framework desktop and Web-based (i.e., ASP.NET) applications. The fundamental elements of the FCL are defined as classes located in the System namespace. All of the most primitive aspects of .NET are stored in System, including built-in value types, the Object type, and support for exception handling and garbage collection. Thousands of more classes are located in second- and third-level namespaces that include support for network and file I/O, graphics, security, configuration management, and Web services. All CLS-compliant compilers can use the FCL.

.NET Framework Configuration Tool—A .NET programming tool (Mscorcfg.msc) used to adjust code access security policy at the machine, user, and enterprise security policy levels. This tool can also be used to configure remoting services, and add, configure, and delete assemblies in the Global Assembly Cache. See Global Assembly Cache Utility.

.NET Services Installation Tool—A .NET programming tool (Regsvcs.exe) used to add managed classes to Windows 2000 Component Services. This tool loads and registers an assembly, generates, registers, and installs a type library into a specified COM+ 1.0 application.

NGSCB—Next-Generation Secure Computing Base—A virtual vault residing within each computer that lets users store encrypted information and only authorize certain entities to see it. It also provides protection for critical data against virus attacks, Trojan horses and spyware and could double as a Digital Rights Management tool to authenticate who is allowed to see a file or use a program.

NGWS—Next Generation Web Service—This was one of the pre-release names for .NET before its release.


O

Object—The instance of a class that is unique and self-describing. A class defines an object, and an object is the functional, realization of the class. Analogously, if a class is a cookie cutter then the cookies are the objects the cutter was used to create.

Object type—The most fundamental base type (System.Object) that all other .NET Framework types are derived from.

OLE (Object Linking and Embedding)—A Microsoft technology that allows an application to link or embed into itself documents created by another type of application. Common examples include using Microsoft Word to embed an Excel spreadsheet file into a Word document file, or emailing a Microsoft Power Point file as an attachment (link) in Microsoft Outlook. OLE is often confused with the Component Object Model (COM), because COM was released as part of OLE2. However, COM and OLE are two separate technologies.

Orcas—The code name for the version of Visual Studio .NET to be released near the time Microsoft Longhorn is released. This follows the release of Visual Studio .NET Whidbey.

Overloading—Using a single identifier to refer to multiple methods that differ by their parameters and/or return type.

Overriding—To supercede an instance field or virtual method in a base class with a new definition of that field or method in the derived class.


P

Palladium—Former code name for Microsoft's Next-Generation Secure Computing Base (NGSCB) project.

"Pheonix"—A software optimization and analysis framework that is to be the basis for all future Microsoft compiler technologies.

"Photon"—A feature-rich upgrade to Windows Mobile that includes features such as battery life. This version will follow Windows Mobiles 2005 (code-named "Magneto").

Pinned—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.

Pre-JIT compiler—Another name for the Native Image Generator tool used to convert MSIL and metadata assemblies to native machine code executables.

Private assembly—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. See Shared assembly.

Pointer—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.

Pointer types—See Managed pointer types, Unmanaged pointer types.

Portable Executable (PE) file—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. The specification for the PE/COFF file formats is available at www.microsoft.com/hwdev/hardware/PECOFF.asp.

Portable Executable Verifier—A .NET programming tool (PEVerify.exe) used to verify that a .NET compiler has created type-safe metadata and MSIL code. Because Microsoft .NET compilers always generate type-safe code, this tool is used primarily with third-party ILASM-based compilers to debug possible code generation problems.

Pre-defined types—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. See User-defined types.

Primary Interop Assemblies (PIAs)—Assemblies that come with Microsoft Office 2003 that allow managed code (VB .NET, C#, etc.) to call Office code.

Project Green— code name for Microsoft's next-generation ERP product code base.

Property—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. See Indexer.


Q

Qualified identifiers—Two or more identifiers that are connected by a dot character (.). Only namespace declarations use qualified identifiers (e.g., System.Windows.Forms).


R

R2—The codename for the Windows Server 2003 Update due in 2005.

Register Assembly Tool—Same as Assembly Registration Tool.

Register Services Utility—Same as .NET Services Installation Tool.

Reference types—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. See Value types, Pointer types.

Reflection—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). See Attribute-based programming.

Remoting—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). See Marshaling.

Resource—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.

Resource File Generator Tool—A .NET programming tool (Resgen.exe) used to convert the resource information stored in text files or XML .resx files to .resource files that can be embedded in a runtime, binary executable, or compiled into satellite assemblies using the Assembly Linking Utility.

Runtime Callable Wrapper (RCW)—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. See COM Callable Wrapper (CCW).

Runtime Debugger—A .NET programming tool (CorDbg.exe) used as a command-line, source-level debugging utility for MSIL programs. See CLR Debugger.

Runtime host—A runtime environment used to manage the execution of program code. Examples include the .NET Common Language Runtime and the Java Virtual Machine (JVM).


S

Satellite assembly—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.

Saturn—the code name for the original ASP.NET Web Matrix product.

Seamless Computing—A term indicating that a user should be able to find and use information effortlessly. The hardware and software within a system should work in an intuitive manner to make it seamless for the user. Seamless computing is being realized with the improvements in hardware (voice, ink, multimedia) and software.

Secure Execution Environment (SEE)—A secure, managed-code, runtime environment within the Microsoft Longhorn Operating System that helps to protected against deviant applications. This is a part of Microsoft's "Trustworthy Computing" initiative.

Serialization—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.

Server—A computer program or system that provides information or services requested by a client. See Client/Server architecture.

Server-side—An operation or event that occurs on a server system. Examples include server-side scripting, server-side objects, and server-side processing. See Client-side.

Service—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 of distributed architecture program design.

SGML (Standard Generalized Markup Language)—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.

Shared assembly—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. See Private assembly.

Shared name—Same as a strong name. Also called published name.

Shared name utility—A .NET programming tool (Sn.exe) used to verify assemblies and their key information and to generate key files. This utility is also used to create strong names for assemblies.

Side-by-Side Execution—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.

Single-module assembly—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.

SLAM—A project for investigating the relationships between software Specifications, Languages, Analysis, and Model checking.

Smart Device Extensions (SDE)—An installable SDK that allows Visual Studio .NET 1.0 to be used for developing .NET application for the Pocket PC and other handheld devices that support the Microsoft Windows CE .NET operating system and the Microsoft .NET Compact Framework. SDE will be fully integrated into Visual Studio .NET 2003.

SOAP (Simple Object Access Protocol)—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.

SoapSuds Tool—A .NET programming tool (SoapSuds.exe) used to create XML schemas for services in a .NET assembly, and to create an assembly from an XML schema. This tool is used primarily to compile client applications that communicate with XML Web services using remoting.

SQL Server 2000—Microsoft's enterprise-scale relational database and member of the .NET Enterprise Server product family.

Stack—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. See Heap.

Static fieldsTypes that declare member variables which are associated with a type rather than an instance of the type. Static fields may be access without first instantiating their associated type.

Starlite—A code name for the original Microsoft .NET Compact Framework

Static methodsTypes 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.

Strong name—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.

Strongly-typed—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.

Structure—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 (identical to structures in the C language). 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.

Stylesheets—Data files used to express how the structured content of a document should be presented on a particular physical medium (e.g., printed pages, Web browser, hand-held device, etc.). Details of the presentation include font style, lay out, and pagination. Also called templates.

System Definition Model (SDM)—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. (From An Overview of Microsoft's Whitehorse.)

System Center—A brand name for Microsoft's systems management products (it is no longer a 'bundled' product).

System Center Capacity Manager—A capacity planning tool from Microsoft due out by the end of 2005. It is designed to help companies model, deploy and manage network resources.

Windows Server Update Services (WSUS)—A free server for downloading patches from Microsoft that can be used by corporations. The server will push the patches out to desktops and servers. Targeted for shipping in July of 2005.


T

"Talisker"—The pre-release code name for Windows CE .NET (a.k.a., Windows CE 4.x).

Throwing—When an abnormal or unexpected condition occurs in a running application, the CLR generates an exception as an alert that the condition occurred. The exception is said to be thrown. Programmers can also programmatically force an exception to be thrown by the use of the throw statement. See Exception Handling.

Trustbridge—A directory-enabled middleware that supports the federating of identities across corporate boundaries.

Try/Catch block—An exception handling mechanism in program code. A try block contains a set of program statements that may possibly throw an exception when executed. The associated catch block contains program statements that handle any exception that is thrown in the try block. Multiple catch blocks may be defined to catch specific exceptions (e.g., divide by zero, overflow, etc.). See Finally block.

Type-safe—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.

Types—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. See Type members.

Type library—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 MIDL compiler.

Type Library Exporter—A .NET programming tool (TlbExp.exe) used to create a COM type library file based on the public types defined within a specified .NET assembly.

Type Library Importer—A .NET programming tool (TlbImp.exe) used to create a managed .NET assembly from a COM type library by mapping the metadata-encoded definitions to the appropriate .NET types.

Type members—Same as class members.

Typelib—A type library.


U

UDDI (Universal Description, Discovery, and Integration)—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.

Unboxing—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. See Boxing.

Unmanaged—An adjective generally applied to any code or data that is outside of the control of a runtime host environment. In .NET, any objects or resources not allocated and controlled by the CLR are considered unmanaged (e.g., Windows handles and calls to the Win32 API).

Unmanaged code—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.

Unmanaged data—Data (i.e. memory) that is allocated outside of the control of the CLR. Unmanaged data can be access by both managed and unmanaged code.

Unmanaged pointer types—Any pointer type that is not managed by the CLR. That is, a pointer that store a reference to an unmanaged object or area of memory.

Unmanaged resources—Objects created and manipulated outside of the control of the CLR. Examples includes file handles opened using the Win32 API, and database connections obtained using ODBC.

Unsafe—Same as unmanaged.

User-defined types—Reference (object) types defined in code by a programmer. See Pre-defined types.


V

Value types—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. See Reference types, Pointer types.

Variable—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. See Types.

Version number—See Assembly version number.

Vienna—Code name for the Microsoft Office Live Communications Server 2005 (LCS 2005) beta.

Visual Basic .NET (VB.NET)—A Microsoft-supported language for the .NET Framework. VB.NET is the "next generation" release of the very popular Visual Basic programming language (a.k.a., VB7).

Visual C++ .NET—A Microsoft-supported language for .NET Framework. Visual C++ .NET allows developers to use the C++ language to write managed applications, and to easily migrate legacy C++ code to the .NET Framework. Code written in Visual C++ .NET is also referred to as managed C++; code written in the legacy Visual C++ language is sometimes referred to as unmanaged C++.

Visual Studio .NET (VS .NET)—A full-featured, Interactive Development Environment (IDE) created by Microsoft for the development of .NET applications. VS .NET makes a better alternative to Visual Notepad for creating .NET applications. Officially called Microsoft Visual Studio .NET 2002.

Visual Studio .NET 2003 (VS .NET)—The second version of Visual Studio .NET that was also known by the code name Everett.

Visual Studio 2005(VS .NET)—The third version of Visual Studio .NET that was also known by the code name Whidbey. This version is due to release in 2005.

Visual Studio Team System 2005 (VS .NET)—A high-end skew for Visual Studio 2005. This version includes enterprise-level tools and more. Codename for this product was known as "Burton".


W

Web Form—A .NET Framework object that allows development of Web-based applications and Web sites. See Windows form.

The Web Matrix Project—A free WSIWIG development product (IDE)for doing ASP.NET development that was released as a community project. The most recent version—The Web Matrix Project (Revisited)—can be found here.

Web service—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.

Web service consumer—An application that uses Internet protocols to access the information and functionality made available by a Web service provider. See Web service.

Web Service Protocols—Open communication standards that are key technologies in the .NET Web Services architecture. These protocols include WSDL, HTTP, XML, SOAP, and UDDI.

Web Service Platform—This was one of the pre-release names for the original Microsoft .NET Framework. See also COM+ 2.0.

Web service provider—A network application that uses Internet protocols to advertise and provide services to Web service consumers. See Web service.

Web Services Description Language (WSDL)—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.

Web Services Description Language Tool—A .NET programming tool (Wsdl.exe) used to create service descriptions and generate proxies for ASP.NET Web service methods.

Web Services Discovery Tool—A .NET programming tool (Disco.exe) used to locate the URLs of XML Web services located on a Web server, and save the information related to the resources of each XML Web service to a set of files. These files can be used as input to the Web Services Description Language Tool to create XML Web service clients. See DISCO.

Whidbey—The pre-release code name for the "next generation" release of Visual Studio after Everett and prior to Longhorn.

Whistler—The pre-release code name used for Windows XP.

Whitehorse—The code name for the set of modeling tools included in Micrsoft Visual Studio 2005 ("Whidbey"). See An Overview of Microsoft's Whitehorse.

Windows 2000 Server—The central server operating system of the Microsoft BackOffice Server 2000 product family. Windows 2000 Sever (also known as Windows NT 5) is the successor of Windows NT Server 4.0 and will be replaced by Windows Server 2003.

Windows Communication Foundation (WCF)—Previously code named "Indigo", WCF is the communications portion of Windows Vista that is built around Web services. This communications technology focuses on providing spanning transports, security, messaging patterns, encoding, networking and hosting, and more. Ultimately, this WCF will deliver a consistent experience — bringing together technologies ranging from Web Services to .NET Remoting to Windows Services — for building connected systems.

Windows Forms Class Viewer—A .NET programming tool (WinCV.exe) used to search for and display the namespace and class information within an assembly.

Windows Forms Resource Editor—A .NET programming tool (Winres.exe) used to help a programmer modify localization information in a Windows Form.

Windows Form—A .NET Framework object that allows the development of "traditional" Windows desktop applications. Also called WinForms. See Web Form.

Windows Installer—The software installation and configuration service for Windows 2000 and Windows XP. Most .NET applications can be successfully deployed using XCOPY. However, if a deployment requires complex tasks, such as changes in system configuration, creation of user, groups, or folders, etc., Windows Installer must be used. Windows Installer 2.0 is required for use by the .NET Framework; it is also available for Windows 9x and Windows NT.

Windows .NET Server 2003—The original name of Windows Server 2003. The ".NET" was dropped as part of an attempt to remarket the concept of .NET not as a product, but instead as a business strategy.

Windows Presentation Foundation (WPF)—Previously code named "Avalon", WPF is often referred to as the graphical subsystem of Windows Vista. More correctly stated, it is the way in which Windows Vista will create, display, and manipulate documents, media, and user interfaces. This system is expected to use vector graphics, allow for better transparency, and more.

Windows Server 2003—The next generation of Windows 2000 Server that offers tighter integration with the .NET Framework, and greater support for Web services using Internet Information Server 6.0 and XML and UDDI services. This product was formerly known as Windows .NET Server 2003.

Windows Update —A site maintained by Microsoft for patch updates. Due out by end of 2005.

Windows Vista—The "next generation" client release of the Windows Operating System after Windows Server 2003, which was code named Longhorn.

WinFS—("Windows Future System") The code name for the new type-aware, transactional, unified file system and programming model that will be a key part of Longhorn. WinFS allows various kinds of data and information stored on your machine to be associated and categorized. You can associate relationships between information and these associations can be used to access what is stored on your machine.

WinFX—The new Windows API that will be released with the Microsoft Longhorn Operating System. This will include features for Avalon, Indigo, and WinFS as well as a number of fundamental routines.

WPO—Whole Program Optimization—This is an optimization that can be done by the C++ compiler. All object modules are viewed at once before generating code, which allows for additional optimizations to be performed.


X

XAML—(Extensible Application Markup Language) The declarative markup language for Longhorn that allows an interface to be defined. Longhorn applications can be created by using XAML for the interface definition and managed procedure code for other logic.

XCOPY—An MS-DOS file copy program used to deploy .NET applications. Because .NET assemblies are self-describing and not bound to the Windows registry as COM-based application are, most .NET applications can be installed by simply being copied from one location (e.g., directory, machine, CD-ROM, etc.) to another. Applications requiring more complex tasks to be performed during installation require the use of the Microsoft Windows Installer.

XDR (XML Data-Reduced)—A reduced version of XML Schema used prior to the release of XML Schema 1.0.

XDA—A consolidated development environment that allows programs to be created for Windows, XBoxes, and more.

XHTML (eXtensible HyperText Markup Language)—The next generation of HTML. HTML was originally designed to display data; XML was specifically designed to describe data. XHTML is a combination of all the elements in HTML 4.01 with the the syntax of XML. Although nearly identical to HTML, XHTML has much stricter rules and is cleaner in its syntax, thus resulting in well-formed Web pages that are more portable across a wide range of Web browsers.

Xlink (XML Linking Language)—A language that allows links to other resources to be embedded in XML documents, similar to the hyperlinks found in HTML Web pages. See the document XML Linking Language (XLink) Version 1.0.

XML (eXtensible Markup Language)—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. See the document Extensible Markup Language (XML) 1.0 (Second Edition).

XML Schema—A description of the structure of an XML document. Schemas are written in XSD and support namespaces and data types.

XML Schema Definition Tool— A .NET programming tool (Xsd.exe) used to generate XML schemas (XSD files) from XDR and XML files, or from class information in an assembly. This tool can also generate runtime classes, or DataSet classes, from an XSD schema file.

XML Web services—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.

XPath (XML Path Language)—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. See the document XML Path Language (XPath) Version 1.0.

XPointer (XML Pointer Language)—A language that supports addressing into the internal structures of XML documents. XPointer allows the traversals of an XML document tree and selection of its internal parts based on element types, attribute values, character content, and relative position. XPointer is based on the XML Path Language (XPath). See the document XML Pointer Language (XPointer).

XSD (XML Schema 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. See the document XML Schema Part 0: Primer.

XSL (eXtensible Stylesheet Language)—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. See the document Extensible Stylesheet Language (XSL) Version 1.0.

XSLT (eXtensible Stylesheet Language Transformation)—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 of XSL. See the document XSL Transformations (XSLT) Version 1.0.

XQL (XML Query Language)—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 document XML Query Language (XQL).


Y

Yukon—The code name for the release of Microsoft SQL Server 2003 (a.k.a., SQL Server 9). Yukon offers a tighter integration with both the .NET Framework and the Visual Studio .NET IDE. Yukon will include full support for ADO.NET and the CLR, allowing .NET languages to be used for writing stored procedures.


Z

No entries.


Other

No entries.


Glossary compiled with the help of James D. Murray and others.

For suggestions, corrections, or other changes, send an e-mail to editor@Developer.com.

# # #






Comment and Contribute

 


(Maximum characters: 1200). You have characters left.

 

 


Sitemap | Contact Us

Rocket Fuel