summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--bash.html.markdown9
-rw-r--r--clojure.html.markdown2
-rw-r--r--csharp.html.markdown583
-rw-r--r--es-es/coffeescript-es.html.markdown4
-rw-r--r--fr-fr/python-fr.html.markdown4
-rw-r--r--haskell.html.markdown2
-rw-r--r--vi-vn/git-vi.html.markdown1
-rw-r--r--vi-vn/objective-c-vi.html.markdown4
-rw-r--r--zh-cn/r-cn.html.markdown1
9 files changed, 373 insertions, 237 deletions
diff --git a/bash.html.markdown b/bash.html.markdown
index 276bc31f..d208b957 100644
--- a/bash.html.markdown
+++ b/bash.html.markdown
@@ -117,7 +117,7 @@ done
# You can also define functions
# Definition:
-foo ()
+function foo ()
{
echo "Arguments work just like script arguments: $@"
echo "And: $1 $2..."
@@ -125,6 +125,13 @@ foo ()
return 0
}
+# or simply
+bar ()
+{
+ echo "Another way to declare functions!"
+ return 0
+}
+
# Calling your function
foo "My name is" $NAME
diff --git a/clojure.html.markdown b/clojure.html.markdown
index 779c28ae..7917ab08 100644
--- a/clojure.html.markdown
+++ b/clojure.html.markdown
@@ -376,5 +376,5 @@ Clojuredocs.org has documentation with examples for most core functions:
4Clojure is a great way to build your clojure/FP skills:
[http://www.4clojure.com/](http://www.4clojure.com/)
-Clojure-doc.org (yeah, really) has a number of getting started articles:
+Clojure-doc.org (yes, really) has a number of getting started articles:
[http://clojure-doc.org/](http://clojure-doc.org/)
diff --git a/csharp.html.markdown b/csharp.html.markdown
index 1471b833..87c2f704 100644
--- a/csharp.html.markdown
+++ b/csharp.html.markdown
@@ -3,7 +3,8 @@ language: c#
contributors:
- ["Irfan Charania", "https://github.com/irfancharania"]
- ["Max Yankov", "https://github.com/golergka"]
- - ["Melvyn Laïly", "http://x2a.yt"]
+ - ["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)
diff --git a/es-es/coffeescript-es.html.markdown b/es-es/coffeescript-es.html.markdown
index 78bb9be5..6bf430e6 100644
--- a/es-es/coffeescript-es.html.markdown
+++ b/es-es/coffeescript-es.html.markdown
@@ -44,7 +44,7 @@ math =
# "cube": function(x) { return x * square(x); }
#}
-# Símbolos:
+# Número de argumentos variable:
race = (winner, runners...) ->
print winner, runners
@@ -52,6 +52,6 @@ race = (winner, runners...) ->
alert "I knew it!" if elvis?
#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("I knew it!"); }
-# Colecciones por comprensión:
+# Listas:
cubes = (math.cube num for num in list) #=> ...
```
diff --git a/fr-fr/python-fr.html.markdown b/fr-fr/python-fr.html.markdown
index 2bf0afd0..9dbdafe1 100644
--- a/fr-fr/python-fr.html.markdown
+++ b/fr-fr/python-fr.html.markdown
@@ -156,9 +156,9 @@ li[4] # Lève un 'IndexError'
# On peut accèder à des rangs de valeurs avec la syntaxe "slice"
# (C'est un rang de type 'fermé/ouvert' pour les plus matheux)
li[1:3] #=> [2, 4]
-# Sans spécifier de début de rang
+# Sans spécifier de fin de rang, on "saute" le début de la liste
li[2:] #=> [4, 3]
-# Sans spécifier de fin de rang
+# Sans spécifier de début de rang, on "saute" la fin de la liste
li[:3] #=> [1, 2, 4]
# Retirer un élément spécifique dee la liste avec "del"
diff --git a/haskell.html.markdown b/haskell.html.markdown
index 6b3c6e17..267b40af 100644
--- a/haskell.html.markdown
+++ b/haskell.html.markdown
@@ -11,7 +11,7 @@ makes coding a real joy for me.
```haskell
-- Single line comments start with two dashes.
{- Multiline comments can be enclosed
-en a block like this.
+in a block like this.
-}
----------------------------------------------------
diff --git a/vi-vn/git-vi.html.markdown b/vi-vn/git-vi.html.markdown
index 77fec983..bdb88204 100644
--- a/vi-vn/git-vi.html.markdown
+++ b/vi-vn/git-vi.html.markdown
@@ -4,6 +4,7 @@ tool: git
contributors:
- ["Jake Prather", "http://github.com/JakeHP"]
filename: LearnGit-vi.txt
+lang: vi-vn
---
Git là một hệ quản lý mã nguồn và phiên bản phân tán (distributed version control and source code management system).
diff --git a/vi-vn/objective-c-vi.html.markdown b/vi-vn/objective-c-vi.html.markdown
index f6296ec0..6d19ca02 100644
--- a/vi-vn/objective-c-vi.html.markdown
+++ b/vi-vn/objective-c-vi.html.markdown
@@ -4,7 +4,7 @@ language: Objective-C
contributors:
- ["Eugene Yagrushkin", "www.about.me/yagrushkin"]
- ["Yannick Loriot", "https://github.com/YannickL"]
-lang: vi-vi
+lang: vi-vn
filename: LearnObjectiveC-vi.m
---
@@ -12,7 +12,7 @@ filename: LearnObjectiveC-vi.m
Objective-C là ngôn ngữ lập trình chính được sử dụng bởi Apple cho các hệ điều hành OS X, iOS và các framework tương ứng của họ, Cocoa và Cocoa Touch.
Nó là một ngôn ngữ lập trình mục đích tổng quát, hướng đối tượng có bổ sung thêm kiểu truyền thông điệp giống Smalltalk vào ngôn ngữ lập trình C.
-```objective-c
+```cpp
// Chú thích dòng đơn bắt đầu với //
/*
diff --git a/zh-cn/r-cn.html.markdown b/zh-cn/r-cn.html.markdown
index 8a542695..ed8c43b6 100644
--- a/zh-cn/r-cn.html.markdown
+++ b/zh-cn/r-cn.html.markdown
@@ -7,6 +7,7 @@ translators:
- ["小柒", "http://weibo.com/u/2328126220"]
- ["alswl", "https://github.com/alswl"]
filename: learnr.r
+lang: zh-cn
---
R 是一门统计语言。它有很多数据分析和挖掘程序包。可以用来统计、分析和制图。