Introduction to C# Programming

Introduction to C# Programming


Spring 2011
01/18/2011 - 05/15/2011

Course Information

Section 001
TTh 7:05PM - 7:55PM
RGC1 111
Paul Russell

Section 001
TTh 8:05PM - 8:55PM
RGC1 109
Paul Russell

Office Hours

  • M W
    12:15 pm - 1:15 pm
    NRG 4239
    before COSC 1315 section
  • M W
    4:30 pm - 5:30 pm
    NRG 4239
    before GAME 2302 course
  • M W
    8:45 am - 9:45 am
    NRG 4239
    before COSC 1320 section
  • T Th
    6:00 pm - 7:00 pm
    RGC 113
    Before ITSE 1330 course

Course Requirements


Grading System:

                                       percent of course grade

Exams (3)                       75 (25 percent per exam)

Programs                         25 (may have varying weights)

course score range    course grade

       90 - 100                     A

       80 - 89.9                    B

       70 - 79.9                    C

       60 - 69.9                    D

       0 - 59.9                      F

 Programming Assignments:                    

100 points for each program

Program 1(data types, operators - chapters 2, 3)

Exercise 3.28, page 123

Program 2(control structures - chapters 5, 6)

A palindrome is a sequence of characters that reads the same backwards as forwards. Write an application that reads a positive, five-digit integer, entered at the keyboard, and determines if it is a palindrome. If the integer is not five digits long or is negative or what is entered is not an integer, display an error message.  Repeat evaluating integers until the user enters zero.

Program 3(methods - chapter 7)

Exercise 7.34, page 329.  Use a loop in Main that asks the user if he/she wants to play the guessing game.  There should be a value for the user to enter to play and a different value for the user to stop.  Inside the loop, another function is called that does the processing described in 7.33 and 7.34.

Program 4(arrays - chapter 8, LINQ - chapter 9)

Code and test two two-dimensional arrays of doubles, each with five rows. The first should be a jagged array with the number of columns equal to the row index plus one. The second should be a symmetric, 2D array with five columns. The elements in the symmetric array should be set to the same or symmetric jagged array elements.  The element that is symmetric to an element with row j and column k has row k and column j.

Program 5(classes and objects - chapter 10)

Code and test a class called Rational, for performing arithmetic operations on fractions with integer numerators and denominators.  Code this as a Windows Forms program with the rational numbers entered by the user.  I will supply a Windows Form skeleton program.

Program 6(inheritance, interfaces, polymorphism - chapters 11, 12 )

Exercise 12.10, page 589.  Code this as a Windows Forms program.  Again, I will provide a Windows Form skeleton program.

Program 7(operator overloading - chapter 12 )

Code and test the addition of operator overloading for operator +, operator -, operator *, and operator / to your solution for program 5.

Program 8(exception handling - chapter 13)

Code and test the addition of exception handling to program 7.  Throw an exception if either denominator is negative or zero.  Also, throw an exception for an attempt to divide by zero.

Program 9(Windows Forms - chapters 14, 15)

Code and test a Windows Forms program that plays the rock, paper, scissors game with the user.

Program 10(multithreaded programming - handouts)

Code and test a program that creates three child Thread objects, with a different integer value passed to each Thread object.  The Run function for the child thread class should display a start message, including the thread object name, and then execute a loop ten times.  The code in the loop should have the thread sleep for 100 milliseconds times the integer value and then display a message about the value of the integer.

Program 11(String class, StringBuilder class, regular expressions - chapter 18)

Exercise 18.11, page 911.

Program 12(files and streams - chapter 18)

Exercise 19.4, page 962.  Define a class with lastName, firstName, IDNbr, class, and grade as its data members.

Program 13(generics - chapter 27)

Exercise 27.11, page 1380. 

Program 14(generic collections - chapter 28)

Code and test the modeling of a multidimensional array by a List<T> object of List<T> objects.  Use double as the value of the generic parameter T.


Programs are to be completed and submitted by midnight of the due date for each program. A 25% penalty may be applied to late programs. Notification will be given when the late penalty goes into effect.

Except for GUI-based programs, a program should include the source code, test results, and, if appropriate, test data. For all programs, the source code should have a multi-line comment at the beginning of Main that includes the name of the student, the course number (ITSE 1330), the program number, and a description of what the program is intended to do. Every function that is coded, except Main, should have a one or two line comment at its beginning, describing the purpose of that function.

GUI-based programs do not need test results and test data, but should include source code and an executable file.  Also, they should be demonstrated to the instructor, if requested.

Any cunning code written by a student should have an accompanying, explanatory comment.

Programs may be coded and tested at ACC facilities or using a computer owned by the student or, with appropriate permission, at a student's place of work. For non-ACC computers, Microsoft Visual Studio .NET 2008 or .NET 2010 should be available.

Programs must be submitted via BlackBoard, using the DigitalDropbox.




Visual C# 2008 How to Program, Third Edition, by P, J. Deitel and H. M. Deitel, Pearson/Prentice Hall, 2009, ISBN-13: 978-0-13605322-4, ISBN-10: 0-13-605322-X

Reference Books and Other Material (not required):

C# 4.0 The Complete Reference, by Herbert Schildt, McGraw-Hill Osborne, 2010, ISBN-10: 007174116X, ISBN-13: 978-0071741163

Course Subjects


week   assignment       topic(s)                                                            

  1         ch 1                overview of course, .NET Framework, CLR             

             ch 2, 3            data types, operators, examples                                 

  2         ch 4                introduction to classes, value and reference types                                          

             ch 5, 6            control structures                                                        

  3         ch 5, 6            control structures (continued)                                    

             ch 7                methods                                                                      

  4         ch 7                methods (continued), recursion                                  

            ch 8                 arrays                                                                                                                                                                                                         

  5         ch 8, 9            arrays (continued), introduction to LINQ                 

            ----                   review for exam 1 (ch 1 - 9)                                       

  6         -----                 exam 1                                                                       

            ch 10               classes and objects                                                     

  7         ch 10              classes and objects (continued)                                                                                  

             ch 11              inheritance                                                                  

  8         ch 12              interfaces, polymorphism                                             

            ch 12               polymorphism (continued), operator overloading                                          

                                    (Spring Break - March 14 - 20)              

  9         handout          operator overloading (continued)                             

             ch 13              exception handling                                                    

10         ch 13              exception handling (continued)                                

             ch 14, 15        Windows Forms, event handling                               

11         ch 14, 15        Windows Forms (continued) , exam 2 due               

             handout          multithreaded programming                                      

12         handout         multithreaded programming (continued)                   

            ch 18               String and StringBuilder classes                               

13        ch 18               regular expressions                                                     

            ch 19               file and streams                                                           

14        ch 19               file and streams (continued)                                     

            ch 27               generics                                                                    

15        ch 27               generics (continued)                                                  

            ch 28               generic collections                                                    

16        ch 16               Introduction to Windows Presentation Foundation (WPF)                                                                         

            handout          unsafe code, exam 3 due                                         

Student Learning Outcomes/Learning Objectives


Instruction Methodology:

The lectures will consist of discussions of the topics to be covered, examples illustrating those topics, and how the code in the examples works to achieve the desired results.

Each of the assigned programs is intended to require practice implementing one or two of the topics to be covered.

Course Rationale:

This course is intended to introduce and present the C# programming language. This will include GUI-based programming using Windows Forms and WPF.

Course Objectives/Learning Outcomes:

Develop correct, well-documented programs using the C# programming language; learn to develop object-oriented programs using C# classes and objects; learn to use Windows Forms and WPF to create GUI-based programs.