|1. Description - |
|Introduction to the C# programming language and the .NET platform. Topics include object oriented programming, graphical user interfaces, elementary data structures, algorithms, recursion, data abstraction, code style, documentation, debugging techniques and testing.|
|Advisory: One of the following: C S 1A, 1AH, 2A, 2AH or equivalent.|
|2. Course Objectives - |
|The student will be able to: |
- Describe the basic components of the C# software development environment.
- Describe the C# software development life cycle from concept design through documentation, testing and maintenance.
- Produce clearly written code in an industry standard style appropriate for C#.
- Define both primitive and compound data types and give examples in C# of each type.
- Write C# applications that define operators, use delegates, add event specifications, and implement predefined and custom attributes.
- Incorporate user-interaction input and output in a program through both the console and a graphical user interface.
- Define, analyze and code the basic C# conditional and iterative control structures and explain how they can be nested and how exceptions can be used.
- Design, implement, test, and debug functions and methods that can be used in programs, and demonstrate the way parameters are passed in such functions and methods.
- Write C# programs using object-oriented design, and contrast the difference between object-oriented and procedural code.
- Write C# applications using derived classes and demonstrate correct use of inheritance.
- Produce a program that interacts with the user using intermediate GUI elements such as buttons and text-boxes.
- Create analytical algorithms that use arrays for solving simple problems.
- Explain methods of error handling and exceptions.
- Explain what an algorithm is and give examples of how algorithms are implemented in a C# program.
- Design, implement, test, and debug a program that uses each of the following fundamental programming constructs: string processing, numeric computation, simple I/O, arrays and the .NET framework collections.
- Solve problems that have origins in a variety of disciplines including math, science, the Internet and business.
|3. Special Facilities and/or Equipment - |
- Access to a computer laboratory with C# compilers.
- Website or course management system with an assignment posting component (through which all lab assignments are to be submitted) and a forum component (where students can discuss course material and receive help from the instructor).
- When taught via Foothill Global Access on the Internet, a fully functional and maintained course management system through which the instructor and students can interact.
- When taught via Foothill Global Access on the Internet, students must have currently existing e-mail accounts and ongoing access to computers with internet capabilities.
|4. Course Content (Body of knowledge) - |
- Introduction to C#
- Structure of a C# program
- The C# run-time environment
- Compiled vs. interpreted languages
- Comparison of major languages
- Compiler errors vs. run-time errors
- The Software Development Environment
- The .NET Framework
- Properties Window
- Using the Help System
- Debugging and using the debugger
- Coding Standards, Conventions and Styles
- Acceptable indentation options
- Naming conventions for variables and methods
- Separation of computation and I/O
- C# Data Types
- Value types and Reference types
- C# compound types
- User-defined data types
- Boxing and Unboxing
- Operators and Events
- Numeric operators and expressions
- String operators and expressions
- Logical operators and expressions
- Overloading Operators
- Using and creating delegates
- Using and defining events
- Basic Input-Output Strategies
- Console I/O
- Simple GUI I/O
- Formatting values for clean output
- Control Structures
- Selective and conditional statements
- Loop statements
- Nesting levels in control statements
- Handling basic exceptions
- Methods and Functional Programming
- Parameter passing
- Functional returns
- Variable scope
- Method overloading
- Object-Oriented Programming - Classes and Methods
- Encapsulation of member data and methods
- Instance vs. static members and methods
- Data abstraction as realized through correct selection of member data and methods
- Data privacy as supported by access modifiers, mutator, accessor and constructor methods
- Object composition (the "has a" relationship)
- Properties and indexers
- Introduction to inner classes
- Class organization using namespaces
- Object-Oriented Programming – Inheritance
- bject hierarchy
- Derived classes (the “is a” relationship)
- Abstract classes and methods
- Sealed classes and methods
- Virtual methods
- Intermediate GUI Elements
- Understanding the Windows Forms control hierarchy
- Adding controls to forms
- Textbox controls
- Command buttons
- Checkboxes and Listboxes
- Other controls
- Anchoring and docking
- Passing arrays to methods
- Passing arrays by value and by reference
- Multiple subscripted arrays
- The foreach repetition structure
- Error Reporting
- Return values
- Avoiding end-use output to report errors in functions or methods
- The .NET exception hierarchy
- Try and catch blocks
- The finally block
- Exception properties
- Programmer designed exception classes
- Handling overflows with the checked and unchecked operators
- Role of algorithms in the problem-solving process
- Simple uses of recursion for divide-and-conquer strategies
- Simple sorting via a representative sort algorithm
- Linear searches
- Essential Examples and Assignment Areas
- String/text processing
- Numeric computation
- User interaction through both console and GUI
- Using the .NET framework collections
- Creating and using a programmer-defined class.
- Applications Used Throughout Course in Selected Areas
- Business and finance
|5. Repeatability - Moved to header area.|
|6. Methods of Evaluation - |
- Tests and quizzes
- Written laboratory assignments which include source code, sample runs and documentation.
- Final examination
|7. Representative Text(s) - |
|Heilsberg, et al. C# Programming Language. 4th Ed. Addison Wesley, 2010. |
Skeet, Jon. C# in Depth. 2nd Ed. Manning, 2010.
|8. Disciplines - |
|Computer Science |
|9. Method of Instruction - |
- Lectures which include motivation for syntax and use of the C# language and OOP concepts, example programs, and analysis of these programs.
- On-line labs (for all sections, including those meeting face-to-face/on campus) consisting of
- A programming assignment web-page located on a college-hosted course management system or other department-approved Internet environment. Here, the students will review the specification of each programming assignment and submit their completed lab work.
- A discussion web-page located on a college hosted course management system or other department-approved Internet environment. Here, students can request assistance from the instructor and interact publicly with other class members.
- Detailed review of programming assignments which includes model solutions and specific comments on the student submissions.
- In person or on-line discussion which engages students and instructor in an ongoing dialog pertaining to all aspects of designing, implementing and analyzing programs.
- When course is taught fully on-line:
- Instructor-authored lecture materials, handouts, syllabus, assignments, tests, and other relevant course material will be delivered through a college hosted course management system or other department-approved Internet environment.
- Additional instructional guidelines for this course are listed in the attached addendum of CS department on-line practices.
|10. Lab Content - |
- Familiarization with the beginning-level lab environment
- Modify and customize the settings of an Integrated Development Environment (IDE).
- Use the IDE to create a new programming project.
- Organize projects within an IDE to make submitting labs and switching project environments an orderly process.
- Gain experience with the steps needed to edit a simple program.
- Modify IDE settings to produce an industry standard code style.
- Finding and fixing errors in simple programs
- Demonstrate the complete edit-compile-run cycle of a simple program using IDE or command-line environment.
- Distinguish between compiler/syntax errors and logic errors.
- Develop strategies for dealing with each type of error.
- Debug code to produce a working program.
- Exploring the different data types using the compiler/IDE
- Gain experience in effectively using the IDE to create code with C# value types.
- Gain experience in effectively using the IDE to create code with C# reference types.
- Use the IDE to assist in defining and using compound data types.
- Solve syntax and logic problems that arise from typical incorrect formulation of data types.
- Demonstrating user interaction (I/O) through the IDE's console or GUI capabilities
- Play the role of user and programmer, alternately, to establish a user-interaction plan for a program.
- Evaluate and comment on other students' user-interaction plan.
- Change modes from source code design (editing mode) to end-user interaction (run mode) in the IDE in order to perform Q/A on the program.
- Fix poor interaction behavior by adjusting source code and rerunning program until a satisfactory result is achieved.
- Building a program that demonstrates “intelligence” though a combination of control statements
- Become familiar with selection, loop and nesting to imbue a program with correct logic behavior.
- Use structured programming to make control structures maintainable.
- Run the program multiple times to verify that its control statements produce the correct behavior or output under any scenario.
- Fix incorrect logic behavior by adjusting control structures and rerunning program until a satisfactory result is achieved.
- Incorporating functions and class methods in programming projects
- Gain experience in writing a function/method.
- Use a previously written function or method in a client program.
- Refine methods/functions by adding or changing their definitions and observe the result.
- Deduce the impact of a function's or method's design on the programs that invoke it.
- Building a program around object-oriented techniques
- Use previously written classes to instantiate objects in program.
- Use the IDE to assist in the creation of a programmer-defined class.
- Demonstrate the correct choice of class members and methods for each class used.
- Use the IDEs class view and object browser tools to navigate from one class to another within a program.
- Exploring Arrays
- Understand the proper use of Arrays.
- Incorporate an array into a program to facilitate the solution of an assigned problem.
- Investigate use of variable indices and loops to shorten and clarify the logic in programs.
- Use debugging techniques to solve problems that arise during the testing of a program.
- Devising and utilizing algorithms
- Write a program that uses a combination of techniques such as looping, arrays, logic and user I/O, all encapsulated in a coherent algorithm.
- Test the algorithm by running the program multiple times giving it different initial values or inputs.
- Implement a sorting or simple searching algorithm using arrays.
- Transcribe an abstract algorithm into a concrete program that is written and tested using the IDE and submitted online for evaluation.
|11. Honors Description - No longer used. Integrated into main description section.|
|12. Types and/or Examples of Required Reading, Writing and Outside of Class Assignments - |
- Textbook assigned reading averaging 30 pages per week.
- Reading the supplied handouts and modules averaging 10 pages per week.
- Reading on-line resources as directed by instructor though links pertinent to programming.
- Reading library and reference material directed by instructor through course handouts.
- Writing technical prose documentation that supports and describes the programs that are submitted for grades.
|13. Need/Justification - |
|This course is a restricted support course for the A.S. degree in Computer Science. |