[Assassins]

LearnVisualStudio.net | Visual C Sharp 2010 Express Edition for Absolute Beginners [2010] [EN] PCRec

Автор (режиссер): LearnVisualStudio.net
Название: Visual C Sharp 2010 Express Edition for Absolute Beginners
Год выпуска: 2010
Жанр: C#
Язык: EN
Качество видео: PCRec
Продолжительность: 11:04:59
Видеокодек: Advanced Video Codec (AVC)
Битрейт видео: ~526 - 920 кбит/с
Размер кадра: 1280 x 720
Аудиокодек: Advanced Audio Codec (AAC)
Битрейт аудио: 96,0 Кбит/сек 2 канала 44,1 КГц

Описание:
Эта серия уроков предлагает разработчикам на C# богатый опыт использования языка и концепций, связанных с .NET Framework, продемонстрированный на последней бесплатной версии Visual Studio, названной Visual C# 2010 Express Edition.
Просмотривая более 11 видеолекций и выполняя связанные с ними домашние задания каждый день, вы получите твердые основы знаний, и в C#, и в создании SQL Server БД. Ежедневно выполняя упражнения по пройденным урокам, вы закрепите изученное.
Каждый следующий день основывается на ранее пройденном материале и приведет даже незнакомых с программированием к тому, что они смогут создавать простые приложения, построенные на принципах объектно-ориентированного программирования с наследованием и полиморфизмом, понимать простые UML Class Diagram и применять эти знания в кодировании, строя нормализованные связанные базы данных и используя T-SQL для построения запросов и обновления данных.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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!

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.

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".

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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".

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.

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").

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".

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").

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..

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.

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!

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.

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.

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..

Picking up from yesterday's discussion of the "new" keyword and the process of instantiation, Bob discusses constructors which are methods that automatically are invoked when a new instance of a class is created. Constructors allow you, the developer, to "plug in" and ensure that the new object is in a valid, usable state before it is used in the client code.

When designing classes, sometimes it's important to provide multiple approaches to invoking a method if you anticipate that the code that will use an instance of your class. Perhaps each approach accomplishes the same task, but in a slightly different manner. Bob demonstrates how to overload a method declaration in order to provide multiple ways to call a method, providing a different set of input parameters for each. In doing so, Bob revisits the previous conversation about the difference between a "method header" and a "method signature".

In this video we tackle a that may have been nagging you … if classes require an instance to be created before it can be used, then in our earliest use of the Console class, how is it that we never had to create an instance of the class before utilizing its methods (WriteLine, ReadLine, etc.)? The reason is because those methods were defined as static methods. Bob explains how and why you would create static methods, as well as entire classes, in your applications.

C# 3.0 introduced a shortcut to creating the private field / public property syntax. During initial development, an auto-implemented property can be used to quickly implement this pattern and adhere to the general convention of preferring to use public properties rather than creating public fields. The intent is to re-visit public properties for those fields that require some "gate keeper" logic.

Building on your UML Class Diagram knowledge, this video demonstrates how to describe static methods, properties and entire classes in a class diagram, and two styles for expressing an inheritance relationship, as well as overriding methods in the derived class.

Today's theme for our Visual Studio IDE overview is "finding a needle in a haystack" … or, in other words, navigating and searching through code to find what you are looking for. The video discusses naming conventions for files, using the Class / Member navigation in the code window, using the Find and Find and Replace panes, using "Go To Definition" and "Find All References" contextual menu options.

Before we conclude the day, Bob sneaks in just one more topic: Enumerations, which are data types that restrict the values of the type to a short list of possibilities. In doing so, Bob discusses the idea of "strongly typed" data versus "weakly typed" data and how enumerations are one way to gain confidence in your code by catching potential errors earlier in the development process.

Day 4's homework assignment requires you to apply concepts you learned today including C# Constructors, Inheritance, overriding virtual methods on the base class, auto-implemented properties and more. I provide you a UML Class Diagram and you build another application for a top secret spy organization.

Stuck on Day 4's homework? Bob walks you through a solution for today's homework assignment.

Building on our discussion of both Arrays and Classes, Bob looks at the pro's and con's of using simple arrays to store collections of references to objects through a series of examples. He then introduces the System.Collections namespace, and one type of collection specifically (ArrayList) demonstrating the added features you get by using a Collection rather than an Array to manage a group of objects. But when Bob tries to add a different type of object to the collection, problems start to crop up. This will provide the basis of conversation for the remainder of the day … how to add manage instances of different types who may share something in common (like the Print method). This also provides the basis for a discussion of the third tenet of Object Oriented Programming, namely "polymorphism".

In C# 2.0, generic collections were added to the language specification allowing for a special kind of collection (in the System.Collections.Generics namespace) that allows you to specific the data type that collection can contain. This is another way to work "strongly typed" further increasing your confidence in the code by catching potential problems during development. Furthermore, you the developer get the benefit of working with data that first does not have to be convert to System.Object and then cast back it's specific data type before a given item in the collection can be used meaningfully. Bob full demonstrates this powerful concept and outlines its benefits in this video.

This video is the first of three techniques to polymorphically call a method (with the same name, signature, etc.) implemented by two different custom types. This first approach involves simple inheritance. Bob shows how -- using a generic collection that accepts a base class type -- to add derived classes to the collection and call the method those types share in common.

Building on the previous video, this second approach to polymorphically calling a method on two different types focuses on using abstract classes, which as we'll see is very similar to the previous implementation (using simple inheritance). Abstract classes provide no base implementation of a given method, relying solely on the derived classes to supply an implementation of the method. Bob discusses both the technique and the reason why you would want to take this approach.

The third approach to polymorphically calling a method on two different types is through the use of interfaces, which does not require that the types are derived from the same base class, or rather, the same "inheritance tree". Bob explains how to define and use an inheritance, it's benefits over inheritance, and it's importance in many design patterns.

Elaborating on the previous discussion of interfaces, this video demonstrates how interfaces can be used to make the methods in your applications flexible enough to work with new custom types you add to your application -- as long as they agree to the "contract" defined in the interface. Amaze your friends and neighbors with generic collections that accept interface types, and other mind-broadening ideas.

Today's Visual Studio IDE overview focuses on the contextual method that implements method stubs defined by interfaces in your new custom types. Bob also shows you how to organize code in your classes by defining #regions.

We're attempting to keep your object oriented knowledge in sync with their representation in a class diagram. Bob demonstrates how to express abstract classes and interfaces (as well as those classes that implement those types) in UML.

Today's homework involves intrigue, mystery, mutants, abstract classes and inheritance. Aren't you just a little bit curious? You'll write an application implementing the design expressed in a UML Class Diagram (with copious use of abstract classes and interfaces) to analyze mutants, their powers, and the likeliness that they'll become a clear and present danger to society.

Ok, so you may not be a comic book or sci-fi fan, but this exercise really pushed you to learn abstract classes and inheritance. Couldn't quite figure it out? Never fear … this video is here to save the day and show you one approach to solving the homework assignment.

One of the great paradoxes of writing C# -- to move forward, we'll have to temporarily move away from C# and on to understanding relational databases, and specifically SQL Server 2008 Express Edition. Bob explains what a database is, why databases are important, explains (IBM researcher) Codd's thought work in the 1970's which changed how data can be more efficiently and reliably stored. Topics include first-looks at databases, tables, columns, rows, fields, constraints, relationships, normalization primary / foreign keys and more.

This video demonstrates how to use the tools built into Visual C# 2010 Express Edition (as well as all editions of the Visual Studio IDE) to create a new SQL Server 2008 Express Edition database, how to add tables with columns, add data (rows) and more.

Bob delves deeper into the high level topic of "data integrity" by exploring it's two material agents in SQL Server: data types and constraints. Bob provides a list of SQL Server datatypes that every developer should commit to memory, with the intent to learn more about other data types later.

In this video, Bob demonstrates how to create a Database Diagram in Visual C# 2010 Express Edition with the ultimate aim of using it to easily create a foreign key relationship between two tables. Along the way, much about the Diagram itself is discussed.

Normalization is the process of deciding how to split data up into the right tables. In this video Bob looks at the first two "forms" of normalization with a couple of sample tables. He also discusses why most developers only choose to normalize to second or third normal form, and why too much normalization is not necessarily a good thing.

Today's Visual Studio IDE overview focuses further on the built-in tools to manage and work with databases. First, we explore the Query window and see how to visually create a query as well as the back-end Structured Query Language that is generated as a result. Second, we look at the Database Explorer window ad pluck out a few additional features we had not discovered before.

Day 6's homework assignment is all about creating a database, tables and a foreign key constraint using only the built-in tools in the Visual C# 2010 Express Edition IDE.

Can't remember a step in building a database, tables and a foreign key constraint using a Database Diagram? No problem … Bob will remind you how in this video.

We'll start today by installing the SQL Server Management Studio (SSMS) Express, the preferred way to work with the Structured Query Language. Usually a simple installation wouldn't require a video, however in this case there are a couple of gotcha's when installing SSMS side-by-side with Visual Studio 2010 Express Edition.

This video demonstrates how to open and execute a SQL script containing potentially dozens or hundreds of lines of code. In our particular situation, Bob wants you, the viewer, to have the same database tables and a thousand rows of data that he's working with, thus this crucial step in staying synced.

Curious how (1) Bob created 3000 rows of fake data, and (2) how he scripted the tables and data into a simple script file … in less than 6 minutes? This video shows two third-party tools that make simple work of both tasks. Note: this is not part of the curriculum … Bob is just demonstrating this in case you ever have a similar need.

In this video we look at how to write a simple SELECT statement in T-SQL, explaining the syntax and variations like selecting only certain columns, aliasing column names using the 'as' keyword, formatting columns and more.

Continuing our work with T-SQL, we explore the INSERT statement syntax to add rows of data to a given database table. Additionally, Bob shows a second form of the syntax "INSERT INTO" which combines a SELECT and an INSERT.

This video comes with a warning label: be careful! Using the UPDATE statement allows you to change one more more rows of data with new values, but can be very destructive. Bob outlines the proper way to execute UPDATE using a copy / backup of the database and a script that is executed on a live production server only after it's been thoroughly tested.

The DELETE statement is simple, but lethal. This video shows you the syntax, but moves past that to explain a different technique for removing data that has a built-in safeguard against accidental deletes.

In the case of the SELECT, UPDATE and DELETE statements, the WHERE clause is crucial to working with only those rows of data the meet certain criteria. In this video Bob demonstrates a dozen WHERE operators such as LIKE, BETWEEN, greater than, greater-than-or-equal-to, not-equal-to, IS, IN and more.

When SELECTing data, the order in which the data is sorted can often be important, and this video demonstrates the ORDER BY statement and it's associated operators.

Till now, we've only worked with T-SQL in the context of a single table. What if you need to perform a join (based on the primary / foreign key relationship between the tables) to select some columns from multiple tables? Bob demonstrates the basic syntax of an INNER JOIN, and shows how to add table aliases, and how to add more than two INNER JOINs in a single statement.

Day 7's homework assignment requires you to write five T-SQL statements based on the Customers and Orders table we used throughout today's videos. You'll exercise virtually everything you learned today, including TOP, LIKE, BETWEEN, INNER JOIN and more.

Got stuck on a query or two? Bob demonstrates step-by-step how to work through and solve the T-SQL queries.

Скриншоты:


Время раздачи: с 23:00 до 8:00 (днём по возможности) до первых пяти скачавших
Заранее извиняюсь за низкую скорость раздачи... быстро скачать не получится...
Отдельная благодарность Группе "Uploaders" и лично slava03 за поддержку релизов