This document provides an overview of the .NET framework and common type system. It discusses key concepts like value types, reference types, inheritance, polymorphism, interfaces, boxing and unboxing. It also covers working with types in .NET like type operators, conversions, casting and managing external types. The document is divided into multiple modules that cover topics such as the .NET framework architecture, common language runtime, deployment, and common type system fundamentals.

1. .NET Programming with C#
Hanoi University of Science and Technology

2. Module 1:
Overview of the Microsoft
.NET framework

3. Overview of the Microsoft .NET framework
• The .NET framework
• Common language runtime
• The .NET framework class library
• ADO.NET: Data and XML
• XML Web service
• Web forms and services

4. The .NET framework

5. The .NET framework

6. Common language runtime

7. Common language runtime

8. Common language runtime

9. The .NET framework class library

10. ADO.NET: Data and XML

11. XML Web service

12. Web forms and services

13. Overview of Namespaces
• Namespaces
• Some commonly used namespaces
• Other important namespaces

14. Namespaces

15. Namespaces

16. Some commonly used namespaces
• System.Console
• System.Windows.Forms
• System.Drawing
• System.Reflection
• System.Text
• System.Collections
• System.IO
• System.Net
• System.Net.Sockets
• System.Runtime.Serialization
• System.Runtime.Remoting.Channels
• System.Web.Services

17. Other important namespaces
• System.Threading
• System.Data
• System.Reflection

18. Module 2:
Introduction to a Managed
Execution Environment

19. Overview

20. Writing a .NET application

21. Demonstration: Hello World

22. Demonstration: Hello World
• Compile the source code from Visual Studio .NET Command Promt
csc HelloDemoCS.cs
• Running the resulting executable file and see the output
Hello World using C#!
• Viewing assembly metadata by using MSIL (ildasm.exe)

23. Using a Namespace

24. Defining a Namespace and a Class

25. Entry Points, Scope and Declarations

26. Console Input and Output

27. Case Sensitivity

28. Compiling and Running a .NET Application

29. Compiler Options

30. The Process of Managed Execution

31. The Process of Managed Execution
• Compilation outputs an executable module (PE – portable executable)
• Microsoft Intermediate Language (MSIL): CPU-independent set of instructions
that can be converted to native code efficiently
• Type Metadata: types, members, references used by CLR at runtime
• Resources: .jpg, .bmp, .wav,…
• When a user executes a managed application:
• Operating System loads CLR
• CLR converts MSIL instructions to native code (only when needed - JIT)
• JIT improve the memory usage and initialization time

32. Metadata

33. Microsoft Intermediate Language

34. Microsoft Intermediate Language
• MSIL is a CPU-independent language
• MSIL contains instructions for many common operations:
• Creating and initializing objects
• Calling methods
• Arithmetic and logical operations
• Control flow
• Memory access
• Exception handling
• …
• MSIL must be converted to CPU-specific (native) code by a JIT
compiler

35. Assemblies

36. Common Language Runtime Tools

37. Demonstration: MSIL Disassembler

38. Just-In-Time Compilation

39. Just-In-Time Compilation
• The code execution process
• CLR loads class types and attach stub code to each method (can be
considered as kind of pseudo-code)
• For subsequent method calls, the stub directs program execution to CLR for
compiling the method’s MSIL to native code
• The stub code is replaced by the address of compiled native code
• Future calls to a compiled method will not involve the JIT compiler

40. Application Domains

41. Garbage Collection

42. Garbage Collection

43. Garbage Collection

44. Module 3:
Working with Components

45. Overview

46. An Introduction to Key .NET Framework
Development Technologies

47. Windows Forms
• To develop applications in which the client computer handles most of
the application processing
• System.Windows.Forms contains classes used to create Windows
forms

48. Web Forms
• To create applications in which the primary user interface is a browser
• Web Forms applications are platform-independent
• System.Web contains classes to create Web Forms

49. XML Web Services
• A programmable entity residing on a Web server and is exposed
through standard Internet protocols
• Programming using XML web services is similar to using COM-based
component (local library)
• XML web services are using SOAP for transferring messages from/to a
Web server, SOAP is almost transparent to the developer

50. Creating a Simple .NET Framework
Component

51. Creating a Simple .NET Framework
Component
• The component provides a simple wrappers for string array
• String GetString(int i): return the string at index i
• Read-Only Count: number of strings in the array
• Structured exception handling

52. Using Namespaces and Declaring the Class

53. Creating the Class Implementation

54. Implementing Structured Exception Handling

55. Creating a Property

56. Compiling the Component

57. Creating a Simple Console Client

58. Using the Libraries

59. Instantiating the Component

60. Calling the Component

61. Building the Client

62. Demonstration: Creating a Windows Forms
Client

63. Creating an ASP.NET Client

64. Writing the HTML for the ASP.NET Application

65. Coding the Page_Load Event Handler

66. Generating the HTML Response

67. Demonstration: Testing the ASP.NET Client

68. Module 4:
Deployment and Versioning

69. Overview

70. Introduction to Application Deployment

71. Common Concepts
• Class libraries are organized
in hierarchical namespaces
and stored in PE files (dll,
exe)
• A PE file may contain
multiple namespaces and
vice versa
• Metadata describes all the
classes and types
• PE files and non-executable
files are combined in to a
assembly file
• Metadata describes files in
one assembly file, exported
and imported classes and
types

72. Simple Applications
• A simplest .NET app can be
executed on any computer as
long as .NET runtime is
installed
• No registry, no external dll,
no registration… (like
COM/COM++ or old DLL-
based software)

73. Componentized Applications
• Componentized application
deployment is more
complicated depending on
how it shares the
components

74. Configuration and Distribution

75. Application Deployment Scenarios

76. A Simple Application

77. A Componentized Application

78. Specifying a Path for Private Assemblies

79. A Strong-Named Assembly
• A component may be shared
among many unrelated
applications. That
component should be
strongly named and located
in the OS assembly cache
• Let’s discuss about dll-
sharing in the conventional
way
• How to call API
dynamically
• How the dll is located
• What are the
disadvantages
• Let’s discuss about COM-
based dll sharing

80. Deploying Shared Components

81. A Versioned Assembly

82. Creating Multiple Versions of a Strong-Named
Assembly

83. Binding Policy

84. Binding Policy

85. Deploying Multiple Versions of a Strong-
Named Assembly

86. Related Topics and Tools

87. Related Topics

88. Packaging and Deployment Tools

89. Module 5:
Common Type System

90. Overview

91. An Introduction to Common Type System

92. An Introduction to Common Type System

93. An Introduction to Common Type System
• Value Types
• Reference Types
• Fields, Methods and Properties
• Interfaces: merely description of methods, properties and events

94. Value Types vs. Reference Type

95. Elements of CTS

96. Primitive Types

97. Objects

98. Constructors

99. Properties

100. Custom Types

101. Enumerations

102. Bit Flags

103. Interfaces

104. Object Oriented Characteristics

105. Abstraction

106. Encapsulation

107. Encapsulation

108. Inheritance

109. Polymorphism

110. Polymorphism

111. Sealed

112. Module 6:
Working with Types

113. Overview

114. System.Object Class Functionality

115. Hash Code

116. Identity

117. Equality

118. String Representation

119. Specialized Constructors

120. Static Constructors

121. Static Constructors
Try/Catch?

122. Private Constructors

123. Type Operators

124. Conversions

125. Conversion Operators

126. Casting

127. Casting

128. Type Operators
• is: determine if an object is of a specific type
• as: convert an object to a specific type, if type is not matched null is
return (it’s different from casting)
• typeof: return the type of an object

129. Casting Interfaces

130. Boxing

131. How Boxing Works
• Boxing:
• A value type is coped from the stack to the heap
• An object is allocated on the heap to store the value
• Unboxing:
• Value is coped from the heap to a variable on the stack
• InvalidCastException may occur

132. Performance
VS

133. Performance

134. Interfaces

135. Inheritance Considerations

136. Base Class Interface

137. Explicit Interface Implementation

138. Managing External Types

139. PInvoke