.NET

IDisposable Interface

http://maxua.posterous.com/29443490#comment

http://www.bluebytesoftware.com/blog/PermaLink.aspx?guid=88e62cdf-5919-4ac7-bc33-20c06ae539ae

I think LinkedList has complexity to remove element O(1) and NOT O(n).

See MSDN (http://msdn.microsoft.com/en-us/library/he2s3bh7.aspx):

LinkedList provides separate nodes of type LinkedListNode, so insertion and removal are O(1) operations.

Parameters in C# are, by default, passed by value.

out - argument is not required to be initialized before the call but must be assigned a value before exiting the method.

ref - argument is required to be initialized before the call but need not be assigned a value before exiting the method.

When you pass a reference type in C#, you aren't passing the object itself, but the reference to the object.

http://geekswithblogs.net/BlackRabbitCoder/archive/2010/08/05/c-fundamentals-parameters-passing-nuances.aspx

1: public static class Program

2: {

3: public static void Main()

4: {

5: string greetings = "Hi";

7: Console.WriteLine("Greetings before call: " + greetings);

8: ReferenceParameter(greetings);

9: Console.WriteLine("Greetings after call: " + greetings);

10: }

11:

12: public static void ReferenceParameter(string p)

13: {

14: Console.WriteLine("string was passed to ReferenceParameter() as: " + p);

15: p = "Bye";

16: Console.WriteLine("string is leaving ReferenceParameter() as: " + p);

17: }

18: }

We now have two references (greetings and p) that both refer to the original object. The object itself was never passed (since it's a reference type), but the reference was and that reference was copied (pass-by-value).

At the point p was reassigned, it released its reference to the object containing "Hi" (reference count went down to 1) and it was assigned the value of 2000 which refers to a new string object holding "Bye". Now, when the method is ended, the local variable p is destroyed

1: public static class Program

2: {

3: public static void Main()

4: {

5: var fruits = new List<string> { "apple", "banana", "peach" };

7: ChangeFruitsToVegetables(fruits);

9: Console.WriteLine("Fruits after call: ");

10: fruits.ForEach(fruit => Console.WriteLine("\t{0}", fruit));

11: }

12:

13: public static void ChangeFruitsToVegetables(List<string> fruitList)

14: {

15: fruitList.Clear();

16: fruitList.Add("carrot");

17: fruitList.Add("asparagus");

18: fruitList.Add("broccoli");

19: }

20: }

What do we expect from this? The answer: the List<string> object reference named fruits never changed (it was still the same object at the same location), only it's contents changed.

Fruits after call:

carrot

asparagus

broccoli

reference types are passed by value by default, this means the reference is copied and you can't alter the original reference argument in the method, but you can alter the object it refers to (if the object is not immutable).

value types are passed by value by default, this means the entire value is copied and you can't alter the original value argument in the reference.

reference types passed by reference (using ref/out) are not copied but are passed as a reference to the original reference which means you can change the reference itself and alter the object it refers to (if the object is not immutable).

value types passed by reference (using ref/out) are not copied but are passed as a reference to the original value which means you can change the original value itself.

WCF http://msdn.microsoft.com/en-us/library/ee958158.aspx

REST: Rather than exposing a different set of operations to clients for each service, as SOAP does, RESTful applications access everything using the same set of operations. Those operations are defined by the basic verbs in HTTP: GET, POST, PUT, DELETE, and perhaps others. And rather than specifying the data those operations work on via parameters, as is typically done with SOAP, everything—everything—is assigned a URL.

REST assumes HTTP, while SOAP and WS-* are explicitly independent of the mechanism used for communication. (SOAP/WS-* can be used directly over TCP, for example, as in WCF’s NetTcpBinding.)

FOR EACH

http://blogs.msdn.com/b/ericlippert/archive/2009/05/18/foreach-vs-foreach.aspx

WPF http://msdn.microsoft.com/en-us/library/ms754130.aspx

Page updated

Google Sites

Report abuse