1. Keith Mulkey Senior Software Engineer SFA, Inc.
An Introduction to .NET
Keith Mulkey
Senior Software Engineer
SFA, Inc.

2. Agenda What is .NET? What is the Common Language Runtime (CLR)?
Introduction to Visual Studio 2005 and the IDE
Introduction to C#

3. What is .NET? According to Microsoft, .NET is
“the Microsoft Web services strategy to connect information, people, systems, and devices through software”
What does this mean to the average developer?
ABSOLUTELY NOTHING!

4. What is .NET to the average developer?
A Framework that provides:
an easy to use development environment
a multitude of libraries that make our job easier including distributed processing
cross-language interoperability
a runtime environment that will manage resources with no assistance from us
tight integration with the operating system
easy integration of third party libraries

5. .NET Framework Design Features
Component (Assembly) Infrastructure
Language Integration
Distributed Computing
Simplified Development
Simplified Deployment
Reliability
Security

6. Component Infrastructure
.NET classes are ready to be used at the binary level
.NET assemblies do not have to be registered in the Windows registry
No special “plumbing” code is required for component registration, class factories, component lifetime or dynamic binding

7. Language Integration Language Independence vs. Language Integration
COM supported language independence
Component can be written in any language
Component must meet COM specification rules
Supports binary reuse
DOES NOT allow COM component code reuse
DOES NOT support COM component class extension
DOES NOT allow catching exceptions thrown by COM component

8. Language Integration Language Independence vs. Language Integration
COM supported language independence
.NET supports language integration
Components can be written in any supported language (C#, VB, Managed C++, J#)
The adherence to a common specification is taken care of by .NET
DOES allow .NET component code reuse
DOES support .NET component class extension
DOES allow catching exceptions thrown by .NET components

9. Language Integration Language Independence vs. Language Integration
COM supported language independence
.NET supports language integration
Made possible by the Common Type System (CTS)
Everything in CTS derives from System.Object
CTS supports concepts of classes, interfaces, delegates, reference types, and value types
CTS supports base system types such as integer, double, string, file manipulation

10. Language Integration Language Independence vs. Language Integration
COM supported language independence
.NET supports language integration
Common Language Specification (CLS) provides minimum set of rules
All .NET language compilers must meet CLS and generate code that conforms to CTS
This allows different .NET languages to be used in the same applicaton

11. Distributed Computing
COM supported distributed computing using DCOM
Due to embedded IP address, DCOM would not work through firewalls and NAT
.NET uses industry standard SOAP to interoperate on the Internet
.NET Remoting uses a CORBA-like approach for distributed computing

12. Simplified Development
Every .NET language uses the same library of .NET components
The API to the .NET library of components is always the same
Integrating with .NET components is always the same
The same IDE is used for all languages
Intellisense® works the same for all languages
The build process is always the same

13. Simplified Deployment
No more “DLL Hell”
Shared DLLs are registered with the Global Assembly Cache (GAC)
Multiple versions of the same DLL can co-exist
Applications are tightly bound to a particular DLL version

14. Simplified Deployment
No more “DLL Hell”
DLL Registry entries eliminated
References and dependencies stored in DLL manifest
Private DLLs are found using logical paths or XML based configuration files
Shared (public) DLLs are found using the GAC
Both are found at runtime

15. Simplified Deployment
No more “DLL Hell”
DLL Registry entries eliminated
“Zero-Impact” installation and removal
.NET DLLs are not entered into registry upon installation
Hence no need to remove from registry upon uninstall
Installation and removal can be accomplished with copy and delete

16. Simplified Deployment
No more “DLL Hell”
DLL Registry entries eliminated
“Zero-Impact” installation and removal

17. Reliability Type safety
CLR must recognize and verify types before they are loaded and executed
Helps prevent buffer overruns (Buffer overflow) which can be a source of program errors and security weaknesses

18. Reliability Type safety Common error handling
Automatic memory management

19. Security .NET can protect access to specific parts of executable code
.NET supports strong naming of assemblies to help prevent pirating and tampering
.NET has extensive support for all of the major security algorithms and practices in use today
.NET can be tightly integrated with the Windows Active Directory

20. .NET Framework Architecture
Application

21. What is the CLR?
The CLR is the heart and soul of the .NET architecture
Analogous to Java’s JVM
The CLR activates objects and:
performs security checks on them
lays them out in memory
executes them
garbage collects them

22. The CLR vs. the JVM
Both are runtime infrastructures that abstract the underlying platform
JVM supports any language that can be represented in its bytecode
Java

23. The CLR vs. the JVM
Both are runtime infrastructures that abstract the underlying platform
JVM supports any language that can be represented in its bytecode
CLR supports any language that can be represented in its Common Intermediate Language (CIL)
C#, VB.NET, Managed C++, J#

24. Which is better, CLR or JVM?
Depends on who you ask
The CLR is not and never has been an interpreter
In April 2003, a subset of the CLR known as the Common Language Interface (CLI) became an international standard
Projects are underway to develop CLRs for Linux and Unix and possibly even Mac OS X

25. Back to the CLR
The CLR manages the execution of code in the .NET environment
The CLR:
loads required classes
performs Just-In-Time (JIT) compilation
enforces security
and much more…
Units of deployment are Portable Executables (PEs) aka assemblies
PEs can be DLLs or EXEs

26. What is a .NET Assembly? Assemblies consist of code and metadata
Code in an assembly is in the form of the Common Intermediate Language (CIL)
Metadata makes it all work together

27. .NET Assembly

28. .NET Metadata In .NET, metadata includes: type definitions
version information
external assembly references
other standardized information

29. .NET Metadata In .NET, metadata includes:
.NET uses metadata to describe an assembly in detail, including:
identity description
types that it references
types that it exports
security requirements for execution

30. .NET Metadata In .NET, metadata includes:
.NET uses metadata to describe an assembly in detail.
Metadata provides enough information for any runtime tool or program to find out everything that is needed for component integration

31. .NET Consumers of Metadata
CLR relies on metadata to support runtime features
verification
security enforcement
cross-context (e.g., remote invocation) marshalling
memory layout
execution

32. .NET Consumers of Metadata
CLR relies on metadata to support runtime features
Class Loader of CLR uses metadata to find and load .NET classes
JIT compiler uses metadata to compile CIL code
Various tools use metadata to support integration (e.g., Intellisense®)

33. Type Libraries on Steroids
Any application, tool, or utility that can read metadata from a .NET assembly can make use of that assembly.
Metadata ensures language interoperability

34. Single-File & Multi-File Assemblies
Assemblies composed of a single *.dll or *.exe are single-file assemblies
Multi-file assemblies are composed of numerous .NET *.dlls or *.exes termed modules
Primary module contains the assembly manifest
Other modules contain module-level manifest
Primary module documents the set of “secondary” modules within the assembly

35. The .NET Runtime Environment
The term runtime can be understood as a collection of external services that are required to execute a given compiled unit of code.
MFC requires mfc42.dll
VB6 requires msvbvm60.dll
Java requires the JVM
.NET requires the CLR

36. The .NET CLR
Crux of the CLR is the Common Object Runtime Execution Engine (mscoree.dll)

37. CLR Execution

38. Links for CLR https://www.youtube.com/watch?v=gCHoBJf4htg

39. What is C# New programming language developed by Microsoft for .NET
Syntax is very similar to Java
Just as Java is in many ways a cleaned-up version of C++, C# can be viewed as a cleaned-up version of Java
C# is managed code

40. Anatomy of a C# Program
A C# application must have one PE that is an .exe; it can have any number of PEs that are .dlls
By convention, C# source code files have a .cs extension
All program logic must be contained within a type definition

41. Anatomy of a C# Program
Every C# application must contain a class defining a Main() method
Main() must be public and static
Main() typically does very little other than start things up

42. Rules of the Road Everything must exist within a namespace
“enum”s and “struct”s can be defined outside of a class but must be scoped within a namespace
Object visibility should always be specified. If one is not provided the compiler will assign a default

43. Data in C# There are NO POINTERs in C# (per se)
ALL reference type objects must be “new”ed and are allocated on the managed heap
Objects are NEVER “delete”ed; the garbage collector will take care of that
Scope resolution operator is always a period (“.”) irrespective of the object’s location (stack or heap)
Pointers can be used in “unsafe” code sections -- but let’s not go there!

44. Data in C#
Class attributes are always initialized to a safe default value
Local variables within a member scope are not initialized
the compiler will force assignment before they can be used
there is one exception to this

45. The Mother of All Objects
When you create a class that does not explicitly specify a base class, you implicitly derive from System.Object
System.Object provides some basic functionality for all C# classes
Example: ToString() returns a string representation of the given object
Some functionality can be overridden: Equals, GetHashCode, ToString, and Finalize

46. Class Objects in C# Class objects are either “public” or “internal”
Every C# class gets a “free” default constructor
ensures that all member data is set to an appropriate default value
value-type data are initialized with a default, safe value (e.g., int and doubles are initialized to 0)
reference-type data are initialized to null

47. Class Objects in C#
As soon as you define a custom constructor, the default constructor is removed
class loader however still initializes attributes to default values
if a default constructor is still needed, you will have to provide it.
There are no “friend” classes. Visibility modifier “internal” is similar but not the same
Class attributes can be initialized by assignment when declared

48. Class Objects in C# A class can be declared as “static”
In fact the class that contains Main() must be declared static
Typically one .cs file contains the declaration of one C# class
C# classes can span multiple files using the “partial” modifier

49. Inheritance in C# Much the same as in C++
Multiple inheritance is not supported
You can however implement as many interfaces as you like
Abstract methods and classes must be marked as such using the keyword “abstract”

50. Loops and Branching in C#
“for”, “while”, “do … while”, “if … else” all work as in C/C++
“foreach” is new to C#
Allows interation over items in a collection or array
No need to test for upper and lower limits
Example:
string[] colorSchemes = { “Day”, “Dusk”, “Night” };
foreach (string s in colorSchemes { … }

51. Loops and Branching in C#
“switch” works as in C/C++ with a couple of exceptions…
each “case” must have a terminating “break” unless there is no code between “case”s
the “switch” statement can evaluate strings

52. Accessors and Mutators
Object oriented encapsulation
Attributes should not be directly accessible
Accessors should be provided to retrieve state
Mutators should be provided to set state
Traditional approach:
GetXXX() or get_XXX()
SetXXX() or set_XXX()
C# uses properties

53. C# Properties Example:
“value” is not a keyword but rather a contentual keyword
Properties feel more “natural”
Instead of:
We use:
private double lat;
public double Lat {get{return lat;} set{lat=value;}}
double myLat = gsoPoint.get_Lat();
double myLat = gsoPoint.Lat;

54. C# Properties Accessors and mutators can have different visibility:
How would you make a property read or write only?
Properties can be “static”
private double lat;
public double Lat {get{return lat;} protected set{lat=value;}}

55. C# Casting Rules Any data type can be stored in an “object” variable:
Any subclass object can be stored in a superclass object variable:
object shape = new GSOLine();
GSOShape shape = new GSOLine();

56. C# Casting Rules How do we get it back?
What if “shape” is not a “GSOLine”?
InvalidCastException is thrown at runtime
GSOLine line = (GSOLine)shape;

57. C# Casting Rules Is there another way?
What if “shape” is not a “GSOLine”?
The “as” operation will return null
GSOLine line = shape as GSOLine;

58. C# Casting Rules Which is better? Can we tell before we cast?
Exceptions are expensive
Can we tell before we cast?
if (shape is GSOLine)