.Net 3.5/C# 3.0 / VS

As you might heard

We've recently updated to .Net 3.5

History

  • 1.0 - Published in 2002
  • 1.1 - Published in 2003
  • 2.0 - Published in 2005
  • 3.0 - Published in 2006
  • 3.5 - Published in 2007
  • 4.0 - Published in 2010
  • 4.5 - Published in 2012
  • 4.6 - Published in 2015

What's new ?

So much...

We can't cover everything...

Still

Let's see what we got

SYNTACTIC SUGAR

  • Automatic Properties
  • Object Initializers
  • Collection Initializers
  • Extension Methods
  • Implicitly Typed Variable
  • Anonymous Types

LINQ - intro to...

LAMBDA EXPRESSION

What we're gonna cover

INTRODUCTION

Not Covered

WPF

 

WCF

 

WF

Allot of Frameworks Classes introduced in .Net 3.5

 - new presentation FW

 - new communication FW

 - no clue

Another day

Introduction

RESEMBLES JAVA

NOT JAVA!

Introduction - Proprties

Let's look at "plain old C# object"

class Customer
{
    string id;
    string name;
    // ...
}

How to access these fields ?

JAVA has the "getX"/"setX"/"isX" notation used as convention (over configuration)

class Customer {
    String getId() {
        return id;
    }
    void setId(String id) {
        this.id = id;
    }
}

C# decided on a less cumbersome notation (still more configurable than you think)

class Customer
{
    string Id
    {
        get { return id; }
        set { id = value; }
    }
}

Introduction - Proprties

Annotations / Attributes

Say we have a requirement for "Author" metadata

// Where do you set the attribute ?
@Author(Name = "Amir")
String id;
// -> or here
String getId() {}
// -> or here
void setId(String id) {}
[Author("Amir")]
string Id
{
    get { return id; }
    set { id = value; }
}

Automatic Properties

nail #1 in the java coffin ?

public class Customer
{
   private int _customerID;
   private string _companyName;
   private Address _businessAddress;
 
   public int CustomerID
   {
      get { return _customerID; }
      set { _customerID = value; }
   }
   public string CompanyName
   {
      get { return _companyName; }
      set { _companyName = value; }
   }
   public Address BusinessAddress
   {
      get { return _businessAddress; }
      set { _businessAddress = value; }
   }
}
public class Customer
{
   public int CustomerID
   {
      get; set;
   }
   public string CompanyName
   {
      get; set;
   }
   public Address BusinessAddress
   {
      get; set;
   }
}

This is soooooo redundant...

JUST WRITE

.Net generates the private fields for us...

// NO NEED
// NO NEED
// NO NEED
// NO NEED
// NO NEED
// NO NEED
// NO NEED
// NO NEED
// NO NEED

Automatic Properties

Or - nail #1 in the java coffin

public class Customer
{
   public int CustomerID
   {
      get; private set;
   }
   public string CompanyName
   {
      get; private set;
   }
   public Address BusinessAddress
   {
      get; private set;
   }
}

This should also be cool

Great support by VS

LET'S SEE AN EXAMPLE

Object Initilizers

Looking at POCO (plain-old-c#-object)

It's very convenient to have C'tor

public Customer(int customerID,
                string companyName,
                Address businessAddress,
                string phone) {}

Or - have many combinations...

public class Customer
{
   private int _customerID;
   private string _companyName;
   private Address _businessAddress;
 
   public int CustomerID
   {
      get { return _customerID; }
      set { _customerID = value; }
   }
   public string CompanyName
   {
      get { return _companyName; }
      set { _companyName = value; }
   }
   public Address BusinessAddress
   {
      get { return _businessAddress; }
      set { _businessAddress = value; }
   }
}
public Customer(int customerID,
                string companyName,
                string phone) {}
public Customer(int customerID,
                string companyName,
                Address businessAddress) {}
public Customer(int customerID,
                string companyName) {}

Object Initilizers

Than... There's the "Builder" pattern

  • More fields - More  Permutations
  • C'tors get "telescopical" !
public class Customer
{
   public class Builder
   {
      private Builder(); // PRIVATE C'TOR
      
      private String _name;

      public Builder Name(String name) { _name  = name; return this; } // RETURNING THE SAME BUILDER
   }
   
   public static Builder Builder() { return new Builder() }
}
Customer.Builder().Name("Amir").Phone("000-000-000").generate()

so you can write...

The C'tor Pattern

Object Initilizers

 Customer customer = new Customer();
 customer.CustomerID = 101;
 customer.CompanyName = "Foo Company";
 customer.BusinessAddress = new Address();
 customer.Phone = "555-555-1212";
Customer customer = new Customer
{
   CustomerID = 101,
   CompanyName = "Foo Company",
   BusinessAddress = new Address
      { City="Somewhere", State="FL" },
   Phone = "555-555-1212"
};

With out C'tor or Builder Patterns

Or you could write

Object Initilizers

Let's see an example

Collection Initilizers

Same "shtik" - very cool...

List<Customer> custList = new List<Customer>
  {
     new Customer {ID = 101, CompanyName = "Foo Company"},
     new Customer {ID = 102, CompanyName = "Goo Company"},
     new Customer {ID = 103, CompanyName = "Hoo Company"}
  };

Hate creating collections than add items one by one ? 

write it

Customer customerFoo = new Customer();
customerFoo.ID = 101;
customerFoo.CompanyName = "Foo Company";
Customer customerGoo = new Customer();
customerGoo.ID = 102;
customerGoo.CompanyName = "Goo Company";
Customer customerHoo = new Customer();
customerHoo.ID = 103;
customerHoo.CompanyName = "Hoo Company";
List<Customer> customerList3 = new List<Customer>();
customerList3.Add(customerFoo);
customerList3.Add(customerGoo);
customerList3.Add(customerHoo);

Collection Initilizers

Let's see an example

Extension Methods

missing some functionality on a known class ?

public static class MyExtensions
{
   public static string SayIm(this string str)
   {
      return "I'm" + str.ToString();
   }
}

What if string could say more ?

//...
string batman= "Batman"
//...
batman.SayIm()

I ACTUALLY DON'T HAVE ANY GOOD EXAMPLE FOR THIS

:)

// OUTPUT: I'm Batman

Extension Methods

Let's see an example

Implicit Types

Or - How .Net learnt to be less tedious !!!

//..
String name = "Yo oh oh";

List<int> ids = new List<int>();

IEnumerable<String> items = ids.Where(x => x.id = 0); // We will get to this...

Dictionary<String, List<Pair<String, int>> current = new Dictionary<String, List<Pair<String, int>>();
//..
var name = "Yo oh oh";

var ids = new List<int>();

var items = ids.Where(x => x.id = 0);

var current = new Dictionary<String, List<Pair<String, int>>();

Suddenly - type deceleration it less tedious...

But is it good practice  ?

Actually - Compiler can infer the type for us...

Implicit Types

Some rules...

var a;

a = "OH NO YOU DIDN'T"

Implicitly-typed local variables must be initilized

// BAD PROGRAMMER
class Program
{
   var str = "";

   static var number = 5;

   static void DoNothing(string[] args)
   {
      // Some code
   }
}
// BAD PROGRAMMER - local scope only
// BAD PROGRAMMER

Inferred type "var" can only be defined locally

Implicit Types

YES ? NO ?

  • Required for "Anonymous Types"
  • Induce better naming for local variable
IUnitTestElement current
var currentUnitTest

VS.

  • removes code noise
  • does not require "using" directive
  • Induces variable initialization
  • Better API - better names for members
// get the xml node name
var string = tree.XmlNodeName
var current = new Dictionary<String, List<Pair<String, int>>();
var current; // COMPILER ERROR

Implicit Types

YES ? NO ?

Most benefits mentioned - ARE STYLISTIC

"better naming":

  • longer (Hungarian style) variable names
  • will show up everywhere...

"better API", let's say in properties

  • XmlNode.XmlNodeName - SUCKS
  • XmlNode.Name

Implicit Types

RULE OF THUMB

When the type is obvious from the right hand side expression

C# team Quote:

"Overuse of var can make code less readable for others..."

Implicit Types

Let's see an example

Anonymous Types

Basically - Create Class Structure on the fly

var dog = new
{
    Bark = "woof",
    Name = "Woofy"
}

Anonymous Types

In JS it is taken to extreme and the main diff's are

We already know the concept of "Dynamic Structure" from JavaScript

  • "Anonymous" the types are still "strict"
  • They cannot be extended further after deceleration
  • "read-only" properties
  • methods are not "first class citizen" - so no !
    • events also (they are semantically the same)
    • There are "dirty" ways to do it... let's not...

BUT IT'S NOT THE SAME

Anonymous Types

Actually - The main use for Anonymous-Types goes in correlation with LINQ, which we'll soon cover

Anonymous Types

Let's see an example

Lambda Expressions

YAY

local Anonymous-Function, to be passed around as arguments, or returned as the value of a function call

Definition

Lambda Expressions

delegate int Operator(int i);


// function
public void TravereseList(List<int> list, Operator op)
{
   for (int i = 0; i < list.Count; i++)
   {
      list[i] = op(list[i]);
   }
}
static void DoSomething()
{
    Operator square = x => x * x;
    int j = square (5); //j = 25
}

Simple Lambda

Pass to function ?

Lambda Expressions

Func<int, bool> myFunc = x => x == 5;
bool result = myFunc(4); // returns false of course

Do we really need delegation ?!

Lambda Expressions

EXAMPLE

Lambda Expressions

Syntax - Expression Lambda

(input parameters) => expression
// THIS
x => x * x
// SAME AS
(x) => x * x

// MORE THAN ONE PARAM
(x, y) => x == y

// ZERO INPUT
() => SomeMethod()
(int x, string s) => s.Length > x

Some times - it's impossible for the compiler to infer the input types

So - Optionally - you can add the types explicitly

Lambda Expressions

Syntax - Statment Lambda

(input parameters) => {statement;}
delegate void SomeDelegate(string s);
// ...
SomeDelegate myDel = n => { string s = n + " " + "World"; Console.WriteLine(s); };
// ...
myDel("Hello");

Almost the same - but body can consist of several statments

Lambda Expressions

Syntax - asynchronous lambdas

Visual Studio Snippets

?

Visual Studio Snippets

CODE SNIPPETS are ready-made snippets of cod you can quickly add into your code

Visual Studio Snippets

Two types

Type 1: Insertion

Type 2: Surround

Visual Studio Snippets

Two types

Type 1: Insertion

Type 2: Surround

Both can be added, either while typing with "tab-tab", or with Ctrl+k than X, Ctrl+k than S respectivily

Visual Studio Snippets

Let's see an examples

LINQ &

Extension Methods

for collections

Language Integrated Query

LINQ

int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
int j = 0;
for(int i = 0; i < numbers.Count ; i++)
{
    if(numbers[i] > 5)
    {
        j++;
    }
}

Let's assume we have the following:

And we want to count the number of items larger than 5

LINQ

int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };

Let's assume we have the following:

And we want to count the number of items larger than 5

int oddNumbers = numbers.Count(n => n > 5);

LINQ

int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };

Let's assume we have the following:

What more can we do

MORE

  • GENERICS - JAVA vs. .NET
  • Coding Conventions
    • https://msdn.microsoft.com/en-us/library/ff926074.aspx

.Net 3.5/C#3.0/VS

By Amir Gal-Or

Made with Slides.com

.Net 3.5/C#3.0/VS

  • 841

More from Amir Gal-Or