Learning to Program Using Visual Basic 2010, Part 4 of 4
Interactive

Learning to Program Using Visual Basic 2010, Part 4 of 4

LearnNow Online
Updated Oct 26, 2018

Course description

In this course, you will learn to use Visual Studio 2010 to explore the Visual Basic language. The course starts with a quick overview of the .NET platform, examining assemblies, Microsoft Intermediate Language, Visual Studio profiles, XML comments, IntelliSense, and debugging. From there, you will learn all the language features that you must internalize in order to create full-featured Web or Windows applications that make best use of the .NET platform. You will learn about data types, variables, and operators, along with all the important flow control structures. You will work through several examples demonstrating the power of the .NET Framework, and dig into creating and consuming your own classes and objects. The course moves on to working with data structures, such as arrays and collection classes, before finishing up with discussions of generics, handling exceptions and working with delegates and events. The course concludes by introducing the new LINQ-oriented features including anonymous types, lambda expressions, and more. By the end of this course, you will understand the important basic concepts that will allow you to start creating the applications you need.

Each LearnNowOnline training course is made up of Modules (typically an hour in length). Within each module there are Topics (typically 15-30 minutes each) and Subtopics (typically 2-5 minutes each). There is a Post Exam for each Module that must be passed with a score of 70% or higher to successfully and fully complete the course.


Prerequisites

This course assumes that students have some programming background. No specific experience with Visual Studio 2010 or the .NET Framework is required. As with any such course, the more experience you bring to the course, the more you’ll get out of it. This course moves quickly through a broad range of programming topics, but it does not require any prior .NET skills.


Meet the experts

Ken Getz

Ken Getz is a featured instructor for several of our Visual Studio courses. He is a Visual Basic and Visual C# expert and has been recognized multiple times as a Microsoft MVP. Ken is a seasoned instructor, successful consultant, and the author or co-author of several best-selling books. He is a frequent speaker at technical conferences like Tech-Ed, VSLive, and DevConnections and he has written for several of the industry's most-respected publications including Visual Studio Magazine, CoDe Magazine, and MSDN Magazine.

Robert Green

Robert Green is a Visual Studio expert and a featured instructor for several of our Visual Basic and Visual C# courses. He is currently a Technical Evangelist in the Developer Platform and Evangelism (DPE) group at Microsoft. He has also worked for Microsoft on the Developer Tools marketing team and as Community Lead on the Visual Basic team. Robert has several years of consulting experience focused on developer training and is a frequent speaker at technology conferences including TechEd, VSLive, VSConnections, and Advisor Live.

Video Runtime

281 Minutes

Time to complete

361 Minutes

Course Outline

Module 10

Introducing Generics (18:08)

  • Introduction (00:33)
  • Overview: Generics (00:54)
  • Generic Methods (01:04)
  • Generic Classes (00:41)
  • Demo: Swapping Values (03:43)
  • Demo: Generic Methods (04:08)
  • Demo: Generic Classes (05:36)
  • Summary (01:26)

Generics and Arrays (29:11)

  • Introduction (00:48)
  • Overview (00:27)
  • Sorting Arrays (01:12)
  • Sort with IComparer (00:39)
  • Demo: Sorting Arrays (03:54)
  • Demo: Sort with IComparer (05:18)
  • Sorting with Generic Comp. (01:03)
  • Search w/ Generic Predicates (01:16)
  • Demo: Sorting w/GC (06:49)
  • Demo: Searching in Arrays (01:05)
  • Demo: Searching w/GP (06:07)
  • Summary (00:27)

Generic Interfaces/Constraints (18:10)

  • Introduction (00:39)
  • Overview: Generic Interfaces (00:54)
  • Generic Constraints (00:29)
  • Generic Sorting Arrays (04:46)
  • Generic Sort w/ ICompare (03:47)
  • Generic Comparison (01:42)
  • Generic Compare Method (05:05)
  • Summary (00:45)

Generic Lists (11:16)

  • Introduction (00:48)
  • Overview: Generic Lists (01:07)
  • Using an ArrayList (04:39)
  • Using a Generic List (01:15)
  • Sort with List Class (02:21)
  • Summary (01:03)
Module 11

Handling Exceptions (32:17)

  • Introduction (00:48)
  • Overview: Exception Handling (02:56)
  • Default Error Handling (00:19)
  • No Error Handling (01:02)
  • Error the User Sees (04:08)
  • Simple Try/Catch Block (04:07)
  • Unhandled Exceptions (01:28)
  • Using an Exception Object (01:29)
  • Error Bubbling (02:09)
  • Demo: Using Exception Object (03:08)
  • Demo: Display Cust. Msg. (00:48)
  • Catching Specific Exceptions (00:59)
  • Ordering Catch Blocks (01:21)
  • Trap Multiple Exceptions (00:21)
  • Code: Multiple Exceptions (01:58)
  • View Exception Handling Docs (04:06)
  • Summary (01:03)

Creating / Throwing Exceptions (17:22)

  • Introduction (00:36)
  • Exception Handling Options (00:44)
  • Using the Throw Keyword (00:45)
  • Throwing Exceptions (00:31)
  • Demo: Throwing Exceptions (01:31)
  • InnerException Property (02:10)
  • Running Code Unconditionally (01:16)
  • Finally Block and/or Catch (00:46)
  • Finally Block (03:07)
  • Using Statement (01:11)
  • Creating an Exception Class (00:39)
  • User Defined Exception Handler (02:53)
  • Summary (01:07)
Module 12

Generic List (33:08)

  • Introduction (00:45)
  • Considering Data Structures (02:38)
  • Generic Collection Interfaces (01:03)
  • IEnumerable (00:41)
  • ICollection (00:52)
  • IList (00:41)
  • IDictionary (00:57)
  • Why Think About Interfaces? (01:06)
  • Interfaces Syntax (02:09)
  • Generic List Class (00:52)
  • List Behavior (03:05)
  • List Class Methods (02:46)
  • Demo: Generic List Class (08:28)
  • Return the List (02:12)
  • Demo: Return a List (04:17)
  • Summary (00:30)

List Sorting (26:02)

  • Introduction (00:51)
  • Sorting the List (00:54)
  • Demo: Sort a List (04:02)
  • Look for Items in a List (01:24)
  • Demo: Look for Items in List (04:49)
  • Working with Predicates (02:49)
  • Predicates and Delegates (01:00)
  • List Methods using Predicates (00:55)
  • Test Predicates (05:22)
  • System.Action Predicates (01:20)
  • Converter Predicate (01:49)
  • Summary (00:39)

Other Collections (36:55)

  • Introduction (00:39)
  • Dictionaries Stacks Queues (01:32)
  • Dictionary Class (04:36)
  • Demo: Dictionary Class (05:15)
  • SortedDictionary SortedList (01:38)
  • Demo: SortedDictionary (05:20)
  • Using Queues and Stacks (02:01)
  • Stack (02:26)
  • Queue (01:24)
  • Creating Collection Classes (03:29)
  • Create Custom Collection (07:48)
  • Summary (00:41)
Module 13

Language Extensions (15:03)

  • Introduction (00:28)
  • LINQ and Languages (00:43)
  • The Sample Application (00:48)
  • Demo: Without New Features (04:11)
  • Implict Type Delcarations (00:31)
  • Demo: With New Features (03:06)
  • Object Initializers (00:36)
  • Constructors to the Rescue (00:45)
  • Demo: Object Initializers (03:07)
  • Summary (00:43)

Lambda Expressions (43:29)

  • Introduction (00:33)
  • Lambda Overview (01:14)
  • Using Delegates (01:08)
  • Demo: Delegates (03:03)
  • Predicate Delegate Type (01:18)
  • Demo: Predicate Delegate (03:43)
  • Using Lambda Expressions (01:13)
  • Demo: Lambda Expressions (05:20)
  • Lambda and Delegates (00:56)
  • Lambda and Sorting (00:47)
  • Func Delegate Type (00:46)
  • Demo: Func Declaration (03:39)
  • Extension Methods (00:55)
  • Creating Extension Methods (01:01)
  • Demo: Extension Method (05:03)
  • Chaining Operations (00:56)
  • Demo: Chaining Operations (04:20)
  • Extension vs. Built-In Methods (01:21)
  • Anonymous Types (00:31)
  • Demo: Anonymous Types (04:40)
  • Summary (00:52)