1 / 31

Microsoft .NET Basics

Microsoft .NET Basics. Daragh Byrne – EPCC. Purpose. Microsoft .NET Framework: Microsoft Intermediate Language (MSIL) Common Language Runtime (CLR) Class Libraries Language Compilers Distributed and Web-based computing .NET Programming with C#. Microsoft .NET Framework. .NET Framework.

donat
Download Presentation

Microsoft .NET Basics

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Microsoft .NET Basics Daragh Byrne – EPCC

  2. Purpose • Microsoft .NET Framework: • Microsoft Intermediate Language (MSIL) • Common Language Runtime (CLR) • Class Libraries • Language Compilers • Distributed and Web-based computing • .NET Programming with C#

  3. Microsoft .NET Framework

  4. .NET Framework “Microsoft .NET is a set of Microsoft software technologies for connecting information, people, systems and devices” • http://www.microsoft.com/net/basics/whatis.asp • In real terms to the developer: • A new platform for building applications that run in stand-alone mode or over the Internet

  5. Evolution • Next Generation of COM: • Component oriented software is a good thing: • Win32/C-style APIs are outdated • COM was step in right direction, but painful to program with • COM was restricted to VB, C++ • Binary compatibility/portability an issue: x86 version of COM component needed to be compiled for e.g. PowerPC • Memory management also a pain • Common Object Runtime: • An execution environment for components written in any language: • Eventually became .NET with incorporation of Web Services • Standardised API • Web Services: • Interoperability is key in the connected world: • Require open standards for interoperability and leveraging legacy code

  6. What’s in the .NET Framework? • Microsoft Intermediate Language (MSIL): • Specification for a platform independent, low-level, stack-based assembly-like language • Common Language Runtime (CLR): • A common runtime for all .NET applications, compiles and executes MSIL • Class libraries: • Common functionality that can be used by all languages • Includes Windows Forms for GUI development • Language compilers: • C#, C++, VB… • Distributed computing: • Networking using sockets, Remoting, Web Services and Applications using ASP.NET

  7. Targeting .NET Compiled to MSIL Source Code (C#, VB.NET) Runs on CLR Compiled to Native Code (x86 etc)

  8. Microsoft Intermediate Language (MSIL) • A machine-independent assembly language: • Similar in nature to Java byte-code • Target language for all .NET compilers • JIT-compiled (Just-In-Time) by the CLR to native code: • Very efficient late compilation approach • Collection of IL known as a managed Assembly: • Library or executable (JAR in Java-speak) • Can examine with ILDasm: • Disassembler • Comes with the framework • Possible to implement interpreter/runtime on any platform: • Open standards

  9. MSIL Example • Example: method body: // Code size 21 (0x15) .maxstack 2 .locals init ([0] string CS$00000003$00000000) IL_0000: ldarg.0 IL_0001: ldfld string NDoc.Core.HtmlHelp::_projectName IL_0006: ldstr ".hhk“ IL_000b: call string [mscorlib]System.String::Concat(string, string) IL_0010: stloc.0 IL_0011: br.s IL_0013 IL_0013: ldloc.0 IL_0014: ret • Yuck! • Thankfully we don’t have to deal with this: • That’s what compilers are for! • You could do it though!

  10. Common Language Runtime • The environment in which all .NET applications run • Somewhat like the Java Virtual Machine: • With explicit multi-language support • With explicit version control at assembly level • JIT-compiles to native code • Deals in the abstract with ‘types’: • classes, structs, interfaces etc. • Handles instances, interactions between instances • Provides runtime services for “Managed Code”: • Type control, exception handling, garbage collection threading etc. • Removes mundane/dangerous tasks from the programmer

  11. Running a .NET Application .NET Executable (Stored as Windows Portable Executable file) mscoree.dll Bind to runtime library Execute MSIL entry point (verifies code, starts compilation and execution)

  12. Types and Assemblies • Fundamentally the CLR deals with instances of ‘types’: • Has a unified type system • Everything descends from System.Object type • Divided into value types or reference types: • Value types are primitives, structs, enums etc and live on the stack • Derived from the System.ValueType type • Reference types are instances of classes, interfaces, arrays, delegates that the programmer deals with via references • Assemblies are essentially collections of type definitions: • Including all metadata about those types

  13. Type Metadata and the CLR • Every CLR type has metadata associated with it: • Field names and sizes, type name, type size etc • Used system-wide: • Serialization of objects to network, disk, in Web Services • Cross-language interoperability • Intellisense in Visual Studio • We use it in our Grid Services software • Possible to use Reflection API to access metadata at runtime: • Plug and play components, late binding • Possible to define application-specific metadata: • Very useful, more later

  14. Metadata Addresses COM Shortcomings • Type system was fragmented • External representation of a component had little bearing on its internal structure: • Interface Definition could not tell you about internals • Needed to use things called Type Libraries to store metadata separately • .NET type system is common among all languages: • Common Type System • C++ string == C# string == VB.NET string

  15. CLR Standards and Implementations • Open standard (ECMA) • CLR will run on any Windows computer: • 95/98, ME, 2000 • Built in to XP • Based on open standards: • Ports to Linux underway: • Mono, dotGNU • Microsoft have a shared-source, cross-platform version known as Rotor: • Runs on FreeBSD • http://msdn.microsoft.com/net/sscli

  16. Class Library (1/2) • IO • GUI Programming (naturally!) • System Information • Collections • Components • Application Configuration • Connecting to Databases (ADO.NET) • Tracing and Logging • Manipulating Images/Graphics

  17. Class Library (2/2) • Interoperability with COM • Globalization and Internationalization • Network Programming with Sockets • Remoting • Serialization • XML • Security and Cryptography • Threading • Web Services

  18. Language Compilers • Over 20 different languages supported to date: • C#, VB, C++ • Perl, Python, Scheme, F#, Fortran, J#, write your own! • All produce IL • Cross-language compatibility is a feature of the runtime: • Write component in VB and use from C++, C#, … • Must adhere to the Common Language Specification: • Limits things you can use e.g. unsigned types, operator overloading

  19. Web Application Development • ASP.NET provides a rich platform for developing Web applications and Web Services • A huge leap forward from traditional ASP: • Aimed towards enterprise class, industrial-strength Web applications • Fully integrated with all areas of .NET • Our software is based on this framework

  20. Distributed Computing • Remoting and Web Services allow remote procedure calls • Remoting is used to make calls between .NET Application Domains: • Built-in to CLR • Web Services are used to provide cross-platform RPC in an interoperable manner: • ASP.NET and CLR support

  21. Obtaining the Framework • Download the Framework SDK via • http://msdn.microsoft.com/netframework/ • ~110 Mb • Support at http://msdn.microsoft.com • Visual Studio .NET is available at a reduced rate for academic institutions

  22. .NET Programming with C#

  23. C# Features (1/2) • Programming language of choice for the .NET platform: • Microsoft’s preferred language • Java-like, but has much in common with C++: • 70% Java, 10% C++, 5% VB, 15% new • Strongly-typed: • Enforced by the compiler and the runtime • As are all .NET languages • Object-oriented: • Every object is an instance of a particular Type • Types are class, interface, enum, struct • Single implementation inheritance, multiple interface inheritance a la Java

  24. C# Features (2/2) • Close coupling with managed code services: • Garbage collection, threading • Operator overloading allowed: • C++ heritage • Can access raw pointers using unsafe code blocks • Properties are a first class language feature: • Unlike Java where accessor methods must be coded • Syntactic sugar, but nice! • Supports strongly-typed callback mechanisms directly using events/delegates: • Unlike Java, where callback support is indirect (interface based, anonymous inner classes etc)

  25. Really New C# Features (compared to Java) • Supports call by reference: • Use of out and ref keywords • Supports stack-allocated objects (structs) – Value Types • Supports enumerations directly: • Can use as C/C++ style bit-mask/flags • Explicit versioning control: • More a feature of the framework but accessible using C# • True multi-dimensional arrays: • More efficient • Semi-deterministic finalization: • Using IDisposable

  26. Namespaces • Means of dividing related classes logically • Avoid name clashes • Analogous to Java packages, C++ namespaces: • MyCompany.MyApplication.Module • Declare using braces: • namespace MyNamespace { // classes etc } • Import namespace with using directive: • usingSystem.Xml • Must include assembly where classes belonging to a namespace reside: • /reference command line option on csc(C# compiler) • Classes from a namespace do not have to all live in same assembly • System namespace is root of .NET framework classes

  27. Sample Program //Person.cs: using System; using SomeLib; namespace MyApplication { class Person {private string name_;public string Name{ get { return name_; } set { if(value == null) throw new ArgumentNullException(“name”); name_ = value; }} public static void Main { Person p = new Person(); p.Name = “Daragh”; Console.WriteLine(p.Name); } } } Compile as follows: Produces Person.exe C:/> csc Person.cs /reference:SomeLib.dll Execute: C:/> personoutput: Daragh

  28. Using C# • Very intuitive at first if you are a Java programmer: • Some differences will soon be noticed • Command-line is good for learning: • csc.exe, vbc.exe, cl.exe • Best way to use is with Visual Studio .NET: • Nice for GUI apps, great designer for forms, Web applications • Integrates with source control (Source Safe) • Good for large multi-component projects • If you do not have it, there is always the command-line: • Good to know your way around this way

  29. Useful Things (1/2) • Boxing and unboxing: • Primitive (value) types can be treated as reference types without explicitly wrapping them: • Java : Integer I = new Integer(5); • C# int i = 5 object o = i; o += 1; // i = 5, o = 6; • foreach • foreach(element e in array) • foreach(element e in somethingEnumerable)

  30. Useful Things (2/2) • Exception safe casts using as Employee e = new Employee()Person p = e as Person;if(p != null){...} • Properties are integral: • Don’t define field, accessor, setter • Looks like field to client:public int MyProperty{ get { // logic } set { myField_ = value; }} x.MyProperty = 2;

  31. Attributes • Can add custom metadata to your types: public class SomeType { [WebMethod] public string SomeMethod() { … } }

More Related