Scribd
Upload
64 views

C# Basics: Muhammad Kamran Rafi

This document provides an overview of C# basics including variable declarations, data types, arrays, loops, decision statements, classes, inheritance, constructors, overriding methods, and operator overloading. It discusses the different variable types in C# like int, float, bool. It also covers how to declare and initialize arrays, use for, while and do-while loops, if/else statements, and switch cases. The document describes class definitions, abstract classes that cannot be instantiated, inheritance between classes, and how to call parent constructors. It explains how methods can be overridden in subclasses by marking them with the override keyword.

Uploaded by

tarnoscribd
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
64 views

C# Basics: Muhammad Kamran Rafi

This document provides an overview of C# basics including variable declarations, data types, arrays, loops, decision statements, classes, inheritance, constructors, overriding methods, and operator overloading. It discusses the different variable types in C# like int, float, bool. It also covers how to declare and initialize arrays, use for, while and do-while loops, if/else statements, and switch cases. The document describes class definitions, abstract classes that cannot be instantiated, inheritance between classes, and how to call parent constructors. It explains how methods can be overridden in subclasses by marking them with the override keyword.

Uploaded by

tarnoscribd
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 15

C# Basics

Muhammad Kamran Rafi [email protected]

Variables Declarations

byte - 0 to 255 char - 2 bytes bool sbyte - -128 to 127 short - 2 byte int ushort - 0 to 65,535 int - 4 bytes uint - 4 bytes positive

float double decimal long ulong string

Using Variables

C# is Strongly Typed
float x = 10.9f; double y = 15.3; y = x; x = (float) y; // okay // conversion required

Variables must have Value before being used.


Hence

declarations usually include initialization

Simple Arrays
int[] myArray1 = new int[5];
int[] myArray2 = {1, 2, 3, 4, 5};

for (int i=0;i<10; i++) Console.Write (myarray[i]); Console.WriteLine();

Looping Statements

Same as C++
while (count > 0)

process_list (count--);
do

process_list( ++count ); while (count < 10);


for (int i=1; i<=10; i++)

Different from C++


while

(count)//

illegal C# unless count is bool

Decision Statements
Almost Just Like C++
if (count >= 10) { dostuff(); domorestuff(); } else ... switch (choice) { case 'Y': //must be empty case 'y': do_yes_stuff(); break; default: ...

Simple Console Output


System.Console.WriteLine System.Console.Write
System.Consolue.WriteLine ("count = {0} and sum = {1}", count, sum);

Simple Console Input


string inputline; char charvalue; int intvalue; Console.Write ("Enter a string: "); inputline = Console.ReadLine(); Console.WriteLine("You just entered \"{0}\"",inputline); Console.Write ("Enter a character: "); charvalue = (char) Console.Read(); Console.WriteLine("You just entered \"{0}\"", charvalue); Console.ReadLine(); Console.Write ("Enter an integer: "); inputline = Console.ReadLine(); intvalue = Convert.ToInt32(inputline); Console.WriteLine("You just entered \"{0}\"", intvalue);

Class/Interface Definitions Like Java

class modifiers: abstract, static, sealed visibility: public, protected, internal, private interface name starts with I like IComparable, ISerializable const vs. readonly attributes

const, predefined type, compile time evaluation, static readonly, value assigned only once (decl or construct)

Static Classes

They only contain static members. They cannot be instantiated. They are sealed. They cannot contain instance Constructors

Abstract Classes

An abstract class cannot be instantiated. An abstract class may contain abstract methods . It is not possible to modify an abstract class with the sealed modifier, which means that the class cannot be inherited. A non-abstract class derived from an abstract class must include actual implementations of all inherited abstract methods.

Inheritance (C++ syntax)


public class Person : IComparable { }
public class Employee : Person, ISerializable { }

Constructor
public Person (string name, int ssn) { } public Employee(string name, int ssn, int phone) : base(name, ssn) { } public Employee(string name) : this (name, 999, 999) { }

Overriding Methods

Must mark all overridable methods in the superclass with virtual


public virtual int foo()

Must mark all overriding methods in the subclass with override


public override int foo()

Use base.MethodName() to call the superclass method

Overloading operators

Like C++, we can overload and redefine operators like == and +.

public static bool operator== (MyClass lhs, MyClass rhs) { } public static MyClass operator+(MyClass lhs, MyClass rhs)

You might also like