mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 17:41:41 +00:00
Added Interesting Features (and fixed / cleaned up other code)
Fixed syntax errors, made items more succinct, and added a section of interesting features in c#
This commit is contained in:
Shaun McCarthy
parent
661d9481c8
commit
0cee5bd79a
@ -3,8 +3,8 @@ language: c#
|
||||
contributors:
|
||||
- ["Irfan Charania", "https://github.com/irfancharania"]
|
||||
- ["Max Yankov", "https://github.com/golergka"]
|
||||
- ["Melvyn Laïly", "http://x2a.yt"]
|
||||
filename: LearnCSharp.cs
|
||||
- ["Melvyn Laïly", "http://x2a.yt"]
|
||||
- ["Shaun McCarthy", "http://www.shaunmccarthy.com"]
|
||||
---
|
||||
|
||||
C# is an elegant and type-safe object-oriented language that enables developers to build a variety of secure and robust applications that run on the .NET Framework.
|
||||
@ -23,7 +23,12 @@ Multi-line comments look like this
|
||||
// Specify namespaces application will be using
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
|
||||
using System.Data.Entity;
|
||||
using System.Dynamic;
|
||||
using System.Linq;
|
||||
using System.Linq.Expressions;
|
||||
using System.Net;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
// defines scope to organize code into "packages"
|
||||
namespace Learning
|
||||
@ -32,8 +37,8 @@ namespace Learning
|
||||
// you're allowed to do otherwise, but shouldn't for sanity.
|
||||
public class LearnCSharp
|
||||
{
|
||||
// A console application must have a main method as an entry point
|
||||
public static void Main(string[] args)
|
||||
// BASIC SYNTAX - skip to INTERESTING FEATURES if you have used Java or C++ before
|
||||
public static void Syntax()
|
||||
{
|
||||
// Use Console.WriteLine to print lines
|
||||
Console.WriteLine("Hello World");
|
||||
@ -46,7 +51,6 @@ namespace Learning
|
||||
Console.Write("Hello ");
|
||||
Console.Write("World");
|
||||
|
||||
|
||||
///////////////////////////////////////////////////
|
||||
// Types & Variables
|
||||
//
|
||||
@ -61,140 +65,83 @@ namespace Learning
|
||||
// (0 <= byte <= 255)
|
||||
byte fooByte = 100;
|
||||
|
||||
// Short - Signed 16-bit integer
|
||||
// (-32,768 <= short <= 32,767)
|
||||
// Short - 16-bit integer
|
||||
// Signed - (-32,768 <= short <= 32,767)
|
||||
// Unsigned - (0 <= ushort <= 65,535)
|
||||
short fooShort = 10000;
|
||||
|
||||
// Ushort - Unsigned 16-bit integer
|
||||
// (0 <= ushort <= 65,535)
|
||||
ushort fooUshort = 10000;
|
||||
|
||||
// Integer - Signed 32-bit integer
|
||||
// (-2,147,483,648 <= int <= 2,147,483,647)
|
||||
int fooInt = 1;
|
||||
// Integer - 32-bit integer
|
||||
int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)
|
||||
uint fooUint = 1; // (0 <= uint <= 4,294,967,295)
|
||||
|
||||
// Uinteger - Unsigned 32-bit integer
|
||||
// (0 <= uint <= 4,294,967,295)
|
||||
uint fooUint = 1;
|
||||
|
||||
// Long - Signed 64-bit integer
|
||||
// (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
|
||||
long fooLong = 100000L;
|
||||
// Long - 64-bit integer
|
||||
long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
|
||||
ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)
|
||||
// Numbers default to being int or uint depending on size.
|
||||
// L is used to denote that this variable value is of type long or ulong
|
||||
// anything without is treated as int or uint depending on size.
|
||||
|
||||
// Ulong - Unsigned 64-bit integer
|
||||
// (0 <= ulong <= 18,446,744,073,709,551,615)
|
||||
ulong fooUlong = 100000L;
|
||||
|
||||
// Float - Single-precision 32-bit IEEE 754 Floating Point
|
||||
// Precision: 7 digits
|
||||
float fooFloat = 234.5f;
|
||||
// f is used to denote that this variable value is of type float;
|
||||
// otherwise it is treated as double.
|
||||
|
||||
// Double - Double-precision 64-bit IEEE 754 Floating Point
|
||||
// Precision: 15-16 digits
|
||||
double fooDouble = 123.4;
|
||||
|
||||
// Decimal - a 128-bits data type, with more precision than other floating-point types,
|
||||
// suited for financial and monetary calculations
|
||||
decimal fooDecimal = 150.3m;
|
||||
double fooDouble = 123.4; // Precision: 15-16 digits
|
||||
|
||||
// Float - Single-precision 32-bit IEEE 754 Floating Point
|
||||
float fooFloat = 234.5f; // Precision: 7 digits
|
||||
// f is used to denote that this variable value is of type float
|
||||
|
||||
// Decimal - a 128-bits data type, with more precision than other floating-point types,
|
||||
// suited for financial and monetary calculations
|
||||
decimal fooDecimal = 150.3m;
|
||||
|
||||
// Boolean - true & false
|
||||
bool fooBoolean = true;
|
||||
bool barBoolean = false;
|
||||
bool fooBoolean = true; // or false
|
||||
|
||||
// Char - A single 16-bit Unicode character
|
||||
char fooChar = 'A';
|
||||
|
||||
// Strings -- unlike the previous base types which are all value types,
|
||||
// a string is a reference type. That is, you can set it to null
|
||||
string fooString = "My string is here!";
|
||||
// a string is a reference type. That is, you can set it to null
|
||||
string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)";
|
||||
Console.WriteLine(fooString);
|
||||
// You can access each character of the string with an indexer:
|
||||
char charFromString = fooString[1]; // 'y'
|
||||
// Strings are immutable: you can't do fooString[1] = 'X';
|
||||
|
||||
// formatting
|
||||
// You can access each character of the string with an indexer:
|
||||
char charFromString = fooString[1]; // 'y'
|
||||
// Strings are immutable: you can't do fooString[1] = 'X';
|
||||
|
||||
// Compare strings with current culture, ignoring case
|
||||
string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);
|
||||
|
||||
// Formatting, based on sprintf
|
||||
string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2);
|
||||
Console.WriteLine(fooFormattedString);
|
||||
|
||||
// formatting dates
|
||||
// Dates & Formatting
|
||||
DateTime fooDate = DateTime.Now;
|
||||
Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));
|
||||
|
||||
// \n is an escaped character that starts a new line
|
||||
string barString = "Printing on a new line?\nNo Problem!";
|
||||
Console.WriteLine(barString);
|
||||
|
||||
// it can be written prettier by using the @ symbol
|
||||
// You can split a string over two lines with the @ symbol. To escape " use ""
|
||||
string bazString = @"Here's some stuff
|
||||
on a new line!";
|
||||
Console.WriteLine(bazString);
|
||||
|
||||
// quotes need to be escaped
|
||||
// use \" normally
|
||||
string quotedString = "some \"quoted\" stuff";
|
||||
Console.WriteLine(quotedString);
|
||||
|
||||
// use "" when strings start with @
|
||||
string quotedString2 = @"some MORE ""quoted"" stuff";
|
||||
Console.WriteLine(quotedString2);
|
||||
on a new line! ""Wow!"", the masses cried";
|
||||
|
||||
// Use const or read-only to make a variable immutable
|
||||
// const values are calculated at compile time
|
||||
const int HOURS_I_WORK_PER_WEEK = 9001;
|
||||
|
||||
// Nullable types
|
||||
// any value type (i.e. not a class) can be made nullable by suffixing a ?
|
||||
// <type>? <var name> = <value>
|
||||
int? nullable = null;
|
||||
Console.WriteLine("Nullable variable: " + nullable);
|
||||
|
||||
// In order to use nullable's value, you have to use Value property
|
||||
// or to explicitly cast it
|
||||
DateTime? nullableDate = null;
|
||||
// The previous line would not have compiled without the '?'
|
||||
// because DateTime is a value type
|
||||
// <type>? is equivalent to writing Nullable<type>
|
||||
Nullable<DateTime> otherNullableDate = nullableDate;
|
||||
|
||||
nullableDate = DateTime.Now;
|
||||
Console.WriteLine("Nullable value is: " + nullableDate.Value + " or: " + (DateTime) nullableDate );
|
||||
|
||||
// ?? is syntactic sugar for specifying default value
|
||||
// in case variable is null
|
||||
int notNullable = nullable ?? 0;
|
||||
Console.WriteLine("Not nullable variable: " + notNullable);
|
||||
|
||||
// Var - compiler will choose the most appropriate type based on value
|
||||
// Please note that this does not remove type safety.
|
||||
// In this case, the type of fooImplicit is known to be a bool at compile time
|
||||
var fooImplicit = true;
|
||||
|
||||
///////////////////////////////////////////////////
|
||||
// Data Structures
|
||||
///////////////////////////////////////////////////
|
||||
Console.WriteLine("\n->Data Structures");
|
||||
|
||||
// Arrays
|
||||
// Arrays - zero indexed
|
||||
// The array size must be decided upon declaration
|
||||
// The format for declaring an array is follows:
|
||||
// <datatype>[] <var name> = new <datatype>[<array size>];
|
||||
int[] intArray = new int[10];
|
||||
string[] stringArray = new string[1];
|
||||
bool[] boolArray = new bool[100];
|
||||
|
||||
// Another way to declare & initialize an array
|
||||
int[] y = { 9000, 1000, 1337 };
|
||||
|
||||
// Indexing an array - Accessing an element
|
||||
Console.WriteLine("intArray @ 0: " + intArray[0]);
|
||||
|
||||
// Arrays are zero-indexed and mutable.
|
||||
// Arrays are mutable.
|
||||
intArray[1] = 1;
|
||||
Console.WriteLine("intArray @ 1: " + intArray[1]); // => 1
|
||||
|
||||
// Lists
|
||||
// Lists are used more frequently than arrays as they are more flexible
|
||||
@ -202,28 +149,21 @@ namespace Learning
|
||||
// List<datatype> <var name> = new List<datatype>();
|
||||
List<int> intList = new List<int>();
|
||||
List<string> stringList = new List<string>();
|
||||
|
||||
// Another way to declare & initialize a list
|
||||
List<int> z = new List<int> { 9000, 1000, 1337 };
|
||||
|
||||
// Indexing a list - Accessing an element
|
||||
// Lists are zero-indexed and mutable.
|
||||
Console.WriteLine("z @ 0: " + z[2]);
|
||||
List<int> z = new List<int> { 9000, 1000, 1337 }; // intialize
|
||||
// The <> are for templates - Check out the cool stuff section
|
||||
|
||||
// Lists don't default to a value;
|
||||
// A value must be added before accessing the index
|
||||
intList.Add(1);
|
||||
Console.WriteLine("intList @ 0: " + intList[0]);
|
||||
|
||||
|
||||
// Others data structures to check out:
|
||||
//
|
||||
// Stack/Queue
|
||||
// Dictionary (an implementation of a hash map)
|
||||
// HashSet
|
||||
// Read-only Collections
|
||||
// Tuple (.Net 4+)
|
||||
|
||||
|
||||
///////////////////////////////////////
|
||||
// Operators
|
||||
///////////////////////////////////////
|
||||
@ -232,10 +172,7 @@ namespace Learning
|
||||
int i1 = 1, i2 = 2; // Shorthand for multiple declarations
|
||||
|
||||
// Arithmetic is straightforward
|
||||
Console.WriteLine("1+2 = " + (i1 + i2)); // => 3
|
||||
Console.WriteLine("2-1 = " + (i2 - i1)); // => 1
|
||||
Console.WriteLine("2*1 = " + (i2 * i1)); // => 2
|
||||
Console.WriteLine("1/2 = " + (i1 / i2)); // => 0 (0.5 truncated down)
|
||||
Console.WriteLine(i1 + i2 - i1 * 3 / 7); //
|
||||
|
||||
// Modulo
|
||||
Console.WriteLine("11%3 = " + (11 % 3)); // => 2
|
||||
@ -266,7 +203,6 @@ namespace Learning
|
||||
Console.WriteLine(i--); //i = 1. Post-Decrementation
|
||||
Console.WriteLine(--i); //i = 0. Pre-Decrementation
|
||||
|
||||
|
||||
///////////////////////////////////////
|
||||
// Control Structures
|
||||
///////////////////////////////////////
|
||||
@ -291,50 +227,37 @@ namespace Learning
|
||||
// A simple if/else can be written as follows
|
||||
// <condition> ? <true> : <false>
|
||||
string isTrue = (true) ? "True" : "False";
|
||||
Console.WriteLine("Ternary demo: " + isTrue);
|
||||
|
||||
|
||||
// While loop
|
||||
int fooWhile = 0;
|
||||
while (fooWhile < 100)
|
||||
{
|
||||
//Console.WriteLine(fooWhile);
|
||||
//Increment the counter
|
||||
//Iterated 99 times, fooWhile 0->99
|
||||
fooWhile++;
|
||||
}
|
||||
Console.WriteLine("fooWhile Value: " + fooWhile);
|
||||
|
||||
// Do While Loop
|
||||
int fooDoWhile = 0;
|
||||
do
|
||||
{
|
||||
//Console.WriteLine(fooDoWhile);
|
||||
//Increment the counter
|
||||
//Iterated 99 times, fooDoWhile 0->99
|
||||
fooDoWhile++;
|
||||
} while (fooDoWhile < 100);
|
||||
Console.WriteLine("fooDoWhile Value: " + fooDoWhile);
|
||||
|
||||
// For Loop
|
||||
int fooFor;
|
||||
//for loop structure => for(<start_statement>; <conditional>; <step>)
|
||||
for (fooFor = 0; fooFor < 10; fooFor++)
|
||||
for (int fooFor = 0; fooFor < 10; fooFor++)
|
||||
{
|
||||
//Console.WriteLine(fooFor);
|
||||
//Iterated 10 times, fooFor 0->9
|
||||
}
|
||||
Console.WriteLine("fooFor Value: " + fooFor);
|
||||
|
||||
// For Each Loop
|
||||
|
||||
// For Each Loop
|
||||
// foreach loop structure => foreach(<iteratorType> <iteratorName> in <enumerable>)
|
||||
// The foreach loop loops over any object implementing IEnumerable or IEnumerable<T>
|
||||
// All the collection types (Array, List, Dictionary...) in the .Net framework
|
||||
// implement one or both of these interfaces.
|
||||
// (The ToCharArray() could be removed, because a string also implements IEnumerable)
|
||||
// The foreach loop loops over any object implementing IEnumerable or IEnumerable<T>
|
||||
// All the collection types (Array, List, Dictionary...) in the .Net framework
|
||||
// implement one or both of these interfaces.
|
||||
// (The ToCharArray() could be removed, because a string also implements IEnumerable)
|
||||
foreach (char character in "Hello World".ToCharArray())
|
||||
{
|
||||
//Console.WriteLine(character);
|
||||
//Iterated over all the characters in the string
|
||||
}
|
||||
|
||||
@ -356,20 +279,18 @@ namespace Learning
|
||||
case 3:
|
||||
monthString = "March";
|
||||
break;
|
||||
// You can assign more than one case to an action
|
||||
// But you can't add an action without a break before another case
|
||||
// (if you want to do this, you would have to explicitly add a goto case x
|
||||
case 6:
|
||||
case 7:
|
||||
case 8:
|
||||
monthString = "Summer time!!";
|
||||
break;
|
||||
// You can assign more than one case to an action
|
||||
// But you can't add an action without a break before another case
|
||||
// (if you want to do this, you would have to explicitly add a goto case x
|
||||
case 6:
|
||||
case 7:
|
||||
case 8:
|
||||
monthString = "Summer time!!";
|
||||
break;
|
||||
default:
|
||||
monthString = "Some other month";
|
||||
break;
|
||||
}
|
||||
Console.WriteLine("Switch Case Result: " + monthString);
|
||||
|
||||
|
||||
///////////////////////////////////////
|
||||
// Converting Data Types And Typecasting
|
||||
@ -384,46 +305,227 @@ namespace Learning
|
||||
// try parse will default to type default on failure
|
||||
// in this case: 0
|
||||
int tryInt;
|
||||
int.TryParse("123", out tryInt);
|
||||
if (int.TryParse("123", out tryInt)) // Funciton is boolean
|
||||
Console.WriteLine(tryInt); // 123
|
||||
|
||||
// Convert Integer To String
|
||||
// Convert class has a number of methods to facilitate conversions
|
||||
Convert.ToString(123);
|
||||
// or
|
||||
tryInt.ToString();
|
||||
}
|
||||
|
||||
///////////////////////////////////////
|
||||
// Classes And Functions
|
||||
///////////////////////////////////////
|
||||
|
||||
Console.WriteLine("\n->Classes & Functions");
|
||||
|
||||
// (definition of the Bicycle class follows)
|
||||
///////////////////////////////////////
|
||||
// CLASSES - see definitions at end of file
|
||||
///////////////////////////////////////
|
||||
public static void Classes()
|
||||
{
|
||||
// See Declaration of objects at end of file
|
||||
|
||||
// Use new to instantiate a class
|
||||
Bicycle trek = new Bicycle();
|
||||
|
||||
// Call object methods
|
||||
trek.speedUp(3); // You should always use setter and getter methods
|
||||
trek.setCadence(100);
|
||||
trek.SpeedUp(3); // You should always use setter and getter methods
|
||||
trek.Cadence = 100;
|
||||
|
||||
// ToString is a convention to display the value of this Object.
|
||||
Console.WriteLine("trek info: " + trek.ToString());
|
||||
|
||||
// Instantiate another new Bicycle
|
||||
Bicycle octo = new Bicycle(5, 10);
|
||||
Console.WriteLine("octo info: " + octo.ToString());
|
||||
Console.WriteLine("trek info: " + trek.Info());
|
||||
|
||||
// Instantiate a new Penny Farthing
|
||||
PennyFarthing funbike = new PennyFarthing(1, 10);
|
||||
Console.WriteLine("funbike info: " + funbike.ToString());
|
||||
Console.WriteLine("funbike info: " + funbike.Info());
|
||||
|
||||
Console.Read();
|
||||
} // End main method
|
||||
|
||||
// CONSOLE ENTRY A console application must have a main method as an entry point
|
||||
public static void Main(string[] args)
|
||||
{
|
||||
OtherInterestingFeatures();
|
||||
}
|
||||
|
||||
//
|
||||
// INTERESTING FEATURES
|
||||
//
|
||||
|
||||
// DEFAULT METHOD SIGNATURES
|
||||
|
||||
public // Visibility
|
||||
static // Allows for direct call on class without object
|
||||
int // Return Type,
|
||||
MethodSignatures(
|
||||
int maxCount, // First variable, expects an int
|
||||
int count = 0, // will default the value to 0 if not passed in
|
||||
int another = 3,
|
||||
params string[] otherParams // captures all other parameters passed to method
|
||||
)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Methods can have the same name, as long as the signature is unique
|
||||
public static void MethodSignature(string maxCount)
|
||||
{
|
||||
}
|
||||
|
||||
// TEMPLATES
|
||||
// The classes for TKey and TValue is specified by the user calling this function.
|
||||
// This method emulates the SetDefault of Python
|
||||
public static TValue SetDefault<TKey, TValue>(
|
||||
IDictionary<TKey, TValue> dictionary,
|
||||
TKey key,
|
||||
TValue defaultItem)
|
||||
{
|
||||
TValue result;
|
||||
if (!dictionary.TryGetValue(key, out result))
|
||||
return dictionary[key] = defaultItem;
|
||||
return result;
|
||||
}
|
||||
|
||||
// You can narrow down the objects that are passed in
|
||||
public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
|
||||
{
|
||||
// We can iterate, since T is a IEnumerable
|
||||
foreach (var item in toPrint)
|
||||
// Item is an int
|
||||
Console.WriteLine(item.ToString());
|
||||
}
|
||||
|
||||
public static void OtherInterestingFeatures()
|
||||
{
|
||||
// OPTIONAL PARAMETERS
|
||||
MethodSignatures(3, 1, 3, "Some", "Extra", "Strings");
|
||||
MethodSignatures(3, another: 3); // explicity set a parameter, skipping optional ones
|
||||
|
||||
// EXTENSION METHODS
|
||||
int i = 3;
|
||||
i.Print(); // Defined below
|
||||
|
||||
// NULLABLE TYPES - great for database interaction / return values
|
||||
// any value type (i.e. not a class) can be made nullable by suffixing a ?
|
||||
// <type>? <var name> = <value>
|
||||
int? nullable = null; // short hand for Nullable<int>
|
||||
Console.WriteLine("Nullable variable: " + nullable);
|
||||
bool hasValue = nullable.HasValue; // true if not null
|
||||
|
||||
// ?? is syntactic sugar for specifying default value (coalesce)
|
||||
// in case variable is null
|
||||
int notNullable = nullable ?? 0; // 0
|
||||
|
||||
// IMPLICITLY TYPED VARIABLES - you can let the compiler work out what the type is:
|
||||
var magic = "magic is a string, at compile time, so you still get type safety";
|
||||
// magic = 9; will not work as magic is a string, not an int
|
||||
|
||||
// TEMPLATES
|
||||
var phonebook = new Dictionary<string, string>() {
|
||||
{"Sarah", "212 555 5555"} // Add some entries to the phone book
|
||||
};
|
||||
|
||||
// Calling SETDEFAULT defined as a template above
|
||||
Console.WriteLine(SetDefault<string,string>(phonebook, "Shaun", "No Phone")); // No Phone
|
||||
// nb, you don't need to specify the TKey and TValue since they can be
|
||||
// derived implicitly
|
||||
Console.WriteLine(SetDefault(phonebook, "Sarah", "No Phone")); // 212 555 5555
|
||||
|
||||
// LAMBDA EXPRESSIONS - allow you to write code in line
|
||||
Func<int, int> square = (x) => x * x; // Last T item is the return value
|
||||
Console.WriteLine(square(3)); // 9
|
||||
|
||||
// PARALLEL FRAMEWORK
|
||||
// http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx
|
||||
var websites = new string[] {
|
||||
"http://www.google.com", "http://www.reddit.com",
|
||||
"http://www.shaunmccarthy.com"
|
||||
};
|
||||
var responses = new Dictionary<string, string>();
|
||||
|
||||
// Will spin up separate threads for each request, and join on them
|
||||
// before going to the next step!
|
||||
Parallel.ForEach(websites,
|
||||
new ParallelOptions() {MaxDegreeOfParallelism = 3}, // max of 3 threads
|
||||
website =>
|
||||
{
|
||||
// Do something that takes a long time on the file
|
||||
using (var r = WebRequest.Create(new Uri(website)).GetResponse())
|
||||
{
|
||||
responses[website] = r.ContentType;
|
||||
}
|
||||
});
|
||||
|
||||
// This won't happen till after all requests have been completed
|
||||
foreach (var key in responses.Keys)
|
||||
Console.WriteLine("{0}:{1}", key, responses[key]);
|
||||
|
||||
// DYNAMIC OBJECTS (great for working with other languages)
|
||||
dynamic student = new ExpandoObject();
|
||||
student.FirstName = "First Name"; // No need to define class first!
|
||||
|
||||
// You can even add methods (returns a string, and takes in a string)
|
||||
student.Introduce = new Func<string, string>(
|
||||
(introduceTo) => string.Format("Hey {0}, this is {1}", student.FirstName, introduceTo));
|
||||
Console.WriteLine(student.Introduce("Beth"));
|
||||
|
||||
// IQUERYABLE<T> - almost all collections implement this, which gives you a lot of
|
||||
// very useful Map / Filter / Reduce style methods
|
||||
var bikes = new List<Bicycle>();
|
||||
bikes.Sort(); // Sorts the array
|
||||
bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // Sorts based on wheels
|
||||
var result = bikes
|
||||
.Where(b => b.Wheels > 3) // Filters - chainable (returns IQueryable of previous type)
|
||||
.Where(b => b.IsBroken && b.HasTassles)
|
||||
.Select(b => b.ToString()); // Map - we only this selects, so result is a IQueryable<string>
|
||||
|
||||
var sum = bikes.Sum(b => b.Wheels); // Reduce - sums all the wheels in the collection
|
||||
|
||||
// Create a list of IMPLICIT objects based on some parameters of the bike
|
||||
var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles });
|
||||
// Hard to show here, but you get type ahead completion since the compiler can implicitly work
|
||||
// out the types above!
|
||||
foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome))
|
||||
Console.WriteLine(bikeSummary.Name);
|
||||
|
||||
// ASPARALLEL
|
||||
// And this is where things get wicked - combines linq and parallel operations
|
||||
var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);
|
||||
// this will happen in parallel! Threads will automagically be spun up and the
|
||||
// results divvied amongst them! Amazing for large datasets when you have lots of
|
||||
// cores
|
||||
|
||||
// LINQ - maps a store to IQueryable<T> objects, with delayed execution
|
||||
// e.g. LinqToSql - maps to a database, LinqToXml maps to an xml document
|
||||
var db = new BikeRespository();
|
||||
|
||||
// execution is delayed, which is great when querying a database
|
||||
var fitler = db.Bikes.Where(b => b.HasTassles); // no query run
|
||||
if (42 > 6) // You can keep adding filters, even conditionally - great for "advanced search" functionality
|
||||
fitler = fitler.Where(b => b.IsBroken); // no query run
|
||||
|
||||
var query = fitler
|
||||
.OrderBy(b => b.Wheels)
|
||||
.ThenBy(b => b.Name)
|
||||
.Select(b => b.Name); // still no query run
|
||||
|
||||
// Now the query runs, but opens a reader, so only populates are you iterate through
|
||||
foreach (string bike in query)
|
||||
Console.WriteLine(result);
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
} // End LearnCSharp class
|
||||
|
||||
// You can include other classes in a .cs file
|
||||
|
||||
public static class Extensions
|
||||
{
|
||||
// EXTENSION FUNCTIONS
|
||||
public static void Print(this object obj)
|
||||
{
|
||||
Console.WriteLine(obj.ToString());
|
||||
}
|
||||
}
|
||||
|
||||
// Class Declaration Syntax:
|
||||
// <public/private/protected/internal> class <class name>{
|
||||
@ -434,64 +536,88 @@ namespace Learning
|
||||
public class Bicycle
|
||||
{
|
||||
// Bicycle's Fields/Variables
|
||||
public int cadence; // Public: Can be accessed from anywhere
|
||||
private int _speed; // Private: Only accessible from within the class
|
||||
protected int gear; // Protected: Accessible from the class and subclasses
|
||||
internal int wheels; // Internal: Accessible from within the assembly
|
||||
string name; // Everything is private by default: Only accessible from within this class
|
||||
public int Cadence // Public: Can be accessed from anywhere
|
||||
{
|
||||
get // get - define a method to retrieve the property
|
||||
{
|
||||
return _cadence;
|
||||
}
|
||||
set // set - define a method to set a proprety
|
||||
{
|
||||
_cadence = value; // Value is the value passed in to to the setter
|
||||
}
|
||||
}
|
||||
private int _cadence;
|
||||
|
||||
protected virtual int Gear // Protected: Accessible from the class and subclasses
|
||||
{
|
||||
get; // creates an auto property so you don't need a member field
|
||||
set;
|
||||
}
|
||||
|
||||
internal int Wheels // Internal: Accessible from within the assembly
|
||||
{
|
||||
get;
|
||||
private set; // You can set modifiers on the get/set methods
|
||||
}
|
||||
|
||||
int _speed; // Everything is private by default: Only accessible from within this class.
|
||||
// can also use keyword privatee
|
||||
public string Name { get; set; }
|
||||
|
||||
// Enum is a value type that consists of a set of named constants
|
||||
// It is really just mapping a name to a value (an int, unless specified otherwise).
|
||||
// The approved types for an enum are byte, sbyte, short, ushort, int, uint, long, or ulong.
|
||||
// An enum can't contain the same value twice.
|
||||
public enum Brand
|
||||
// It is really just mapping a name to a value (an int, unless specified otherwise).
|
||||
// The approved types for an enum are byte, sbyte, short, ushort, int, uint, long, or ulong.
|
||||
// An enum can't contain the same value twice.
|
||||
public enum BikeBrand
|
||||
{
|
||||
AIST,
|
||||
BMC,
|
||||
Electra=42, //you can explicitly set a value to a name
|
||||
Electra = 42, //you can explicitly set a value to a name
|
||||
Gitane
|
||||
}
|
||||
// We defined this type inside a Bicycle class, so it is a nested type
|
||||
// Code outside of this class should reference this type as Bicycle.Brand
|
||||
|
||||
public Brand brand; // After declaring an enum type, we can declare the field of this type
|
||||
public BikeBrand Brand; // After declaring an enum type, we can declare the field of this type
|
||||
|
||||
// Static members belong to the type itself rather then specific object.
|
||||
static public int bicyclesCreated = 0;
|
||||
// You can access them without a reference to any object:
|
||||
// Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated);
|
||||
static public int BicyclesCreated = 0;
|
||||
|
||||
// readonly values are set at run time
|
||||
// they can only be assigned upon declaration or in a constructor
|
||||
readonly bool hasCardsInSpokes = false; // read-only private
|
||||
readonly bool _hasCardsInSpokes = false; // read-only private
|
||||
|
||||
// Constructors are a way of creating classes
|
||||
// This is a default constructor
|
||||
private Bicycle()
|
||||
public Bicycle()
|
||||
{
|
||||
gear = 1;
|
||||
cadence = 50;
|
||||
this.Gear = 1; // you can access mmebers of the object with the keyword this
|
||||
Cadence = 50; // but you don't always need it
|
||||
_speed = 5;
|
||||
name = "Bontrager";
|
||||
brand = Brand.AIST;
|
||||
bicyclesCreated++;
|
||||
Name = "Bontrager";
|
||||
Brand = BikeBrand.AIST;
|
||||
BicyclesCreated++;
|
||||
}
|
||||
|
||||
// This is a specified constructor (it contains arguments)
|
||||
public Bicycle(int startCadence, int startSpeed, int startGear,
|
||||
string name, bool hasCardsInSpokes, Brand brand)
|
||||
string name, bool hasCardsInSpokes, BikeBrand brand)
|
||||
: base() // calls base first
|
||||
{
|
||||
this.gear = startGear; // "this" keyword denotes the current object
|
||||
this.cadence = startCadence;
|
||||
this._speed = startSpeed;
|
||||
this.name = name; // it can be useful when there's a name conflict
|
||||
this.hasCardsInSpokes = hasCardsInSpokes;
|
||||
this.brand = brand;
|
||||
Gear = startGear;
|
||||
Cadence = startCadence;
|
||||
_speed = startSpeed;
|
||||
Name = name;
|
||||
_hasCardsInSpokes = hasCardsInSpokes;
|
||||
Brand = brand;
|
||||
}
|
||||
|
||||
// Constructors can be chained
|
||||
public Bicycle(int startCadence, int startSpeed, Brand brand) :
|
||||
this(startCadence, startSpeed, 0, "big wheels", true)
|
||||
public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :
|
||||
this(startCadence, startSpeed, 0, "big wheels", true, brand)
|
||||
{
|
||||
}
|
||||
|
||||
@ -501,27 +627,8 @@ namespace Learning
|
||||
// classes can implement getters and setters for their fields
|
||||
// or they can implement properties (this is the preferred way in C#)
|
||||
|
||||
// Method declaration syntax:
|
||||
// <scope> <return type> <method name>(<args>)
|
||||
public int GetCadence()
|
||||
{
|
||||
return cadence;
|
||||
}
|
||||
|
||||
// void methods require no return statement
|
||||
public void SetCadence(int newValue)
|
||||
{
|
||||
cadence = newValue;
|
||||
}
|
||||
|
||||
// virtual keyword indicates this method can be overridden in a derived class
|
||||
public virtual void SetGear(int newValue)
|
||||
{
|
||||
gear = newValue;
|
||||
}
|
||||
|
||||
// Method parameters can have default values.
|
||||
// In this case, methods can be called with these parameters omitted
|
||||
// In this case, methods can be called with these parameters omitted
|
||||
public void SpeedUp(int increment = 1)
|
||||
{
|
||||
_speed += increment;
|
||||
@ -541,12 +648,12 @@ namespace Learning
|
||||
get { return _hasTassles; }
|
||||
set { _hasTassles = value; }
|
||||
}
|
||||
|
||||
// You can also define an automatic property in one line
|
||||
// this syntax will create a backing field automatically.
|
||||
// You can set an access modifier on either the getter or the setter (or both)
|
||||
// to restrict its access:
|
||||
public bool IsBroken { get; private set; }
|
||||
|
||||
// You can also define an automatic property in one line
|
||||
// this syntax will create a backing field automatically.
|
||||
// You can set an access modifier on either the getter or the setter (or both)
|
||||
// to restrict its access:
|
||||
public bool IsBroken { get; private set; }
|
||||
|
||||
// Properties can be auto-implemented
|
||||
public int FrameSize
|
||||
@ -558,13 +665,13 @@ namespace Learning
|
||||
}
|
||||
|
||||
//Method to display the attribute values of this Object.
|
||||
public override string ToString()
|
||||
public virtual string Info()
|
||||
{
|
||||
return "gear: " + gear +
|
||||
" cadence: " + cadence +
|
||||
" speed: " + _speed +
|
||||
" name: " + name +
|
||||
" cards in spokes: " + (hasCardsInSpokes ? "yes" : "no") +
|
||||
return "Gear: " + Gear +
|
||||
" Cadence: " + Cadence +
|
||||
" Speed: " + _speed +
|
||||
" Name: " + Name +
|
||||
" Cards in Spokes: " + (_hasCardsInSpokes ? "yes" : "no") +
|
||||
"\n------------------------------\n"
|
||||
;
|
||||
}
|
||||
@ -573,9 +680,10 @@ namespace Learning
|
||||
public static bool DidWeCreateEnoughBycles()
|
||||
{
|
||||
// Within a static method, we only can reference static class members
|
||||
return bicyclesCreated > 9000;
|
||||
return BicyclesCreated > 9000;
|
||||
} // If your class only needs static members, consider marking the class itself as static.
|
||||
|
||||
|
||||
} // end class Bicycle
|
||||
|
||||
// PennyFarthing is a subclass of Bicycle
|
||||
@ -586,20 +694,27 @@ namespace Learning
|
||||
|
||||
// calling parent constructor
|
||||
public PennyFarthing(int startCadence, int startSpeed) :
|
||||
base(startCadence, startSpeed, 0, "PennyFarthing", true)
|
||||
base(startCadence, startSpeed, 0, "PennyFarthing", true, BikeBrand.Electra)
|
||||
{
|
||||
}
|
||||
|
||||
public override void SetGear(int gear)
|
||||
protected override int Gear
|
||||
{
|
||||
gear = 0;
|
||||
get
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
set
|
||||
{
|
||||
throw new ArgumentException("You can't change gears on a PennyFarthing");
|
||||
}
|
||||
}
|
||||
|
||||
public override string ToString()
|
||||
public override string Info()
|
||||
{
|
||||
string result = "PennyFarthing bicycle ";
|
||||
result += base.ToString(); // Calling the base version of the method
|
||||
return reuslt;
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
@ -624,7 +739,7 @@ namespace Learning
|
||||
damage += meters;
|
||||
}
|
||||
|
||||
public void Broken
|
||||
public bool Broken
|
||||
{
|
||||
get
|
||||
{
|
||||
@ -632,24 +747,34 @@ namespace Learning
|
||||
}
|
||||
}
|
||||
}
|
||||
} // End Namespace
|
||||
|
||||
/// <summary>
|
||||
/// Used to connect to DB for LinqToSql example.
|
||||
/// EntityFramework Code First is awesome (similar to Ruby's ActiveRecord, but bidirectional)
|
||||
/// http://msdn.microsoft.com/en-us/data/jj193542.aspx
|
||||
/// </summary>
|
||||
public class BikeRespository : DbSet
|
||||
{
|
||||
public BikeRespository()
|
||||
: base()
|
||||
{
|
||||
}
|
||||
|
||||
public DbSet<Bicycle> Bikes { get; set; }
|
||||
}
|
||||
} // End Namespace
|
||||
```
|
||||
|
||||
## Topics Not Covered
|
||||
|
||||
* Flags
|
||||
* Attributes
|
||||
* Generics (T), Delegates, Func, Actions, lambda expressions
|
||||
* Static properties
|
||||
* Exceptions, Abstraction
|
||||
* LINQ
|
||||
* ASP.NET (Web Forms/MVC/WebMatrix)
|
||||
* Winforms
|
||||
* Windows Presentation Foundation (WPF)
|
||||
|
||||
|
||||
|
||||
## Further Reading
|
||||
|
||||
* [DotNetPerls](http://www.dotnetperls.com)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user