Download as PDF, PPTX
![A Typical and Trivial
Program in C#
class
Program{
static
void
Main(string[]
args){
House
h
=
new
House();
for
(int
i
=
0;
i
<
4;
i++){
System.Console.WriteLine("i={0},
house
says:
{1}",
i,
h.ToString());
}
System.Console.Read();
}
}
}
… continuing from the previous slide
3/8:C# Basics
3/3:Typical and Trivial](https://image.slidesharecdn.com/understandingc-170517115205/85/Understanding-C-in-NET-12-320.jpg)
![Arrays
4/8:Code Elements
2/12:Array
Following is an example of declaring and
using a simple array.
int[]
items
=
new
int[]{5,19,41,1,9};
foreach
(int
i
in
items)
{
System.Console.WriteLine("{0}n",
i-‐1);
}](https://image.slidesharecdn.com/understandingc-170517115205/85/Understanding-C-in-NET-17-320.jpg)
![Properties
class
Client{
private
string
name
;
public
string
Name{
get{
return
name;
}
set{
name=value;
}
}
static
void
Main(string[]
args)
{
Client
c
=
new
Client();
c.Name
=
"Celia";
System.Console.WriteLine(c.Name);
System.Console.ReadLine();
}
}
4/8:Code Elements
3/12:Property](https://image.slidesharecdn.com/understandingc-170517115205/85/Understanding-C-in-NET-20-320.jpg)
![Properties
class
Client2{
public
string
Name
{
get;
set;
}
static
void
Main(string[]
args){
Client2
c
=
new
Client2();
c.Name
=
"Cruz";
System.Console.WriteLine(c.Name);
System.Console.ReadLine();
}
}
C# also has a feature to automatically implement the getters
and setter for you.
Users have direct access to the data members of the class.
Following example does the same thing as the previous
example, but using automatically implemented properties
Automatically Implemented
4/8:Code Elements
3/12:Property](https://image.slidesharecdn.com/understandingc-170517115205/85/Understanding-C-in-NET-21-320.jpg)
![Indexers
4/8:Code Elements
4/12:Indexer
Indexers allow a class to be used as an array. For
instance the “[]” operator can be used and the
‘foreach’, ‘in’ keywords can also be used on a
class that has indexers.
The internal representation of the items in that class
are managed by the developer.
Indexers are defined by the following expression.
public int this[int idx]{
get{/* your code*/}; set{/*code here*/};
}](https://image.slidesharecdn.com/understandingc-170517115205/85/Understanding-C-in-NET-22-320.jpg)
![Nested Classes
4/8:Code Elements
5/12:Nested Class
C# supports nested class which defaults
to private.
class
Program
{
public
class
InsiderClass
{
private
int
a;
}
static
void
Main(string[]
args)
{
}
}](https://image.slidesharecdn.com/understandingc-170517115205/85/Understanding-C-in-NET-23-320.jpg)
![Inheritance and
Interface
class
BaseClass{
public
virtual
void
show(){
System.Console.WriteLine("base
class");}
}
interface
Interface1{void
showMe();}
interface
Interface2{void
showYou();}
class
DerivedAndImplemented:
BaseClass,Interface1,Interface2{
public
void
showMe()
{
System.Console.WriteLine("Me!");
}
public
void
showYou()
{
System.Console.WriteLine("You!");
}
public
override
void
show(){
System.Console.WriteLine("I'm
in
derived
Class");}
static
void
Main(string[]
args){
DerivedAndImplemented
de
=
new
DerivedAndImplemented();
de.show();
System.Console.Read();}
}
4/8:Code Elements
6/12:Inheritance and Interface](https://image.slidesharecdn.com/understandingc-170517115205/85/Understanding-C-in-NET-25-320.jpg)
![Delegates
class
Program
{
delegate
int
mydel(int
aa);
int
myfunc(int
a){
return
a*a;
}
int
myfunc2(int
a)
{
return
a
+
a;
}
static
void
Main(string[]
args)
{
Program
p=new
Program();
mydel
d=p.myfunc;
System.Console.WriteLine(d(5));
d
=
p.myfunc2;
System.Console.WriteLine(d(5));
System.Console.Read();
}
}
4/8:Code Elements
8/12:Delegate](https://image.slidesharecdn.com/understandingc-170517115205/85/Understanding-C-in-NET-28-320.jpg)
![Delegates
In C#, implementors (functions) that are targeted by a
delegate, can be created anonymously, inline and on
the fly by using the lambda operator “=>”.
Lambda Expression
class
Program
{
delegate
int
mydel(int
aa,
int
bb);
static
void
Main(string[]
args)
{
mydel
d
=
(a,
b)
=>
a
+
2
*
b;
//
in
above
line,
read
a,b
go
to
a+b*2
to
evaluate
System.Console.WriteLine(d(2,3));
System.Console.Read();
}
}
4/8:Code Elements
8/12:Delegate](https://image.slidesharecdn.com/understandingc-170517115205/85/Understanding-C-in-NET-29-320.jpg)
![Generics
class
Genclass<T>{
public
void
genfunc(int
a,
T
b){
for
(int
i
=
0;
i
<
a;
i++){
System.Console.WriteLine(b);
}
}
}
class
Program{
static
void
Main(string[]
args){
Genclass<float>
p
=
new
Genclass<float>();
p.genfunc(3,(float)5.7);
System.Console.Read();
}
}
4/8:Code Elements
9/12:Generic](https://image.slidesharecdn.com/understandingc-170517115205/85/Understanding-C-in-NET-31-320.jpg)
![Object Initializer
class
Client2
{
public
string
Name
{
get;
set;
}
static
void
Main(string[]
args)
{
Client2
c
=
new
Client2
{Name="Adalbarto"};
//
above
is
the
object
initializer
System.Console.WriteLine(c.Name);
System.Console.ReadLine();
}
}
4/8:Code Elements
10/12:Object Initializer](https://image.slidesharecdn.com/understandingc-170517115205/85/Understanding-C-in-NET-33-320.jpg)
![Iterator
public
class
MyBooks
:
System.Collections.IEnumerable
{
string[]
books
=
{
"Linear
Systems",
"Design
Patterns
Explained",
"The
Now
Habbit",
"The
DeVinci
Code"
};
public
System.Collections.IEnumerator
GetEnumerator()
{
for
(int
i
=
0;
i
<
books.Length;
i++)
{
yield
return
books[i];
}
}
}
class
Program
{
static
void
Main(string[]
args)
{
MyBooks
b
=
new
MyBooks();
foreach
(string
s
in
b)
{
System.Console.Write(s
+
"
");
}
System.Console.Read();
}
}
4/8:Code Elements
11/12:Iterator](https://image.slidesharecdn.com/understandingc-170517115205/85/Understanding-C-in-NET-35-320.jpg)
![Structure
struct
Rectangle{
public
int
length;
public
int
width;
public
Rectangle(int
length,int
width){
this.length=length;
this.width=width;
}
public
int
getArea(){
return
length*width;
}
}
class
Program{
static
void
Main(string[]
args){
Rectangle
r=new
Rectangle(2,5);
System.Console.WriteLine("The
area
is:
{0}",r.getArea());
System.Console.Read();
}
}
4/8:Code Elements
12/12:Sturcture](https://image.slidesharecdn.com/understandingc-170517115205/85/Understanding-C-in-NET-37-320.jpg)
![Namespace
using
System;
namespace
space1{
class
MyClass1{
public
void
show(){
System.Console.WriteLine("MyClass1");
}
}
}
namespace
space2{
class
Program{
static
void
Main(string[]
args){
space1.MyClass1
c=new
space1.MyClass1();
c.show();
Console.Read();
}
}
}
5/8:Organization
1/4:Namespaces](https://image.slidesharecdn.com/understandingc-170517115205/85/Understanding-C-in-NET-39-320.jpg)
![Attribute
[Obsolete("Do
not
use
this")]
public
class
Myclass
{
public
void
disp()
{
System.Console.WriteLine("..");
}
}
class
Program
{
[STAThread]
//
means
thread
safe
for
COM
static
void
Main(string[]
args)
{
Myclass
mc
=
new
Myclass();
mc.disp();
System.Console.Read();
}
}
5/8:Organization
2/4:Attribute](https://image.slidesharecdn.com/understandingc-170517115205/85/Understanding-C-in-NET-41-320.jpg)
![A Typical and Trivial
Program in C#
class
Program{
static
void
Main(string[]
args){
House
h
=
new
House();
for
(int
i
=
0;
i
<
4;
i++){
System.Console.WriteLine("i={0},
house
says:
{1}",
i,
h.ToString());
}
System.Console.Read();
}
}
}
… continuing from the previous slide
3/8:C# Basics
3/3:Typical and Trivial](https://image.slidesharecdn.com/understandingc-170517115205/75/Understanding-C-in-NET-12-2048.jpg)
![Arrays
4/8:Code Elements
2/12:Array
Following is an example of declaring and
using a simple array.
int[]
items
=
new
int[]{5,19,41,1,9};
foreach
(int
i
in
items)
{
System.Console.WriteLine("{0}n",
i-‐1);
}](https://image.slidesharecdn.com/understandingc-170517115205/75/Understanding-C-in-NET-17-2048.jpg)
![Properties
class
Client{
private
string
name
;
public
string
Name{
get{
return
name;
}
set{
name=value;
}
}
static
void
Main(string[]
args)
{
Client
c
=
new
Client();
c.Name
=
"Celia";
System.Console.WriteLine(c.Name);
System.Console.ReadLine();
}
}
4/8:Code Elements
3/12:Property](https://image.slidesharecdn.com/understandingc-170517115205/75/Understanding-C-in-NET-20-2048.jpg)
![Properties
class
Client2{
public
string
Name
{
get;
set;
}
static
void
Main(string[]
args){
Client2
c
=
new
Client2();
c.Name
=
"Cruz";
System.Console.WriteLine(c.Name);
System.Console.ReadLine();
}
}
C# also has a feature to automatically implement the getters
and setter for you.
Users have direct access to the data members of the class.
Following example does the same thing as the previous
example, but using automatically implemented properties
Automatically Implemented
4/8:Code Elements
3/12:Property](https://image.slidesharecdn.com/understandingc-170517115205/75/Understanding-C-in-NET-21-2048.jpg)
![Indexers
4/8:Code Elements
4/12:Indexer
Indexers allow a class to be used as an array. For
instance the “[]” operator can be used and the
‘foreach’, ‘in’ keywords can also be used on a
class that has indexers.
The internal representation of the items in that class
are managed by the developer.
Indexers are defined by the following expression.
public int this[int idx]{
get{/* your code*/}; set{/*code here*/};
}](https://image.slidesharecdn.com/understandingc-170517115205/75/Understanding-C-in-NET-22-2048.jpg)
![Nested Classes
4/8:Code Elements
5/12:Nested Class
C# supports nested class which defaults
to private.
class
Program
{
public
class
InsiderClass
{
private
int
a;
}
static
void
Main(string[]
args)
{
}
}](https://image.slidesharecdn.com/understandingc-170517115205/75/Understanding-C-in-NET-23-2048.jpg)
![Inheritance and
Interface
class
BaseClass{
public
virtual
void
show(){
System.Console.WriteLine("base
class");}
}
interface
Interface1{void
showMe();}
interface
Interface2{void
showYou();}
class
DerivedAndImplemented:
BaseClass,Interface1,Interface2{
public
void
showMe()
{
System.Console.WriteLine("Me!");
}
public
void
showYou()
{
System.Console.WriteLine("You!");
}
public
override
void
show(){
System.Console.WriteLine("I'm
in
derived
Class");}
static
void
Main(string[]
args){
DerivedAndImplemented
de
=
new
DerivedAndImplemented();
de.show();
System.Console.Read();}
}
4/8:Code Elements
6/12:Inheritance and Interface](https://image.slidesharecdn.com/understandingc-170517115205/75/Understanding-C-in-NET-25-2048.jpg)
![Delegates
class
Program
{
delegate
int
mydel(int
aa);
int
myfunc(int
a){
return
a*a;
}
int
myfunc2(int
a)
{
return
a
+
a;
}
static
void
Main(string[]
args)
{
Program
p=new
Program();
mydel
d=p.myfunc;
System.Console.WriteLine(d(5));
d
=
p.myfunc2;
System.Console.WriteLine(d(5));
System.Console.Read();
}
}
4/8:Code Elements
8/12:Delegate](https://image.slidesharecdn.com/understandingc-170517115205/75/Understanding-C-in-NET-28-2048.jpg)
![Delegates
In C#, implementors (functions) that are targeted by a
delegate, can be created anonymously, inline and on
the fly by using the lambda operator “=>”.
Lambda Expression
class
Program
{
delegate
int
mydel(int
aa,
int
bb);
static
void
Main(string[]
args)
{
mydel
d
=
(a,
b)
=>
a
+
2
*
b;
//
in
above
line,
read
a,b
go
to
a+b*2
to
evaluate
System.Console.WriteLine(d(2,3));
System.Console.Read();
}
}
4/8:Code Elements
8/12:Delegate](https://image.slidesharecdn.com/understandingc-170517115205/75/Understanding-C-in-NET-29-2048.jpg)
![Generics
class
Genclass<T>{
public
void
genfunc(int
a,
T
b){
for
(int
i
=
0;
i
<
a;
i++){
System.Console.WriteLine(b);
}
}
}
class
Program{
static
void
Main(string[]
args){
Genclass<float>
p
=
new
Genclass<float>();
p.genfunc(3,(float)5.7);
System.Console.Read();
}
}
4/8:Code Elements
9/12:Generic](https://image.slidesharecdn.com/understandingc-170517115205/75/Understanding-C-in-NET-31-2048.jpg)
![Object Initializer
class
Client2
{
public
string
Name
{
get;
set;
}
static
void
Main(string[]
args)
{
Client2
c
=
new
Client2
{Name="Adalbarto"};
//
above
is
the
object
initializer
System.Console.WriteLine(c.Name);
System.Console.ReadLine();
}
}
4/8:Code Elements
10/12:Object Initializer](https://image.slidesharecdn.com/understandingc-170517115205/75/Understanding-C-in-NET-33-2048.jpg)
![Iterator
public
class
MyBooks
:
System.Collections.IEnumerable
{
string[]
books
=
{
"Linear
Systems",
"Design
Patterns
Explained",
"The
Now
Habbit",
"The
DeVinci
Code"
};
public
System.Collections.IEnumerator
GetEnumerator()
{
for
(int
i
=
0;
i
<
books.Length;
i++)
{
yield
return
books[i];
}
}
}
class
Program
{
static
void
Main(string[]
args)
{
MyBooks
b
=
new
MyBooks();
foreach
(string
s
in
b)
{
System.Console.Write(s
+
"
");
}
System.Console.Read();
}
}
4/8:Code Elements
11/12:Iterator](https://image.slidesharecdn.com/understandingc-170517115205/75/Understanding-C-in-NET-35-2048.jpg)
![Structure
struct
Rectangle{
public
int
length;
public
int
width;
public
Rectangle(int
length,int
width){
this.length=length;
this.width=width;
}
public
int
getArea(){
return
length*width;
}
}
class
Program{
static
void
Main(string[]
args){
Rectangle
r=new
Rectangle(2,5);
System.Console.WriteLine("The
area
is:
{0}",r.getArea());
System.Console.Read();
}
}
4/8:Code Elements
12/12:Sturcture](https://image.slidesharecdn.com/understandingc-170517115205/75/Understanding-C-in-NET-37-2048.jpg)
![Namespace
using
System;
namespace
space1{
class
MyClass1{
public
void
show(){
System.Console.WriteLine("MyClass1");
}
}
}
namespace
space2{
class
Program{
static
void
Main(string[]
args){
space1.MyClass1
c=new
space1.MyClass1();
c.show();
Console.Read();
}
}
}
5/8:Organization
1/4:Namespaces](https://image.slidesharecdn.com/understandingc-170517115205/75/Understanding-C-in-NET-39-2048.jpg)
![Attribute
[Obsolete("Do
not
use
this")]
public
class
Myclass
{
public
void
disp()
{
System.Console.WriteLine("..");
}
}
class
Program
{
[STAThread]
//
means
thread
safe
for
COM
static
void
Main(string[]
args)
{
Myclass
mc
=
new
Myclass();
mc.disp();
System.Console.Read();
}
}
5/8:Organization
2/4:Attribute](https://image.slidesharecdn.com/understandingc-170517115205/75/Understanding-C-in-NET-41-2048.jpg)
More Related Content
Similar to Understanding C# in .NET
Understanding C# in .NET
- 1. 1. Introduction 2. .NETBasics 3. C# Basics 4. Code Elements 5. Organization 6. GUI 7. Demo 8. Conclusion Contents
- 2. Introduction This presentation ispart of the requirements for this (stated below) class. Student Name: Adnan Reza Class: Object Oriented Analysis and Design Instructor: Ken Anderson Semester: Fall 2011 School: University of Colorado at Boulder 1/8:Introduction
- 3. Introduction Topic: .NET Frameworkand C# Details: This presentation describes some elementary features of .NET Framework and C#. Organization: The index that contains the chapters of this document is found in the first slide. On the top-left corner of every slide show the name of the chapter, sub-chapter etc. The titles are at top-right 1/8:Introduction
- 4. .NET Basics • The.NET Framework is a framework for developing and implementing software for personal computer, web etc. • It was designed and is maintained by Microsoft Corporation. • It came out around the year 2000, even though Microsoft started its development in early 90s. • .NET has a rich collection of class library (called the Base Class Library) to implement GUI, query, database, web services etc. 2/8:.NET Basics
- 5. .NET Basics • Programsdeveloped with .NET needs a virtual machine to run on a host. This virtual machine is called Common Language Runtime (CLR). • Since the compiler doesn’t produce native machine code, and its product is interpreted by the CLR, there’s much security. • .NET allows using types defined by one .NET language to be used by another under the Common Language Infrastructure (CLI) specification, for the conforming languages. 2/8:.NET Basics
- 6. .NET Basics • Anylanguage that conforms to the Common Language Infrastructure (CLI) specification of the .NET, can run in the .NET run-time. Followings are some .NET languages. • Visual Basic • C# • C++ (CLI version) • J# (CLI version of Java) • A# (CLI version of ADA) • L# (CLI version of LISP) • IronRuby (CLI version of RUBY) 2/8:.NET Basics
- 7. .NET Basics Microsoft providesa comprehensive Integrated Development Environment (IDE) for the development and testing of software with .NET. Some IDEs are as follows • Visual Studio • Visual Web Developer • Visual Basic • Visual C# • Visual Basic 2/8:.NET Basics
- 8. What is C# C#is a general purpose object oriented programming language developed by Microsoft for program development in the .NET Framework. It’s supported by .NET’s huge class library that makes development of modern Graphical User Interface applications for personal computers very easy. It’s a C-like language and many features resemble those of C++ and Java. For instance, like Java, it too has automatic garbage collection. 3/8:C# Basics 1/3:What is C#
- 9. What is C# Itcame out around the year 2000 for the .NET platform. Microsoft’s Anders Hejlsberg is the principal designer of C#. The “#” comes from the musical notation meaning C# is higher than C. The current version (today’s date is Nov 2, 2011) is 4.0 and was released on April, 2010 More information about C#, tutorial, references, support and documentation can be found in the Microsoft Developers Network website. 3/8:C# Basics 1/3:What is C#
- 10. Types of Application The productof the C# compiler is called the “Assembly”. It’s either a “.dll” or a “.exe” file. Both run on the Common Language Runtime and are different from native code that may also end with a “.exe” extension. C# has two basic types of application. • Windows From Application This is GUI based, runs in a window of some sort • Console Application • This application runs in the command prompt 3/8:C# Basics 2/3:Types of Application
- 11. A Typical andTrivial Program in C# using System; namespace typical_trivial{ class House{ private int location; protected string name; public House(){ name = "No Name Yet!"; } // every class inherits ‘object’ that has ToString() public override string ToString(){ string disp = "Name is " + name + ", location= " + location.ToString(); return disp; } } Continues to the next slide … 3/8:C# Basics 3/3:Typical and Trivial
- 12. A Typical andTrivial Program in C# class Program{ static void Main(string[] args){ House h = new House(); for (int i = 0; i < 4; i++){ System.Console.WriteLine("i={0}, house says: {1}", i, h.ToString()); } System.Console.Read(); } } } … continuing from the previous slide 3/8:C# Basics 3/3:Typical and Trivial
- 13. Types 1. Value type 1. Variable name contains the actual value 2. int, double and other primitive types 3. Structure, Enumeration, etc. 2. Reference Type 1. Variable name contains the reference or pointer to the actual value in memory 2. Array, derived from class Array 3. Class, Interface, Delegate, String, etc. 4/8:Code Elements 1/12:Types
- 14. Types • The valuetypes are derived from System.ValueType • All types in C# are derived from System.Object which is also accessed by the alias keyword ‘object’ • This type hierarchy is called Common Type System (CTS) 4/8:Code Elements 1/12:Types
- 15. Types The value typescan’t be assigned a null. To enable regular primitive value types to take a null value, C# uses nullable types using ‘?’ with type name. Following example shows how. int? a; a = null; int b; b = a ?? -‐99; // the ?? operator picks -‐99 if null System.Console.WriteLine("this is null. {0}",b); a = 23; // not null System.Console.WriteLine("this is not null. {0}", a ?? -‐99); Nullable 4/8:Code Elements 1/12:Types
- 16. Types Variables can bedefined without an explicit name and to encapsulate a set of values. This is useful for C#’s Language Integrated Query (which will not be discussed in this presentation) var a = 3; // the type is automatically inferred by compiler var b = new { id = 21, name = "Tito" }; System.Console.WriteLine("a={0}, b.id={1}, b.name={2}", a, b.id, b.name); Anonymous 4/8:Code Elements 1/12:Types
- 17. Arrays 4/8:Code Elements 2/12:Array Following isan example of declaring and using a simple array. int[] items = new int[]{5,19,41,1,9}; foreach (int i in items) { System.Console.WriteLine("{0}n", i-‐1); }
- 18. Array The ‘foreach’ ,’in’keywords are used to provide read only (recommended) access to members of an array or any object implementing the IEnumerable interface (more about this is discussed in the section ‘Iterator’). 4/8:Code Elements 2/12:Array
- 19. Properties 4/8:Code Elements 3/12:Property Properties aremembers of a class that allows for easy and simplified getters and setters implementation of its private field variables. The next slide has an example.
- 20. Properties class Client{ private string name ; public string Name{ get{ return name; } set{ name=value; } } static void Main(string[] args) { Client c = new Client(); c.Name = "Celia"; System.Console.WriteLine(c.Name); System.Console.ReadLine(); } } 4/8:Code Elements 3/12:Property
- 21. Properties class Client2{ public string Name { get; set; } static void Main(string[] args){ Client2 c = new Client2(); c.Name = "Cruz"; System.Console.WriteLine(c.Name); System.Console.ReadLine(); } } C# also has a feature to automatically implement the getters and setter for you. Users have direct access to the data members of the class. Following example does the same thing as the previous example, but using automatically implemented properties Automatically Implemented 4/8:Code Elements 3/12:Property
- 22. Indexers 4/8:Code Elements 4/12:Indexer Indexers allowa class to be used as an array. For instance the “[]” operator can be used and the ‘foreach’, ‘in’ keywords can also be used on a class that has indexers. The internal representation of the items in that class are managed by the developer. Indexers are defined by the following expression. public int this[int idx]{ get{/* your code*/}; set{/*code here*/}; }
- 23. Nested Classes 4/8:Code Elements 5/12:NestedClass C# supports nested class which defaults to private. class Program { public class InsiderClass { private int a; } static void Main(string[] args) { } }
- 24. Inheritance and Interface 4/8:Code Elements 6/12:Inheritanceand Interface A class can directly inherit from only one base class and can implement multiple interfaces. To override a method defined in the base class, the keyword ‘override’ is used. An abstract class can be declared with the keyword ‘abstract’. A static class is a class that is declared with the ‘static’ keyword. It can not be instantiated and all members must be static.
- 25. Inheritance and Interface class BaseClass{ public virtual void show(){ System.Console.WriteLine("base class");} } interface Interface1{void showMe();} interface Interface2{void showYou();} class DerivedAndImplemented: BaseClass,Interface1,Interface2{ public void showMe() { System.Console.WriteLine("Me!"); } public void showYou() { System.Console.WriteLine("You!"); } public override void show(){ System.Console.WriteLine("I'm in derived Class");} static void Main(string[] args){ DerivedAndImplemented de = new DerivedAndImplemented(); de.show(); System.Console.Read();} } 4/8:Code Elements 6/12:Inheritance and Interface
- 26. Class Access and Partial 4/8:CodeElements 7/12:Class Access & Partial The class access modifiers are public, private, protected and internal. ‘internal’ is an intermediate access level which only allows access to classes in the same assembly. The ‘partial’ keyword can be used to split up a class definition in to multiple location (file etc). Can be useful when multiple developers are working on different parts of the same class.
- 27. Delegates 4/8:Code Elements 8/12:Delegate Delegates aretypes that describe a method signature. This is similar to function pointer in C. At runtime, different actual methods of same signature can be assigned to the delegate enabling encapsulation of implementation. These are extensively used to implement GUI and event handling in the .net framework (will be discussed later).
- 28. Delegates class Program { delegate int mydel(int aa); int myfunc(int a){ return a*a; } int myfunc2(int a) { return a + a; } static void Main(string[] args) { Program p=new Program(); mydel d=p.myfunc; System.Console.WriteLine(d(5)); d = p.myfunc2; System.Console.WriteLine(d(5)); System.Console.Read(); } } 4/8:Code Elements 8/12:Delegate
- 29. Delegates In C#, implementors(functions) that are targeted by a delegate, can be created anonymously, inline and on the fly by using the lambda operator “=>”. Lambda Expression class Program { delegate int mydel(int aa, int bb); static void Main(string[] args) { mydel d = (a, b) => a + 2 * b; // in above line, read a,b go to a+b*2 to evaluate System.Console.WriteLine(d(2,3)); System.Console.Read(); } } 4/8:Code Elements 8/12:Delegate
- 30. Generics 4/8:Code Elements 9/12:Generic Generics area powerful feature of C#. These enable defining classes and methods without specifying a type to use at coding time. A placeholder for type <T> is used and when these methods or classes are used, the client just simply has to plug in the appropriate type. Used commonly in lists, maps etc.
- 31. Generics class Genclass<T>{ public void genfunc(int a, T b){ for (int i = 0; i < a; i++){ System.Console.WriteLine(b); } } } class Program{ static void Main(string[] args){ Genclass<float> p = new Genclass<float>(); p.genfunc(3,(float)5.7); System.Console.Read(); } } 4/8:Code Elements 9/12:Generic
- 32. Object Initializer 4/8:Code Elements 10/12:ObjectInitializer Using automatically implemented properties (discussed earlier), object initializers allow for initializing an object at creation time without explicit constructors. It can also be used with anonymous types (discussed earlier). The following slide has an example.
- 33. Object Initializer class Client2 { public string Name { get; set; } static void Main(string[] args) { Client2 c = new Client2 {Name="Adalbarto"}; // above is the object initializer System.Console.WriteLine(c.Name); System.Console.ReadLine(); } } 4/8:Code Elements 10/12:Object Initializer
- 34. Iterator 4/8:Code Elements 11/12:Iterator Any classimplementing the interface IEnumerable can be invoked by client code using the ‘foreach’, ‘in’ statements. The code loops through the elements of the class and provides access to its elements. This class defines the GetEnumerator method, where, individual elements are returned by the ‘yield’ keyword.
- 35. Iterator public class MyBooks : System.Collections.IEnumerable { string[] books = { "Linear Systems", "Design Patterns Explained", "The Now Habbit", "The DeVinci Code" }; public System.Collections.IEnumerator GetEnumerator() { for (int i = 0; i < books.Length; i++) { yield return books[i]; } } } class Program { static void Main(string[] args) { MyBooks b = new MyBooks(); foreach (string s in b) { System.Console.Write(s + " "); } System.Console.Read(); } } 4/8:Code Elements 11/12:Iterator
- 36. Structure 4/8:Code Elements 12/12:Sturcture Structures arevalue types that can in some respect act similar to a class. It has fields, methods, constructors (no argument constructors are not allowed) like a class. Structures can’t take part in inheritance, meaning that they can’t inherit from a type and be a base from which other types can inherit.
- 37. Structure struct Rectangle{ public int length; public int width; public Rectangle(int length,int width){ this.length=length; this.width=width; } public int getArea(){ return length*width; } } class Program{ static void Main(string[] args){ Rectangle r=new Rectangle(2,5); System.Console.WriteLine("The area is: {0}",r.getArea()); System.Console.Read(); } } 4/8:Code Elements 12/12:Sturcture
- 38. Namespace 5/8:Organization 1/4:Namespaces Names in C#belong to namespaces. They prevent name collision and offers a manageable code and libraries. In the previous examples, ‘System’ is a namespace. System.Console.Write() is a method of a class defined in that namespace. So, the name of the namespace is put in front to fully qualify a name. With the statement “using System;”, we can skip the System part and just write Console.Write().
- 39. Namespace using System; namespace space1{ class MyClass1{ public void show(){ System.Console.WriteLine("MyClass1"); } } } namespace space2{ class Program{ static void Main(string[] args){ space1.MyClass1 c=new space1.MyClass1(); c.show(); Console.Read(); } } } 5/8:Organization 1/4:Namespaces
- 40. Attribute 5/8:Organization 2/4:Attribute Attributes add metadatato the code entities such as assembly, class, method, return value etc about the type. This metadata describes the type and it’s members This metadata is used by the Common Runtime Environment or can also be used by client code. Attributes are declared in square brackets above the class name, method name etc.
- 41. Attribute [Obsolete("Do not use this")] public class Myclass { public void disp() { System.Console.WriteLine(".."); } } class Program { [STAThread] // means thread safe for COM static void Main(string[] args) { Myclass mc = new Myclass(); mc.disp(); System.Console.Read(); } } 5/8:Organization 2/4:Attribute
- 42. The IDE 5/8:Organization 3/4:The IDE Microsoftprovides Visual Studio for the development of applications, web services etc using the .NET Framework with it’s supported languages. Microsoft Visual C# Express is a free Microsoft product that can be used to develop C# applications for evaluation purposes. The examples provided in this presentation were developed using this software.
- 43. Other Miscellaneous Items 5/8:Organization 4/4:Other Misc • Use of pointers: C# can be configured to allow pointer declaration and arithmetic. • XML comments: It’s possible to follow the XML comments syntax in code and the compiler will generate a documentation for you based of those comments and their location. • Threading: It’s possible to write multi-threaded programs using the System.Threading class library. • C# allows easy integration to unmanaged code (outside of .NET) such as Win32Api, COM,C++ programs etc to it’s own.
- 44. Other Miscellaneous Items • C#allows editing the file system and the Windows System Registry. • Exception: Exceptions can be handled using C#’s try, throw, catch. • Collection Classes: These provide support for various data structures such as list, queue, hash table etc. • Application Domain: The context in which the assembly is run is known as the application domain and is usually determined by the Common Language Runtime (it is also possible to handle this in code). This isolates individual programs and provides security. 5/8:Organization 4/4:Other Misc
- 45. GUI: Introduction 6/8:GUI 1/3:Introduction The .NET frameworkprovides a class library of various graphical user interface tools such as frame, text box, buttons etc. that C# can use to implement a GUI very easily and fast. The .NET framework also equips these classes with events and event handlers to perform action upon interacting with these visual items by the user.
- 46. Visual Items 6/8:GUI 2/3:Visual Items Thefollowing are some of the visual items. • Form: displays as a window. • Button: displays a clickable button • Label: displays a label • TextBox: displays an area to edit • RadioButton: displays a selectable button
- 47. Visual Items The containing windowis called the “Frame”. Inside are some other GUI elements, such as Button, TextBox etc 6/8:GUI 2/3:Visual Items
- 48. Events 6/8:GUI 3/3:Events 1/4:Intro When anything ofinterest occurs, it’s called an event such as a button click, mouse pointer movement, edit in a textbox etc. An event is raised by a class. This is called publishing an event. It can be arranged that when an event is raised, a class will be notified to handle this event, i.e. perform required tasks. This is called subscribing to the event. This is done via: • Delegates or • Anonymous function or • Lambda expression. These will be discussed shortly
- 49. Events The .NET Frameworkhas many built-in events and delegates for easily subscribing to these events by various classes. For example, for Button class, the click event is called “Click” and the delegate for handler is called “System.EventHandler”. These are already defined in the .NET class library. To tie the event with the handler, the operator “+=” is used. (Will be discussed shortly) Then, when the Button object is clicked, that function will execute. 6/8:GUI 3/3:Events 1/4:Intro
- 50. With Delegates 6/8:GUI 3/3:Events 2/4:With Delegates Thefollowing code segment shows the subscription of the event Button.Click by the method button_Click(…) which matches the System.EventHandler delegate signature. Class Form1:Form{ private System.Windows.Forms.Button button1; ///... Void init(){ this.button1.Click += new System.EventHandler(this.button1_Click); } private void button1_Click(object sender, EventArgs e){ button1.Text = "clicked1"; } }
- 51. With Lambda Expression 6/8:GUI 3/3:Events 3/4:With Lambda Thefollowing code segment shows the subscription of the event Button.Click by inline code which is defined using the lambda operator. This program does the same thing as the last. Class Form1:Form{ private System.Windows.Forms.Button button1; ///... Void init(){ // the arguments a,b are just to satisfy the delegate signature. // they do nothing useful in this simple example. this.button1.Click += (a,b) => { this.button1.Text = "clicked1"; }; } }
- 52. With Anonymous Methods 6/8:GUI 3/3:Events 4/4:With AnonymousMethod An anonymous method is declared with the keyword “delegate”. It has no name in source code level. After the delegate keyword, the arguments need to be put in parenthesis and the function body needs to be put in braces. It is defined in-line exactly where it’s instance is needed. Anonymous methods are very useful in event programming in C# with .NET Framework.
- 53. With Anonymous Methods The followingexample does the same thing as the previous two examples but uses anonymous methods to handle that event. Class Form1:Form{ private System.Windows.Forms.Button button1; ///... Void init(){ this.button1.Click += delegate(object oo, System.EventArgs ee) { this.button1.Text = "clicked1"; }; } } 6/8:GUI 3/3:Events 4/4:With Anonymous Method
- 54. Demo 7/8:Demo For this section,please see the attached video demonstration of the following. • Basic use of Visual C# IDE • Showing of how easily GUI can be created • Creation of a simple web browser
- 55. Conclusion 8/8:Conclusion This presentation describedin short some interesting and important features of the .NET and C#. However, the .NET and C# are not without their trade offs such as the followings. • The .NET currently doesn’t support optimized Single Instruction Multiple Data (SIMD) support for parallel data processing. • Since it’s run in a virtual machine, the demands on system resources are higher than native code of comparable functionality.
- 56. Conclusion 8/8:Conclusion Overall, .NET andC# are very robust, flexible, object oriented, with large library support, secure means of software design and development. Some of the features that were discussed in this presentation, are as follows • Virtual Machine provides security and isolation • Common Runtime Infrastructure enables any language to adapt to the run time
- 57. Conclusion 0/0:Conclusion • The CommonLanguage Infrastructure and Common Type System makes it possible for multiple languages to use each others defined types and libraries. • It has extensive class library for easily developing GUI and web application. • C# has many very nice and flexible features such as partial class/method, nullable type, anonymous method, indexers, generics, iterators, properties etc.
- 58.