Overview

Overview of Course and .Net

Part A: Overview of .NWDP Course

Go Over Roster
- Tell us something about yourself.
- What do you hope to get out of this course?
Course Website
Website for Jost Lectures
Projects

Part B: Overview of .NET

Common Acronyms
- Some common acronyms related to .NET.

History of Visual Basic and Visual Studio

Release Date	Version	Code Name	New Features
1991	VB1	Thunder	Control Toolbox + event handlers
1992	VB2	Rawhide	ODBC Support, MDI forms, object variables
1993	VB3		Jet Engine, OLE, reporting
1996	VB4		Classes and OCX files
1997	VB5		Compiler, ActiveX controls
1998	VB6		Web classes, windowless controls, more data sources
2002	.Net 7.0	Rainier	CLR, constructors, inheritance, polymorphism, C#
2003	.Net 7.1	Everett	Minor upgrades, support for mobile devices
2005	.Net 8.0	Whidbey	64-bit support, deployment designer
2008	.Net 9.0	Orcas	XAML, WPF, WCF, WF, LINQ
2010	.Net 10.0	Rosario	Software testing and management tools
2012	Visual Studio 2012	VS 11.0	Metro-style Programming (HTML5 and JavaScript)

Why .Net?
- Some issues motivating the creation of .Net
.Net Design Goals
- Support Language Integration
- Simplify Deployment
- Unify Development Environments
- Provide robust execution environment
- Provide infrastructure for components
- Support industry standards for XML and other technologies
- Support Internet Interoperability
- Insure Reliability
- Insure Security
Orcas Design Goals
- Orcas is the .Net 2008 version.
- Unify the desktop application and web application models.
- Use XAML to code user interface, analogous to HTML.
- Unify fragmented .Net 2.0 technologies.
- Here are the technogies designed to accomplish this:
- Orcas supports both WinForms and WPF applications.
Solutions, Assemblies, Manifests and Metadata
- A solution is a collection of source code and resource files. Less commonly, it contains data files. A solution is compiled to produce one or more .exe or .dll files.
- An assembly is a collection of compiled binary code files, usually one standard executable file (.exe extension) and zero or more dynamic link library files (.dll extension).
- A manifest is a list of all the files and resources contained in an assembly. Each assembly must contain a manifest.
- Metadata is information contained in an assembly that describes the assembly.
- See Section 13 for more details about assemblies, metadata and manifests.
The CLR (Common Language Runtime)
- Managed code execution means that memory is allocated and deallocated under the supervision of the garbage collector.
- The CLR is a virtual machine providing managed code execution.
- .Net language source code is compiled into Microsoft Intermediate Language (MSIL) binary executable code. This MSIL code is run on the CLR.
- The CLR provides execution support and code management, including garbage collection, exception handling, support for security, debugging and interoperation. Here is an illustration of some CLR services.
- Details of the .NET PE (Portable Executable) execution.
- The CLR provides just-in-time (JIT) compilation, that is, code is compiled from Microsoft Intermediate Language binary executable code into native executable code just before it is actually needed. This is useful for large projects that only execute a small portion of their code in any one run.
- The first CLR execution of an assembly is slow because the relevent executable code is loaded into the memory. Usually subsequent executions are faster because the executable code from the first run stays in memory and need not be reloaded.
- Runtime JIT cases can be avoided by pre-JITting using, for example, ngen.exe.
The Structure of PE files
- Windows .exe or .dll files conform to the PE file format. This is derived from the COFF (Common Object File Format) specification.
- The PE file sections:
- To view the PE file structure:
  1. Create a file containing the C# program ClickCounter1.cs.
  2. Obtain a VS command prompt window:
  3. Compile this program in the VS command prompt window:
    A more complete version of the command to invoke the C# compiler:
    Use to compile without the core types library file MSCorLib.dll:
  4. This command saves the C# compiler help:
  5. Execute this command to see the PE file structure of hello.exe:
  6. Note the reference to _CorExeMain within the library file mscoree.dll. This is the entry point for the CLR.
  7. Look at ClickCounter1.exe using ILDASM (Intermediate Language Disassembler).
    Run ILDASM from the command prompt:
    Open a .Net executable file and use ILDASM to disassemble the binary code into Immediate Language opcodes.
    You can also use software like Red Hat Reflector to convert an .exe or .dll fileinto C# code.
    Here are the IL Dump File ClickCounter1.il and the TreeView file ClickCounter1TreeView.txt produced by ILDASM.
The LanguageIntegration Example
- The LanguageIntegration Example shows how to construct a project with classes written in C# and Visual Basic.
- The LanguageIntegration source code files
  Build (compile) the project using the following code in the batch file build1.bat:
- An alternative is to use .netmodule files that are then linked to form the assembly. The commands in build2.bat compiles the project using .netmodule files:
- A .netmodule file cannot function as a standalone assembly because it does not contain manifest metadata tables.
- .netmodule files can be added to an assembly using the compiler with the /addmodule flag.
- Here is a third alternative using the assembly linker al.exe. These commands are in build3.bat:
Strong Named Assemblies and the Global Assembly Cache
- A strong named assembly (SNA) is more secure than a non-strong named assembly.
- Verifying that a strong named assembly is genuine.
- The global assembly cache (GAC) is used to store library (DLL) files so they can be used by multiple users.
- Use sn.exe to create and manipulate public and private keys:
  1. Create a public/private key pair:
  2. Extract the public key:
  3. Display the public key:
  4. Create a help file for sn.exe:
- To add version information, say Version 1.0.3.25, to an assembly, place these lines at the beginning of the C# source code file:
- To create a strong named assembly, compile the DLL file with the command
- To insert a strong named assembly into the GAC, use the command
- Use this command to create a helpfile for gacutil.exe:
- GAC files for .Net Framework 4.0 are stored at C:\WINDOWS\Microsoft.Net\assembly.
- GAC files for older frameworks are stored at C:\WINDOWS\assembly.
- Here is a more detailed overview of strong names and the GAC.
Namespaces
- A namespace is a conceptual folder that contains classes, modules, interfaces, enumerations, delegates or other namespaces.
- A DLL file usually contains one or more namespaces.
- Here is the official list of .Net namespaces.
- Namespaces do not exist in MSIL code. When compiled, the namespace is concatenated with an unqualified identifier to produce the fully qualified MSIL identifier. For example:
Windows Applications
- Directions for Building a Windows application.
- Source code files for the ClickCounter2 Visual Basic Windows Example:
- Compile the ClickCounter2 Example with this command:
- Alternatively, place the compiler options in the .rsp file ClickCounter2.rsp and compile like this:
- Practice Problem: Convert the ClickCounter2 project to C#.
The Relationship Between the CLR and the CLS
- The CLR (Common Language Runtime) is Microsoft's implementation of the .Net Runtime.
- The CLS (Common Language Specification) is the specification that third parties must follow to create a runtime environment that is compatible with .Net.
- The CTS (Common Type System) is the system of types required by the CLS.
- More information about the CLS.
More about Assemblies, Metadata and Manifests
- Example: In the LanguageIntegration folder of the overview.zip examples, compile the project by running the batch file build1.bat. Then create a subfolder named my-libraries and move the file vehicle.dll to MyLibraries. Run the executable drive.exe. It will not run because it cannot find vehicle.dll. Now copy the configuration file drive.exe.config to the folder LanguageIntegration and run drive.exe again. The application should now execute correctly.
- If a DLL file is strong named, the rules that the CLR uses for locating it at runtime are more complicated. "Look in the GAC" is one of the rules, but configuration files are used as well.
- Usually DLL files placed in the GAC are not created and compiled on that same machine.
- The compiler never looks for DLL references in the GAC. A local copy of this DLL file must be used for compiling.
- Here is a script, which verifies that if a DLL file is not found on the local hard drive, it looks in the GAC: build4.bat.
- The file csc.exe.config can tell the compiler additional locations to look for .Net System or other DLL files.
- Here are more details about assemblies, metadata and manifests.
Windows Applications using XAML
- XAML means Extensible Application Markup Language.
- XAML is new in 2008 version; however, it is not yet integrated into the C#.Net and VB.Net compilers.
- Here is the XAML version of the Windows ClickCounter Example:
- The C# compiler does not currently understand the XAML markup language.
- Use the msbuild utility uses information in a csproj file to convert XAML files to C# files and then to an executable file.
- Use this csproj file to compile App.xaml and Form1.xaml: