C# (Sharp) Programming Language

Transaction must be Atomic (it is one unit of work and does not dependent on previous and following transactions), Consistent (data is either committed or roll back, no in-between case where something has been updated and something hasnot), Isolated (no transaction sees the intermediate results of the current transaction), Durable (the values persist if the data had been committed even if the system crashes right after).

To the Console or a text file depending on the parameter passed to the constructor.

They all must be public. Therefore, to prevent you from getting the false impression that you have any freedom of choice, you are not allowed to specify any accessibility, it is public by default.

This is currently not supported by Visual Studio .NET.

There is no way to restrict to a namespace. Namespaces are never units of protection. But if you're using assemblies, you can use the 'internal' access modifier to restrict access to only within the assembly.

The tracing dumps can be quite verbose and for some applications that are constantly running you run the risk of overloading the machine and the hard drive there. Five levels range from None to Verbose, allowing to fine-tune the tracing activities.

The syntax for calling another constructor is as follows:

class B

{

B(int i)

{ }

}

class C : B

{

C() : base(5) // call base constructor B(5)

{ }

C(int i) : this() // call C()

{ }

public static void Main() {}

}

The most common problem is that you used a lowercase 'm' when defining the Main method. The correct way to implement the entry point is as follows:

class test

{

static void Main(string[] args) {}

}

The following is a response from a developer on the C# compiler team:

We get rid of unused locals (i.e., locals that are never read, even if assigned).

We get rid of unreachable code.

We get rid of try-catch w/ an empty try.

We get rid of try-finally w/ an empty try (convert to normal code...).

We get rid of try-finally w/ an empty finally (convert to normal code...).

We optimize branches over branches:

gotoif A, lab1

goto lab2:

lab1:

turns into: gotoif !A, lab2

lab1:

We optimize branches to ret, branches to next instruction, and branches to branches.

The following code should run the executable and wait for it to exit before

continuing: using System;

using System.Diagnostics;

public class ProcessTest {

public static void Main(string[] args) {

Process p = Process.Start(args[0]);

p.WaitForExit();

Console.WriteLine(args[0] + " exited.");

}

}

Remember to add a reference to System.Diagnostics.dll when you compile.

The first one performs a deep copy of the array, the second one is shallow.

The equivalent of inout in C# is ref. , as shown in the following

example: public void MyMethod (ref String str1, out String str2)

{

...

}

When calling the method, it would be called like this: String s1;

String s2;

s1 = "Hello";

MyMethod(ref s1, out s2);

Console.WriteLine(s1);

Console.WriteLine(s2);

Notice that you need to specify ref when declaring the function and calling it.

The difference is that static read-only can be modified by the containing class, but const can never be modified and must be initialized to a compile time constant. To expand on the static read-only case a bit, the containing class can only modify it: -- in the variable declaration (through a variable initializer).

-- in the static constructor (instance constructors if it's not static).

The database name to connect to.

System.Object.

Yes, just leave the class public and make the method sealed

Yes, if you are debugging via Visual Studio.NET, just go to Immediate window.

Yes. .NET does support multiple interfaces.

With regard to versioning, interfaces are less flexible than classes. With a class, you can ship version 1 and then, in version 2, decide to add another method. As long as the method is not abstract (i.e., as long as you provide a default implementation of the method), any existing derived classes continue to function with no changes. Because interfaces do not support implementation inheritance, this same pattern does not hold for interfaces. Adding a method to an interface is like adding an abstract method to a base class--any class that implements the interface will break, because the class doesn't implement the new interface method.