C969 Software II - Advanced C# is banner number ITSW 3225 and six competency units in the School of Technology. The catalog describes it as refining C# expertise with lambda expressions, collections and input and output to build database and file-server applications. That combination sets the course apart from the first C# course: this one connects a program to things outside itself, which introduces every problem that comes with data you do not control and resources that can fail while you are using them.
Programs that reach outside themselves
A self-contained program is deterministic. Give it the same input and it does the same thing. The moment a program reads a file or queries a database, that guarantee is gone: the file may be missing, locked, half-written or encoded differently than expected, and the database may be unreachable, slow or holding data that violates the assumptions your code was written under. Handling that gracefully is the competency this course is built around.
Collections and lambda expressions are the language tools that make the data work readable. Filtering, projecting, grouping and ordering a collection with expressions rather than nested loops is not a style preference in a course that names them in its description, it is the demonstration the aspects are looking for. Deferred execution is the concept to actually understand rather than to memorize, because a query defined in one place and enumerated in another behaves in ways that surprise people who think of it as a list.
Input and output brings resource discipline. Anything opened has to be released, and releasing it in a normal code path is not enough because an exception can skip that line. The language has a construct that guarantees release, and using it consistently is the difference between a program that works and a program that leaves a file locked after its first failure.
Database work in a course like this rewards a small number of habits: parameterized queries rather than assembled strings, connections opened as late and closed as early as possible, and a clear boundary between the code that talks to the database and the code that holds the rules. Building a query by concatenating user input is both a correctness problem and a security one, and it is the defect most likely to be flagged on sight.
From scored aspects to a data plan and a word budget
Aspects are scored individually at WGU and each needs a 2. For a data-driven application the useful conversion is aspect to data operation or aspect to resource, and every row should point at a specific method, query or file interaction.
Budget it. Suppose thirteen scored aspects and a document of about 1,900 words. Thirteen into 1,900 is 146 each. Sort them. Seven are implementation aspects proved by the running application, so 75 words each of pointer text, which is 525 and releases about 500. Two ask for justification of the data access approach and the collection or query design, at 330 each, or 660. One asks about exception and resource handling, 320. One asks about the file or report output, 200. Two are setup and summary at 110 each, or 220. That totals 525 plus 660 plus 320 plus 200 plus 220, or 1,925, near target with the three argument sections holding just over half the prose.
Alongside it, write a resource inventory: every file and connection the program opens, where it opens, where it closes, and what happens if the open fails. Aspects about robustness in this course are answered almost entirely from that inventory.
Working the C969 application?
Send the aspects and your specification document. You get a data access plan, a resource inventory and a model design document.
The resource inventory that prevents the classic returns
| Resource | Opened where | Released how | Failure to plan for |
|---|---|---|---|
| Database connection | Inside the data access method, per operation | A construct that guarantees disposal | Server unreachable at startup |
| Query with user input | Data access layer only | Parameters, never string assembly | Input containing quotes or separators |
| Input file | At the point of reading, not at startup | Guaranteed disposal, even on exception | File missing, locked or empty |
| Output or report file | When the report is generated | Flushed and closed before the user is told it exists | No write permission in the target folder |
| Configuration values | Once at startup | Held in memory | Missing setting, reported clearly rather than as a null failure |
| Large result set | Enumerated once, deliberately | Materialized where it will be reused | A deferred query enumerated repeatedly by accident |
The last row is the lambda expression trap specifically. A query is a description until something enumerates it, and enumerating the same description in a loop runs it again every time.
Evidence, schema and citation for a data application
Data applications need evidence that the data moved. Show the state of the table or the file before and after each operation, paired with a screenshot of the interface that triggered it. That pairing is stronger than either image alone, because it demonstrates the whole path rather than the visible end of it.
Ship what an evaluator needs to run it. The schema, any seed data, the connection details in a configuration file rather than in code, and clear instructions. A data-driven application that cannot reach a database is an application nobody can score, and this is the most preventable return in the course. Never commit a real credential, even for a course database.
Document the queries. For each one, say what it retrieves and why it is shaped that way, particularly where you chose to filter in the database rather than in memory or the reverse. For citation, the platform and data provider documentation are the authorities for behavior and cite in APA as organizational web sources where your program requires it. Adapted example code is attributed in a comment, and anything you cannot explain line by line is a liability in a course where justification aspects are common.
What passes, and what comes back
Work is Competent or Not Competent at WGU, with no letter grades behind it, and performance assessment work can be revised and resubmitted freely when an aspect is missed. In a six month flat rate term the cost of that loop is days, and in a six unit course those days are expensive.
Applications that clear run from a clean build, connect using configuration rather than hardcoded values, release everything they open even when an operation fails, and use parameters for every query that touches user input. Their collection work uses the expressions the catalog names rather than nested loops. Their documentation names methods and queries.
Returns concentrate on four defects. Queries assembled from strings, which is both a correctness and a security failure. Resources opened in a path that can throw before the close line is reached. Hardcoded connection strings. And an aspect about collections answered with a loop, in a course whose catalog description names lambda expressions explicitly.
Five mistakes that cost C969 students days
- Building the query as a string. Parameters exist. String assembly is the defect most likely to be flagged the moment a reviewer opens the data layer.
- Closing resources on the happy path only. An exception skips your close line. Use the construct that guarantees release and stop thinking about it.
- Enumerating a deferred query repeatedly. Each enumeration is another round trip. Materialize once when you will use it more than once.
- Mixing data access into interface code. A query inside a button handler makes structural aspects unanswerable and makes the program impossible to test.
- Assuming the file exists. Missing, locked and empty are three separate cases, and a course about input and output will ask about them.
How we work on this course
C969 support is planning around the data. Send the scored aspects and the specification and you get a data access design with the boundary drawn, a resource inventory covering every open and close, a query list with the reasoning behind each shape, and a model document written the way WGU evaluators read technical work. Reviews explain the defect and its consequence so the fix is yours. Where a section is assessed by an objective assessment, we prepare only, and objective assessments are proctored: we never sit or assist during one and never ask for or touch portal credentials.
Six units in a six month flat rate term is a large share of what the term can hold. Getting the data layer right early is what keeps the rest of the plan on schedule.
Three questions C969 students ask
Is C969 the same as ITSW 3225?
How is C969 different from C968?
Do I need to set up a database server?
Where C969 sits in WGU's programs
The July 2026 catalog places this code in 1 current WGU program. Open a program page for the complete standard path and term positions. The live Degree Plan remains authoritative after transfer credit, substitutions, and mentor planning.
The assessments, one by one
The public catalog does not publish this course's PA/OA identity or task count. WGU Tutors publishes at most one PA manual per course and only from a WGU-controlled public rubric. Until that source exists, PA help begins from the student's real Course of Study and OA support remains preparation only.