Trending

Sunday, October 27, 2013

TekPub – Mastering C# 4.0 with Jon Skeet

Mastering C# 4.0
If you’re just learning Microsoft’s flagship language – or if you’ve been at it for years – this production will teach you a lot. Jon Skeet is well-known as the “Chuck Norris” of StackOverflow.com with inhuman skills when it comes to answering questions about C# 4.0. Tap his brain and learn the language like never before with our all-new series.

Table of content:

1 – What’s New With 4.0?

In this episode we’ll take a quick tour of all the new goodies in C# 4.0 – showing you why you should care about this latest rev of the language. This is a summary episode only – we’ll dive deep into each topic later on.

2 – Basics: The Coding Environment

In this episode Jon gives you a quick tour of Visual Studio 2010 – the place where you’ll write your code most often. This is a beginner episode, for those who have not worked with Visual Studio before.

3 – Basics: Writing Your First Class

In this episode Jon starts from the ground up – writing a C# class and then testing it with NUnit. Along the way he’ll talk about various details related to classes and things to look out for. Even if you’re a seasoned C# developer – going over the basics never hurts – and Jon might drop some pearls of wisdom along the way!

4 – Basics: Methods, Constructors, and Exceptions

In this episode Jon covers the actions and behaviours that you can program for a C# Class. This is a beginner’s episode, but there is plenty in here for seasoned developers as well.

5 – Basics: Class Properties and Structure

In this episode Jon shows you how to work with Property assignments in C# and how you can set them up to convey specific behaviour of your class. This is a beginner’s episode – but there’s a lot in here that would make for a good review for any C# developer.

6 – Basics: Integers and Operators

In this episode Jon talks about integers and the different “shades of int” you find in C# 4.0. He also talks about reference vs. value types, and various operators you can use when doing some math in C#.

7 – Decimals and Floating Points

In this episode Jon walks through the various issues you might encounter when dealing with decimals and floating-point numbers. It’s not straightforward in C#, and Jon gives you practical advice on when and how to use the various types in C#.

8 – Strings: Equality, Interning, and Concatenation

In this episode (the first of a small series on Strings) Jon takes a look at the beloved, intense, misunderstood and vast System.String class. He’ll walk you through Equality – how to tell if a string truly equals another, Interning and if you should care about it, and Concatenation: when do you need a StringBuilder?

9 – String Manipulation

In this episode Jon shows you how to manipulate strings using Substring, IndexOf and Split.

10 – Regular Expressions

In this episode Jon walks you through 3 scenarios where Regular Expressions can help – and also hurt. Simple string replacement and matching, as well as a more complicated example of log parsing.

11 – Encoding

In this episode Jon shows you the various ways that C# represents strings and how you can manipulate encodings.

12 – Cultures

In this ever-so-brief episode Jon shares his experience with “The Turkey Test” – and ways to deal with Cultures and strings. It’s short, but it’s very valuable.

13 – Dates and Time

In this episode Jon dives deep into Timespan and DateTime – and how the .NET framework designers dealt with the interesting ways that humans deal with time.

14 – Conditions and Loops

In this episode Jon dives into controlling the flow of execution in your application using structures such as if/else, for, while, and break/continue.

15 – Arrays

Jon walks through the seldom-used array in C#4 (it’s seldom-used because generic lists offer a lot more functionality). Though you might not use it often – understanding how it works is very important.

16 – Intro to Generics, and var

Jon talks about generics and what they are in a basic sense. We then talk about the need for the “var” keyword as generics add wrist-cramping typing needs. This episode is rather basic – so if you’re familiar with generics it might not suit you. We will be moving to more advanced topics in the coming episodes.

17 – Basics: Lists and Dictionaries

Jon talks about Generic Lists and Dictionaries, their core functionality, and their methods and properties. LINQ is not discussed in this episode – that comes later.

18 – Inheritance

Jon explores the basic concepts behind inheritance with C#4, including AbstractBase classes and virtual methods and properties.

19 – Interfaces

Jon explores compositional structuring using Interfaces instead of Inheritance. Along the way we’ll discuss ballet and chainsaws.

20 – Advanced: Delegates and Events

In this episode Jon walks through how delegates work, then constructs his own Events and Event Handlers. From there, he goes into Events, and the syntax changes from .NET through .NET 4.

21 – Advanced: Delegates with Lambdas

Jon continues his discussion of delegates, but goes into the new features of C# 3.5 and 4.0 – particularly lambdas. He also shows a few ways you might get screwy results along the way.

22 – Advanced: Anonymous Types

In this episode Jon discusses anonymous types and various ways you can use types without declaring a class.

23 – Extension Methods

In this episode Jon dives into Extension methods and how you can use them to with Anonymous Types and LINQ.

24 – LINQ

In this episode Jon wraps up the previous discussions on Lambdas, Extension Methods and Expressions – showing you how they are used in LINQ – .NET’s Language INtegrated Query feature. This is not a full dive into LINQ, just the mechanisms that make it run.

25 – Covariance and Contravariance

In this episode Jon melts Rob’s brain as he tries to explain the new Covariance and Contravariance features in C# 4.0. This is a very advanced episode – you should be comfortable with generics, LINQ, and C# in general.

26 – Advanced: Dynamics

In this episode Jon shows various ways to work with C# 4.0 Dynamics – a way to delay type inference until runtime (like Ruby or javascript). Rob and Jon debate the merits of using dynamics (Rob’s a fan, Jon is not) and in the end Jon creates Massive (Rob’s little ORM) on the fly.


Uploaded.net
  1. http://ul.to/8ljgq8ge
  2. http://ul.to/jwmycdiq
  3. http://ul.to/5u5kyoq7
  4. http://ul.to/y7d8jc0e
  5. http://ul.to/0tp4qq4d
  6. http://ul.to/np1zjq53
  7. http://ul.to/f71qqkos
  8. http://ul.to/665yq3el
  9. http://ul.to/hrcte1m1
  10. http://ul.to/uz61v8nf
  11. http://ul.to/sbwlsrbr
  12. http://ul.to/87u024b8
  13. http://ul.to/h3rukj99 
  14. http://ul.to/l09e4wbh 
Letitbit.ne
  1. http://bit.ly/1bO427U
  2. http://bit.ly/1mvhsdl 
  3. http://bit.ly/1jKAmYD 
  4. http://bit.ly/1jSjr9L 
  5. http://bit.ly/1jSjr9L 
  6. http://bit.ly/NdiZVr 
  7. http://bit.ly/1l0sKEJ 
  8. http://bit.ly/1l0sKEJ 
  9. http://bit.ly/1dQmxr5 
  10. http://bit.ly/1c465PD 
  11. http://bit.ly/1d3meVI 
  12. http://bit.ly/1bO52ZH 
  13. http://bit.ly/1e9QVZ6 
  14. http://bit.ly/1l0tWYQ 
cloudzer.net
  1. http://clz.to/nz57xvq0
  2. http://clz.to/idywvdqj
  3. http://clz.to/zmf5cncf
  4. http://clz.to/tqs0z2ck
  5. http://clz.to/99t7vert
  6. http://clz.to/r5ed8lxu
  7. http://clz.to/8773ia91
  8. http://clz.to/pi6zcw91
  9. http://clz.to/1srkr5r5
  10. http://clz.to/3cu0r68h
  11. http://clz.to/eo2pmrkt
  12. http://clz.to/itazk9e0

About

Contact Form

Name

Email *

Message *

Copyright © 2013 TOTdownload.com
Designed By Blogger Templates