NET

Document Sample
NET Powered By Docstoc
					Introduction to .Net/C#


          By Oliver
        Feb 23, 2011
Outline

   Introduction to .NET
   Introduction to C#
   Data Type
   Array
   Property
   Flow control
   Exception handler
   Hello world and debug
        Microsoft .NET
   .NET initiative
       Introduced by Microsoft (June 2000)
         • Vision for embracing the Internet in software development
       Independence from specific language or platform
         • Applications developed in any .NET-compatible language
             • Visual Basic.NET, Visual C++.NET, C# and more
         • Supports portability and interoperability
       Architecture capable of existing on multiple
        platforms
         • Supports portability
    Microsoft .NET
   Key components of .NET
       Web services
         • Applications used over the Internet
       Software reusability
         • Web services provide solutions for variety of companies
             • Cheaper than one-time solutions that can’t be reused
             • Single applications perform all operations for a company
               via various Web services
                  • Manage taxes, bills, investments and more
         • Pre-packaged components using Visual Programming
         •    (buttons, text boxes, scroll bars)
             • Make application development quicker and easier
Microsoft .NET

   Keys to interaction
       XML (Extreme Markup Language) and
        SOAP (Simple Object Access Protocol)
        • “Glue” that combines various Web services
          to form applications
           • XML gives meaning to data
           • SOAP allows communication to occur easily
Microsoft .NET

     RTM:
         2002(v1.0)
         2003 (v1.1)
         2005 (v2.0)
         2006 (v3.0)
         2007 (v3.5)
         2010 (v4.0)
         …
    .NET Framework
   .NET Framework
      Heart of .NET strategy
         • Manages and executes applications and Web services
         • Provides security, memory management and other
           programming capabilities

       Includes Framework Class Library (FCL)
         • Pre-packaged classes ready for reuse
         • Used by any .NET language

       Details contained in Common Language Specification (CLS)
         • Submitted to European Computer Manufacturers Association
           to make the framework easily converted to other platforms

       Executes programs by Common Language Runtime (CLR)
   Common Language
   Runtime (CLR)

                                         Managed Executable
   Legacy               Reusable
                   Managed Components
   Software
(unmanaged code)
                            Common Language Runtime
                       (JIT compilation, memory management, etc.)


                             Windows
                      (or other operating oystem)
    Common Language
    Runtime (CLR)
   Why two compilations?
     Platform independence
         • .NET Framework can be installed on different platforms
         • Execute .NET programs without any modifications to code
         • .NET compliant program translated into platform independent
           MSIL
       Language independence
         •   MSIL form of .NET programs not tied to particular language
         •   Programs may consist of several .NET-compliant languages
         •   Old and new components can be integrated
         •   MSIL translated into platform-specific code
   Other advantages of CLR
      Execution-management features
         • Manages memory, security and other features
               • Relieves programmer of many responsibilities
               • More concentration on program logic
Compilation And Execution
             Compilation

Source           Language              Code (IL)
 Code            Compiler             Assembly
                                        Metadata




  Native               JIT Compiler      At installation or
  Code                                  the first time each
                                         method is called
           Execution
JIT
   All managed code runs in native machine
    language
   However, all managed code is made up of IL
    and metadata
   The CLR JIT-compiles the IL and metadata
       At execution time
       Executed directly by CPU
   Allows for the best of both worlds
       Code management features
       Performance of full-speed execution
    Garbage Collector

   GC is a most important part of CLR
   It manages many objects lifetime.
   Instead of allocate/delete keywords in C++, objects
    are automatically deleted when the application no
    longer needs them.
   It’s Important to build a efficiently application.
Garbage Collector
  string s;
  StraighLine line;
  s = "dog";
  line = new StraightLine(0.5, 2.5);




                                        0.5

                             "dog"      2.5

line
   s


       Stack
                                     Heap
Garbage Collector

   CLR will run GC automatically to
    free all unreachable objects in heap
    memory which no references
    remained.
Garbage Collector
                  Free space


                    object6

                    object5

                    object4
                     object3
x                     a
     …                b
…
     …              banana
                    object2
…
                    object1
    Stack
                    …
                    allocated
               Managed Heap
Garbage Collector
                  Free space




                    object6

                    object5
x
     …               object3
…                     a
     …                b
…
                    object1
    Stack
                    …
                    allocated
               Managed Heap
Garbage Collector

   GC demo, show GC collect and
    different result in debug and release
    mode.
Garbage Collector

   GC manages all objects in Heap, but
    not any objects been allocated on
    Heap, like: Unmanaged resource,
    windows handler, DB connection, file
    handler…therefore, we need use the
    Dispose pattern to clean up the
    memory.
Garbage Collector
    FileStream fs = new FileStream("Temp.dat",
    FileMode.Create);
           try
           {
              fs.Write(bytesToWrite, 0, bytesToWrite.Length);
           }
           finally
           {
              if (fs != null)
                  ((IDisposable)fs).Dispose();
           }
Garbage Collector

   GC events notification have been
    added in .Net 4.0.
    Summary

   CLR will run GC automatically to free all unreachable
    objects in heap memory which no references remained.
   The GC is only called by the CLR when heap memory
    becomes scarce.
   The GC only can collect manage resources, all
    unmanaged resources need to be collected by
    programmer.
   The GC will reduce memory leak, but not disappeared.
The .NET Framework Library

   Sit on top of the CLR
   Reusable types that tightly integrate with the
    CLR
   Object oriented – inheritance, polymorphism,
    etc.
   Provide functionality for ASP.NET, XML Web
    Services, ADO.NET, Windows Forms, basic
    system functionality (IO, XML, etc.)
The .NET Framework Library
          System.Web                     System.Windows.Forms
Services         UI                 Design         ComponentModel
Description
                 HtmlControls
Discovery
Protocols        WebControls                  System.Drawing
Caching         Security            Drawing2D        Printing
Configuration   SessionState        Imaging          Text

          System.Data                          System.Xml
OleDb           SqlClient           XSLT             Serialization
Common          SQLTypes            XPath

                               System
Collections      IO               Security          Runtime
Configuration    Net              ServiceProcess    InteropServices
Diagnostics      Reflection       Text              Remoting
Globalization    Resources        Threading         Serialization
Base Framework
 Collections     Security


 Configuration   ServiceProcess


 Diagnostics     Text


 Globalization   Threading


 IO
                  Runtime

 Net              InteropServices

 Reflection       Remoting


 Resources        Serialization
    Summary

   .NET Framework is a code execution platform
   .NET Framework consists of two primary parts: .NET
    Class Libraries, Common Language Runtime
   All CLR-compliant compilers support the common
    type system
   Managed code is object oriented
   Managed code is compiled to and assembly (MSIL)
    by language specific compiler
   Assemblies are compiled to native code by JIT
    compiler
         .NET and C#

   .NET platform
      Web-based applications can be distributed to variety of
       devices and desktops

   C#
        Developed specifically for .NET
        Enable programmers to migrate from C/C++ and Java easily
        Event-driven, fully OO, visual programming language
        Has IDE
        Process of rapidly creating an application using an IDE is
         called Rapid Application Development (RAD)
C#

   Language interoperability
       Can interact with software components written in
        different languages or with old packaged software
        written in C/C++
   Can interact via internet, using industry
    standards (SOAP and XML)
       Simple Object Access Protocol - Helps to share
        program “chunks” over the internet

   Accommodates a new style of reusable
    programming in which applications are created
    from building blocks
Data Types/Arrays
System-defined types
                                             Object
User-defined types




  String                 Array   ValueType            Exception    Delegate    Class1




      Primitive types                                              Multicast
                                   Enum               Structure1               Class2
                                                                   Delegate
 Boolean               Single

   Byte                Double

   Int16               Decimal     Enum1                           Delegate1   Class3

   Int32             DateTime

   Int64             TimeSpan

   Char                 Guid
 Mapping C# to CTS
Keyword   Description                Special format for literals
bool      Boolean                    true false
char      16 bit Unicode character   'A' '\x0041' '\u0041'
sbyte     8 bit signed integer       none
byte      8 bit unsigned integer     none
short     16 bit signed integer      none
ushort    16 bit unsigned integer    none
int       32 bit signed integer      none
uint      32 bit unsigned integer    U suffix
long      64 bit signed integer      L or l suffix
ulong     64 bit unsigned integer    U/u and L/l suffix
float     32 bit floating point      F or f suffix
double    64 bit floating point      no suffix
decimal   128 bit high precision     M or m suffix
string    character sequence         "hello",
                                     @"C:\dir\file.txt"
Value & Reference Types

   ctor
       Value type always have a default value
       Reference type can be null



           x =0       int x;

        obj is null   MyClass obj;
Value & Reference Types

    Memory allocation
         Reference type always allocate in heap
         Value type always be allocated in a place
          where its been declared

    Allocate a variable on stack   int x;

    Allocate a variable on stack   MyClass obj;

    Allocate the object on heap    obj = new MyClass();
Value & Reference Types


                     0.5

                     2.5

obj
  x


      Stack
                   Heap
Value & Reference Types

   Copy

                     int x;

                     MyClass obj;
                     obj = new MyClass();

      deep copy      Int y = x;

      shallow copy   MyClass objCopy = obj;
Value & Reference Types

   Memory Disposal
       Once the method has finished running, its local stack-allocated
        variable, x, obj, will disappear from scope and be “popped” off the
        stack.
       GC will automatically deallocate it from the heap some times later.
        GC will know to delete it, because the object has no valid referee
        (one whose chain of reference originates back to a stack-allocated
        object).
       C++ programmers may be a bit uncomfortable with this and may
        want to delete the object anyway (just to be sure!) but in fact there
        is no way to delete the object explicitly. We have to rely on the
        CLR for memory disposal—and indeed, the whole .NET framework
        does just that!
Type Example
    An example of using types in C#
       declare before you use (compiler enforced)
       initialize before you use (compiler enforced)

                      public class App
                      {
                        public static void Main()
                        {
    declarations          int width, height;
                          width = 2;
decl + initializer        height = 4;

                              int area = width * height;

error, x not set              int x;
                              int y = x * 2;
                              ...
                          }
                      }
Type conversion

   Some automatic type conversions available
      from smaller to larger types
   Otherwise you need a cast or an explicit conversion…
      typecast syntax is type name inside parentheses
      conversion based on System.Convert class
   Type conversion

                       int      i = 5;
                       double   d = 3.2;
                       string   s = "496";

 implicit conversion   d = i;

  typecast required    i = (int) d;

conversion required    i = System.Convert.ToInt32(s);
Boxing and Unboxing

   Boxing
       Automatic conversion of a value-type in a
        reference-type
       Like:   Object o = 25;

   Unboxing
       Conversion of a reference-type into a value-
        type
                int i= (int)o;
       Like:
Boxing and Unboxing

   Boxing
     Memory is allocated from the
      managed heap.
     The value type’s fields are copied to
      the newly allocated heap memory
     The address of the object is returned.
      This address is now a reference to an
      object
Boxing and Unboxing

   Performance
     If boxing occurs frequently, it will
      wastes memory and hurts
      performance.
     Because many small objects will be
      created on heap, and waiting be clean
      up by GC
     Instead, we often use generics
      method or delegate.
String

 How to create a string object.
 String’s performance

 StringBuilder object

 String encoding
String

        Create       string s = "496";
                     String ss = “adasdc”;




String object is immutable. That is, once created, a string
can never get longer, get shorter, or have any of its
characters changed.
    String

                      string s = "496";
                      String ss = “adasdc”;
Bad performance       String text = s + ” and ” +
                        ss + “ and …”;




   because it creates multiple string objects on the garbage-
   collected heap.
String

 StringBuilder sbText= new stringBuilder();
 sbText.append(s);
 sbText.append(“ and ”);
 sbText.append(ss);
 sbText.append(“ and… ”);
 string text = sbText.ToString();
String

OR:


 string text = String.Format(“{0} and {1}
 and…”, s, ss);




Because String.Format() method be implemented by
StringBuilder operations.
String

   Encoding
       Demo
Collections

 Array
 Queue

 Stack

 HashTable

 List<T>

 Dictionary<Tkey,Tvalue>

…
   Arrays

      Arrays are reference types
         assigned default values (0 for numeric, null for
          references, etc.)

                      int[] a;
            create    a = new int[5];

   element access     a[0] = 17;
                      a[1] = 32;
                      int x = a[0] + a[1] + a[4];

number of elements    int l = a.Length;
    Queue

       Use Queue to implement a First-In, First-Out type (FIFO)
        type of collection:


              create   Queue myQ = new Queue();

insert an element      myQ.Enqueue( new Robin( 8 ) );
                       myQ.Enqueue( new BlueJay( 14 ) );


pop an element         ((Bird)myQ.Dequeue()).Speak();
                       ((Bird)myQ.Dequeue()).Speak();
 Stack

 Use Stack to implement a Last-In, First-Out type (LIFO) type
   of collection:


           create   Stack myStack = new Stack();

insert an element   myStack.Push( new Robin( 8 ) );
                    myStack.Push( new BlueJay( 14 ) );


 pop an element     ((Bird)myStack.Pop()).Speak();

                    ((Bird)myStack.Pop()).Speak();
     HashTable

     Use Hashtable to implement a dictionary type of collection:



           create   Hashtable myHT = new Hashtable();

insert an element   myHT["Robin"] = new Robin( 8 );
                    myHT["BlueJay"] = new BlueJay( 14 );


 use an element     ((Bird)myHT["BlueJay"]).Speak();
     List<T>

     It’s the most commonly collection type, use List<T> to
         implement a Robin collection :


           create   List<Robin> myList= new List<Robin> ();

                    myList.Add( new Robin ( 8 );
insert an element
                    myList.Add( new Robin ( 10 );

                    foreach (Robin obj in myList)
                    {
                             obj.Speak();
 use an element
                    }
     Dictionary<Tkey,Tvalue>

     It’s the most commonly collection type, use List<T> to
         implement a Robin Dictionary:
           create   Dictionary<string,Robin> myDic= new
                    Dictionary<string,Robin>();

                    string sarah = " Sarah ";
                    string harold= " harold ";


insert an element   myDic.Add(sarah , new Robin ( 8 );
                    myDic.Add(harold , new Robin ( 10 );

                     if (myDic.ContainsKey(sarah))
                     {
 use an element               myDic[sarah].Speak();
                     }
Dictionary VS Hashtable

   Dictionary<K,V> is used in signal threaded application.

   Hashtable is a thread safe type, it also can be used in
    multi-threaded application.

   Hashtable table=Hashtable.Synchronized(new
    Hashtable());
     Properties

        Instead expose a field, in C#, we usually use get/set to
         expose a property of class. Like:
                      using System;
                      class MyClassk
                      {
                               int _integer;
                               public int Integer
Define a Property
                               {
                                     get {return _integer;}
Get method block
                                     set {_integer = value;}
Set method block               }
                        }
 Properties

    After compilation, we can got the following code from IL


                class MyClassk
                {
                         int _integer;
                         public int get_Integer()
Get method
                         {
                                return _integer;
                         }
                         public void set_Integer( int value)
Set method
                         {
                               _integer = value;
                         }
                  }
     Properties

        To avoid the data be destroyed, we can make a read only
         property :
                     using System;
                     class MyClassk
                     {
                              int _integer;
                              public int Integer
Define a Property
                              {
                                    get {return _integer;}
Get method block
                              }
                       }
             Properties

                Property has all features of method

                            using System;
                            class MyClassk
                            {
                                     int _integer;
define a virtual Property            public virtual int Integer
                                     {
      get method block                     get {return _integer;}
                                           protected set {_integer = value;}
      access modifiers
                                     }
                            }
Properties

   Enhanced features of Interface, more component-
    oriented
                           using System;
     define an interface   Interface INameValuePair
                           {
                           string Name
                           {
                                      get;
                           }
      define a Property    Object Value
                           {
                                      get;
                                      set;
                           }
                           }
Properties Summary
   More component-oriented
   Accommodate the changes of the feature
   JIT often use code inline to speed up application
   Code snippet let coding properties more easy.
Iteration & Flow Control

 Iteration Constructs
 Flow Control
Iteration Constructs

   Loop over data
     for
     foreach
     while
     do while
Iteration Constructs: for


 for (int index = 0; index < int.MaxValue; index++)
            {
                //just do it...
            }
Iteration Constructs: foreach


     List<Robin> myList= new List<Robin> ();

     myList.Add( new Robin ( 8 );
     myList.Add( new Robin ( 10 );

     foreach (Robin obj in myList)
     {
              obj.Speak();
     }
 Iteration Constructs: while


                             int index = 0;
check first before running   while (index < int.MaxValue)
                             {
                                      //just do it...
                                      index++;
                             }
 Iteration Constructs: do while


                             int index = 0;
 check after the running     Do
                             {
                                            //just do it...
first pass always executed            index++;
                             } while (index < int.MaxValue);
Flow Control

   Flow control statements
     if
     switch
Flow Control: IF

       if ("" == string.Empty)
       {
              Console.WriteLine("equal");
       }
       else
       {
              Console.WriteLine(“not equal");
       }
Flow Control: IF
     if (string.Empty == “”)
     {
             Console.WriteLine("equal");
     }
     else if (string.Empty == null)
     {
             Console.WriteLine(“equal N");
     }
     else
     {
              Console.WriteLine(“not equal");
     }
Flow Control: switch

   Numeric and string types are allowed

       Switch(variable)
       {
              case a:
                      //code
                      break;
              case b:
                      //code
                      break;
              default:
                      //default code or exception
       }
Exception Handling

   No matter which kind of programming
    languages, exception handling is
    always a necessary features.
     Try-catch
     Finally
       Coding practice
       Performance
Exception Handling

   Try-catch
       Place the sections of code that might throw exceptions in a
        try block and place code that handles exceptions in a catch
        block

                      try
                      {
                                 //remote access.
                      }
           catch      catch (InvalidOperationException )
                      {
                               throw;
                      }
Exception Handling
It throws the same exception object that it caught and
causes the CLR to reset its starting point for the
exception:


              try
              {
                      //InvalidOperationException
              }
               catch (InvalidOperationException ex)
              {
 Incorrect           throw ex;
              }
Exception Handling

   finally
        When an exception occurs, execution stops and control is
         given to the closest exception handler. This often means
         that lines of code you expect to always be called are not
         executed. Some resource cleanup, such as closing a file,
         must always be executed even if an exception is thrown. To
         accomplish this, you can use a finally block. A finally block
         is always executed, regardless of whether an exception is
         thrown.
      Exception Handling
          FileStream fs = null;
          try {

          fs = new FileStream(@"C:\temp\data.txt", FileMode.Open);
try       StreamReader sr = new StreamReader(fs);

          string line;
          line = sr.ReadLine();
          Console.WriteLine(line);
          }

          catch (FileNotFoundException e)
catch
          {
                      throw new NameNotFoundException(@"[data.txt not in
          c:\temp directory]",e); }
          catch (IOException e)
catch
          {
                      throw new NameNotFoundException(@"[data.txt not in
finally   c:\temp directory]",e); }
          finally
          {
          if (fs != null) fs.Close();
          }
Exception Handling

User-defined exception
 public class EmployeeListNotFoundException: Exception
 {

 public EmployeeListNotFoundException() { }

 public EmployeeListNotFoundException(string message)
 : base(message) { }

 public EmployeeListNotFoundException(string message,
 Exception inner) : base(message, inner) { }

 }
Exception Handling

   Best Practice
      add more friendly information to an
       exception when thrown, like parameters…
      Never throw an Exception type error, use a
       more meaningful exception type instead.
      Don’t catch everything
      Never ignore any exception
Exception Handling
                  try {
                  // try to execute code that the programmer
                  knows might fail...
                  }
     Incorrect    catch (Exception) {
                  ...
                  }



This code indicates that it was expecting any and all
   exceptions and knows how to recover
from any and all situations. How can this possibly be?
Exception Handling

 FileStream fs = new FileStream("Temp.dat", FileMode.Create);
        try
        {
           fs.Write(bytesToWrite, 0, bytesToWrite.Length);
        }
        finally
        {
           if (fs != null)
               ((IDisposable)fs).Dispose();
        }
Exception Handling



using (FileStream fs = new FileStream("Temp.dat", FileMode.Create))
{
          fs.Write(bytesToWrite, 0, bytesToWrite.Length);
}
Exception Handling

   Performance
     If an exception occurs frequently,
      performance hit of throwing and
      catching the exceptions was taking a
      large toll on the application’s overall
      performance.
Exception Handling

   Debugging
       Run the DEMO and show how to
        debugging exception in Visual studio
        2010.
             Exception Handling
                     static void Main(string[] args)
                             {
                                 try
                                 {
                                     InternalMethod();
                                 }
                                 catch (InvalidOperationException ex)
                                 {
                                         Console.WriteLine(ex.Message);
What’s the result?               }
                             }
                             static void InternalMethod()
                             {
                                 try
                                 {
                                     throw new InvalidOperationException ("try");
                                 }
                                 finally
                                 {
                                     Console.WriteLine("exception finally");
                                 }
                             }
Hello world

   Create a DEMO and debug

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:33
posted:9/24/2012
language:English
pages:85