http:// introduction to c#. c# – the big ideas the first component oriented language in the c/c++...
Post on 03-Jan-2016
220 Views
Preview:
TRANSCRIPT
http://www.mahendar.com
C# – The Big Ideas• The first component oriented language in
the C/C++ family• Everything really is an object• Next generation robust and durable
software• Preservation of investment
http://www.mahendar.com
C# – The Big IdeasA component oriented language
• C# is the first “component oriented” language in the C/C++ family
• Component concepts are first class:– Properties, methods, events– Design-time and run-time attributes– Integrated documentation using XML
• Enables one-stop programming– No header files, IDL, etc.– Can be embedded in web pages
http://www.mahendar.com
C# – The Big IdeasEverything really is an object
• Traditional views– C++, Java: Primitive types are “magic” and do not
interoperate with objects– Smalltalk, Lisp: Primitive types are objects, but at great
performance cost
• C# unifies with no performance cost– Deep simplicity throughout system
• Improved extensibility and reusability– New primitive types: Decimal, SQL…– Collections, etc., work for all types
http://www.mahendar.com
C# – The Big IdeasRobust and durable software
• Garbage collection– No memory leaks and stray pointers
• Exceptions– Error handling is not an afterthought
• Type-safety– No uninitialized variables, unsafe casts
• Versioning– Pervasive versioning considerations in all aspects of
language design
http://www.mahendar.com
C# – The Big IdeasPreservation of Investment
• C++ heritage– Namespaces, enums, unsigned types, pointers (in unsafe
code), etc.– No unnecessary sacrifices
• Interoperability– What software is increasingly about– MS C# implementation talks to XML, SOAP, COM,
DLLs, and any .NET language• Millions of lines of C# code in .NET
– Short learning curve– Increased productivity
http://www.mahendar.com
Hello Worldusing System;using System;
class Helloclass Hello{{ static void Main() {static void Main() { Console.WriteLine("Hello world");Console.WriteLine("Hello world"); }}}}
http://www.mahendar.com
C# Program Structure• Namespaces
– Contain types and other namespaces
• Type declarations– Classes, structs, interfaces, enums,
and delegates
• Members– Constants, fields, methods, properties, indexers, events,
operators, constructors, destructors
• Organization– No header files, code written “in-line”– No declaration order dependence
http://www.mahendar.com
C# Program Structureusing System;using System;
namespace System.Collectionsnamespace System.Collections{{ public class Stackpublic class Stack {{ Entry top;Entry top;
public void Push(object data) {public void Push(object data) { top = new Entry(top, data);top = new Entry(top, data); }}
public object Pop() {public object Pop() { if (top == null) throw new InvalidOperationException();if (top == null) throw new InvalidOperationException(); object result = top.data;object result = top.data; top = top.next;top = top.next; return result;return result; }} }}}}
http://www.mahendar.com
Type System• Value types
– Directly contain data– Cannot be null
• Reference types– Contain references to objects– May be null
int i = 123;int i = 123;string s = "Hello world";string s = "Hello world";
123123ii
ss "Hello world""Hello world"
http://www.mahendar.com
Type System• Value types
– Primitives int i;– Enums enum State { Off, On }– Structs struct Point { int x, y; }
• Reference types– Classes class Foo: Bar, IFoo {...}– Interfaces interface IFoo: IBar {...}– Arrays string[] a = new string[10];
– Delegates delegate void Empty();
http://www.mahendar.com
Predefined Types• C# predefined types
– Reference object, string– Signed sbyte, short, int, long– Unsigned byte, ushort, uint, ulong– Character char– Floating-point float, double, decimal– Logical bool
• Predefined types are simply aliases for system-provided types– For example, int == System.Int32
http://www.mahendar.com
Classes• Single inheritance• Multiple interface implementation• Class members
– Constants, fields, methods, properties, indexers, events, operators, constructors, destructors
– Static and instance members– Nested types
• Member access– public, protected, internal, private
http://www.mahendar.com
Structs• Like classes, except
– Stored in-line, not heap allocated– Assignment copies data, not reference– No inheritance
• Ideal for light weight objects– Complex, point, rectangle, color– int, float, double, etc., are all structs
• Benefits– No heap allocation, less GC pressure– More efficient use of memory
http://www.mahendar.com
Classes And Structs class CPoint { int x, y; ... }class CPoint { int x, y; ... }struct SPoint { int x, y; ... }struct SPoint { int x, y; ... }
CPoint cp = new CPoint(10, 20);CPoint cp = new CPoint(10, 20);SPoint sp = new SPoint(10, 20);SPoint sp = new SPoint(10, 20);
1010
2020spsp
cpcp
1010
2020
CPointCPoint
http://www.mahendar.com
Interfaces• Multiple inheritance• Can contain methods, properties, indexers, and
events• Private interface implementations
interface IDataBoundinterface IDataBound{{ void Bind(IDataBinder binder);void Bind(IDataBinder binder);}}
class EditBox: Control, IDataBoundclass EditBox: Control, IDataBound{{ void IDataBound.Bind(IDataBinder binder) {...}void IDataBound.Bind(IDataBinder binder) {...}}}
http://www.mahendar.com
Enums• Strongly typed
– No implicit conversions to/from int– Operators: +, -, ++, --, &, |, ^, ~
• Can specify underlying type– Byte, short, int, long
enum Color: byteenum Color: byte{{ Red = 1,Red = 1, Green = 2,Green = 2, Blue = 4,Blue = 4, Black = 0,Black = 0, White = Red | Green | Blue,White = Red | Green | Blue,}}
http://www.mahendar.com
Delegates• Object oriented function pointers• Multiple receivers
– Each delegate has an invocation list– Thread-safe + and - operations
• Foundation for events
delegate void MouseEvent(int x, int y);delegate void MouseEvent(int x, int y);
delegate double Func(double x);delegate double Func(double x);
Func func = new Func(Math.Sin);Func func = new Func(Math.Sin);double x = func(1.0);double x = func(1.0);
http://www.mahendar.com
Unified Type System• Everything is an object
– All types ultimately inherit from object– Any piece of data can be stored, transported, and
manipulated with no extra work
StreamStream
MemoryStreamMemoryStream FileStreamFileStream
HashtableHashtable doubledoubleintint
objectobject
http://www.mahendar.com
Unified Type System• Boxing
– Allocates box, copies value into it
• Unboxing– Checks type of box, copies value out
int i = 123;int i = 123;object o = i;object o = i;int j = (int)o;int j = (int)o;
123123i
o
123123
System.Int32System.Int32
123123j
http://www.mahendar.com
Unified Type System• Benefits
– Eliminates “wrapper classes”– Collection classes work with all types– Replaces OLE Automation's Variant
• Lots of examples in .NET Framework
string s = string.Format(string s = string.Format( "Your total was {0} on {1}", total, date);"Your total was {0} on {1}", total, date);
Hashtable t = new Hashtable();Hashtable t = new Hashtable();t.Add(0, "zero");t.Add(0, "zero");t.Add(1, "one");t.Add(1, "one");t.Add(2, "two");t.Add(2, "two");
http://www.mahendar.com
Component Development• What defines a component?
– Properties, methods, events– Integrated help and documentation– Design-time information
• C# has first class support– Not naming patterns, adapters, etc.– Not external files
• Components are easy to build and consume
http://www.mahendar.com
Properties
• Properties are “smart fields”– Natural syntax, accessors, inlining
public class Button: Controlpublic class Button: Control{{ private string caption;private string caption;
public string Caption {public string Caption { get {get { return caption;return caption; }} set {set { caption = value;caption = value; Repaint();Repaint(); }} }}}}
Button b = new Button();Button b = new Button();b.Caption = "OK";b.Caption = "OK";String s = b.Caption;String s = b.Caption;
http://www.mahendar.com
Indexers
• Indexers are “smart arrays”– Can be overloaded
public class ListBox: Controlpublic class ListBox: Control{{ private string[] items;private string[] items;
public string this[int index] {public string this[int index] { get {get { return items[index];return items[index]; }} set {set { items[index] = value; items[index] = value; Repaint();Repaint(); }} }}}}
ListBox listBox = new ListBox();ListBox listBox = new ListBox();listBox[0] = "hello";listBox[0] = "hello";Console.WriteLine(listBox[0]);Console.WriteLine(listBox[0]);
http://www.mahendar.com
Events Sourcing
• Define the event signature Define the event and firing logicDefine the event and firing logic
public delegate void EventHandler(object sender, EventArgs e);public delegate void EventHandler(object sender, EventArgs e);
public class Buttonpublic class Button{{ public event EventHandler Click; public event EventHandler Click;
protected void OnClick(EventArgs e) {protected void OnClick(EventArgs e) { if (Click != null) Click(this, e); if (Click != null) Click(this, e); } }}}
http://www.mahendar.com
Events Handling
• Define and register event handlerpublic class MyForm: Formpublic class MyForm: Form{{ Button okButton;Button okButton;
public MyForm() {public MyForm() { okButton = new Button(...);okButton = new Button(...); okButton.Caption = "OK";okButton.Caption = "OK"; okButton.Click += new EventHandler(OkButtonClick);okButton.Click += new EventHandler(OkButtonClick); }}
void OkButtonClick(object sender, EventArgs e) {void OkButtonClick(object sender, EventArgs e) { ShowMessage("You pressed the OK button");ShowMessage("You pressed the OK button"); }}}}
http://www.mahendar.com
Attributes• How do you associate information with types
and members?– Documentation URL for a class– Transaction context for a method– XML persistence mapping
• Traditional solutions– Add keywords or pragmas to language– Use external files, e.g., .IDL, .DEF
• C# solution: Attributes
http://www.mahendar.com
Attributespublic class OrderProcessorpublic class OrderProcessor{{ [WebMethod][WebMethod] public void SubmitOrder(PurchaseOrder order) {...}public void SubmitOrder(PurchaseOrder order) {...}}}
[XmlRoot("Order", Namespace="urn:acme.b2b-schema.v1")][XmlRoot("Order", Namespace="urn:acme.b2b-schema.v1")]public class PurchaseOrderpublic class PurchaseOrder{{ [XmlElement("shipTo")] public Address ShipTo;[XmlElement("shipTo")] public Address ShipTo; [XmlElement("billTo")] public Address BillTo;[XmlElement("billTo")] public Address BillTo; [XmlElement("comment")] public string Comment;[XmlElement("comment")] public string Comment; [XmlElement("items")] public Item[] Items;[XmlElement("items")] public Item[] Items; [XmlAttribute("date")] public DateTime OrderDate;[XmlAttribute("date")] public DateTime OrderDate;}}
public class Address {...}public class Address {...}
public class Item {...}public class Item {...}
http://www.mahendar.com
Attributes• Attributes can be
– Attached to types and members– Examined at run-time using reflection
• Completely extensible– Simply a class that inherits from System.Attribute
• Type-safe– Arguments checked at compile-time
• Extensive use in .NET Framework– XML, Web Services, security, serialization, component
model, COM and P/Invoke interop, code configuration…
http://www.mahendar.com
XML Commentsclass XmlElementclass XmlElement{{ /// <summary>/// <summary> /// Returns the attribute with the given name and/// Returns the attribute with the given name and /// namespace</summary>/// namespace</summary> /// <param name="name">/// <param name="name"> /// The name of the attribute</param>/// The name of the attribute</param> /// <param name="ns">/// <param name="ns"> /// The namespace of the attribute, or null if/// The namespace of the attribute, or null if /// the attribute has no namespace</param>/// the attribute has no namespace</param> /// <return>/// <return> /// The attribute value, or null if the attribute/// The attribute value, or null if the attribute /// does not exist</return>/// does not exist</return> /// <seealso cref="GetAttr(string)"/>/// <seealso cref="GetAttr(string)"/> ////// public string GetAttr(string name, string ns) {public string GetAttr(string name, string ns) { ...... }}}}
http://www.mahendar.com
Statements And Expressions
• High C++ fidelity• If, while, do require bool condition• goto can’t jump into blocks• Switch statement
– No fall-through, “goto case” or “goto default”
• foreach statement• Checked and unchecked statements• Expression statements must do work
void Foo() {void Foo() { i == 1; // errori == 1; // error}}
http://www.mahendar.com
foreach Statement• Iteration of arrays
• Iteration of user-defined collections
foreach (Customer c in customers.OrderBy("name")) {foreach (Customer c in customers.OrderBy("name")) { if (c.Orders.Count != 0) {if (c.Orders.Count != 0) { ...... }}}}
public static void Main(string[] args) {public static void Main(string[] args) { foreach (string s in args) Console.WriteLine(s);foreach (string s in args) Console.WriteLine(s);}}
http://www.mahendar.com
Parameter Arrays
• Can write “printf” style methods– Type-safe, unlike C++
void printf(string fmt, params object[] args) {void printf(string fmt, params object[] args) { foreach (object x in args) {foreach (object x in args) { ...... }}}}
printf("%s %i %i", str, int1, int2);printf("%s %i %i", str, int1, int2);
object[] args = new object[3];object[] args = new object[3];args[0] = str;args[0] = str;args[1] = int1;args[1] = int1;Args[2] = int2;Args[2] = int2;printf("%s %i %i", args);printf("%s %i %i", args);
http://www.mahendar.com
Operator Overloading• First class user-defined data types
• Used in base class library– Decimal, DateTime, TimeSpan
• Used in UI library– Unit, Point, Rectangle
• Used in SQL integration– SQLString, SQLInt16, SQLInt32, SQLInt64,
SQLBool, SQLMoney, SQLNumeric, SQLFloat…
http://www.mahendar.com
Operator Overloadingpublic struct DBIntpublic struct DBInt{{ public static readonly DBInt Null = new DBInt();public static readonly DBInt Null = new DBInt();
private int value;private int value; private bool defined;private bool defined;
public bool IsNull { get { return !defined; } }public bool IsNull { get { return !defined; } }
public static DBInt operator +(DBInt x, DBInt y) {...}public static DBInt operator +(DBInt x, DBInt y) {...}
public static implicit operator DBInt(int x) {...}public static implicit operator DBInt(int x) {...} public static explicit operator int(DBInt x) {...}public static explicit operator int(DBInt x) {...}}}
DBInt x = 123;DBInt x = 123;DBInt y = DBInt.Null;DBInt y = DBInt.Null;DBInt z = x + y;DBInt z = x + y;
http://www.mahendar.com
Versioning• Problem in most languages
– C++ and Java produce fragile base classes – Users unable to express versioning intent
• C# allows intent to be expressed– Methods are not virtual by default– C# keywords “virtual”, “override” and “new” provide
context
• C# can't guarantee versioning– Can enable (e.g., explicit override)– Can encourage (e.g., smart defaults)
http://www.mahendar.com
Versioning
class Derived: Baseclass Derived: Base // version 1// version 1{{ public virtual void Foo() {public virtual void Foo() { Console.WriteLine("Derived.Foo"); Console.WriteLine("Derived.Foo"); }}}}
class Derived: Baseclass Derived: Base // version 2a// version 2a{{ new public virtual void Foo() {new public virtual void Foo() { Console.WriteLine("Derived.Foo"); Console.WriteLine("Derived.Foo"); }}}}
class Derived: Baseclass Derived: Base // version 2b// version 2b{{ public override void Foo() {public override void Foo() { base.Foo();base.Foo(); Console.WriteLine("Derived.Foo"); Console.WriteLine("Derived.Foo"); }}}}
class Baseclass Base // version 1// version 1{{}}
class Base class Base // version 2 // version 2 {{ public virtual void Foo() {public virtual void Foo() { Console.WriteLine("Base.Foo"); Console.WriteLine("Base.Foo"); }}}}
http://www.mahendar.com
Conditional Compilation• #define, #undef• #if, #elif, #else, #endif
– Simple boolean logic
• Conditional methods
public class Debugpublic class Debug{{ [Conditional("Debug")][Conditional("Debug")] public static void Assert(bool cond, String s) {public static void Assert(bool cond, String s) { if (!cond) {if (!cond) { throw new AssertionException(s);throw new AssertionException(s); }} }}}}
http://www.mahendar.com
Unsafe Code• Platform interoperability covers most cases• Unsafe code
– Low-level code “within the box”– Enables unsafe casts, pointer arithmetic
• Declarative pinning– Fixed statement
• Basically “inline C”
unsafe void Foo() {unsafe void Foo() { char* buf = stackalloc char[256];char* buf = stackalloc char[256]; for (char* p = buf; p < buf + 256; p++) *p = 0;for (char* p = buf; p < buf + 256; p++) *p = 0; ......}}
http://www.mahendar.com
Unsafe Codeclass FileStream: Streamclass FileStream: Stream{{ int handle;int handle;
public unsafe int Read(byte[] buffer, int index, int count) {public unsafe int Read(byte[] buffer, int index, int count) { int n = 0;int n = 0; fixed (byte* p = buffer) {fixed (byte* p = buffer) { ReadFile(handle, p + index, count, &n, null);ReadFile(handle, p + index, count, &n, null); }} return n;return n; }}
[dllimport("kernel32", SetLastError=true)][dllimport("kernel32", SetLastError=true)] static extern unsafe bool ReadFile(int hFile,static extern unsafe bool ReadFile(int hFile, void* lpBuffer, int nBytesToRead,void* lpBuffer, int nBytesToRead, int* nBytesRead, Overlapped* lpOverlapped);int* nBytesRead, Overlapped* lpOverlapped);}}
top related