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. 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.
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
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.
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
B2B—Business-to-Business. The exchange of information between business entities.
B2C—Business-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ω (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 Attributes—Attributes 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