C# Programming

Course Description

COP2360C – C# Programming is a 3-credit-hour foundational course in computer science covering programming using the C# programming language. The course covers C# syntax and semantics; object-oriented programming foundations; common .NET APIs; the Visual Studio development workflow; and the systematic application of C# to typical programming problems. The course serves as either a first programming course (at institutions where C# is the introductory language, common at institutions with Microsoft ecosystem orientation) or as a second programming course following a different first language.

The "C" lab indicator denotes integrated lecture and laboratory components, with the laboratory typically providing structured programming practice. Coursework typically combines lecture and demonstration with extensive hands-on C# programming. Students complete numerous programming exercises and several larger programming projects through the term.

C# (pronounced "C-sharp") is Microsoft's flagship programming language and one of the most widely used languages in industry. C# has substantial use in enterprise application development, Windows desktop development, web development with ASP.NET, game development with Unity (the dominant game engine for indie and mobile games), and increasingly cross-platform development with .NET (the cross-platform runtime that succeeded the Windows-only .NET Framework). C# shares many similarities with Java (both have C-style syntax, strong type systems, garbage-collected runtimes, and OOP foundations); students familiar with Java typically find C# accessible and vice versa.

COP2360C is a Florida common course offered at approximately 16 Florida institutions. It is required or recommended in computer science, software engineering, information technology, and game development programs at institutions with substantial Microsoft ecosystem orientation. Florida-specific C# industry includes Microsoft itself (Microsoft Tampa offices, Microsoft Government Solutions), game development studios using Unity, healthcare technology companies, financial services software, and government contractors. COP2360C transfers as the equivalent course at all Florida public postsecondary institutions per SCNS articulation policy.

Learning Outcomes

Required Outcomes

Upon successful completion of this course, students will be able to:

• Apply C# syntax and program structure, including the namespace and class structure of C# programs; the Main method as program entry point; using directives; the C# compilation and execution model.
• Apply C# value types and reference types, including value types (int, long, float, double, decimal, char, bool, struct types); reference types (string, class types, array types); the distinction between value and reference semantics; the engineering implications.
• Apply C# operators and expressions, including arithmetic, comparison, logical, and bitwise operators; null-conditional operators (?., ??, ??=); operator precedence; the engineering applications.
• Apply C# control flow, including if/else statements; switch statements (including modern switch expressions in C# 8+ with pattern matching); while, do-while, for, and foreach loops; break and continue statements.
• Apply C# methods, including method definition; parameters and arguments (with value, ref, out, and in parameter modifiers); return values; method overloading; static vs. instance methods; the engineering value of methods.
• Apply object-oriented programming foundations, including the concepts of class and object; instance fields and methods; constructors; the this reference; encapsulation with private fields and public properties (a C#-distinctive feature); the engineering value of OOP.
• Apply C# properties, including the property syntax (a C# feature combining field-like access syntax with method-like behavior); auto-implemented properties; computed properties; the engineering value as encapsulated state access.
• Apply C# arrays, including array declaration and initialization; array access and modification; multi-dimensional arrays (rectangular and jagged); common array patterns; the engineering applications.
• Apply C# strings, including the string class as immutable; common string methods; string interpolation (with $ prefix); the StringBuilder class for mutable string building; the engineering applications in text processing.
• Apply introductory inheritance, including the colon syntax for inheritance; base classes and derived classes; method overriding with virtual and override keywords; the base keyword; the Object class as universal superclass.
• Apply introductory polymorphism, including polymorphism through inheritance and method overriding; the appropriate use of polymorphism.
• Apply basic .NET collections, including List<T> for dynamic lists; Dictionary<TKey, TValue> for key-value associations; basic IEnumerable use with foreach; the engineering applications.
• Apply C# exception handling, including the try/catch/finally construct; common exception types (NullReferenceException, IndexOutOfRangeException, FormatException, IOException, FileNotFoundException); custom exceptions at introductory level; the using statement for automatic resource management; the engineering applications.
• Apply C# file input and output, including reading from text files (with StreamReader or File.ReadAllText/File.ReadAllLines); writing to text files (with StreamWriter or File.WriteAllText/File.WriteAllLines); proper resource management with using statements; the engineering applications.
• Apply Visual Studio development environment use, including project creation; solution organization; basic Visual Studio features (IntelliSense, debugger, refactoring tools); basic NuGet package awareness.
• Apply systematic debugging, including the Visual Studio debugger; reading C# exception details; the engineering value of disciplined debugging.
• Apply basic .NET software development practices, including code organization in namespaces and assemblies; consistent code style (C# conventions for naming and formatting); basic XML documentation comments; basic testing.

Optional Outcomes

• Apply introductory abstract classes and interfaces, including the abstract keyword; the interface keyword; the engineering applications.
• Apply introductory generics, including parameterized types; generic methods at introductory level.
• Apply introductory delegates and events, including delegate types; basic event handling; the engineering applications.
• Apply introductory LINQ (Language Integrated Query), including basic LINQ to Objects queries; the engineering applications in data processing.
• Apply introductory GUI programming, including basic Windows Forms or WPF applications at conceptual level (where institutional emphasis includes desktop GUI).
• Apply principles to specific application areas reflecting program emphasis (basic Unity game development, basic web programming with ASP.NET, basic mobile development with .NET MAUI).

Major Topics

Required Topics

• C# in the Software Industry: C#'s role in modern software development; the .NET platform and its evolution (.NET Framework legacy, modern .NET 6/7/8 cross-platform); the C# ecosystem (libraries, frameworks, tools); industry use cases (enterprise applications, Windows desktop, web development with ASP.NET, game development with Unity, mobile with .NET MAUI).
• C# Program Structure: Namespaces; the class structure; the Main method; using directives; the relationship between source files and types; the C# compilation model (.cs files compiled to assemblies; the CLR — Common Language Runtime).
• C# Value and Reference Types: The value type / reference type distinction; built-in value types (int, long, float, double, decimal, char, bool); user-defined value types (struct); reference types (string, class types, array types); the engineering implications (value semantics vs. reference semantics).
• C# Variables and Constants: Variable declaration; the const keyword for compile-time constants; the readonly keyword for runtime constants; variable scope; naming conventions (camelCase for variables, PascalCase for properties and methods).
• C# Operators: Arithmetic operators; comparison operators; logical operators (&&, ||, !); bitwise operators; null-conditional operators (?. for safe member access; ?? for null coalescing; ??= for null coalescing assignment); the engineering applications.
• C# Input and Output — Console: Output with Console.WriteLine(), Console.Write(); input with Console.ReadLine(); string interpolation with $ prefix; the engineering applications.
• C# Conditional Statements: if statements; if-else statements; chained if-else if-else; nested conditionals; switch statements (traditional with break, modern switch expressions with pattern matching); the engineering use.
• C# Loop Statements: while loops; do-while loops; for loops; foreach loops (for IEnumerable types); break and continue statements; nested loops.
• C# Methods: Method definition; method signature; parameters (value parameters, ref parameters for pass-by-reference, out parameters for output, in parameters for read-only references); return values; method overloading; static vs. instance methods.
• Object-Oriented Programming — Classes and Objects: The class as a blueprint; the object as an instance; the new keyword for object creation; the relationship between classes and objects.
• Object-Oriented Programming — Fields and Methods: Instance fields; instance methods; the this reference for accessing instance members; the engineering applications.
• Object-Oriented Programming — Constructors: Constructor methods; default constructors; constructor overloading; the this() call to other constructors; the engineering applications.
• C# Properties: The property syntax (a distinctive C# feature); auto-implemented properties; computed properties (with get and optionally set accessors); read-only properties; init-only setters (modern C# 9+); the engineering value as encapsulated state access; the contrast with Java's getter/setter pattern.
• Encapsulation: Access modifiers (public, private, protected, internal, protected internal, private protected); the principle of encapsulation; the engineering value.
• C# Arrays: Array declaration; array creation with new; array initialization; array access; the Length property; multi-dimensional arrays (rectangular with [,] and jagged with [][]); the Array class methods; the engineering applications.
• C# Strings: The string class as immutable; common string methods (Length, Substring, IndexOf, Contains, StartsWith, EndsWith, ToLower, ToUpper, Trim, Split, Replace, ToCharArray); string concatenation; string interpolation with $ prefix and {expression}; the StringBuilder class for mutable string building; the engineering applications.
• String Formatting: string interpolation; the older string.Format() method; format specifiers; the engineering applications.
• Inheritance — Foundations: The colon syntax for inheritance; base and derived classes; the inheritance of fields and methods; the Object class (System.Object) as universal superclass; sealed classes that prevent inheritance.
• Method Overriding: Overriding inherited methods with virtual and override keywords; the base keyword for calling base class methods; the new keyword for hiding (vs. overriding); the rules of method overriding.
• Polymorphism — Foundations: Polymorphism through inheritance; the use of base class references for derived class objects; the is operator for runtime type checking; the as operator for safe casting; pattern matching (modern C#); the engineering applications.
• .NET Collections — Basic: The System.Collections.Generic namespace; List<T> for dynamic lists; Dictionary<TKey, TValue> for key-value associations; HashSet<T> for unique element collections; basic IEnumerable<T> use; the engineering applications.
• C# Exception Handling: The try/catch/finally construct; the exception hierarchy (System.Exception); common exception types and their causes; the throw statement; throwing custom exceptions at introductory level; the using statement for automatic resource management; the engineering applications.
• C# File I/O: The System.IO namespace; reading from text files with StreamReader or File class methods; writing to text files with StreamWriter or File class methods; proper resource management with using; the engineering applications.
• Visual Studio Development: Visual Studio Community edition (free for individual use, students, and small teams); project creation; solution organization; IntelliSense (Microsoft's intelligent code completion); the Visual Studio debugger; basic refactoring tools; NuGet package management at conceptual level.
• Debugging in C#: Reading exception details; using the Visual Studio debugger (breakpoints, step over, step into, watch windows, immediate window); the engineering value of disciplined debugging.
• .NET Software Development Practices: Code organization in namespaces; the C# coding conventions (PascalCase for types, methods, properties; camelCase for parameters and local variables); XML documentation comments (/// summary); basic testing approaches with MSTest, NUnit, or xUnit at conceptual level.

Optional Topics

• Abstract Classes and Interfaces: The abstract keyword; the interface keyword; abstract methods; default interface methods (modern C# 8+); the engineering applications.
• Generics: Parameterized types; generic methods; constraints on generic types (where clauses); the engineering value.
• Delegates and Events: Delegate types as type-safe function references; multicast delegates; the event keyword; basic event handling patterns; the engineering applications.
• LINQ — Introduction: Language Integrated Query; LINQ to Objects with method syntax (Where, Select, OrderBy); query syntax (from, where, select); the engineering applications in data processing.
• GUI Programming: Windows Forms (the legacy desktop framework, still widely used); WPF (Windows Presentation Foundation); the engineering applications in desktop development.
• Specific Application Areas: Unity game development (basic Unity scripting in C#); ASP.NET web programming concepts; .NET MAUI for cross-platform mobile/desktop applications.

Resources & Tools

• Common Texts: Starting Out with Visual C# (Gaddis — widely adopted); C# in Depth (Skeet — advanced reference); Pro C# (current version) (Troelsen — comprehensive coverage); C# 12 in a Nutshell (Albahari — reference); Murach's C# (Boehm — textbook style)
• Online Resources: Microsoft Learn (free, official .NET and C# learning paths); the official C# documentation at learn.microsoft.com; Pluralsight C# courses (subscription); Coursera C# specializations
• Software: Visual Studio Community Edition (free for individual use, students, and small teams); .NET (free, cross-platform); Visual Studio Code with C# extension (free, lightweight cross-platform alternative); the .NET CLI (dotnet command) for command-line workflows
• Reference Resources: Stack Overflow (for specific C# questions); the official C# language reference at learn.microsoft.com; .NET API documentation; institutional tutoring centers

Career Pathways

COP2360C is foundational for C#/.NET career pathways:

• Enterprise C# Software Development — C# is dominant in Microsoft-ecosystem enterprise software; substantial demand for C# developers across industries.
• Web Development with ASP.NET — ASP.NET (especially modern ASP.NET Core) is widely used for enterprise web development.
• Game Development with Unity — Unity is the dominant game engine for indie, mobile, and increasingly AAA games; Unity scripts are written in C#; substantial Florida game development industry uses Unity.
• Windows Desktop Development — C# remains the primary language for native Windows desktop applications.
• Cross-Platform Development with .NET MAUI — modern cross-platform mobile and desktop development with C#.
• Cloud Development with Azure — Microsoft Azure cloud development frequently uses C#; substantial enterprise demand.
• Healthcare Technology — C# is common in healthcare software at Microsoft-ecosystem healthcare technology companies.
• Government and Defense Software — C# is widely used in government software systems; relevant to Florida government contractors and defense employers.
• Florida Tech Industry — Florida's technology sector includes substantial Microsoft-ecosystem employers and game development studios.

Special Information

The C# Position in Software Industry

C# is one of the most widely used languages in industry, with particular dominance in: enterprise software development at Microsoft-ecosystem companies; Windows desktop applications; game development with Unity; ASP.NET web development. The cross-platform .NET (which succeeded the Windows-only .NET Framework) has substantially broadened C#'s applicability beyond Windows.

The C# / Java Comparison

C# and Java are remarkably similar in many ways: C-style syntax with curly braces; static typing with class-based OOP; garbage-collected runtime; extensive standard libraries; mature ecosystems. C# has some distinctive features (properties as first-class language feature, value types/structs, async/await for asynchronous programming, LINQ for query operations, more aggressive language evolution); Java has some distinctive features (write-once-run-anywhere portability historically, JVM as language platform supporting many languages). Students proficient in one typically find the other accessible.

The Modern C# Language Evolution

C# has evolved substantially with regular major language updates. Modern C# (C# 11, C# 12, C# 13) includes substantial language features beyond traditional C# (records as concise data classes, pattern matching with match expressions, top-level statements that eliminate boilerplate Main, file-scoped namespaces, raw string literals, primary constructors, etc.). Course content typically tracks current C# versions.

Game Development Connection

Unity is the dominant game engine for indie game development, mobile game development, and increasingly mid-sized commercial game development. Unity uses C# as its scripting language, making C# foundational for game development careers. Florida hosts game development studios and educational programs in game development; COP2360C is foundational for game development pathways.

General Education and Transfer

COP2360C is a Florida common course number that transfers as the equivalent course at all Florida public postsecondary institutions per SCNS articulation policy.

Course Format

COP2360C is offered in face-to-face, hybrid, and online formats. Visual Studio's strong remote development support makes online delivery work well; many institutions offer online sections.

Position in the Computer Science Curriculum

COP2360C is typically taken in the second semester of CS study (after COP1000C if C# is the second language) or as the first programming course (at institutions where C# is the introductory language). The course supports subsequent specialized C#/.NET coursework and game development coursework.

Difficulty and Time Commitment

COP2360C is challenging for students new to C# or programming generally. The course requires substantial out-of-class time (typically 6-9 hours per week beyond class time) and disciplined practice. C#'s relatively rich language features can be a learning challenge for new programmers but provide substantial expressive power once mastered.

Prerequisites

COP2360C typically requires either COP1000C (Introduction to Computer Programming) with grade of C or better at institutions where C# is the second language, or college-level reading/writing placement and MAT1033 (Intermediate Algebra) at institutions where C# is the introductory language. Students should consult their specific institution.

AI Integration (Optional)

AI tools (large language models like Claude and ChatGPT; code-focused AI tools like GitHub Copilot, Cursor) are widely used in C# development contexts. The foundational considerations for AI use in introductory programming (extensively addressed in the COP1000C guide) apply to COP2360C; this section focuses on C#-specific considerations.

C#-Specific AI Tool Considerations

• GitHub Copilot's relationship to C# is particularly tight — GitHub Copilot is owned by Microsoft (the creators of C#); Copilot integration with Visual Studio is particularly strong; Copilot's training data includes substantial C# code
• C#'s strong type system helps AI tools — like Java, C#'s static typing catches many AI mistakes at compile time; AI-generated C# code typically encounters compile errors when wrong rather than running but producing wrong output
• Modern C# language features may confuse AI tools — C# evolves rapidly; AI tools sometimes generate C# code using older patterns when modern features would be better (e.g., generating manual properties when records would be more concise; using older async patterns)
• Microsoft's substantial C# ecosystem helps AI accuracy — the .NET API is well-documented and stable; AI tools generally produce reasonable .NET API usage

Where AI Tools Help in C# Programming

• Boilerplate generation — generating properties (with the modern shorthand), constructors, override methods (where Visual Studio refactoring tools also help)
• LINQ query generation — AI tools can generate LINQ queries from natural-language descriptions (with verification)
• Concept explanation — alternative explanations of OOP, properties, async/await, LINQ
• API discovery — finding the right .NET API for a task (with verification)

Where AI Tools Mislead

• Generated complete homework — AI can write entire homework assignments; the academic integrity considerations from COP1000C apply
• Outdated patterns — AI tools sometimes generate C# patterns that are dated; students should verify against current language guidance
• Mixing .NET Framework and modern .NET — AI tools sometimes mix legacy .NET Framework patterns with modern .NET patterns; students should verify compatibility

Academic Integrity

The use of AI tools to generate C# code submitted as student work without permission is academic dishonesty under most institutional policies. The OOP thinking and C# programming skill developed in COP2360C are foundational for subsequent C#/.NET coursework and game development — students who use AI to bypass developing these skills typically struggle in subsequent courses. Students should consult their institution's specific AI use policies.