In July 2001, Microsoft has shipped « Microsoft .Net Framework SDK Beta 2 ». Do you remember these old days? Do you remember what .NET is? From the marketing side, you will find some PowerPoint presentations but from the Team that built it, here is the memo from the Windows Source Code Training.

What is .NET? …

• Microsoft Marketing: “Microsoft .NET is software that connects information, people, systems, and devices. It spans clients, servers, and developer tools.”
  • A vision or marketing strategy, as much as a technology
• .NET is a “software platform”
  • Language-neutral environment
  • Produces programs that can easily and securely interoperate
  • “.NET” programs should run wherever .NET is implemented
    • Not targeted or tied to a particular hardware/OS combination
• Framework for developing all types of applications – especially client-server and web applications

… What is .NET? …

• .NET is also the collective name given to various bits of software built upon the .NET platform
  • Some products:
    • Visual Studio.NET
    • Windows 2003 Server
    • SQL Server
    • BizTalk Server
    • etc.
  • Some services
    • e.g. Passport
• Client systems, such as Windows XP, Windows CE, Microsoft Office

… What is .NET?

• C# and Common Language Infrastructure are international standards (ECMA)
  • Common Language Infrastructure (CLI)
  • Common Language Runtime (CLR)
  • Common Type System (CTS)
  • Common Language Specification (CLS)
  • Framework Class Libraries
  • Specifications available at
    http://www.ecma-international.org/  or http://msdn.microsoft.com/net/ecma/
• Web Services
• Assemblies
• Metadata
• Attributes
• Managed Code and Data
• Microsoft Intermediate Language (MSIL)

Microsoft Intermediate Language …

• All .NET languages compile into Microsoft Intermediate Language (MSIL)
  • In the ECMA standard, MSIL is known as the Common Intermediate Language (CIL)
• Processor-neutral pseudo machine language
  • Similar in concept to Java byte code
  • But, designed to be compiled into native processor instructions before being run (rather than interpretated)
  • Converted to executable machine code by the Framework JIT (Just in Time) compiler
• MSIL assembler converts MSIL text into MSIL binary
  • [ilasm.exe : root\NT\com\netfx\src\clr\ilasm]
• Just-in-Time compiler performs transformation from MSIL to native processor instructions
  • [root\NT\com\netfx\src\clr\jit]

… Microsoft Intermediate Language

• .NET Execuatables (.exe’s) and DLLs contain MSIL
  • Not x86 machine code
• ILDASM is an MSIL “disassembler”
  • [ildasm.exe  : root\NT\com\netfx\src\clr\ildasm]
• “Obfuscator” converts class/method/variable names in a .NET executable into unintelligible equivalents to help prevent reverse-enginering a .NET program
  • [root\NT\com\netfx\src\clr\toolbox\obfus]
• MSIL may be “pre-compiled” into native processor instructions before runtime using NGEN utility
  • [ngen.exe : root\NT\com\netfx\src\clr\tools\ngen]

Common Language Runtime …

• Manages memory
  • All memory allocations come from a single process heap
  • Automatic garbage collection
    • No API to free memory (“garbage collection” performed automatically)
• Thread execution
• Code execution
• Type safety verification
• Compilation (Just in Time (JIT) compiler)
• Exception handling
• Language neutral

… Common Language Runtime …

• CLR Security
  • PKI/CS7 signing and encryption supported
    • Also used by Authenticode
  • Signing and encrypting XML
    • Allows sending of encrypted data over SOAP
    • W3C standard
  • X.509 certificates
    • Widely used standard for digital certificates
    • Many uses, including Secure Socket Layer (SSL)
• Code Access Security (CAS)
  • CAS enforces security policies by preventing unauthorized access to protected resources and operations
    • Restricts what your code can do
    • Restricts which code can call your code
    • Authenticates code

… Common Language Runtime

• CAS consists of the following elements
  • Permissions: represent access to a protected resource or operation
    • FileIOPermission, RegistryPermission, UIPermission, etc.
  • Permission sets: collections of permissions
    • FullTrust, Nothing, Internet, etc.
  • Code groups: specifies a grouping of code with specific conditions for membership
    • Particular web site, local system, Internet zone, etc.
  • Evidence: provided by the .NET framework to authenticate assemblies at three levels: enterprise, machine, and user
    • Where did the assembly come from?
    • Does the assembly have a strong name?
      • Assemblies with strong names are cryptographically signed to prevent tampering
  • Policy: determines the permissions to grant to code
    • [root\NT\com\netfx\src\clr\toolbox\caspol]

Common Language Infrastructure

• Subset of CLR submitted to ECMA standards organization
  • C# (C-Sharp)
  • Semantics for metadata
  • Microsoft Intermediate Language (MSIL)
  • Parts of the .NET Framework class library
  • “ROTOR” Shared Source Common Language Infrastructure http://www.sscl.net

Common Type System

• A single type system shared by all .NET-compliant compilers, tools, and the CLR
• Everything is an object
• No variant records (each variant is its own object type)
• Native string type
  • All strings are Unicode
  • Passed by descriptor; no more zero terminated strings!
• The CTS ensures that all classes are compatible with each other, by describing types in a common way. The CTS defines how types work within the runtime (their declaration and usage), which enables types in one language to interoperate with types in another language, including cross-language exception handling.  The CTS also ensures that types are used only in appropriate ways
  • The runtime also ensures that code doesn’t attempt to access memory that hasn’t been allocated to it

Common Language Specification

• Contract between the language designer/implementer and the .NET Framework
• Subset of Common Type System
• Must be supported by language in order to be .NET compliant
• All CLS features guaranteed to be available in all languages

Framework Class Libraries

• Object oriented hierarchical collection of reusable classes
  • Replaces Win32 API
• Base Class Library (BCL)
• Data and XML classes
• ASP.NET
• XML Web Services
• Web Forms
• Windows Forms

Class Libraries …

• System
  • .CodeDom
    root\NT\com\netfx\src\framework\compmod\system\codedom
  • .Collections
    root\NT\com\netfx\src\clr\bcl\system\collections
  • .ComponentModel
    root\NT\com\netfx\src\framework\compmod\system\
    componentmodel
  • .Configuration
    root\NT\com\netfx\src\framework\config\system\configuration
  • .Data
    root\NT\com\netfx\src\framework\data\systemdata
  • .Diagnostics
    root\NT\com\netfx\src\clr\bcl\system\diagnostics
    root\NT\com\netfx\src\framework\compmod\system\diagnostics
  • root\NT\com\netfx\src\framework\services\monitoring\system\
    diagnostics

… Class Libraries …

• System (continued)
  • .DirectoryServices
    root\NT\com\netfx\src\framework\services\ds\system\
    directoryservices
  • .Drawing
    root\NT\com\netfx\src\framework\commonui\system\drawing
  • .EnterpriseServices
    root\NT\com\netfx\src\clr\managedlibraries\enterpriseservices
  • .Globalization
    root\NT\com\netfx\src\bcl\system\globalization
  • .IO
    root\NT\com\netfx\src\clr\bcl\system\io
    root\NT\com\netfx\src\framework\services\io\system\io
  • .Management
    root\NT\com\netfx\src\config\wmi
  • .Messaging
    root\NT\com\netfx\src\framework\services\messaging\system\
    messaging

… Class Libraries …

• System (continued)
  • .Net
    root\NT\com\netfx\src\framework\net\system\net
  • .Reflection
    root\NT\com\netfx\src\clr\bcl\system\reflection
  • .Resources
    root\NT\com\netfx\src\clr\bcl\system\resources
    root\NT\com\netfx\src\framework\winforms\managed\system\
    resources
  • .Runtime
    root\NT\com\netfx\src\clr\bcl\system\runtime
  • .Security
    root\NT\com\netfx\src\clr\bcl\system\security
    root\NT\com\netfx\src\clr\clr\managedlibraries\security\
    system\security
  • .ServiceProcess
    root\NT\com\netfx\src\framework\services\servproc\system\
    serviceprocess

… Class Libraries

• System (continued)
  • .Text
    root\NT\com\netfx\src\clr\bcl\system\text
  • .Threading
    root\NT\com\netfx\src\clr\bcl\system\threading
    root\NT\com\netfx\src\framework\compmon\system\
    threading
  • .Timers
    root\NT\com\netfx\src\framework\services\timers\system\
    timers
  • .Web
    root\NT\com\netfx\src\framework\compmods\system\
    security\permissions
  • .Windows.Forms
    root\NT\com\netfx\src\framework\winforms\managed\
    system\winforms
  • .Xml
    root\NT\com\netfx\src\framework\data\system\newxml

Side by Side …

• Side-by-side allows multiple versions of .NET framework to coexist on same system
  • Introduced in Framework 1.1
  • Vast majority of applications will work with new versions of framework – very little intentional breakage
    • Applications prefer the version that they were built against
      • Administrator may specify (after testing!) that an application use a newer version of the framework
      • Applications built against newer version of framework will not work with older version of framework, if the application uses new features only present in newer version
• Part of image activator [root\nt\base\ntdll\sxs*.c]

… Side by Side …

• Traditional client applications (Windows Forms, Windows Services, command window applications), are configured with an application configuration file
  • Config file tells CLR which framework version to load
  • Config file is an XML file in the same directory as the .exe file
    • Same name as .exe file, with .config suffix
    • Config file also affects other areas of behavior
  • Applications without .config file, or don’t specify SupportedRuntime, will only work with the version against which they were built against, or a later version if the exact version isn’t available
    • Framework version included in .exe image header
    • If a suitable version is not found, a dialog box will ask the user which version to use
      • May be supressed by setting HKLM\Software\Microsoft\.NETFramework\NoGuiFromShim=1

… Side by Side

• Web applications (ASP.NET, XML Web Services) are configured through the IIS administrator
• Web servers may be configured to use separate versions of the Framework for each individual web site
  • Sites that don’t specify default to what the server was configured to use
• Configuration through the IIS administrative console, by selecting the specific versions of the ASP.NET ISAPI filter
  • ASP.NET filter [aspnet_filter.dll] on the ISAPI Filter tab of the Web Site Properties dialog
• Filter may be set for each web site, or the server (change filter for root web site)

Web Services

• XML
  • Describes information in a structured format
  • World Wide Web Consortium (W3C) standard
• WDSL
  • XML-based language which defines web services interfaces
  • Similar to IDL, used by COM and CORBA
• SOAP
  • Provides an XML “envelope” for exchanging data across a network
  • Encoding rules for application-defined data types
  • Protocol for Remote Procedure Calls (RPC)
• UDDI
  • An organization of business that want to expose web services through a registry (which is also a web service)

Assemblies …

• .NET programs are constructed from “Assemblies“
  • A compiled and versioned collection of code and metadata that forms an atomic functional unit
• All Assemblies contain a Manifest, which contains:
  • the Assembly name
  • version
  • locale
  • a list of files that form the Assembly
  • what dependencies the Assembly has
  • what features are exported by the Assembly
  • Manifest may be manipulated with the GenMan32 utility
    • [root\NT\com\netfx\src\clr\toolbox\genman32]
• An assembly may be contained in a single file, or spread across multiple files
• Assembly dependencies can be displayed with “Adepends”
  • [root\NT\com\netfx\src\clr\toolbox\adepends]

… Assemblies …

• Assembly types:
  • Private
    • Private assemblies live within an application’s directory
    • Private assemblies are typically written by the author of an application, for use by that application
    • Version control is left to the discretion of the author
    • The assembly name is the filename (without any file extension), of the file that contains the manifest

… Assemblies …

• Assembly types:
  • Shared
    • Shared assemblies live in a common Assembly repository (currently, %systemroot%\Assembly), called the Global Assembly Cache (GAC)
    • Shared assemblies are intended to be used by multiple authors, and therefore have stricter constraints
      • Rigorous version control
      • Assembly names are unique
      • Shared assemblies contain a pair of encryption keys (one “public”, and one “private“)
        • The private key is kept secret by the author of the assembly
        • The public key is published within the manifest.  The file containing the manifest is hashed, and that value is signed with the private key

… Assemblies …

• When loading a shared assembly, the following are used to identify which assembly to load: name, public key, version, locale
  • Requiring this information allows multiple versions of the same assembly to co-exist  (the GAC might contain 1.0.0.0/English, 1.0.0.9/Italian and 2.0.0.0/English for a particular assembly )
• When installing an assembly into the GAC, the system verifies the digital signature of the manifest file
  • Hashing the manifest file, decrypting the signature stored in the manifest using the public key, and then comparing the two hashes

… Assemblies …

• The rest of the verification occurs at runtime
  • When an assembly from the GAC is referenced, the runtime compares the public key of the assembly to the public key that the referring assembly has in its manifest.  If they don’t match, an exception is thrown, and the load fails
  • If the assembly has multiple parts, each part is hashed as it is loaded, and this hash is compared to the value stored in the manifest — if they do not match, an exception is thrown, and the load fails
• When an application needs to use a particular assembly, it queries the GAC for an assembly matching the name, public key, version, and locale
  • The components of the assembly have their hashes checked.  If an assembly can be found that matches the query, and it hasn’t been tampered with, then the assembly can be loaded

… Assemblies

• Assemblies eliminate dll conflicts
  • Multiple versions of “the same” assembly can co-exist in the GAC,
    • Libraries no longer have to maintain backwards compatibility with their predecessors
  • A program will always get the version of the assembly that it is expecting
    • This can be done even within the same program — if you have a web server, you can run multiple versions of the same application within it, side-by-side.
• Guarantees that files will not be modified after their release
  • Viruses cannot infect a file without changing its hash
• Application memory allocation profiling via “AllocationProfiler” tool
  • [root\NT\com\netfx\src\clr\toolbox
    \allocationprofiler]

Metadata

• An important feature of managed code
  • Metadata is data that describes other data
• Assemblies rely on several types of metadata
  • The security privileges required by the assembly
  • Descriptions of classes, types, methods, and members
  • Makes the assemblies self-describing, and ensures that the descriptions are always accurate
    • Unlike mechanisms such as C/C++ header files, where the interface described in the header could become out of date, and no longer an accurate description of how a library works (“fragile interface” problem)
    • Removes the need for an interface description or type library file, such as Interface Description Language (IDL) used in COM development
    • Describes the classes in an assembly so that other classes (perhaps in other languages) can inherit from them
• [root\NT\com\netfx\src\clr\md]

Attributes …

• Attributes provide a flexible and extensible way of modifying the compile-time and run-time environment
• ‘DllImport’ is used to denote that a function should be imported from a native library (a DLL), rather than being in a .NET library
• To import a function from a DLL, write an appropriate function prototype, and apply an attribute to that prototype that tells the runtime, “go get the code for this function from this library“
  • The runtime hides the messy details, such as “this imported function won’t be in IL but is instead native code”
    • Allows the programmer to concentrate on solving their problem – not the mechanics of the solution
• Attributes can also act at compile-time
  • An attribute allows a function to be marked as obsolete, so that the compiler emits a warning informing the programmer

… Attributes

• Programmers may define their own run-time attributes
  • To define an attribute, create a class that derives from System.Attribute
  • For example, an attribute to describe the author of each piece of code, and when it was last modified it
    • Define an attribute with a “name” property and a “modified date” property
    • The people writing the code would use this attribute to annotate their code
    • At runtime it is possible to interrogate these attributes, and find out who wrote each class and when.  Or do anything else that you defined; some attributes do some complex things (e.g., there are attributes that turn your .NET class into a COM class, without requiring you to write any COM code at all!!).

Managed vs. Unmanaged …

• “Managed Code” is code whose lifetime and execution is managed by the CLR
• Managed code targets .NET, and contains metadata to describe itself
  • Managed and unmanaged code can run in the runtime, but only managed code contains the information that allows the runtime to guarantee, safe execution and interoperability
• “Managed Data” is a dynamic memory management scheme
  • The CLR provides memory allocation and garbage collection Some .NET languages use Managed Data by default (C#, Visual Basic.NET, JScript.NET), while others (C++),  do not.
  • Targeting the CLR can impose constraints on language features
    • C++ loses multiple inheritance

… Managed vs. Unmanaged …

• Some languages will lose case sensitivity (C, C++, Java)
  • Names exposed to classes in other assemblies have to be differentiated by more than case
  • Names internal to a class’s implementation can still be distinguished only by case
• As with managed and unmanaged code, there can be both managed and unmanaged data
  • Data that doesn’t get garbage collected (deallocated) by the CLR, but is managed and deallocated by unmanaged code
    • Garbage collector knows when one object’s data fields reference another object
    • Easily allows components written in one language to be used by components written in another language
    • At runtime, an application can determine which types are in a file, and what members the type defines (a.k.a. late binding)

… Managed vs. Unmanaged

• “Unmanaged applications” are not built using the .NET Framework
  • May use the services of managed applications through COM interop
  • May be configured to specify which version of Framework to use for its managed components (with a .config file, just like a managed app)
    • By default, managed components which are loaded by an unmanaged application, the latest version of the Framework is used
      • Unmanaged applications do not have the framework version in their image header (unlike a managed app)