UNIT I An overview of Programming models Programmers Perspective

Transcription

1 UNIT I An overview of Programming models Programmers Perspective 1. C/Win32 API Programmer It is complex C is short/abrupt language Manual Memory Management, Ugly Pointer arithmetic, ugly syntactic constructs Not a object oriented language 2. C++/MFC Programmer (Microsoft Foundation Classes) Object oriented layer on top of C C++ with MFC is still complex & error-prone. 3. Visual Basic (VB) Programmer Not a complete oriented OOP (Doesn t support inheritance) No multithreading No parameterized classes Low level API calls are complex 4. Java/J2EE Programmer Use of Java front to back during development cycle No language freedom Pure java is not suitable for graphic intense application (EX:30) No cross-language integration 5. as a COM (Component Object Model) Programmer Complex creation of COM types Active template library Forced to contend with fragile registration entries Deployment Issues 6. as a DNA Programmer (Distributed internet Applications Architecture)

2 .NET Framework VB C++ C# JavaScript J# Common Language Specification ASP.NET (Web forms Web Services) CTS Windows Forms.NET and XML Base Class Library Common language runtime(clr) Operating System CLS VISUAL STUDIO.NET Common Language Runtime (CLR) The CLR, the virtual machine component of Microsoft.NET framework, manages the execution of.net Programs. It runs the code and provides services that make the development process easier CLR Handles Runtime objects Memory leaks (Garbage Collection) Programming errors Performance improvements Ability to easily use components developed in other languages Explicit free threading to support(multi threading and scalable applications) Use delegates instead of function pointers for increased type safety and security, code verification CLR sits on top of OS Code is managed(writes in.net framework) or unmanaged(cannot be hosted on.net framework)

3 .NET Source Code (Any.NET Langauage) Any.NET Compiler *.dll or *.exe Assembly (CJL, Metadata, Manifest).NET Execution (mscore.dll) Base Class Libraries (mscorlib.dll) etc. Class Loader Jitter Platform Specific Instructions Member Execution CLR is physically represented by a library called mscoree.dll (Microsoft Common Object Runtime Execution Engine). When an assembly (.dll (dynamic linking library) or.exe) is in use, mscoree.dll is loaded automatically which in turn loads the required assembly into memory. CLR will also interact with the types contained with.net base class libraries when required for example (mscorlib.dll) mscorlib.dll contains a large number of core types that encapsulate a wide variety of common programming tasks as well as the core data types used by all all.net languages

4 Jitter compiles CIL(Common Intermediate Language or IL, MSIL) instructions on the fly into corresponding machine code and cache it. This is useful for not recompiling, if the same method is called again. CIL is not in a binary format. Desktop CJL JIT Server Packet PC Base Class Library Support Thread support COM Marshall Type Checker Exception Manager Security Engine Debug Engine IL to native compilers Code Manager Garbage Collection Class Loader

5 Common Language Specification It is 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 users &. C# allows operator overloading but VB does not allow. The void functions may differ in syntax. VB. NET Public Sub Foo().. End Sub C#.NET Public void Foo() CLS Compliance byte short int long float double object string char bool CLS Non-Compliance sbyte ulong uint ushort CLS rules apply to those parts of a type that are exposed outside the defining assembly. Ex 1. public class calc public ulong Add(ulong x, ulong y) //Not CLS Complaint return x+y;

6 Ex 2. Using system; [assembly : CLSComplaint(ture)] public class visible public sbyte x() return 0; // not CLS-compliant Error by the compiler Using system; [assembly : CLSComplaint(ture) public class visible [CLS Complaint(false)] public sbyte x() return 0; // no error by (An Assembly (.dll) is generated).net framework is that applications written in different languages can interoperate with one another only if it adheres to set of 41 rules knows as common language specification (CLS) standardized by European Computer Manufacturers Association (ECMA). Common Type Systems The common type system defines how types are declared, used and managed in the common language runtime and is also an important part of the runtimes support for cross-language integration. Functions of CTS Establishes a framework that helps enable cross-language integration, type safety and high performance code execution. Provides object-oriented model that supports the complete implementation of many programming languages Defines rules that languages must follow, which helps ensure that objects written in different languages can interact with each other. Provides a library that contains the primitive data types (ex: Boolean, Byte, Char, Int32 & UInt64) used in application development.

7 Types:.NET Classifies the types either as value types or reference types. 1. Values Types are data types whose objects are represented by the objects actual value. If an instance of a value type is assigned to a variable, that variable is given a fresh copy of the value. All value types are derived implicitly from System.ValuType. Ex: Structures, Enumerations 2. Reference types are data types whose objects are represented by a reference to the objects actual value. No copy is made. Ex : Classes, Delegates. CTS-Class Types A class is a reference type and is derived implicitly from System.Object. A class may be composed of any number of members (methods, events and properties) and the data that object contains (fields). Although, class generally includes both definition and implementation (unlike interface), it can have one or more members that have no implementation. public class add public int Addition(int x, int y) return x+y;

8 Characteristics of a class 1. Visibility: This feature indicates whether a class is visible outside the assembly in which it is defined. However this is applied only to top level classes but not to the nested classes. 2. Concrete/ Abstract: Concrete type classes can be created directly. On the other hand abstract classes cannot be derived or instantiated. In order to use the features of abstract class one must derive another class from it. 3. Implements: this indicates whether the classes uses either one or more interfaces by providing implementation details of the interface members. 4. Sealed: This feature make the class as a non-derivable class. No class can inherit the sealed class at any point of time. CTS-Structure Types: A structure is a value type that derives implicitly from System.ValueType, which in turn is derived from System.Object. A structure is very useful for representing values whose memory requirements are small, and for passing values as by-value parameters to methods that have strongly typed parameters. Ex: All primitive data types in.net framework class library are defined as structures. Boolean, Byte, Char, DateTime, Decimal, Double, Int16, Int32, Int64, SByte, Single, UInt16, UInt64, UInt32. Structures can have fields, properties and events as well as static and nonstatic methods. You can create instances of structures, pass them as parameters, store them as local variables or store them in a field of another value type or reference type. Structures can also implement interfaces

9 struct point public int xpos, ypos; public point(int x, int y) xpos = x; ypos = y; public void Display() Console.WriteLine("0,1", xpos, ypos); CTS-Enumeration Types An enumeration is a value type which allows the programmers to group name/value pairs. It is inherited directly from System.Enum. Enumerations are generally used for lists of unique elements such as days of the week, country or region names etc., Ex: public enum days sunday =0, monday =1, tuesday =2 Restrictions on Enumerations They cannot define their own methods They cannot implement interfaces They cannot define properties/events They cannot be generic (i.e., they cannot have type parameters of its own). The approved enum types are byte, sbyte, short, ushort, int, uint, long or ulong. CTS-Interface Types Interfaces define Can do relationship or has a relationship. Interfaces can have properties, methods and events all of which are

10 abstract members. Interfaces cannot define constructors, fields. They can define only instance members, non-static members. public interface IDraw void Draw() CTS-Delegate Type Delegates are reference types that serve a purpose similar to that of function pointers in c++/ they are used for event handlers and callback functions in the.net framework. Unlike function pointers, delegates are typesafe, secure and verifiable. public delegate int BinaryOp(int x, int y); C# Intrinsic CTS Data Types

11 .NET Assembly All windows applications have dependencies on one or more dll s (Dynamic Linking Libraries). These dll s may contain COM (Component Object Model) classes registered in the system registry. When these components are updated, applications may break this situation is termed as ( DLL Hell ). To overcome the above Microsoft introduced.net Assemblies. C#.NET compiler does not guarantee machine code. it is always compiled into assembly. Intermediate Language (IL) is like first pass of a compiler which is not in a binary format. All.NET compilers emit IL instructions and metadata. C# Source Code C# Compiler Perl.NET VB.NET Perl. NET Compiler VB Compiler IL And Metadata (*.dll & *.exe) Assembly Metadata It describes the assembly contents No need for component registry Each assembly includes information about references to other assemblies Ex: if you have an employee class in a given assembly the metadata describes Employee base class Which interfaces it implemented Members description Apart form CIL and Metadata, aseemblies themselves are also described using metadata called as manifest. It holds the following information Assembly Name Version Number(Major/Minor/Build/Revision) Culture( the language the assembly supports)

12 Strong Name Information List of Files in Assembly Type Reference information Information on the referenced assemblies Types of Assemblies Single-File/Private Assembly: Used by single application It is not shared Most preferred method Multi-file/Shared Assembly Used/designed for multiple applications Global Assembly Cache Note: The files of multifile assembly are not physically linked by the file system. All these files are linked through the assembly manifest and CLR treats them as a unit.

13 Features of C# 1. No pointers are required. C# programs typically have no need for direct pointer manipulation. 2. Automatic memory management through garbage collection. C# does not support delete keyword. 3. C# supports syntactic constructs for enumerations, structures and class properties. 4. Operator over loading is allowed for a custom type. 5. Building generic types and generic members syntax is similar to C It support interface-based programming. 7. Also supports aspect-oriented programming(allows to further qualify the behaviour of types and their members) technique via attributes. C#- Command-Line Compiler (csc.exe) Compiles File.cs producing File.exe: csc File.cs Compiles File.cs producing File.dll: csc /target:library File.cs Compiles File.cs and creates My.exe: csc /out:my.exe File.cs Compiles all the C# files in the current directory, with optimizations on and defines the DEBUG symbol. The output is File2.exe: csc /define:debug /optimize /out:file2.exe *.cs Compiles all the C# files in the current directory producing a debug version of File2.dll. No logo and no warnings are displayed: csc /target:library /out:file2.dll /warn:0 /nologo /debug *.cs

14 Compiles all the C# files in the current directory to Something.xyz (a DLL): csc /target:library /out:something.xyz *.cs Referencing External Assemblies using System.Windows.Forms; class TestApp public static void Main() Console.WriteLine( Testing! 1, 2, 3 ); //Add this! MessageBox.Show( Hello ); During Compilation csc /r:system.windows.forms.dll testapp.cs Compiling Multiple Source Files with csc.exe csc /r:system.windows.forms.dll testapp.cs hellomsg.cs

15 csc.exe response files A file that lists compiler options or source code files to compile. The compiler options and source code files will be processed by the compiler just as if they had been specified on the command line. To specify more than one response file in a compilation, specify multiple response file options. In a response file, multiple compiler options and source code files can appear on one line. A single compiler option specification must appear on one line (cannot span multiple lines). Response files can have comments that begin with the # symbol. The compiler processes the command options as they are encountered. Therefore, command line arguments can override previously listed options in response files. Conversely, options in a response file will override options listed previously on the command line or in other response files. The compiler processes the command options as they are encountered. Therefore, command line arguments can override previously listed options in response files. Conversely, options in a response file will override options listed previously on the command line or in other response files. # build the first output file /target:exe /out:myexe.exe source1.cs source2.cs

16 Command Line Debugger The Runtime Debugger helps tools vendors and application developers find and fix bugs in programs that target the.net Framework common language runtime. This tool uses the runtime Debug API to provide debugging services. The source code for Cordbg.exe is being shipped as a sample application. Developers can examine the code to learn how to use the debugging services. Currently, you can only use Cordbg.exe to debug managed code; there is no support for debugging unmanaged code. When you start a debugging session from the command line, you can also provide the name of the application you want to debug, program arguments, and optional arguments. The Cordbg.exe optional arguments are the same commands that you would use while in Cordbg.exe but you must prefix them with the exclamation point (!) character. You can use the! character as a literal in a string by prefixing it with the backslash (\) character If a numeric argument to a command begins with the prefix 0x, Cordbg.exe assumes the argument is in hexadecimal format. Otherwise, it assumes the argument is in decimal format Flags b[reak] del[ete] ex[it] g[0] o[ut] p[rint] si so Set or display current breakpoints Remove one or more breakpoints Exit the debugger Continue debugging the current process until hitting next breakpoint Step out of the current function Print all loaded variables local, arguments etc., Step into next line Step over the next line Running an executable inside a Cordbg.exe session The following command entered from within a Cordbg.exe session (at the (cordbg) prompt) runs the executable MyApplication.exe with the program arguments a and 2. run MyApplication.exe a 2

17 Using the print command The following commands demonstrate that you can use dot notation with the print command to specify variables within objects. print obj.var1 print obj1.obj2.var1 Ildasm.exe The Ildasm.exe parses any.net Framework.exe or.dll assembly, and shows the information in human-readable format. Ildasm.exe shows more than just the Microsoft intermediate language (MSIL) code it also displays namespaces and types, including their interfaces. You can use Ildasm.exe to examine native.net Framework assemblies, such as Mscorlib.dll, as well as.net Framework assemblies provided by others or created yourself. Most.NET Framework developers will find Ildasm.exe indispensable To get started, build the WordCount sample, and load it into Ildasm.exe using the following command line: ildasm WordCount.exe You can see that the WordCounter type contains five private fields: totalbytes, totalchars, totallines, totalwords, and wordcounter. The first four of these fields are instances of the int64 type, while the wordcounter field is a reference to a System.Collections.SortedList type.

18