Your SlideShare is downloading. ×
  • Like
1.Philosophy of .NET
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Now you can save presentations on your phone or tablet

Available for both IPhone and Android

Text the download link to your phone

Standard text messaging rates apply

1.Philosophy of .NET

  • 3,361 views
Published

 

  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
No Downloads

Views

Total Views
3,361
On SlideShare
0
From Embeds
0
Number of Embeds
1

Actions

Shares
Downloads
203
Comments
1
Likes
4

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. C# Programming and .NET Concepts By S. Nandagopalan www.bitignou.com [email_address]
  • 2. Books for Reference
    • C# and the .NET Platform (2 Ed)
      • By Andrew Troelsen
      • Dreamtech Publications
    • Microsoft Visual C# .NET
      • By Mickey Williams
      • Microsoft Press
    S. Nandagopalan, B I T
  • 3. Chapter - 1
    • The Philosophy of .NET
    S. Nandagopalan, B I T
  • 4. Objectives
    • Understanding the previous state of affairs
    • The .NET Solution
    • Building blocks of .NET Platform
      • CLR, CTS, and CLS
    • .NET Base Class Libraries
    S. Nandagopalan, B I T
  • 5. Understanding the previous state of affairs
    • As a C/Win32 API Programmer
      • It is complex
      • C is a short/abrupt language
      • Manual memory management, ugly pointer arithmetic, ugly syntactic constructs
      • Not a OO language
    • As a C++/MFC Programmer
      • Root is C
      • C++ with MFC is still complex and error-prone
    • As a VB 6 Programmer
      • Not a complete OOP (“Object-aware”) – Why?
      • Doesn’t support inheritance
      • No multithreading
      • No parameterized Classes
      • Low-level API calls are complex
    S. Nandagopalan, B I T
  • 6. Previous state of affairs…
    • As a Java/J2EE Programmer
      • Use of Java front-to-back during development cycle
      • No language freedom!
      • Pure Java is not suitable for graphic intensive problems (E.g. 3D game)
      • No cross-language integration
    • As a COM Programmer
      • Complex creation of COM types
      • Active Template Library (ATL)
      • Forced to contend with brittle/fragile registration entries
      • Deployment issues
    S. Nandagopalan, B I T
  • 7. .NET Solution
    • Full interoperability with existing Win32 Code
      • Existing COM binaries can interoperate with .NET binaries
    • Complete and total language integration
      • Supports cross-language inheritance, exception handling, and debugging
    • Common runtime engine shared by all .NET aware languages
    • A base class library
      • Good object model used by all .NET aware languages
    • No more COM plumbing!
      • No IClassFactory, IUnKnown, IDispatch, etc.
    • Truly simplified deployment model
      • No need to register a binary unit into the system registry
      • Allows multiple versions of same *.dll
    S. Nandagopalan, B I T
  • 8. .NET Framework S. Nandagopalan, B I T Operating System Common Language Runtime Base Class Library ADO.NET and XML Common Language Specification Visual Studio.NET ASP.NET Web Forms Web Services Windows Forms VB C++ C# JScript J#
  • 9. Building Blocks of .NET
    • CLR (Common Language Runtime)
      • To locate, load, and manage .NET types
      • Automatic memory management, language integration, and type safety
    • CTS (Common Type System)
      • Describes all possible data types and programming constructs supported by the runtime
    • CLS (Common Language Specification)
      • A set of rules that defines a subset of types and specifications
    S. Nandagopalan, B I T
  • 10. CLR (Common Language Runtime)
    • CLR sits on top of OS (same as JVM of Java)
    • CLR loads modules containing executables and executes them
    • Code may be managed or unmanaged
    • Managed code consists of instructions in pseudo random code called CIL ( Common Intermediate Language ). CIL instructions are JIT compiled into native machine code at runtime
    • JIT compiled methods reside in cache until the application’s life time
    • Advantages of managed code: type safety, memory management, and code verification security
    • CLR can translate code from C#, J#, C, C++, VB, and Jscript into CIL.
    • CLR doesn’t launch a new process for every application. It launches one process and hosts individual applications in application domains
    S. Nandagopalan, B I T
  • 11. Base Class Libraries
    • Encapsulates various primitives like: threads, file IO, graphical rendering, and other interaction with HW devices
    • It also provides: database manipulation, XML integration, Web-enabled front-end.
    S. Nandagopalan, B I T Common Language Runtime CTS CLS Base Class Libraries Threading Data Access File IO XML/SOAP GUI
  • 12. C#
    • Almost same as Java
    • No pointers required
    • Automatic memory management (No ‘delete’)
    • Enumeration, class, structure, etc.
    • Operator overloading allowed
    • Interface-based programming techniques
    • Assign characteristics to types (same as COM IDL)
    • C# can produce code that can run only on .NET environment (unlike COM server or Win32 API)
    S. Nandagopalan, B I T
  • 13. Understanding Assemblies
    • Windows applications have dependencies on one or more DLLs
    • These DLLs may contain COM classes registered in System registry
    • When these components are updated, applications may break – 'DLL hell'
    • Solution: .NET Assemblies
    • C# .NET compiler doesn't generate machine code.
    • It is compiled into " assembly "
    S. Nandagopalan, B I T
  • 14. Assembly
    • Intermediate Language (IL/CIL):
      • Same as first pass of compiler. It can't be executed (it is not in binary format)
    • Metadata
      • Describes the assembly contents
      • No need for component registry
      • Each assembly includes information about references to other assemblies
      • E.g. If you have a class called Car in a given assembly, the type metadata describes Car's base class, which interfaces are implemented by Car, description of members of Car.
    S. Nandagopalan, B I T C# source code C# .NET Compiler Assembly Metadata IL + =
  • 15. Assembly…
    • When CLR loads your application, it examines your program's metadata to know which external assemblies are required for execution
    • Private assemblies
      • Used by single application
      • Is not shared
      • Most preferred method
    • Shared assemblies
      • Intended for multiple applications
      • Global Assembly Cache
    • Manifest
      • The metadata of assemblies: version, list of externally defined assemblies, etc.
    S. Nandagopalan, B I T
  • 16. Example of CIL
    • CIL sits above a specific compiler (C#, J#, etc.)
    • The associated compiler emits CIL instructions
    • using System;
    • namespace Calculator
    • {
    • public class CalcApp
    • {
    • public static void Main(string[] args)
    • {
    • Calc c = new Calc();
    • int ans = c.Add(10, 84);
    • Console.WriteLine(ans);
    • Console.ReadLine();
    • }
    • }
      • public class Calc
      • {
      • public int Add(int x, int y)
      • { return x + y; }
      • }
      • }
      • All .NET aware languages
    • emit same CIL instructions
    S. Nandagopalan, B I T
  • 17. CIL of Add() Method
    • .method public hidebysig instance int32 Add(int32 x,
    • int32 y) cil managed
    • {
    • // Code size 8 (0x8)
    • .maxstack 2
    • .locals init ([0] int32 CS$00000003$00000000)
    • IL_0000: ldarg.1
    • IL_0001: ldarg.2
    • IL_0002: add
    • IL_0003: stloc.0
    • IL_0004: br.s IL_0006
    • IL_0006: ldloc.0
    • IL_0007: ret
    • } // end of method Calc::Add
    S. Nandagopalan, B I T
  • 18. Manifest
    • .assembly extern mscorlib
    • {
    • .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .zV.4..
    • .ver 1:0:5000:0
    • }
    • .assembly ConsoleApplication1
    • {
    • .hash algorithm 0x00008004
    • .ver 1:0:2058:39833
    • }
    • .module ConsoleApplication1.exe
    • // MVID: {51BE4F31-CBD0-4AE6-BC9D-F9A4976795FD}
    • .imagebase 0x00400000
    • .subsystem 0x00000003
    • .file alignment 4096
    • .corflags 0x00000001
    • // Image base: 0x070b0000
    S. Nandagopalan, B I T External Assembly
  • 19. CIL to Execution
    • Jitter compiles CIL instructions on the fly into corresponding machine code and cache it. This is useful for not recompiling, if the same method is called again
    S. Nandagopalan, B I T CIL JIT Desktop Pocket PC Server
  • 20. Common Type System (CTS)
    • CTS is a formal specification that describes how a given type must be defined for CLR
    • CTS Class Type
    • CTS Structure Type
    • CTS Interface Type
    • CTS Enumeration type
    • CTS Delegate type
    S. Nandagopalan, B I T
  • 21. CTS Class Type
    • Same as C++ class
    • Can contain members: methods, properties, events, etc.
    • Support for abstract members that define a polymorphic interface for derived classes
    • Multiple inheritance is not allowed
    S. Nandagopalan, B I T
  • 22. CTS Class Characteristics
    • "sealed"? – sealed classes can't function as base classes
    • Implement any interfaces? – An interface is a collection of abstract members
    • Abstract or Concrete? – Abstract classes (to define common behaviors for derived) can't be created directly but concrete classes can.
    • Visibility? – visibility attribute to know whether external assemblies can use it.
    S. Nandagopalan, B I T
  • 23.
    • CTS Structure types
      • Same as C/C++
    • Derived from a common base class System.ValueType
    • CTS Enumeration type
      • To group name/value pairs under a specific name
      • Default Storage: System.Int32 (could be changed)
    • CTS Interface Type
      • Same as pure abstract class of C++
      • A description of work that a derived class can perform
      • Similar to a class, but can never be instantiated
    • CTS Delegate type
      • Same as C's function pointer ( System.MulticastDelegate)
      • Useful for event handling (ASP .NET)
  • 24. Intrinsic CTS Data Types S. Nandagopalan, B I T .NET Base Type C# Type System.Byte Byte System.SByte sbyte System.Int16 short System.Int32 int System.Int64 long System.UInt64 ulong System.Single float System.Double double System.Object object System.String string System.Boolean bool
  • 25. Common Language Specification (CLS)
    • Set of guidelines that describe the minimal and complete set of features a given .NET aware compiler must support
    • C# uses + for concatenation whereas VB .NET uses &
    • C# allows operator overloading but VB .NET does not!
    • The void functions may differ in syntax:
    • ' VB .NET // C#
    • Public Sub Foo() public void Foo()
      • '……. { ……. }
      • End Sub
    S. Nandagopalan, B I T
  • 26. CLS Compliance S. Nandagopalan, B I T C# Type CLS Compliance byte Yes sbyte No short Yes int Yes long Yes ulong No float Yes double Yes object Yes string Yes char Yes bool Yes
  • 27. Example
      • public class Calc
      • {
      • // CLS compliant
      • public int Add(int x, int y)
      • { return x + y; }
      • // Not CLS compliant
      • public ulong Add( ulong x, ulong y)
      • { return x + y; }
      • }
    • Once a method is CLS compliant, then all the .NET aware languages can interact with that implementation
    S. Nandagopalan, B I T
  • 28. CLR .NET Source Code Base Class Libraries (mscorlib.dll) .NET Execution Engine Class Loader Jitter Platform Specific code Execute .NET Compiler DLL or EXE (CIL) mscoree.dll mscoree.dll MicroSoft Common Object Runtime Execution Engine
  • 29. .NET Namespace
    • MFC, Java, VB 6.0 have predefined set of classes; C# doesn't
    • C# uses namespace concept
    • Any language targeting the .NET runtime makes use of the same namespaces and same types as C#
    • System is the root namespace
    S. Nandagopalan, B I T
  • 30. Example in C#
    • using System;
    • public Class MyApp
    • {
    • public static void Main()
    • {
    • Console.WriteLine("Hello World");
    • }
    • }
    S. Nandagopalan, B I T System Namespace Console class in System Namespace
  • 31. Example in VB .NET
    • Imports System
    • Public Module MyApp
    • Sub Main()
    • Console.WriteLine("Hello World")
    • End Sub
    • End Module
    S. Nandagopalan, B I T
  • 32. Example in Managed C++
    • #using <mscorlib.dll>
    • using namespace System;
    • void Main()
    • {
    • Console::WriteLine(&quot;Hello World&quot;);
    • }
    S. Nandagopalan, B I T
  • 33. Sample .NET namespaces S. Nandagopalan, B I T System primitive types, garbage collection, etc System.Collections Container objects: ArrayList, Queue, etc. System.Data System.Data.Common System.Data.OleDb System.Data.SqlClient For Database manipulations ADO .NET System.IO file IO, buffering, etc. System.Drawing System.Drawing.2D GDI+ primitives, bitmaps, fonts, icons, etc. System.Threading Threads
  • 34. Demo
    • Console Application
    • Windows Application
    • Graphics
    S. Nandagopalan, B I T
  • 35.
    • End of Chapter 1
    S. Nandagopalan, B I T