I love programming

Dear,

I wish you a very Merry Christmas and Happy New Year.

Sebastian

InfoQ: Apollo Next Generation Message Queuing Posts Some Impressive Benchmarks:

'via Blog this'

Let’s say your program needs to work with a date and time value. Normally you’d use a
DateTime variable. But what if that variable doesn’t always have a value? That’s where
nullable types comes in really handy. All you need to do is add a question mark (?) to the end
of any value type, and it becomes a nullable type that you can set to null.


bool? myNulableInt = null;
DateTime? myNullableDate = null;

You will find out that the question mark T? is an alias for Nullable<T>.

One of the types in .NET we haven’t talked about much is the struct.
struct is short for structure, and structs look a lot like objects.
They have fields and properties, just like objects. And you can even pass
them into a method that takes an object type parameter:
A struct looks like an object…
…but isn’t an object

public struct Dog {
public string Name;
public string Breed;
public Dog(string name, string breed) {
this.Name = name;
this.Breed = breed;
}
public void Speak() {
Console.WriteLine(“My name is {0} and I’m a {1}.”, Name, Breed);
}
}



But structs aren’t objects. They can have methods and fields, but
they can’t have finalizers. They also can’t inherit from other classes or
structs, or have classes or structs inherit from them.


Structs are best used for storing data, but the lack of inheritance and references can be a serious limitation.


But the thing that sets structs apart from objects more than almost anything else is that you copy them by value, not by reference. Which me…

C# has a really useful feature called LINQ (which stands for Language INtegrated Query). The idea behind LINQ is that it gives you a way to take an array, list, stack, queue, or other collection and work with all the data inside it all at once in a single operation. But what’s really great about LINQ is that you can use the same syntax that works with collections as you can for working with database


LINQ makes working with data in collections and databases easy.

- to be updated later...

In .NET, when an exception occurs, an object is created to represent the problem. It’s called, no surprise here, Exception. When your program throws an exception, .NET generates an Exception object.



Exceptions are all about helping you find and fix situations where your code behaves in ways you didn’t expect.


In C#, you can basically say, “Try this code, and if an exception occurs, catch it with this other bit of code.”

I've been using seriazation for several years, this is the best explaination for me about this theory. Yes, It saves the complete state of the object, so that an identical instance can be brought back to life on the heap later!
When an object is serialized, all of the objects it refers to get serialized, too. It is actually very cool.

When a collection implements IEnumerable<T>, It’s giving you a way to write a loop that goes through its contents in order. E.g. When you write a foreach loop, you’re using IEnumerable, as below,


foreach (Duck duck in ducks) {
Console.WriteLine(duck);
}




public Deck(IEnumerable<Card> initialCards) {
cards = new List<Card>(initialCards);
}

The List.Sort() method knows how to sort any type or class that implements the
IComparable<T> interface. That interface has just one member—a method called
CompareTo(). Sort() uses an object’s CompareTo() method to compare it with
other objects, and uses its return value (an int) to determine which comes first.

e.g.

class Duck : IComparable<Duck> {
public int Size;
public KindOfDuck Kind;
public int CompareTo(Duck duckToCompare) {
if (this.Size > duckToCompare.Size)
return 1;
else if (this.Size < duckToCompare.Size)
return -1;
else
return 0;
}
}


List<Duck> ducks = new List<Duck>() {
new Duck() { Kind = KindOfDuck.Mallard, Size = 17 },

....
}
ducks.Sort();



Or you can use IComparer to tell your List how to sort, e.g.


class DuckComparerBySize : IComparer<Duck>
{ public int Compare(Duck x, Duck y)
{ if (x.Size < y.Size)
return -1;
if (x.Size > y.Size)
return 1;
return 0;
} }


DuckComparerBySize sizeComparer = new DuckComparerBySize();
ducks.Sort(s…

A queue is FIFO—First In, First Out


Queue<string> myQueue = new Queue<string>();
myQueue.Enqueue(“first in line”);

A stack is LIFO - Last In, First Out

Java: I guess there is similiar data type, but I've never used them .

A list is like a big long page full of names. But what if you also want, for each name, an
address? Or for every car in the garage list, you want details about that car? You need a
dictionary. A dictionary lets you take a special value—the key—and associate that key
with a bunch of data—the value. And one more thing: a specific key can only appear
once in any dictionary.

Dictionary <Tkey, TValue> kv = new Dictionary <TKey, TValue>()

Java uses Map or table(like HashTable) to deal with key/value case. Still, too many options's in Java World.

List<Shoe> shoeCloset = new List<Shoe>();

shoeCloset.Add(new Shoe()
{ Style = Style.Sneakers, Color = “Black” });

....
foreach (Shoe shoe in shoeCloset) {
...
}
shoeCloset.RemoveAt(4);
if (shoeCloset.Contains(secondShoe))..


Not like java, having many kinds of List, C# only have one, which is way more easier for developers like me to use. Thanks.

Interface names start with I Whenever you create an interface, you should make its name start with an uppercase I. There’s no rule that says you need to do it, but it makes your code a lot easier to understand. You can see for yourself just how much easier that can make your life. Just go into the IDE to any blank line inside any method
and type “I”—IntelliSense shows .NET interfaces.


interface IStingPatrol
{
int AlertLevel { get;}
int StingerLength { get; set;}
bool LookForEnemies();
int SharpenStinger(int length);
}


When you mark a class abstract, C# won’t let you write
code to instantiate it. It’s a lot like an interface—it acts like a
template for the classes that inherit from it.
abstract class abc{}

You extend a class by adding a colon to the end of class declaration, followed by the base class to inherit from.


class Bird {
public void Fly() {
// here’s the code to make the bird fly
}
public void LayEggs() { ... };
public void PreenFeathers() { ... };
}
class Pigeon : Bird {
public void Coo() { ... }
}


A subclass can override methods to change or replace methods it inherited
Sometimes you’ve got a subclass that you’d like to inherit most of the behaviors from the base class, but not all of them. When you want to change the behaviors that a class has inherited, you can override the methods.


A subclass can only override a method if it’s marked with the virtual keyword, which
tells C# to allow the subclass to override methods.

class Bird {
public virtual void Fly() {
// code to make the bird fly
}
}


Add a method with the same name to the derived class
You’ll need to have exactly the same signature—meaning the same return value and
parameters—and you’ll need to use the override keywo…

public const int CostOfFoodPerPerson = 25;
public int NumberOfPeople {
get { return numberOfPeople; }
set {
numberOfPeople = value;  // I think value is a hidden object in the calss.
}
}



Java:
I can only implement the const by define the variable like below,
public final static  int CostOfFoodPerPerson = 25;


Access LevelsModifierClassPackageSubclassWorldpublicYYYYprotectedYYYNno modifierYYNNprivateYNNN

When your code needs to work with an object in memory, it uses a reference, which is a variable whose type is a class of the object it’s going to point to. A reference is like a label that your code uses to talk about a specific object.

This is also apply in Java World. May I say C# is the subset of Java? I guess it's yes in some way.

int can store any whole number from –2,147,483,648 to 2,147,483,647.
string can hold text of any length (including the empty string “”).
bool is a Boolean value—it’s either true or false.
double can store real numbers from ±5.0 × 10−324 to ±1.7 × 10308 with up to
16 significant figures. That range looks weird and complicated, but it’s actually
pretty simple. The “significant figures” part means the precision of the number:
35,048,410,000,000, 1,743,059, 14.43857, and 0.00004374155 all have seven
significant figures.


byte can store any whole number between 0 and 255.
sbyte can store any whole number from –128 to 127
short can store any whole number from –32,768 to 32,767.
ushort can store any whole number from 0 to 65,535.
uint can store any whole number from 0 to 4,294,967,295.
long can store any whole number between minus and plus 9 billion billion.
ulong can store any whole number between 0 and about 18 billion billion.

Java's counterpart,

Primitive TypeSizeMinimum ValueMaximum …