Student Guide Revision 1.0

Size: px

Start display at page:

Download "Student Guide Revision 1.0"

Lambert Sutton
5 years ago
Views:

1 Robert J. Oberg Student Guide Revision 1.0 Object Innovations Course 411

2 C# Essentials Rev. 1.0 Student Guide Information in this document is subject to change without notice. Companies, names and data used in examples herein are fictitious unless otherwise noted. No part of this document may be reproduced or transmitted in any form or by any means, electronic or mechanical, for any purpose, without the express written permission of Object Innovations. Product and company names mentioned herein are the trademarks or registered trademarks of their respective owners. Copyright 2002 Object Innovations, Inc. All rights reserved. Object Innovations, Inc Emory Lane Charlotte, NC Printed in the United States of America. Rev. 1.0 Copyright 2002 Object Innovations, Inc. ii

3 Table of Contents (Overview) Chapter 1.NET: What You Need To Know Chapter 2 C# Overview for the Sophisticated Programmer Chapter 3 Object-Oriented Programming in C# Chapter 4 C# and the.net Framework Chapter 5 Introduction to Windows Forms Appendix A Appendix B Using Visual Studio.NET Learning Resources Rev. 1.0 Copyright 2002 Object Innovations, Inc. iii

5 Table of Contents (Detailed) Chapter 1.NET: What You Need to Know... 1 Getting Started... 3.NET: What Is Really Happening... 4.NET Programming in a Nutshell... 5.NET Program Example... 6 Viewing the Assembly... 7 Viewing Intermediate Language... 8 Understanding.NET... 9.NET Documentation Visual C#.NET and GUI Programs Summary Chapter 2 C# Overview for the Sophisticated Programmer Hello, World Compiling, Running (Command Line) Program Structure Namespaces Variables...21 Input in C# More About Classes InputWrapper Class Sample Program Input Wrapper Implementation Compiling Multiple Files Control Structures switch C# Operators Precedence Table Types in C# Simple Types Types in System Namespace Integer Data Types Floating Point Data Types Implicit Conversions Explicit Conversions Boolean Data Type struct Uninitialized Variables Enumeration Types Reference Types Class Types object Rev. 1.0 Copyright 2002 Object Innovations, Inc. v

6 string Classes and Structs CHotel Class Hotel Struct Test Program RaisePrice Methods Comparing Struct and Class Arrays One Dimensional Arrays System.Array Jagged Arrays Rectangular Arrays foreach for Arrays Boxing and Unboxing Output in C# Formatting Formatting Example Exceptions Exception Example Checked Integer Arithmetic Throwing New Exceptions finally System.Exception Lab Summary Chapter 3 Object-Oriented Programming in C# C# Object-Oriented Features Encapsulation and Accessors Using a Property Indexers Bank Example Account Class Namespace Constructors Static Members Static in Main Inheritance in C# New Version of Base Class Features of the New Base Class Derived Class Overriding a Virtual Function Fragile Base Class Problem Access Control and Assemblies Assembly Example Internal Accessibility Building Modules and Assemblies Rev. 1.0 Copyright 2002 Object Innovations, Inc. vi

7 Lab Summary Chapter 4 C# and the.net Framework Components and OO in C# Copy Semantics in C# Arrays Embedded Objects Copying a Class Instance class vs. struct Copying a Struct Instance Shallow Copy Shallow Copy Output Deep Copy and ICloneable Interfaces Generic Interfaces Implementing ICloneable Using an Interface is Operator as Operator NET and COM Arrays and Collections Lab 4A Sorting an Array Anatomy of Array.Sort Using the is Operator The Use of Dynamic Type Checking Implementing IComparable An Incomplete Solution Overriding ToString Understanding Frameworks Delegates Stock Market Simulation Running the Simulation Delegate Code Random Number Generation Using the Delegates Events Events in C# and.net Client Side Event Code Chat Room Example Lab 4B Summary Chapter 5 Introduction to Windows Forms Creating a Windows Forms App Windows Forms Event Handling Add Events for a Control Rev. 1.0 Copyright 2002 Object Innovations, Inc. vii

8 Events Documentation Lab Summary Appendix A Using Visual Studio.NET Visual Studio.NET Overview of VS.NET Toolbars Customizing a Toolbar Creating a Console Application Adding a C# File Using the Visual Studio Text Editor Build and Run the Bytes Project Project Configurations Creating a New Configuration Setting Build Settings for a Configuration Debugging Just-in-Time Debugging Standard Debugging -- Breakpoints Standard Debugging -- Watch Variables Debugger Options Stepping with the Debugger Demo: Stepping with the Debugger The Call Stack Summary Appendix B Learning Resources Rev. 1.0 Copyright 2002 Object Innovations, Inc. viii

10 Object-Oriented Programming in C# Objectives After completing this unit you will be able to: Give an overview of the object-oriented features of C#. Implement accessors and indexers to provide access to encapsulated data. Describe the use of constructors in C#. Use static data and methods. Use inheritance and virtual functions. Discuss the fragile base class problem and explain the uses of new and override in C#. Describe the access control facilities of C#. Work with assemblies in your C# programs. Rev. 1.0 Copyright 2002 Object Innovations, Inc. 74

11 C# Object-Oriented Features C# is a fully object-oriented language having many similarities to C++ and Java but also some important differences. C# fully supports encapsulation. In addition to methods for accessing encapsulated data, C# also provides accessors and indexers. Besides private and protected access control, C# also has internal access control, restricting access to an assembly. C# has a single inheritance model. In this regard C# is more akin to Smalltalk and Java than to C++. All classes (and effectively all data types) in C# inherit from a root class object. C# has the notion of interfaces. A class in C# may inherit from only one other class, but it may support many interfaces. We discuss interfaces in the next chapter. Rev. 1.0 Copyright 2002 Object Innovations, Inc. 75

12 Encapsulation and Accessors It is good programming practice to encapsulate data within the class and provide public methods to access the data. But it would be nice to be able to access the data as if it were public. You can do just that with the C# accessor feature. public class Course private string title; private int numstudents = 0; private string[] students; private int maxsize; public string Title get return title; set title = value; // value is keyword... Title is now a property, and has easy to use syntax in a client program. You can implement a read-only property by providing only the get accessor (and write-only via set byitself). Rev. 1.0 Copyright 2002 Object Innovations, Inc. 76

13 Using a Property You can obtain the value of a property using the standard dot notation. Course c1 = new Course("Intro to C#", 10); Console.WriteLine(c1.Title); // use the field You can also use the property on the right-hand side: C1.Title = ".NET Programming"; // set the field If you are familiar with Visual Basic, you will be very familiar with properties..net brings the convenience and ease-of-use of properties to all.net languages. Rev. 1.0 Copyright 2002 Object Innovations, Inc. 77

14 Indexers C# provides another easy to use feature that adds the capability to access an object as if it were an array. Through implementing an indexer on a class, you can use array notation on both left and right hand sides. public class Course private string title; private string[] students;... public string this[int i] get return students[i]; set students[i] = value; Course c1 = new Course("Intro to C#", 10); Console.WriteLine(c1[0]); // use indexer c1[0] = "John New Name"; // on LHS As with accessors, you can have read-only and writeonly indexers. Our example illustrates both accessors and indexers. See Course. Rev. 1.0 Copyright 2002 Object Innovations, Inc. 78

15 Bank Example We will illustrate many object-oriented features of C# with a simple bank example. See Bank\Step1 for the first step. The project consists of the following classes, each in its own file: SimpleMath provides operations Add and Subtract. Account maintains a private balance exposed through the public read-only property Balance. Methods Deposit and Withdraw are provided. There is a read/write property Owner and a static read/write property BankName. InputWrapper class makes input operations more concise. TestBank is an interactive console test program. Here is the output of a sample run of the program (run from inside Visual Studio): Welcome to Fiduciary Bank balance = 100 Enter command, quit to exit : deposit amount: 25 balance = 125 : quit Press any key to continue Rev. 1.0 Copyright 2002 Object Innovations, Inc. 79

16 Account Class Here is the code for the Account class: // Account.cs namespace OI.NetCs.Examples using OI.NetCs.Examples; public class Account private int balance; private string owner; static private string bankname = "Fiduciary Bank"; public Account(int balance) this.balance = balance; public Account(int balance, string owner) this.balance = balance; this.owner = owner; public void Deposit(int amount) balance = SimpleMath.Add( balance, amount); public void Withdraw(int amount) balance = SimpleMath.Subtract( balance, amount); Rev. 1.0 Copyright 2002 Object Innovations, Inc. 80

17 Account Class (Cont d) public int Balance get return balance; public string Owner get return owner; set owner = value; static public string BankName get return bankname; set bankname = value; Rev. 1.0 Copyright 2002 Object Innovations, Inc. 81

18 Namespace The namespace directive places the following elements inside the OI.NetCs.Examples namespace. namespace OI.NetCs.Examples... The using directive gives us concise access to the names in the namespace OI.NetCs.Examples. using OI.NetCs.Examples; SimpleMath is in this namespace, so we can use this code: balance = SimpleMath.Add(balance, amount);... in place of the following code using a fully qualified name: balance = OI.NetCs.Examples.SimpleMath.Add( balance, amount); Note our use of a hierarchy in our namespace: OI is a company/brand (Object Innovations) NetCs is an acronym for.net using C# Examples for the example programs Rev. 1.0 Copyright 2002 Object Innovations, Inc. 82

19 Constructors An important issue for classes is initialization. When an object is created, what initial values are assigned to the instance data? Through a constructor you can initialize an object in any way you wish. A constructor is like a special method which is automatically called when an object is created. A constructor has no return type A constructor has the same name as the class A constructor may take parameters, which are passed when invoking new. There may be several overloaded constructors. public Account(int balance) this.balance = balance; public Account(int balance, string owner) this.balance = balance; this.owner = owner; Note use of keyword this to refer to current object. C# does not have default arguments, so we need two constructors in this example. Rev. 1.0 Copyright 2002 Object Innovations, Inc. 83

20 Static Members In C# a static member applies to the entire class, not to a particular instance of a class. public class Account private int balance; private string owner; static private string bankname = "Fiduciary Bank";... All instances of the class share the same static field (for all accounts the bank name is the same). A static method or property can access static data members but cannot access non-static data members. static public string BankName get return bankname; set bankname = value; A client program does not have to instantiate an instance in order to access a static member. The class name is used rather than an object instance. Console.WriteLine("Welcome to 0", Account.BankName); Rev. 1.0 Copyright 2002 Object Innovations, Inc. 84

21 Static in Main The Main method of a class is static. The runtime must be able to invoke Main without instantiating an object instance. This implies that any helper methods you call from within Main should also be static. public static void Main()... private static void show(account acc) Console.WriteLine("owner = 0, balance = 1", acc.owner, acc.balance); private static void help() Console.WriteLine( "The following commands are available:"); Console.WriteLine( "\tdeposit -- make a deposit"); Console.WriteLine( "\twithdraw -- make a withdrawal"); Console.WriteLine( "\towner -- change owner name"); Console.WriteLine( "\tshow -- show account information"); Console.WriteLine( "\tquit -- exit the program"); Rev. 1.0 Copyright 2002 Object Innovations, Inc. 85

22 Inheritance in C# The next step of our bank example illustrates inheritance. See Bank\Step2 Here is the scenario. We wish to implement a special kind of an account, a checking account. A checking account has a fee based on the number of transactions The fee is waived if the minimum balance is at least a certain threshold value. Here is the design: Define a class CheckingAccount derived from the base class Account. Add to the base class some generic code that might apply to other kinds of accounts besides checking (a counter of number of transactions and a read-only property that will return this count). Add to the derived class specific code that applies only to checking accounts (track the minimum balance and compute fee) Rev. 1.0 Copyright 2002 Object Innovations, Inc. 86

23 New Version of Base Class public class Account... protected int numxact = 0; // number of // transactions virtual public void Deposit(int amount) numxact++; balance = SimpleMath.Add(balance, amount); virtual public void Withdraw(int amount) numxact++; balance = SimpleMath.Subtract( balance, amount); public int Transactions get return numxact; Rev. 1.0 Copyright 2002 Object Innovations, Inc. 87

24 Features of the New Base Class The class counts the number of transactions with a private field exposed by a read-only public method. This counter is declared protected so that the derived class can access it. The Deposit and Withdraw methods are declared virtual so that the derived class will be able to override them. Rev. 1.0 Copyright 2002 Object Innovations, Inc. 88

25 Derived Class public class CheckingAccount : Account private int minbalance; public CheckingAccount(int bal) : base(bal) minbalance = balance; public CheckingAccount(int bal, string owner) : base(bal, owner) minbalance = bal; public int Fee get if (minbalance < 100) return numxact; else return 0;... The constructors pass parameters to the base class using the keyword base. The Fee property has access to the numxact field in the base class, because numxact was declared protected. The Fee property is an illustration of a property which is calculated at runtime and not simply stored in a private field. Rev. 1.0 Copyright 2002 Object Innovations, Inc. 89

26 Overriding a Virtual Function The Withdraw method in the base class is overridden to update a minimum balance field, for the purpose of being able to calculate the fee. override public void Withdraw(int amount) base.withdraw(amount); if (balance < minbalance) minbalance = balance; The base keyword is used to call the base class, as was done in the constructors. Note use of the keyword override to tell the compiler that you are explicitly overriding an inherited virtual function. Without the override the compiler will issue a warning message, saying that you are hiding the original method with a new one. If you do want to hide the original method (and defeat any polymorphic behavior), you can use the new keyword. Rev. 1.0 Copyright 2002 Object Innovations, Inc. 90

27 Fragile Base Class Problem Inheritance is a powerful feature in object-oriented programming, but there is a subtle pitfall known as the fragile base class problem. Suppose you are responsible for a class D that is derived from a base class B and you have a method f in your class (which does not override any such method in the base class). Then a new version of class B is released which provides a new virtual function that happens to match the name and signature of your f but does something completely different. Then polymorphic code which uses a reference to an object of B and calls f will wind up calling your version of f rather than the f in the base class. This kind of difficulty can arise in a large framework. Here is a scenario. The base class is a Windows class with many methods. The derived class implements a custom control, which responds to its own methods directly and to methods from the Windows class through inheritance. Application code may be called by the framework, and code that uses your custom control may suddenly not work properly with the installation of a new version of the framework that has a new method matching one of yours. This problem was an argument for COM not supporting implementation inheritance. The issue is addressed in C# and.net with the override keyword. Rev. 1.0 Copyright 2002 Object Innovations, Inc. 91

28 Access Control and Assemblies Object-oriented languages such as C++, Java and C# have access control features, which can control access to a class, method or other entity through keywords such as public, private and protected. C# adds assembly-level access as an option. C# has a very rich set of access control modifiers: public protected internal internal protected private access not restricted access restricted to the containing type or derived types access restricted to files in the same assembly access restricted to the containing type or derived types or files in the same assembly access restricted to the containing type Rev. 1.0 Copyright 2002 Object Innovations, Inc. 92

29 Assembly Example We redo our bank example into three assemblies: Account.dll is an assembly consisting of two modules Bank.dll is an assembly built from two source files TestBank.exe is a test program Account.DLL Bank.DLL Account CheckingAccount SimpleMath Statement TestBank.EXE The code is illustrated in three steps: Bank\Step3A is a monolithic program Bank\Step3B has three assemblies as shown Rev. 1.0 Copyright 2002 Object Innovations, Inc. 93

30 Internal Accessibility Step3A illustrates internal accessibility. internal is the default accessibility for a class, and means accessible within the assembly. All Step3A is within one project and so within the same assembly, so internal classes and members are accessible. // Statement.cs using OI.NetDev.Examples; internal class Statement internal static string GetStatement( CheckingAccount acc) string s = "Statement for " + acc.owner + "\n" + acc.numxact + " transactions, balance = " + acc.balance + ", fee = " + acc.fee; return s; The field numxact has the accessibility changed to internal, so the Statement class can access the field in Account without going through the public Transactions property. public class Account... internal int numxact = 0; // number of // transactions Rev. 1.0 Copyright 2002 Object Innovations, Inc. 94

31 Building Modules and Assemblies Step3B illustrates building multiple assemblies. To have a finer degree of control of the build process, we use command-line build tools. First we build Account.dll: csc /t:module /out:simplemath.mod SimpleMath.cs csc /t:library /addmodule:simplemath.mod Account.cs Next we build Bank.dll: csc /t:library /r:account.dll /out:bank.dll CheckingAccount.cs Statement.cs Finally we build TestBank.exe: csc /t:exe /r:bank.dll /r:account.dll /out:testbank.exe TestBank.cs InputWrapper.cs Batch file build.bat automates the build. We return to public accessibility in Statement.cs. public class Statement public static string GetStatement( CheckingAccount acc) string s = "Statement for " + acc.owner + "\n" + acc.transactions + " transactions, balance = " + acc.balance + ", fee = " + acc.fee; return s; Rev. 1.0 Copyright 2002 Object Innovations, Inc. 95

32 Lab 3 A Bank Account Hierarchy In this lab you will practice working with inheritance in C# by adding a savings account class to a simple bank account hierarchy. You will also observe the use of virtual and override in C#. Account CheckingAccount SavingsAccount NOTE: This version of the bank example is a little different than the one used in the lecture. Detailed instructions are contained in the Lab 3 write-up at the end of the chapter. Suggested time: 30 minutes Rev. 1.0 Copyright 2002 Object Innovations, Inc. 96

33 Summary C# is a fully object-oriented language with a single inheritance model. You can implement accessors and indexers to provide access to encapsulated data. Constructors are used in C# for initialization. Static data and methods apply on a per class basis. C# provides inheritance and virtual functions. C# provides the new and override keywords, which can mitigate the fragile base class problem. C# has elaborate access control facilities, including controlling access on an assembly basis. You can inherit a class in C# from a class implemented in another.net language. Rev. 1.0 Copyright 2002 Object Innovations, Inc. 97

34 Lab 3 A Bank Account Hierarchy Introduction In this lab you will practice working with inheritance in C# by adding a savings account class to a simple bank account hierarchy. You will also observe the use of virtual and override in C#. Account CheckingAccount SavingsAccount NOTE: This version of the bank example is a little different than the one used in the lecture. Our example will consists of four classes, each in its own file. Account. This class encapsulates a single bank account consisting of an Id, an Owner, and a Balance. Operations are Deposit and Withdraw. There is also a field holding the number of transactions, and a GetStatement method is provided to show the current data for an account. The Account class counts the number of transactions. CheckingAccount. This derived class adds a monthly fee, which is assessed to checking accounts but not to other accounts. SavingsAccount. This derived class adds interest, which is paid to savings accounts but not to other accounts. TestAccount. This class provides a hardcoded test program, which instantiates some classes, performs some transactions, and obtains statements. Suggested Time: 30 minutes Rev. 1.0 Copyright 2002 Object Innovations, Inc. 98

35 Root Directory: OIC\CsEss Directories: Labs\Lab3\BankLab Chap03\BankLab\Step1 Chap03\BankLab\Step2 Chap03\BankLab\Step3 (Do your work here) (Backup of starter files) (Answer to first part) (Answer to second part) Files: Account.cs SavingsAccount.cs CheckingAccount.cs TestAccount.cs.cs Instructions 1. Build the starter program and study the code. There is only a CheckingAccount class at this point. 2. Add a SavingsAccount class, derived from Account, to implement the interest feature. Interest is 6% per year, paid on the minimum balance. You will need to hide the Withdraw method to update the minimum balance. You will also need to hide the GetStatement method to show the interest amount as well as the standard information for a statement. 3. Modify the test program to create a SavingsAccount object and perform a few transactions, and show the account before and after. Notice that at this point you have three overloaded ShowAccount helper methods, one for each kind of account. You are now at Step Modify the program to use virtual methods, and collapse the ShowAccount methods to a single method that applies polymorphically to all the different kinds of accounts. Rev. 1.0 Copyright 2002 Object Innovations, Inc. 99

Object-Oriented Programming in C# (VS 2015)

Object-Oriented Programming in C# (VS 2015) This thorough and comprehensive 5-day course is a practical introduction to programming in C#, utilizing the services provided by.net. This course emphasizes