learnvisualstudio.net VCS2010 C#

Core C# Course



Start here and quickly go beyond the fundamentals! This series provides the aspiring C# developer a comprehensive experience with the language and concepts associated with the .NET Framework.

By watching 22 hours of fun, personalized video lectures and the associated homework each day, you will have a firm grasp on the basics of both C# and creating SQL Server databases. The creative hands on exercises re-enforce the lessons learned each day.

Each day builds on the topics learned previously and will take someone with no programming knowledge at all to the point where they can build simple applications utilizing Object Oriented Programming principles with inheritance and polymorphism, understand a simple UML Class Diagram and implement that design in code, build normalized relational databases, and use T-SQL to query and update the data.


This series is organized into 10 days’ worth of material:
Jump To …
Day 1
Day 2
Day 3
Day 4
Day 5
Day 6
Day 7
Day 8
Day 9
Day 10



Day 1
VCS2010_01_01 – Visual C# 2010 Express Edition Installation on Windows 7
For the sake of completeness, we included this video to demonstrate how to download and install Visual C# 2010 Express Edition on to a fresh machine sporting Windows 7. If you already have the app installed, you can save 7 minutes of your life and move on to the next video.

VCS2010_01_02 – Building your First Application in C#
In this video Bob demonstrates how to build a simple application in C# (prints “Hello World” to a Windows console) as the basis for a larger discussion on creating new projects and using the Visual C# 2010 Express Edition IDE for basic tasks, running an application, and more.

VCS2010_01_03 – Dissecting the First Application you Wrote in C#
Building on the previous video, here Bob examines the specifics and importance of each part of the syntax that comprised the simple “Hello World” example. Topics include a first-look at the major parts of the .NET Framework, Framework Class Library classes, methods, and the dot syntax, literal strings, code blocks and the curly brace, namespaces, and basic C# lexical grammar and finally, the IDE’s color coded display.

VCS2010_01_04 – Visual Studio IDE Overview Day 1: General Overview
If you’re following along the Core Curriculum, each day Bob will show you something new about the Visual Studio IDE in Visual C# 2010 Express Edition. Today’s topics include: Intellisense, hovering over keywords, methods and other identifiers, status bar information, adding line numbers down the left-hand column using the Tools | Options dialog (Show all settings), changing code font size and background color, pinning and re-arranging windows, rolling up code using the + / – icons, and finally tracking changes with the left-hand green / yellow vertical stripe.

VCS2010_01_05 – Declaring Variables and Assigning Values
In this video Bob explores how to declare, initialize and use variables in your code, and begins a preliminary discussion on data types and how values are stored in your computer’s memory.

VCS2010_01_06 – Commenting Code
In this video, Bob explains why you would add code comments — essentially lines of code that are ignored by the compiler when an assembly is built — and demonstrates several different ways to add comments to your code, including single line, multi-line, and automating the process using the Comment / Uncomment IDE toolbar icons.

VCS2010_01_07 – Accepting Input in Command Line Applications
Building off the code example from earlier in the day, Bob demonstrates how to now use the Console.ReadLine() method to retrieve user input into a variable, and how to then display it back out to the Console window with some additional formatting of the string of characters that’s displayed.

VCS2010_01_08 – The if Decision Statement
To round out the first day, we now tie together concepts discussed during the course of the day to make programmatic decisions in code based on user input. The if statement is one way to create a decision structure in C# and probably the easiest to memorize and most widely used. After an initial pass at writing the code, Bob adds a short discussion on re-writing our code (refactoring) to make the code more readable and more concise.

VCS2010_01_09 – Variable Scope
In this brief video, Bob explains the scope of a variable you declare in one code block and how “visible” that variable is throughout your application.

VCS2010_01_Homework – Day 1 Homework
If you’re planning on following along with the suggested daily Core Curriculum, each day there will be an assignment that should help to solidify concepts discussed during the course of the day into a “real” project. This video explains the assignment and demonstrates example output or expected results. Today’s exercise requires you to build a simple application that allows a user to type in a series of values to save the world from catastrophic doom. No pressure!

VCS2010_01_Solution – Day 1 Homework Solution
Bob will never leave you hanging. If you get stuck during the homework assignment, you can watch the solution video which demonstrates and explains both the solution to the primary exercise as well as the “stretch goals” for bonus points. BUT DON’T CHEAT … to really learn a programming language — or any foreign language — you must immerse yourself into the language which requires you to “get your hands dirty” and practice writing code.

Top

Day 2
VCS2010_02_01 – Introduction to the .NET Framework
Day 2 kicks off with an exploration into a few of the major parts of the .NET Framework, including the purpose of the Runtime, the compiler and assemblies, the Framework Class Library (FCL), the Common Intermediate Language (CIL) and more. Then Bob turns his attention to addressing the different phases of software development, compilation and executing and the roles that the developer, the C# compiler and the .NET Framework Runtime play during “design time”, “compile time”, “run time” and during “debugging”.

VCS2010_02_02 – Operators, Expressions and Statements
In this video we dig deeper into the C# language talking about the grammatical structure of a line of code (expressions and statements) as well as the “verbs” (operators). Then Bob creates a list of about a dozen operators that you as the beginning developer must commit to memory. Finally, we talk about what happens when you do not follow the rules of proper C# grammar with regards to the IDE’s warnings and the compilers compilation errors.

VCS2010_02_03 – More About Data Types
Building on yesterday’s discussion of variables, in this video Bob discusses how variables are stored and accessed from your computer’s memory. He discusses the technique of converting numbers into binary values, how C# data types are just “shortcuts” to underlying .NET Framework’s Common Type System definitions for values, and provides a short list of the data types you will probably most frequently be using and thus must initially commit to memory.

VCS2010_02_04 – More Decision Statements – Switch Statement and Conditional Operator
In this video we add two more methods for implementing decision structures in our code, including the switch statement and the conditional operator with discussion about the nuances of each approach and when you should prefer one over the other.

VCS2010_02_05 – for Iterations
Continuing our look at basic C# syntax, we move on to the topic of iteration statements and start with the for statement which allows you to iterate over a code-block a pre-determined number of times, or until the break keyword is encountered. Bob expands the initial example to tie together a common use: adding an if statement in the body of the for’s code block to evaluate the conditions in the current iteration.

VCS2010_02_06 – while Iterations and Reading Data from a Text File
In this example, we examine a snippet of code that allows us to open an external text file and iterate through each line of the text file using the while statement. While we don’t want to get too deep into working with external content just yet, this does serve as the means for demonstrating the basic difference between the for and while iteration statements. Also starring in this video: the StreamReader, null, and the not-equal-to != operator.

VCS2010_02_07 – Arrays
Arrays are simple variables that store multiple values (or rather, elements of the array), each accessible through an index and the index accessor operator (square brackets [ ] ). This video demonstrates how to declare, initialize and access elements in an array, and demonstrates the use of a third iteration statement, the foreach statement, to loop through a code-block once for each element in the array, assigning the value of the element to a temporary variable.

VCS2010_02_08 – Visual Studio IDE Overview Day 2: Debugging Tools
The focus of today’s IDE exploration session is “debugging”, and so Bob tours features such as: setting and removing break points, hitting break points and stepping through code, viewing values in the Watch window and more.

VCS2010_02_Homework – Day 2 Homework
Day 2′s homework assignment requires you to open a text file filled with important spy information, read it’s contents, reverse the order of the contents and display on screen. An additional “stretch goal” requires you to then write the string back out to a new text file.

VCS2010_02_Solution – Day 2 Homework Solution
Stuck? This was a difficult assignment, and so Bob will help you get un-stuck by demonstrating one approach to solving today’s homework problems. This is especially helpful in solving the “stretch goal” involving both reading from and writing to an external text file.

Top

Day 3
VCS2010_03_01 – Introduction to Object Oriented Programming
Leaving the most basic discussions of the C# programming language, we move on to the important topic of object oriented programming which will dominate our understanding of the C# language from here on out. Bob explains the thought process behind object oriented programming, classes, instantiation, fields, properties, methods, “black box programming” (also known as “encapsulation”), and much more.

VCS2010_03_02 – Methods
This video begins to unravel some of the mystery surrounding methods … methods like those we’ve worked with since Day 1. Bob demonstrates how to create methods, defining return values or void methods, defining parameters and how to call methods using the dot notation and method invocation operators. Finally, Bob discusses some terminology that we’ll need to know a couple of days from now … “method headers” versus “method signatures”.

VCS2010_03_03 – Fields and Properties
Methods define what an instance of a class can “do”. Fields define the “state” or “attributes” of an instance of a class. First, Bob recalls the earlier discussion of fields and points out the problems in exposing fields “publicly”. This leads to a discussion of encapsulation and using hidden (private) fields to store the values and implement publicly visible properties as the “gate keepers” to prevent the code that is working with an instance of the class (the client) from setting the fields to an impractical or improper value.

VCS2010_03_04 – Understanding Instantiation with the new Operator
In this video we turn our focus solely to the process of creating a new instance of a class, often referred to as “instantiation”. Bob explains the difference between a class and an object, or rather, one instance of a class … explaining how a variable is just a reference to an object stored in the computer’s heap. Bob reinforces this notion by quizzing you on a few code snippets that “play” with this idea of references and objects, and challenges you to think about the method invocation operator ( ) when creating a new instance of an object (he answers it on Day 4 .. see “Constructors”).

VCS2010_03_05 – Accessibility Modifiers
In this anticlimactic video, Bob now officially discusses “private” and “public” … even though he has inadvertently discussed the topic a couple of times previously. However, to add a bit of value, he discusses naming conventions for private and public class members (camel case for private members, pascal case for public members) and discusses the use of private methods, also known as “helper methods”.

VCS2010_03_06 – Object Associations: Aggregation and Containment
The secret lives of objects … they have relationships with each other! This video explains two typical types of relationships – aggregation and containment and discusses the nuanced differences between the two. This may not mean much at the moment (other than seeing a demonstration of declaring a field / property in one class using the type defined by a second class) but later will become the basis of “patterns” of class interaction (known as “design patterns”).

VCS2010_03_07 – Visual Studio IDE Overview Day 3: Code Snippets, Managing Tabs, Intermediate Window
Today’s Visual Studio IDE overview is a hodgepodge of ideas … first, Bob explains how to use code snippets to speed up your typing of commonly used structures like creating properties and popular decision and iteration structures. Second, he demonstrates the flexibility of the main area, showing how to manage tab groups in multiple panes, slitting a single code pane, and arranging tabs. Finally, he builds on your debugging skills by introducing the immediate window to display values using the ? operator, and shows how the immediate window allows you to modify variables in memory while the application is paused in debug mode.

VCS2010_03_08 – Introduction to UML and Class Diagrams
Now that we’ve started talking about object oriented programming, Bob thought it would be a great time to gently introduce a common notation for expressing class design and object interactions called the Unified Modeling Language, specifically, the Class Diagram artifact. Bob demonstrates how to explain your design decisions on a napkin or whiteboard to explain what members (fields, properties, methods) that should be added to a class, as well as how to represent a basic (aggregation) interaction between two classes.

VCS2010_03_Homework – Day 3 Homework
We’ve been filling your head will all manner of Object Oriented goodness. Now it’s time for you to take the reins and steer us towards an object oriented solution for a new global spy analysis application. You are given a UML Class Diagram and asked to pull an “all nighter” to write the code that implements the design decisions your team members have agreed on to implement this new spy app. Also, you’re asked to write a small Console window application to demonstrate that your code indeed works!

VCS2010_03_Solution – Day 3 Homework Solution
Did you figure out Day 3′s homework assignment? Awesome! No? Well, don’t worry … Bob shows you one approach to solving the assignment and explains how to interpret every part of the UML diagram into C# code.

Top

Day 4
VCS2010_04_01 – Introduction to Inheritance
Today we begin to see the power of object oriented programming. Inheritance is the second major “tenet” of OO, allowing a developer to create specialized versions of a class. In our example, we take our Automobile example and create a specialized “child” class called Truck, which has all the features of Automobile, but extends it to include truck-specific features as well. Bob explains how to create a derived class, or child class, or rather, how to inherit from a base class, and takes a first-look at why inheritance is so important.

VCS2010_04_02 – Overriding Methods on the Base Classes
In the previous video we looked at how to inherit a base class’ implementation of properties and methods in the derived class. But what if you need to modify a given method, for example? Suppose the way a Truck works internally is fundamentally different from other types of Automobiles? To accomplish this in C#, you would override a base class’ implementation of a method using the “virtual” keyword on the base class and the “override” keyword on the derived class. This video demonstrates these ideas and explains further why you might want to do this.

VCS2010_04_03 – Constructors
Picking up fro