The course objective is to give the students a stable basis of knowledge and skills for working as a software engineer for the Microsoft .NET platform. The course covers the fundamental set of knowledge and skills that any .NET developer should have: C# language, object-oriented programming, standard .NET Framework APIs, database development with MS SQL Server and ADO.NET, Windows Forms GUI applications, ASP.NET Web applications and Web services. The course is based on .NET Framework 2.0, MS Visual Studio 2005 and MS SQL Server 2005.
- Course scope, curriculum, exams, homework, lectures, exercises
- Common Language Runtime (CLR)
- Intermediate language (MSIL)
- Assemblies and .NET Framework execution model
- Creating, compiling and running .NET applications
- C# language design principles
- C# programs structure
- Identifiers; Keywords
- Primitive data types; Enumerations; Typecasting and conversion
- Variables; Declarations
- Operators
- Expressions; Statements
- Control structures, conditionals, loops (if, switch, for, while, do … while)
- Console input/output
- Object-oriented programming and design fundamentals
- Classes, objects and interfaces
- Inheritance, abstraction, encapsulation and polymorphism
- Creating and using objects
- Defining classes and class members (fields, properties, constants)
- Partial classes
- Defining and using methods; Method overloading
- Defining and using properties
- Constructors
- Static members and static constructor
- Structures
- Inheritance and polymorphism
- Abstract classes
- Namespaces
- Defining, implementing and using interfaces
- Defining and using indexers
- Overloading operators
- Built-in types hierarchy
- The base type System.Object; Overriding equality and hash code methods
- Object cloning and ICloneable
- Implementing IComparable
- Iterators: IEnumerable and IEnumerator
- Value types and reference types; Representation in the memory
- Boxing and unboxing value types
- Passing arguments by value, reference and as output (in, out and ref parameters)
- Nullable types
- Error handling and exceptions
- Catching and throwing exceptions
- Defining and using custom exception classes
- What is high-quality programming code?
- High-quality software design (cohesion, coupling, complexity, reusability, fan-in, fan-out, etc.)
- High-quality methods (cohesion, coupling, naming, parameters, length, etc.)
- Defensive programming and exceptions
- Best practices using variables (naming, scope, span, lifetime, etc.)
- Naming variables, methods, classes and other identifiers
- Best practices using conditionals and loops
- Self-documenting code and effective comments
- Using attributes, attribute parameters, attribute targets
- Defining custom attributes
- Generic methods and generic classes
- Creating, initializing and using arrays
- Jagged and multidimensional arrays
- Standard algorithms on arrays: sorting, binary search, printing
- The Unicode standard
- Characters, strings and string processing: creating, concatenating, extracting substrings, searching, comparing, and splitting
- Building and modifying strings with StringBuilder
- String, numbers and date formatting
- Parsing numbers and dates
- Encodings and conversions
- Resources and satellite assemblies
- Defining and using delegates and events
- Anonymous delegates
- Generic EventHandler delegate
- Numeral systems
- Computer representation of numbers
- Algorithms complexity
- Asymptotic notation
- Analyzing and computing complexity
- Lists and representation
- Queues and representation
- Stacks and representation
- Trees, binary trees and balanced search trees
- Hash-tables and representation
- Graphs – basic concepts and representation
- Depth First Search (DFS) algorithm
- Breath First Search (BFS) algorithm
- Collections Interfaces: IEnumerable<T>, ICollection<T>, IList<T>, IDictionary<K, T>
- Collection Classes – List<T>, Dictionary<K, T>, Queue<T>, Stack<T>
- The regular expressions language – literals and meta-characters, character classes, quantifiers, grouping characters, etc.
- Regular expressions API in .NET Framework
- Searching, extracting, validating, splitting and replacing text by regular expressions
- Memory management, managed heap and garbage collection
- Resource management, IDisposable and finalizers
- Binary streams and text streams
- File streams
- Files and directories
- Test – 35 questions (25 required to pass)
- Practical exam – 3 practical problems (70% required to pass)
- Homework check – 25 homework submitted required to pass (at least one for each topic)
- Trainer checks 2 randomly selected homework in class
- Students not passed the exam sit for a second attempt a week later
- Students that fail on the exam at the second try can leave the course permanently
- Basic database concepts: database systems, relational databases
- Tables, relationships, multiplicity, primary keys, foreign keys, E/R diagrams, normalization
- Database constraints, indexes, views, triggers, stored procedures
- Database transactions
- Introduction to Microsoft SQL Server 2005
- Using SQL Server Management Studio
- Database modeling and entity/relationship diagrams
- SQL Server data types
- Creating E/R models with SQL Server Management Studio
- Data manipulation language (DML): SELECT, INSERT, UPDATE and DELETE statements
- Joining tables, inner and outer join
- Nested queries
- Aggregate functions and grouping
- Data definition language (DDL): CREATE, ALTER, DROP statements
- Introduction to T-SQL
- Stored procedures, functions and triggers
- Transactions management
- ADO.NET architecture: data providers, connected and disconnected data models
- Using the connected data model: connections, commands, data readers
- Using SQL Server data provider
- Transaction management (Transaction, TransactionScope)
- Using the OLDDB data provider
- Best practices using ADO.NET
- Introduction to ADO.NET disconnected model
- Data sets, data tables and data adapters
- Using typed data sets and Visual Studio dataset designer
- Basic XML concepts
- Well-formed XML, namespaces
- XML schemas: DTD and XSD
- XML parsers: DOM, SAX and StAX
- XML Processing in .NET Framework
- Using the DOM parser (XmlDocument): parsing, processing, modifying and creating XML documents
- Using the high performance streaming parser: XmlReader and XmlWriter
- Querying XML documents with XPath
- Performing XSL transformations
- Windows Forms programming model
- Windows Forms basic classes: Component, Control, ScrollableControl, ContainerControl
- Windows Forms events model, event queue and controls rendering model
- Basic controls: Form, Label, TextBox, Button
- Handling events
- Creating and using dialog boxes
- Advanced controls (panels, pictures, list boxes, combo boxes, menus, status bars,
toolbars, file dialog, etc.)
- Data validation
- Data binding, navigation and binding sources
- Data bound controls (DataGridView, ListBox, ComboBox, etc.)
- Forms inheritance
- Graphics primitives and System.Drawing
- Custom controls
- Drag and drop
- Multithreading overview – processes and threads
- Using the Thread class – creating, starting and stopping threads; Threads lifecycle
- Threads synchronization – race conditions, critical sections, monitors
- Using the built-in thread pool (the ThreadPool class)
- Asynchronous execution in Windows Forms
- Asynchronous execution with BeginInvoke() / EndInvoke()
- Loading assemblies and classes
- Exploring metadata – assemblies, classes and class members
- Dynamically instantiating classes and invoking methods
- Automatic and custom serialization; Formatters
- XML and binary serialization
- Test – 35 questions (25 required to pass)
- Practical exam – 3 practical problems (70% required to pass)
- Homework check – 25 homework submitted required to pass (at least one for each topic)
- Trainer checks 2 randomly selected homework in class
- Students not passed the exam sit for a second attempt a week later
- Students that fail on the exam at the second try can leave the course permanently
- Basic Internet concepts: OSI seven-layer model, TCP/IP protocol suite, protocols, services, IP address, network interface, DNS, TCP, UDP, sockets, etc.
- TCP and UDP sockets
- Accessing Internet resources through URL
- E-mail API
- The HTTP protocol; Request-response model;
- The World Wide Web (WWW) infrastructure; URI and URL
- Web-programming fundamentals, Web servers, Web browsers
- HTML basics: formatting tags, images, hyperlinks, lists, tables, forms
- Creating and using CSS files
- Using JavaScript language – first steps
- Manipulating the HTML DOM tree
- Cutting the site design into pieces
- Creating the HTML and CSS
- Introduction to ASP.NET
- Web forms; Web controls; Code-behind; Page execution model
- Internet Information Server (IIS 5.0, IIS 6.0)
- ASP.NET Web Forms
- Code behind pages
- ASP.NET syntax: directives, attributes, expressions, code blocks, server-side comments, server controls, binding expressions, etc.
- ASP.NET HTML server controls
- ASP.NET Web server controls
- Web controls execution lifecycle
- HTML escaping
- Data binding in ASP.NET
- DataBind(), Eval() and Bind() methods and DataBinder class
- Data sources: SqlDataSource and ObjectDataSource
- Data bound controls
- GridView and its fields (BoundField, TemplateField, etc.), sorting, paging, in place editing
- FormView, DetailsView, DataList, Repeater
- Validation controls: RequiredFieldValidator, CompareValidator, RegularExpressionValidator, ValidationSummary, etc.
- View state and postbacks
- Intrinsic variables: Application, Session, Request, Response, Server, Context, Cache
- Session and application state management
- Using cookies
- Creating ASCX user controls
- Using master pages and content pages
- Site navigation controls
- Localization of Web sites; Using resources and resource expressions
- Authentication and authorization
- Forms authentication and Windows authentication
- Membership and Role Manager Providers; Login controls
- AJAX technology overview
- ASP.NET AJAX architecture
- Installing and configuring ASP.NET AJAX
- ASP.NET AJAX server controls: UpdatePanel, ScriptManager, UpdateProgress, Timer
- AJAX Control Toolkit
- Web services basic concepts – request-response model, SOAP, WSDL, UDDI
- Creating Web services, exposing methods
- Consuming Web services; Asynchronously invocation
- Software engineering fundamentals
- Processes, methodologies and typical project development lifecycle
- Project plan
- Analysis and specification
- Architecture and design
- Implementation
- Testing: unit testing, integration testing, stress testing
- Deployment
- Software configuration management and source control repositories
- Versioning models: Lock-Modify-Unlock and Copy-Modify-Merge
- Using Team Foundation Server (TFS) as source control repository
- Unit testing fundamentals
- Introduction to NUnit
- Creating test cases and test fixtures
- Executing test cases and test fixtures
- NUnit GUI tools
- Build tools – creating and using NAnt build scripts
- NAnt build files
- NAnt build process
- Using properties, conditional tasks and multiple build files
- Logging fundamentals
- Logging levels; Loggers, appenders, filters and layouts
- Test – 35 questions (25 required to pass)
- Practical exam – 3 practical problems (70% required to pass)
- Homework check – 25 homework submitted required to pass (at least one for each topic)
- Trainer checks 2 randomly selected homework in class
- Students not passed the exam sit for a second attempt a week later
- Students that fail on the exam at the second try can leave the course permanently
Each practical project will cover these technologies (but not only):
- ASP.NET Web applications: Web forms, Web controls, data bound controls, master pages, custom controls, Forms authentication, AJAX
- Microsoft SQL Server database
- ADO.NET – typed data sets
- Windows Forms – desktop GUI front-end
The project covers the following elements of the software engineering:
- Analyzing the software requirements documentation and defining UI prototype
- Creating system architecture, designing the database and designing the modules of the system
- Implementing the modules of the system and integration
- Testing and debugging
- Using source control repository (Team Foundation Server)
Each project is done by a team of 3-5 students.
The final exam is an assignment for development of a small project with SQL Server, ADO.NET, ASP.NET and Windows Forms, and should be implemented in 6 hours in class. The exam consists of the following tasks:
- Defining database schema and entering sample data
- Design and implement ADO.NET based data access layer
- Design and implement ASP.NET Web application
- Design and implement Windows Forms GUI application
To successfully pass the exam 75% of the tasks should be solved.
Lectures: 101 hours
Exercises: 105 hours
Homework: 219 hours
Practical project (in class): 54 hours
Practical project (at home): 120 hours
Exams: 30 hours
Total: ~ 630 hours
On even weeks: 2 times / week: 18-22 h -> 16 h / month
On odd weeks: 3 times / week: 18-22 h -> 24 h / month
Two weekends / month: 9-18 h -> 32h
Total: 72 h / month -> ~ 5 months
Visit the official discussion forum of the course if you have any technical questions regarding the lectures, exercises or homeworks.
