1. Notes on C# and object oriented programming for CSE 3902 By: Matt Boggus Some material based on slides by Roger Crawfis

2. Outline Motivation for using OOP Motivation for using C# C# syntax and examples – Classes – Interfaces – Abstract classes – Class internals – Type conversion Demo of development environment

3. Why Object-Oriented Programming? Code Reuse – Objects made for one program are usable in another. – Inheritance - objects can reuse parts of other objects without modifying the original – Polymorphism - an operation may exhibit different behaviors in different instances (i.e. it can take on multiple forms) Encapsulation – All data and functionality for an object are included inside its implementation – For a well designed object, the client/user of an object does not need to know its implementation details. – The implementer of the object controls what functionality of the object is available to clients Design Benefits – Creation of objects encourages planning as objects must be implemented before being used – Generally speaking: more planning = less flaws Software Maintenance – Object implementation is not coupled to the application, thus making changes to either is easier Additional discussion can be found herehere

4. An alternative – entity component system A component encapsulates a specific set of functions or data Entities are objects that may have any number of attached components Example – Unity game engine – Almost everything is a GameObject – Components can be attached to GameObjects Ex: Collider, RigidBody, Scripts, etc. – Every component is updated by a corresponding system or manager class

5. Object-oriented vs. Component based OOP – Focus on readability – Objects are an abstraction to be used by client programmers, and should follow a mental model of the actual or imagined object it represents – Objects are “nouns” that have fields “adjectives” and methods “verbs” Components – Focus on reusability – Software should be constructed by gluing together prefabricated components like in electrical engineering – Functionality is attached to an object instead of inside its implementation

6. Why C#? Compared to other languages – Focus on object oriented programming –.NET framework Large library of features and objects Portability and integration with software written in other languages – More discussion herehere Other reasons – Game engines support C# -> XNA, Monogame, Unity – Useful in other CSE courses (3541 Game and Animation Techniques and 5912 Game Capstone) – Visual Studio is a single point of access for software development, source code control, project management, and code reviews and is Microsoft software -> use Microsoft developed language

7. C# language features 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 OO Features – Type Unification – Inheritance – Polymorphism

8. Some syntax to know about C# No pointers. Use the dot “.” to access both namespaces and fields/methods. – Automatic memory management – garbage collection All fields are initialized by the CLR (zero for value types, null for reference types) – Structs are value type, classes are reference type Switch statements – Does not “fall-thru” (unless empty) – Can take bool’s, enum’s, integer types, and strings Expressions must be useful (no a==b;) Conditionals must evaluate to a Boolean

9. CLASSES VS. STRUCTS

10. Classes vs. structs Both are user-defined types Both can implement multiple interfaces Both can contain – Data Fields, constants, events, arrays – Functions Methods, properties, indexers, operators, constructors – Type definitions Classes, structs, enums, interfaces, delegates

11. ClassStruct Reference typeValue type Can inherit from any non-sealed reference type No inheritance (inherits only from System.ValueType ) Can have a destructorNo destructor Can have user-defined parameterless constructor No user-defined parameterless constructor Classes vs. structs

12. public class Car : Vehicle { public enum Make { GM, Honda, BMW } private Make make; private string vid; private Point location; Car(Make make, string vid, Point loc) { this.make = make; this.vid = vid; this.location = loc; } public void Drive() { Console.WriteLine(“vroom”); } } Car c = new Car(Car.Make.BMW, “JF3559QT98”, new Point(3,7)); c.Drive(); Class definition syntax

13. INTERFACES

14. Interfaces An interface defines a contract – An interface is a type – Contain definitions for methods, properties, indexers, and/or events – Any class or struct implementing an interface must support all parts of the contract Interfaces provide no implementation – When a class or struct implements an interface it must provide the implementations

15. Interfaces Explicit interface – Requires/ensures clauses or pre/post-conditions – Functionality is explicitly defined Implicit interface – Only method signatures are specified – Ex: Bird interface defines void Fly() Duck class implements void Fly { position.y += 5; } Penguin class implements void Fly { // no-op }

16. public interface IDelete { void Delete(); } public class TextBox : IDelete { public void Delete() {... } } public class Car : IDelete { public void Delete() {... } } TextBox tb = new TextBox(); tb.Delete(); IDelete deletableObj = new Car(); deletableObj.Delete(); deletableObj = new TextBox(); deletableObj.Delete(); Interfaces example

17. Object and interface design Keep it simple! – The Magical Number Seven, Plus or Minus Two The Magical Number Seven, Plus or Minus Two The average person can hold 7 ± 2 objects in memory at a time Experts recall more by “chunking” – combining multiple objects into one – Think You're Multitasking? Think Again Think You're Multitasking? Think Again The average person is bad at multi-tasking, so focus on what you’re doing if you want it done well Only provide the minimum amount of functionality required You can always add functionality later, but beware functionality bloat

18. ABSTRACT CLASSES

19. Abstract class Similar to interfaces – Cannot be instantiated – In some cases, contain no executable code – Can contain method headers/signatures and properties (more on these in a bit), but unlike interfaces they can contain concrete elements like method bodies and fields Some quirks when working with abstract classes and interfaces – A concrete class may implement an unlimited number of interfaces, but may inherit from only one abstract (or any other kind of) class – A class that is derived from an abstract class may still implement interfaces For 3902, you can use abstract classes to avoid code duplication when functionality of methods will be the same for classes that implement them

20. abstract class Shape { protected int x = 50; protected int y = 50; public abstract int Area(); } class Square : Shape { public int width; public int height; public override int Area() { return width * height; } public void MoveLeft() { x--; } Abstract class example See http://msdn.microsoft.com/en- us/library/sf985hc5.aspx for a longer examplehttp://msdn.microsoft.com/en- us/library/sf985hc5.aspx Another good resource on this topic: http://www.codeproject.com/Article s/6118/All-about-abstract-classes

21. CLASS INTERNALS

22. The this keyword is a predefined variable available in non-static function members – Used to access data and function members unambiguously public class Person { private string name; public Person(string name) { this.name = name; } public void Introduce(Person p) { if (p != this) Console.WriteLine(“Hi, I’m “ + name); } this name is a parameter and a field.

23. base The base keyword can be used to access class members that are hidden by similarly named members of the current class public class Shape { private int x, y; public override string ToString() { return "x=" + x + ",y=" + y; } internal class Circle : Shape { private int r; public override string ToString() { return base.ToString() + ",r=" + r; }

24. public class MyClass { public const string version = “1.0.0”; public const string s1 = “abc” + “def”; public const int i3 = 1 + 2; public const double PI_I3 = i3 * Math.PI; public const double s = Math.Sin(Math.PI); //ERROR... } Constants A constant is a data member that is evaluated at compile-time and is implicitly static (per type) – e.g. Math.PI

25. Fields A field or member variable holds data for a class or struct Can hold: – A built-in value type – A class instance (a reference) – A struct instance (actual data) – An array of class or struct instances (an array is actually a reference) – An event

26. Properties A property is a member that provides a flexible mechanism to read, write, or compute the value of a private field. Properties can be used as if they are public data members, but they are actually special methods called accessors. This enables data to be accessed easily and still helps promote the safety and flexibility of methods. Properties encapsulate a getting and setting a field – Useful for changing the internal type for a field – Useful for adding code or breakpoints when getting/setting a field

27. Properties – examples type PropertyName { get; set; } Examples int Score { get; set; } double Time { get; private set; } string Name { get; } Code examples – person.cs (see course calendar for link) – abstractshape.cs (see course calendar for link) – http://www.dotnetperls.com/property http://www.dotnetperls.com/property

28. Methods (a.k.a. functions) All code executes in a method – Constructors, destructors and operators are special types of methods – Properties and indexers are implemented with get/set methods Methods have argument lists Methods contain statements Methods can return a value

29. Modifiers Public – Accessible anywhere Protected – Accessible within its class and by derived class instances Private – Accessible only within the body of the class – (Or anywhere if you use reflection)reflection Static – Belongs to the type Instance – Belongs to the instance

30. Static field example public class Variable { public static int i = 5; public void test() { i=i+5; Console.WriteLine(i); } public class Exercise { static void Main() { Variable var = new Variable(); var.test(); Variable var1 = new Variable(); var1.test(); Console.ReadKey(); } Output is: 10 15

31. CONVERSION

32. Can also specify user-defined explicit and implicit conversions internal class Note { private int value; // Convert to hertz – no loss of precision public static implicit operator double(Note x) { return...; } // Convert to nearest note public static explicit operator Note(double x) { return...; } Note n = (Note)442.578; double d = n; Conversion operators

33. The is Operator The is operator is used to dynamically test if the run-time type of an object is compatible with a given type private static void DoSomething(object o) { if (o is Car) ((Car)o).Drive(); }

34. The as Operator The as operator tries to convert a variable to a specified type; if no such conversion is possible the result is null More efficient than using is operator – Can test and convert in one operation private static void DoSomething(object o) { Car c = o as Car; if (c != null) c.Drive(); }

35. Java to C# resources Java for C# developers – fairly brief syntax and terminology differences Java for C# developers The C# Programming Language for Java Developers – documentation of language differences organized by programming constructs The C# Programming Language for Java Developers Additional Suggestions from StackOverflow

36. VS 2012 and XNA demo