Classes (Part 1) Lecture 3 M.T. Ipalakova

Object-Oriented Programming (OOP) Object-oriented programming helps you think about the problem you want to solve and gives you a way to represent, or model, that problem in your code The main principles of OOP are encapsulation, inheritance and polymorphism A class is the fundamental concept of OOP, which defines both representation and behavior in a single unit Classes are the primary mechanism you use to create user-defined types

Classes Classes in C# are reference types that implicitly derive from object To define a class, use the class keyword The body of the class enclosed in the opening and closing braces The body contains the definition of the data and behavior for the class The main class members are fields, properties and methods class Person { }

Accessibility Accessibility enables you to control the visibility, or accessibility, of an entity outside of its containing scope C# provides this through access modifiers Namespaces are not allowed to have any access modifiers and are always public Classes default to internal accessibility but are allowed to have either public or internal declared accessibility Class members default to private accessibility but can have any of the four kinds of declared accessibility

Access Modifiers public – access is not limited protected – access is limited to the containing class or classes derived from the containing class internal – access is limited to the containing assembly private – access is limited to the containing class only

Fields Fields are variables that represent data associated with a class Must be defined in the outermost scope of a class Can be either an instance field or a static field Any access modifier can be specified, but typically, fields are private, which is the default If a field is not given an initial value when it is declared, it is assigned the default value appropriate for its type

Fields class Person { string firstName; string lastName; int yearOfBirth; bool gender; }

Properties A property provides a simple way to access a private field, called the backing field, which can be publicly available while still allowing the internal details of that field to be hidden Can also be static Do not require storage in memory Declared with accessors that enable you to control whether a value can be read or written and what should occur when doing so Get accessor enables the property value to be read Set accessor enables the value to be written

Properties class Person { private string firstName; // field public string FirstName // property get return this.firstName; } set this.firstName = value;

Properties The name of a property must be the same as the name of backing field, but starting with the upper-case letter The value keyword always means “the value that was provided by the caller” and is always typed to be the same as the property type None of the accessors is obligatory, however, at least one must be present Read-only property has only get accessor Write-only property has only set accessor (not reccomendable)

Calculated Properties You can create calculated properties that are read-only and do not have a backing field They are excellent ways to provide data derived from other information class Contact { private string firstName; private string lastName; public string FullName get return this.firstName + “ “ + this.lastName; }

Automatic Properties The simplest way to declare a property When using this syntax, you omit the backing field declaration and must always include both the get and set accessor without a declared implementation, which the compiler provides class Person { public string FirstName get; set; } This code will be transformed by the compiler to the code on the next slide

Automatic Properties class Person { private string firstName; public string FirstName get return this.firstName; } set this.firstName = value;

Encapsulation Encapsulation, as one of the principles of OOP, enables a class to hide the internal implementation details and itself from unwanted changes that would result in an invalid or inconsistent internal state Encapsulation is also sometimes referred to as data hiding Encapsulation is realized with help of properties

Methods If fields and properties define and implement data, methods, which are also called functions, define and implement a behavior or action that can be performed A method declaration can specify any access modifier A method can include the static modifier Methods can accept zero or more parameters, declared by the formal parameter list, which consists of one or more comma-separated parameters Each parameter must include both its type and an identifier If a method accepts no parameters, an empty parameter list must be specified

Methods The method signature is made up of the method name and the formal parameters list When two or more methods have the same name in a declaration space but have different method signatures, they are overloaded public int CalcAge() { return 2012 – yearOfBirth; }

Constructors A constructor is a special method which creates an instance of a class A constructor has the same name of the class It cannot return a value, which is different from a method that returns void If the constructor has no parameters, it is the default constructor Constructors are usually public

Declaring a Constructor public class Person { public Person() // default constructor } public Person(string firstName, string lastName) this.firstName = firstName; this.lastName = lastName;

Nested Classes A nested class is one that is fully enclosed, or nested, inside another class declaration Nested classes are a convenient way to allow an outer class to create and use objects without making them accessible outside of that class Are easy to overuse, making your class more difficult to work with Nested classes implicitly have at least the same access level as the containing class

Partial Classes Enable you to split the declaration of a class into multiple parts, typically across multiple files Are implemented in exactly the same way as normal classes but contain the keyword partial just before the class keyword When working with partial classes, all the parts must be available during compilation and have the same accessibility to form the complete class

Static Classes You can apply the static modifier to a class as well, which defines a static class A static class can have only a static constructor, and as a result, it is not possible to create an instance of a static class Static classes most commonly contain utility or helper methods that do not require a class instance to work Static classes can contain only static members. You must explicitly include the static modifier Any static member can be public, private, or internal

Object Initializers Person p1 = new Person(); p1.FirstName = “Jim”; p1.LastName = “Morrison”; Console.WriteLine(p1.ToString()); Person p2 = new Person { FirstName = “Jim”, LastName = “Morrison”, }; Console.WriteLine(p2.ToString());