CSharp_02_LanguageOverview_andintroduction

Programming in C#
Language Overview
Language Overview
CSE 459.24
Prof. Roger Crawfis

Overview
Quickly go through some of the major
differences between C++ or Java and
C#.
Overview of a C# program.
Built-in C# types.
Canonical Hello World program

My View on C#
 I have been using C# in our research for since C# 1.0 in 2004.
 I think it is a great language!!!
 However, programming languages are a dime a dozen and
somewhat insignificant to large-scale programming.
 The .NET libraries are the real time savers.
 Or stated differently – well tested, well maintained and well
documented reusable components.
 I could do everything in C, but view C# as an automatic code-
generator for many recurring design and programming patterns.
 A strongly-typed language prevents many simple typos from
being bugs.

Language
 Namespaces
 Classes
 Fields
 Properties
 Methods
 Attributes
 Events
 Interfaces (contracts)
 Methods
 Properties
 Events
 Control Statements
 if, else, while, for,
switch
 foreach
 Additional Features
 Operation Overloading
 Structs
 Enums
 Delegates
 OO Features
 Type Unification
 Inheritance
 Polymorphism

C# Program Structure
 Namespaces
 Contain types and other namespaces
 Type declarations
 Classes, struct’s, interfaces, enum’s, and delegates
 Contain members
 Members
 Constants, fields, methods, operators, constructors,
destructors
 Properties, indexers, events
 Organization
 No header files, types imported using assemblies (dll’s).
 Type reflection

Major Language Differences
 Automatic memory management
 Garbage Collection
 No pointers
 Everything inherits from System.Object
 Additional language constructs to aid in implementing
common patterns:
 Iterators – foreach and yield statements
 Data encapsulation – Properties
 Function pointers or Functors – delegates
 Observer Design Pattern – events
 Aspect-oriented programming – Attributes (loosely)
 Functional programming – LINQ and anonymous methods

Other Language Differences
 Salient points
 Conditionals must evaluate to a Boolean
 No pointers. Use the dot “.” to access both
namespaces and fields/methods.
 All fields are initialized by the CLR (zero for value
types, null for reference types).
 The switch statement does not “fall-thru” (unless
empty)
 The switch statement can take bool’s , enum’s,
integral types and strings.
 Expressions must be useful (no a==b;).
 Internal or assembly protection control.

Built-in Types
 C# predefined types
 The “root” object
 Logical bool
 Signed sbyte, short, int, long
 Unsigned byte, ushort, uint, ulong
 Floating-point float, double, decimal
 Textual char, string
 Textual types use Unicode (16-bit characters)

Common Value Types
All integral types: int, uint, long, short,
byte, …
float’s, double’s and decimal’s
Structs
 Aka - user-defined value (light-weight) types
 Can contain arbitrary data
 Non-extensible (sealed subclasses)
 System.Decimal is a struct.

MSDN Documentation
Let’s look at the MSDN documentation
for ValueType and few other types.
Namespace
Assembly
Language filters
Versions

Built-in Types - Strings
 Strings are first-class immutable objects in C#
 Behave like a value type
 Can be indexed like a char array.
 Has many methods (see System.String)
 The @ command allows specifying a string
literal spanning lines.
string s = “Hello”;
char third = s[2];
string[] split = s.Split(third);

Instance Intialization
 Must be initialized (unlike C++)
 double x; // x == 0
 string f; // f.equals(“”)
 A a; // a == null
 Fundamental difference between double and
class A?
 Reference types vs. value types

Reference Types
Classes, including user-defined classes
 Inherited from System.Object
 Transparently refers to a memory location
 Similar to pointers in other languages
 Other view is that: Everything is a pointer.
 Can be set to null memory
}fields in class A
for instance a
{
A a = new A();
A b = a;
}
a
b

Value Types
 Contain the actual value, not the location
 Inherited from System.ValueType
 Which is (logically) derived from System.Object.
 Treated specially by the runtime
 Need to be boxed in order to get a reference
memory
{
int a = 137;
int b = a;
}
a
b
137
137

Boxing and Unboxing
 Value types are not indirectly referenced
 More efficient.
 Less memory.
 In order to treat all types uniformly, a value
type needs is converted to a reference type.
 called boxing. Reverse is unboxing
{
int a = 137;
object o1 = a;
object o2 = o1;
int b = (int)o2;
}
memory
a
b
o1
o2
137
137
int
137

Differences Between Types
Copy semantics:
Polynomial a = new Polynomial();
Polynomial b = a;
b.Coefficient[0] = 10;
Console.WriteLine(a.Coefficient[0]);
int a = 1;
int b = a;
b = 10;
Console.WriteLine(a);
Copies of value types make a real copy
 Important for parameter passing
 Boxing still copies

Function Parameters
 In C++ you could pass a variable by:
 Value (creating a new copy and passing it)
 Pointer (passing in the address)
 Reference (same as pointer, less cluttered syntax).
 In C# there seems to be some confusion and
misinformation (including C# in a Nutshell) on this.
 The MSDN documentation for ref has this correct.
 If you were raised on pointers and understand this
(which you are not), then it is quite simple.
 The ref and out keywords indicate that you should pass:
 Value types – address of value type is passed.
 Reference types – address of pointer is passed.

Function Parameters
ref parameters
Use the value that is passed in
Change the value of a value type passed in
Change the instance that a reference type
points to.
A valid (or initialized) instance or value type
must be passed in.
 Null is a valid value.

Function Parameters
out parameters
Set the value of a value type passed in.
Set the instance that a reference type points
to.
Does not need to be initialized before
calling.
Compiler forces you to set a value for all
possible code paths.

Function Parameters
For variable number of parameters
public void f(int x, params char[] ar);
call f(1), f(1, ‘s’), f(1, ‘s’, ‘f’), f(1, “sf”.ToCharArray());
Must be the last argument in the list

Control Statements
 If, Else
 While
 For
 Foreach

Switch Statement
Switch statements must be expressions
that can be statically evaluated.
Restricted to primitive types, strings and
enums.
There is no fall through on switch cases
unless the case is an empty case:

Switch Statement
switch (myEmployee.Name)
{
case “Boss”:
Console.Writeline(“Your fired!”);
break;
case “Henry”:
case “Jane”:
Console.Writeline(“I need a pay raise.”);
break;
default:
Console.Writeline(“Busy working.”);
break;
}

Jump Statements
Several C# statements provide a break in
the execution:
 break – jumps out of a while or for loop or a
switch statement.
 continue – starts the next iteration of a loop.
 goto – do not use.
 return – returns out of the current method.
 throw – Causes an exception and ends the
current try block or method recursively.

Implicit Type Declarations
C# 3.0 feature
Aids readability in declaring instances of
complex types with redundant initialization:
var myStringBuilder = new StringBuilder();
var myList = new List<IDictionary<string,int>>();
Added for LINQ support (anonymous types).
Avoid using!
Note: still strongly and statically typed

Homework and Quiz
Memorize the C# keywords from the
appendix in the book that start with the
letters a-b.
Read the first two chapters of the book.
Look over the MSDN documentation for
System.String and in particular the Split
method.

CSharp_02_LanguageOverview_andintroduction

More Related Content

Similar to CSharp_02_LanguageOverview_andintroduction (20)

More from Ranjithsingh20 (9)

Recently uploaded (20)

CSharp_02_LanguageOverview_andintroduction