summaryrefslogtreecommitdiffhomepage
path: root/csharp.html.markdown
diff options
context:
space:
mode:
authorAdam <adam@adambard.com>2013-10-27 22:18:31 -0700
committerAdam <adam@adambard.com>2013-10-27 22:18:31 -0700
commitdadd4c2a2bf180dccdc74a89a82cfe42db1cedb9 (patch)
tree94db3c6fd5dc197ce303464f5128696e794d56bf /csharp.html.markdown
parent7ff3de74fe941a220e6fb3e3e3434d90d0d51cc6 (diff)
parent0c523f4e95ef7dabfbd14a6a90f86035e01f75a4 (diff)
Merged with latest from upstream
Diffstat (limited to 'csharp.html.markdown')
-rw-r--r--csharp.html.markdown581
1 files changed, 354 insertions, 227 deletions
diff --git a/csharp.html.markdown b/csharp.html.markdown
index ccc0ffad..87c2f704 100644
--- a/csharp.html.markdown
+++ b/csharp.html.markdown
@@ -4,6 +4,7 @@ contributors:
- ["Irfan Charania", "https://github.com/irfancharania"]
- ["Max Yankov", "https://github.com/golergka"]
- ["Melvyn Laïly", "http://x2a.yt"]
+ - ["Shaun McCarthy", "http://www.shaunmccarthy.com"]
filename: LearnCSharp.cs
---
@@ -23,7 +24,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 +38,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 +52,6 @@ namespace Learning
Console.Write("Hello ");
Console.Write("World");
-
///////////////////////////////////////////////////
// Types & Variables
//
@@ -61,140 +66,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;
+ // Double - Double-precision 64-bit IEEE 754 Floating Point
+ double fooDouble = 123.4; // Precision: 15-16 digits
// 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.
+ float fooFloat = 234.5f; // Precision: 7 digits
+ // f is used to denote that this variable value is of type float
- // 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;
+ // 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 +150,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 generics - 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 +173,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 +204,6 @@ namespace Learning
Console.WriteLine(i--); //i = 1. Post-Decrementation
Console.WriteLine(--i); //i = 0. Pre-Decrementation
-
///////////////////////////////////////
// Control Structures
///////////////////////////////////////
@@ -291,50 +228,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 +280,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 +306,228 @@ 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)
+ {
+ }
+
+ // GENERICS
+ // 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
+
+ // GENERICS
+ //
+ var phonebook = new Dictionary<string, string>() {
+ {"Sarah", "212 555 5555"} // Add some entries to the phone book
+ };
+
+ // Calling SETDEFAULT defined as a generic 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 +538,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 +629,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 +650,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 +667,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 +682,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 +696,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 +741,7 @@ namespace Learning
damage += meters;
}
- public void Broken
+ public bool Broken
{
get
{
@@ -632,24 +749,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)