slide1 n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
[ISRAR ALI] PowerPoint Presentation
Download Presentation
[ISRAR ALI]

Loading in 2 Seconds...

play fullscreen
1 / 38

[ISRAR ALI] - PowerPoint PPT Presentation


  • 159 Views
  • Uploaded on

[ISRAR ALI]. Hammad Khan. The namespace keyword is used to declare a scope. Making software components reusable can result in naming collisions (two classes defined by two programmers can have the same name). using System.Collections ;

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about '[ISRAR ALI]' - scot


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
slide1

[ISRAR ALI]

Hammad Khan

slide2
The namespace keyword is used to declare a scope.
  • Making software components reusable can result in naming collisions (two classes defined by two programmers can have the same name).

using System.Collections;

  • An assembly is a dynamic link library created when compiling a project. The assembly can be found in the bin\Debug folder of the project.
  • By default, the assembly name will include the namespace name
example
Example

// Namespace Declarationusing System;// The C# Station Tutorial Namespacenamespace csharp_station{    namespace tutorial     { // Program start class        class NamespaceCSS        { // Main begins program execution.            public static void Main()             { // Write to consoleConsole.WriteLine("This is the new C# Station Tutorial Namespace.");            }        }    }}

slide4

Methods Are Actions

  • methods can be implemented within the scope of classes or structures
  • prototyped within interface types
  • may be decorated with various keywords (internal, virtual, public, new, etc.)
  • // static returnVal MethodName(args) {...}
  • class Program
  • {
  • static int Add(int x, int y)
  • {
  • return x + y;
  • }
  • }
slide5

static void Main(string[] args)

{

Console.WriteLine("***** Fun with Methods *****"); // Pass two variables in by value.

int x = 9, y = 10;

Console.WriteLine("Before call: X: {0}, Y: {1}", x, y);

Console.WriteLine("Answer is: {0}", Add(x, y));

Console.WriteLine("After call: X: {0}, Y: {1}", x, y);

Console.ReadLine();

}

static int Add(int x, int y)

{

int ans = x + y;

// Caller will not see these changes as you are modifying a copy of the original data.

x = 10000; y = 88888;

return ans;

}

slide6
void MyMethod()

{

int num1 = 7, num2 = 9;

Swap(ref num1, ref num2);

// num1 = 9, num2 = 7

}

void Swap(refint x, refint y)

{

int temp = x; x = y; y = temp;

}

slide7
void MyMethod()

{

int num1 = 7, num2;

Subtraction(num1, out num2);

// num1 = 7, num2 = 5

}

void Subtraction(int x, out int y)

{

y = x - 2;

// y must be assigned a value

}

uninitialised

slide8
void MyMethod()

{

int sum = Addition(1, 2, 3); // sum = 6

}

int Addition(params int[] integers)

{

int result = 0;

for (int i = 0; i < integers.Length; i++)

result += integers[i];

return result;

}

slide9
class Program

{

static void Main(string[] args) { }

// Overloaded Add() method.

static int Add(int x, int y)

{ return x + y; }

static double Add(double x, double y)

{ return x + y; }

static long Add(long x, long y)

{ return x + y; }

}

slide11

Object-oriented programming (OOP) is a programming paradigm that uses objects and data structures consisting of data fields and methods together with their interactions to design applications and computer programs. Programming techniques may include features such as Information Hiding, Data Abstraction, Encapsulation, Modularity, Polymorphism, and Inheritance

slide12
Everything is an object.

Think of an object as a fancy variable . it stores data, but you can “make requests” to that object, asking it to perform operations on itself.

  • A program is a bunch of objects telling each other what to do by sending messages.
  • Each object has its own memory made up of other objects.
  • Every object has a type.
  • All objects of a particular type can receive the same messages.

An object has state, behavior and identity

This means that an object can have internal data (which gives it state),

methods (to produce behavior), and each object can be uniquely identified.

slide13
The ability to generalize an object as a data type that has a specific set of characteristics and is able to perform a set of actions.
  • Object-oriented languages provide abstraction via classes. Classes define the properties and methods of an object type.
    • You can create an abstraction of a dog with characteristics, such as color, height, and weight, and actions such as run and bite. The characteristics are called properties, and the actions are called methods.
    • Classes are blueprints for Object and Objects are instance of classes.
slide14
public class MyArray

{

private constint MAX_LENGTH = 100;

private int length;

public MyArray() {

length = 0;

}

public int Length {

get {

return length;

}

set {

length = value;

}

}

}

slide15
None or Internal
  • Public
  • Abstract or internal abstract
  • Public abstract
  • Sealed or internal sealed
  • Public sealed
slide16
A constructoris called automatically right after the creation of an object to initialize it.
  • Constructors have the same name as their class names
  • Default constructor:if no constructor is declared, a parameterless constructor can be declared
  • A class can contain default constructor and overloaded constructors to provide multiple ways to initialise objects.
  • Static constructor: similar to static method. It must be parameterless and must not have an access modifier (private, public).
slide17
public class Languages

{

static Languages() // static constructor

{. . .}

public Languages() // default constructor

{. . .}

public Languages(string lang) // overloaded constructor

{. . .}

}

public class MyClass()

{

Languages langs = new Languages();

}

slide18
public class CSharp

{

public CSharp () { . . .}

public static void StaticMethod() { . . .}

public void NonStaticMethod() { . . .}

}

public class MyClass()

{

CSharpcs = new CSharp();

cs.NonStaticMethod();

CSharp.StaticMethod();

}

slide19
public class CSharp

{

private int count = 0;

. . .

public int Count {

get {

return count;

}

internal set {

count = value;

}

}

public class MyClass()

{

CSharp cs = new CSharp();

cs.Count = 5;

int num = cs.Count;

}

slide20
public class CSharp

{

int [] vals = new int [10];

. . .

public int this [int i]

{

get

{

return vals[i];

}

}

}

public class MyClass()

{

CSharp cs = new CSharp();

int num = cs[2];

}

slide21
Nested types can see all the members of their closing type, both private and public ones.
  • External types only see nested types if they are declared as public.
  • Fields of inner types and outer types belong to different objects. We must specify the object to which they belong when we want to access them. In Java, inner classes can access fields of outer class

public class MyClass

{

private class NestedClass

{

}

}

slide22
Inheritance is a form of software reusability in which classes are created by reusing data and behaviours of an existing class with new capabilities.
  • Inheritance combines with object composition to create the primary techniques for reusing software
  • A class inheritance hierarchy begins with a base class that defines a set of common attributes and operations that it shares with derived classes.
  • A derived class inheritsthe resources of the base class and overrides or enhancestheir functionality with new capabilities.
  • The classes are separate, but related
slide23
public: access is not restricted
  • private: access is limited to the containing type
  • protected: access is limited to the containing class or types derived from the containing class
  • internal: access is limited to the current assembly
  • protected internal: access is limited to the current assembly or types derived from the containing class
slide24
Abstract class is normally used as a base class and never intended to instantiate any objects.
  • The use of polymorphism requires declaring virtual or abstract methods and properties in the abstract base class and overriding them in the derived classes.
  • Any class with an abstract method in it must be declared abstract.
  • Abstract methods donot have an implementation in the abstract base class and every concrete derived class must override all base-class abstract methods and properties using keyword override.
  • Virtual methods have an implementation in the abstract base class and its derived classes have an option of overriding the method
slide25
Abstract class:

public abstract class AbstractClass

{

public AbstractClass()

{

}

public abstractintAbstractMethod();

public virtualintVirtualMethod()

{

return 0;

}

}

slide26
Derived class:

public class DerivedClass : AbstractClass

{

public DerivedClass()

{ }

public overrideintAbstractMethod()

{

return 0;

}

public overrideintVirtualMethod()

{

return base.VirtualMethod ();

}

}

slide27
The keyword sealed is applied to classes and methods to prevent overriding and inheritance.
  • A method declared sealed cannot be overridden in a derived class
  • Static methods and private methods are implicitly sealed.
  • Recall that a method can be overridden if it is declared either virtual or abstract. The keyword sealed is not applied to these cases. However, we can use the keyword sealed for methods we have overridden and we do not want to override it in further derived classes.
  • A sealed class cannot be a base class since it cannot be inherited and hence it cannot have any derived classes.
  • All methods in a sealed class are sealed implicitly
slide28
sealed class SealedClass

{

public int x;

public int y;

}

class MyClass

{

SealedClass sc = new SealedClass();

sc.x = 10;

sc.y = 20;

}

class InClass : SealedClass // error: cannot inherit

{ }

slide29
All source code for a type is normally in a single file
  • Sometimes a type becomes large enough that this is an impractical constraint.
  • Partial types allow classes and interfaces to be broken into multiple pieces stored in different source files for easier development and maintenance.
  • Additionally, partial types allow separation of machine-generated and user-written parts of types so that it is easier to augment code generated by a tool
slide30

public partial class Student { private intstudentID; public Student () { . . . }

}

public class Student

{ private int studentID; private int name;

public Student () { ... }

public ChangeName() { ... }

public ChangeID () {

}

}

public partial class Student { private int name; public ChangeName() { . . . }

public ChangeID () {

. . .

}

}

slide31
An interface definition begins with a keyword interface and contains a set of public methods and properties that have no default implementation to inherit.
  • An interface must be declared as public.

public interface IStudent

{

intStudentID {get; set;}

void AddSubject(string subjectName);

}

  • Interfaces can be implemented by classes.
  • An interface defines a contract. This means that a class that implements an interface must provide implementations for every method and property specified in the interface definition.
slide32

public class Student : IStudent

{

private int studentID = 0;

private ArrayList subjects = null;

public Student() {}

public int StudentID {

get { return studentID; }

set { studentID = value; }

}

public void AddSubject(string subjectName) {

subjects.Add(subjectName);

}

}

slide33

public class List

{

private object[] elements;

private int count;

public void Add(object element) {

if (count == elements.Length) Resize(count * 2);

elements[count++] = element;

}

public object this[int index] {

get { return elements[index]; }

set { elements[index] = value; }

}

public int Count {

get { return count; }

}

}

public class List<T>

{

private T[] elements;

private int count;

public void Add(T element) {

if (count == elements.Length) Resize(count * 2);

elements[count++] = element;

}

public T this[int index] {

get { return elements[index]; }

set { elements[index] = value; }

}

public int Count {

get { return count; }

}

}

List<int> intList = new List<int>();

intList.Add(1); // No boxing

intList.Add(2); // No boxing

intList.Add("Three"); // Compile-time error

inti = intList[0]; // No cast required

List intList = new List();

intList.Add(1);

intList.Add(2);

intList.Add("Three");

int i = (int)intList[0];

List intList = new List();

intList.Add(1); // Argument is boxed

intList.Add(2); // Argument is boxed

intList.Add("Three"); // Should be an error

inti = (int)intList[0]; // Cast required

slide34

Why generics?

    • Type checking, no boxing, no downcasts
    • Increased sharing (typed collections)
  • How are C# generics implemented?
    • Instantiated at run-time, not compile-time
    • Checked at declaration, not instantiation
    • Work for both reference and value types
    • Exact run-time type information
slide35

List<T>

Dictionary<K,V>

SortedDictionary<K,V>

Stack<T>

Queue<T>

IList<T>

IDictionary<K,V>

ICollection<T>

IEnumerable<T>

IEnumerator<T>

IComparable<T>

IComparer<T>

  • Collection classes
  • Collection interfaces
  • Collection base classes
  • Utility classes
  • Reflection

Collection<T>

KeyedCollection<T>

ReadOnlyCollection<T>

Nullable<T>

EventHandler<T>

Comparer<T>

slide36

public class Generic<T>

{

T item;

public T Item

{

get {

return item;

}

set {

item = value;

}

}

}

public class NonGeneric

{

object item;

public object Item

{

get {

return item;

}

set {

item = value;

}

}

}

public class MyClass()

{

NonGeneric ng = new NonGeneric ();

Generic<int> g = new Generic<int>();

}

slide37

static void AddMultiple<T>(List<T> list, params T[] values)

{foreach (T value in values)

list.Add(value);

}

void MyMethod()

{

List<int> list = new List<int>();

AddMultiple<int>(list, 2, 4, 6);

}

slide38

Methods that incrementally compute and return a sequence of values

class Program

{

static IEnumerable<int> Range(int start, int count) {

for (inti = 0; i < count; i++) yield return start + i;

}

static IEnumerable<int> Squares(IEnumerable<int> source) {

foreach (int x in source) yield return x * x;

}

static void Main() {

foreach (inti in Squares(Range(0, 10))) Console.WriteLine(i);

}

}

0

1

4

9

16

25

36

49

64

81