Explore topic-wise InterviewSolutions in .

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 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.

<P>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 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 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 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 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 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 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 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 WORD CHECKED is a KEYWORD in C#.

The word checked is a keyword in C#.

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.

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.

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.

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.

This is currently not supported by Visual Studio .NET.

TRY using RegAsm.exe. The general syntax would be: RegAsm. A good DESCRIPTION of RegAsm and its ASSOCIATED switches is located in the .NET SDK docs. Just search on "Assembly Registration Tool".Explain ACID rule of thumb for transactions.

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).

Try using RegAsm.exe. The general syntax would be: RegAsm. A good description of RegAsm and its associated switches is located in the .NET SDK docs. Just search on "Assembly Registration Tool".Explain ACID rule of thumb for transactions.

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).

Unfortunately, this is CURRENTLY not supported in the IDE. To do this from the command line, you must compile your projects into netmodules (/target:module on the C# COMPILER), and then use the command line TOOL al.exe (alink) to link these netmodules together.

Unfortunately, this is currently not supported in the IDE. To do this from the command line, you must compile your projects into netmodules (/target:module on the C# compiler), and then use the command line tool al.exe (alink) to link these netmodules together.

Use a conditional attribute on the method, as shown below:
class Debug
{
[conditional("TRACE")]
public VOID Trace(string s)
{
Console.WriteLine(s);
}
}
class MYCLASS
{
public static void Main()
{
Debug.Trace("hello");
}
}

In this example, the call to Debug.Trace() is made only if the preprocessor symbol TRACE is DEFINED at the call SITE. You can define preprocessor symbols on the command line by using the /D switch. The restriction on conditional methods is that they must have void return type.

Use a conditional attribute on the method, as shown below:
class Debug
{
[conditional("TRACE")]
public void Trace(string s)
{
Console.WriteLine(s);
}
}
class MyClass
{
public static void Main()
{
Debug.Trace("hello");
}
}

In this example, the call to Debug.Trace() is made only if the preprocessor symbol TRACE is defined at the call site. You can define preprocessor symbols on the command line by using the /D switch. The restriction on conditional methods is that they must have void return type.

USE the regasm.exe utility to generate a type LIBRARY (if NEEDED) and the NECESSARY entries in the Windows Registry to make a class available to classic COM clients. Once a class is registered in the Windows Registry with regasm.exe, a COM client can use the class as THOUGH it were a COM class.

Use the regasm.exe utility to generate a type library (if needed) and the necessary entries in the Windows Registry to make a class available to classic COM clients. Once a class is registered in the Windows Registry with regasm.exe, a COM client can use the class as though it were a COM class.

WEB SERVICES MIGHT use it, as WELL as non-Windows applications.

Web Services might use it, as well as non-Windows applications.

When overriding, you CHANGE the method behavior for a derived class. OVERLOADING SIMPLY involves having a method with the same name WITHIN the class.

When overriding, you change the method behavior for a derived class. Overloading simply involves having a method with the same name within the class.

Yes. Here's a simple example:
USING System;
class Class1
{
PRIVATE string[] MyField;
public string[] MyProperty
{
get { return MyField; }
set { MyField = VALUE; }
}
}
class MainClass
{
public static int Main(string[] args)
{
Class1 c = new Class1();
string[] arr = new string[] {"APPLE", "banana"};
c.MyProperty = arr;
Console.WriteLine(c.MyProperty[0]); // "apple"
return 0;
}
}

Yes. Here's a simple example:
using System;
class Class1
{
private string[] MyField;
public string[] MyProperty
{
get { return MyField; }
set { MyField = value; }
}
}
class MainClass
{
public static int Main(string[] args)
{
Class1 c = new Class1();
string[] arr = new string[] {"apple", "banana"};
c.MyProperty = arr;
Console.WriteLine(c.MyProperty[0]); // "apple"
return 0;
}
}

YES. SET all references to null and then call System.GC.Collect(). If you need to have some OBJECTS DESTRUCTED, and System.GC.Collect() doesn't seem to be doing it for you, you can force finalizers to be RUN by setting all the references to the object to null and then calling System.GC.RunFinalizers().

Yes. Set all references to null and then call System.GC.Collect(). If you need to have some objects destructed, and System.GC.Collect() doesn't seem to be doing it for you, you can force finalizers to be run by setting all the references to the object to null and then calling System.GC.RunFinalizers().

Yes. The .NET class LIBRARIES PROVIDE support for REGULAR expressions. Look at the documentation for the SYSTEM. Text.Regular Expressions NAMESPACE.

Yes. The .NET class libraries provide support for regular expressions. Look at the documentation for the System. Text.Regular Expressions namespace.

Yes. Try-catch-finally blocks are supported by the C# compiler. Here's an example of a try-catch-finally block:
using SYSTEM;
public class TryTest
{
static void MAIN()
{
try
{
Console.WriteLine("In Try block");
throw new ArgumentException();
}
catch(ArgumentException n1)
{
Console.WriteLine("Catch Block");
}
finally
{
Console.WriteLine("Finally Block");
}
}
}
Output: In Try Block
Catch Block
Finally Block

If I return out of a try/finally in C#, does the code in the finally-clause run? Yes. The code in the finally always runs. If you return out of the try block, or even if you do a "goto" out of the try, the finally block always runs, as shown in the following example:
using System;
class main
{
public static void Main()
{
try
{
Console.WriteLine("In Try block");
return;
}
finally
{
Console.WriteLine("In Finally block");
}
}
}

Both "In Try block" and "In Finally block" will be displayed. Whether the return is in the try block or after the try-finally block, performance is not affected either WAY. The compiler treats it as if the return were OUTSIDE the try block anyway. If it's a return without an expression (as it is above), the IL emitted is identical whether the return is inside or outside of the try. If the return has an expression, there's an extra store/load of the value of the expression (since it has to be computed within the try block).

Yes. Try-catch-finally blocks are supported by the C# compiler. Here's an example of a try-catch-finally block:
using System;
public class TryTest
{
static void Main()
{
try
{
Console.WriteLine("In Try block");
throw new ArgumentException();
}
catch(ArgumentException n1)
{
Console.WriteLine("Catch Block");
}
finally
{
Console.WriteLine("Finally Block");
}
}
}
Output: In Try Block
Catch Block
Finally Block

If I return out of a try/finally in C#, does the code in the finally-clause run? Yes. The code in the finally always runs. If you return out of the try block, or even if you do a "goto" out of the try, the finally block always runs, as shown in the following example:
using System;
class main
{
public static void Main()
{
try
{
Console.WriteLine("In Try block");
return;
}
finally
{
Console.WriteLine("In Finally block");
}
}
}

Both "In Try block" and "In Finally block" will be displayed. Whether the return is in the try block or after the try-finally block, performance is not affected either way. The compiler treats it as if the return were outside the try block anyway. If it's a return without an expression (as it is above), the IL emitted is identical whether the return is inside or outside of the try. If the return has an expression, there's an extra store/load of the value of the expression (since it has to be computed within the try block).

You NEED to USE the /TARGET:LIBRARY compiler option.

You need to use the /target:library compiler option.

You should DECLARE the variable as an int, but when you pass it in you MUST specify it as 'out', like the FOLLOWING:
int i;
foo(out i);
where foo is declared as FOLLOWS:
[return-type] foo(out int o) { }

You should declare the variable as an int, but when you pass it in you must specify it as 'out', like the following:
int i;
foo(out i);
where foo is declared as follows:
[return-type] foo(out int o) { }

Yes, you can USE System.Environment.Exit(INT exitCode) to exit the application or Application.Exit() if it's a WINDOWS Forms APP.

Yes, you can use System.Environment.Exit(int exitCode) to exit the application or Application.Exit() if it's a Windows Forms app.

USE publisher policy. To CONFIGURE a publisher policy, use the publisher policy configuration file, which uses a format similar app .CONFIG file. But unlike the app .config file, a publisher policy file needs to be compiled into an assembly and PLACED in the GAC.

Use publisher policy. To configure a publisher policy, use the publisher policy configuration file, which uses a format similar app .config file. But unlike the app .config file, a publisher policy file needs to be compiled into an assembly and placed in the GAC.

Yes, remember that GAC is a very special FOLDER, and while normally you WOULD not be able to place two files with the same name into a Windows folder, GAC differentiates by version number as WELL, so it’s possible for MyApp.dll and MyApp.dll to co-exist in GAC if the first one is version 1.0.0.0 and the second one is 1.1.0.0.

Yes, remember that GAC is a very special folder, and while normally you would not be able to place two files with the same name into a Windows folder, GAC differentiates by version number as well, so it’s possible for MyApp.dll and MyApp.dll to co-exist in GAC if the first one is version 1.0.0.0 and the second one is 1.1.0.0.

USUALLY C:\winnt\assembly or C:\windows\assembly.

Usually C:\winnt\assembly or C:\windows\assembly.

With the HELP of STRONG NAME TOOL (sn.exe).

With the help of Strong Name tool (sn.exe).

GLOBAL ASSEMBLY CACHE.

Global assembly cache.

Use the Assembly BINDING Log VIEWER (fuslogvw.exe) to FIND out the paths SEARCHED.

Use the Assembly Binding Log Viewer (fuslogvw.exe) to find out the paths searched.

USE the directive in the XML .CONFIG file for a given application.
< PROBING privatePath=c:\mylibs; bin\debug />
should do the trick. Or you can add additional SEARCH paths in the Properties box of the deployed application.

Use the directive in the XML .config file for a given application.
< probing privatePath=c:\mylibs; bin\debug />
should do the trick. Or you can add additional search paths in the Properties box of the deployed application.

A strong name includes the name of the ASSEMBLY, version number, CULTURE identity, and a PUBLIC KEY token.

A strong name includes the name of the assembly, version number, culture identity, and a public key token.

Private assembly is used inside an APPLICATION only and does not have to be identified by a strong name. Shared assembly can be used by MULTIPLE applications and has to have a strong name.

Private assembly is used inside an application only and does not have to be identified by a strong name. Shared assembly can be used by multiple applications and has to have a strong name.

Assemblies are the smallest units of versioning and deployment in the .NET application. Assemblies are also the building blocks for PROGRAMS such as WEB services, Windows services, SERVICED COMPONENTS, and .NET remoting applications.

Assemblies are the smallest units of versioning and deployment in the .NET application. Assemblies are also the building blocks for programs such as Web services, Windows services, serviced components, and .NET remoting applications.

You MUST USE the Missing CLASS and pass Missing.Value (in System.Reflection) for any values that have OPTIONAL parameters.

You must use the Missing class and pass Missing.Value (in System.Reflection) for any values that have optional parameters.

Here’s a quick example of the DllImport attribute in action:

using System.Runtime.InteropServices; 
class C
{
[DllImport(\"user32.dll\")]
PUBLIC static extern INT MessageBoxA(int h, string m, string c, int type);
public static int Main()
{
RETURN MessageBoxA(0, \"Hello World!\", \"Caption\", 0);
}
}

This example shows the minimum REQUIREMENTS for declaring a C# method that is IMPLEMENTED in a native DLL. The method C.MessageBoxA() is declared with the static and external modifiers, and has the DllImport attribute, which tells the compiler that the implementation comes from the user32.dll, using the default name of Message BoxA. For more information, look at the Platform Invoke tutorial in the documentation.

Here’s a quick example of the DllImport attribute in action:

using System.Runtime.InteropServices; 
class C
{
[DllImport(\"user32.dll\")]
public static extern int MessageBoxA(int h, string m, string c, int type);
public static int Main()
{
return MessageBoxA(0, \"Hello World!\", \"Caption\", 0);
}
}

This example shows the minimum requirements for declaring a C# method that is implemented in a native DLL. The method C.MessageBoxA() is declared with the static and external modifiers, and has the DllImport attribute, which tells the compiler that the implementation comes from the user32.dll, using the default name of Message BoxA. For more information, look at the Platform Invoke tutorial in the documentation.

You WANT the LOCK statement, which is the same as Monitor Enter/Exit:
lock(OBJ) { // code }
translates to
TRY {
CriticalSection.Enter(obj);
// code
}
finally
{
CriticalSection.Exit(obj);
}

You want the lock statement, which is the same as Monitor Enter/Exit:
lock(obj) { // code }
translates to
try {
CriticalSection.Enter(obj);
// code
}
finally
{
CriticalSection.Exit(obj);
}

[OBSOLETE] public int FOO() {...}
or
[Obsolete(\"This is a MESSAGE describing why this method is obsolete\")] public int Foo() {...}
NOTE: The O in Obsolete is always capitalized.

[Obsolete] public int Foo() {...}
or
[Obsolete(\"This is a message describing why this method is obsolete\")] public int Foo() {...}
Note: The O in Obsolete is always capitalized.

Global attributes must APPEAR after any top-level using CLAUSES and before the first type or namespace declarations. An example of this is as follows:
using System;
[ASSEMBLY : MyAttributeClass] class X {}
Note that in an IDE-created PROJECT, by convention, these attributes are placed in AssemblyInfo.cs.

Global attributes must appear after any top-level using clauses and before the first type or namespace declarations. An example of this is as follows:
using System;
[assembly : MyAttributeClass] class X {}
Note that in an IDE-created project, by convention, these attributes are placed in AssemblyInfo.cs.

In the past, you had to call .ToString() on the strings when using the == or != operators to compare the strings’ values. That will still work, but the C# compiler now automatically compares the values instead of the references when the == or != operators are used on string types. If you actually do want to compare references, it can be DONE as follows: if ((object) str1 == (object) STR2) { } Here’s an example showing how string compares work:
using System;
public class StringTest
{
public static void Main(string[] args)
{
Object nullObj = NULL; Object realObj = new StringTest();
int i = 10;
Console.WriteLine(\"Null Object is [\" + nullObj + \"]\n\" + \"Real Object is [\" + realObj + \"]\n\" + \"i is [\" + i + \"]\n\");
// Show string EQUALITY operators
string str1 = \"foo\";
string str2 = \"bar\";
string STR3 = \"bar\";
Console.WriteLine(\"{0} == {1} ? {2}\", str1, str2, str1 == str2 );
Console.WriteLine(\"{0} == {1} ? {2}\", str2, str3, str2 == str3 );
}
}

Output:
Null Object is []
Real Object is [StringTest]
i is [10]
foo == bar ? False
bar == bar ? True

In the past, you had to call .ToString() on the strings when using the == or != operators to compare the strings’ values. That will still work, but the C# compiler now automatically compares the values instead of the references when the == or != operators are used on string types. If you actually do want to compare references, it can be done as follows: if ((object) str1 == (object) str2) { } Here’s an example showing how string compares work:
using System;
public class StringTest
{
public static void Main(string[] args)
{
Object nullObj = null; Object realObj = new StringTest();
int i = 10;
Console.WriteLine(\"Null Object is [\" + nullObj + \"]\n\" + \"Real Object is [\" + realObj + \"]\n\" + \"i is [\" + i + \"]\n\");
// Show string equality operators
string str1 = \"foo\";
string str2 = \"bar\";
string str3 = \"bar\";
Console.WriteLine(\"{0} == {1} ? {2}\", str1, str2, str1 == str2 );
Console.WriteLine(\"{0} == {1} ? {2}\", str2, str3, str2 == str3 );
}
}

Output:
Null Object is []
Real Object is [StringTest]
i is [10]
foo == bar ? False
bar == bar ? True

You should declare the VARIABLE as an int, but when you pass it in you MUST specify it as ‘out’, LIKE the following: int i; FOO(out i); where foo is declared as FOLLOWS:
[return-type] foo(out int o) { }

You should declare the variable as an int, but when you pass it in you must specify it as ‘out’, like the following: int i; foo(out i); where foo is declared as follows:
[return-type] foo(out int o) { }

Yes. The code in the FINALLY always runs. If you return out of the try block, or even if you do a goto out of the try, the finally block always runs:
USING System;
class main
{
public static void Main()
{
try
{
Console.WriteLine(\"In Try block\");
return;
}
finally
{
Console.WriteLine(\"In Finally block\");
}
}
}

Both In Try block and In Finally block will be displayed. Whether the return is in the try block or after the try-finally block, performance is not affected either way. The compiler treats it as if the return were OUTSIDE the try block anyway. If it’s a return without an expression (as it is above), the IL emitted is identical whether the return is inside or outside of the try. If the return has an expression, there’s an extra store/load of the value of the expression (since it has to be computed WITHIN the try block).

Yes. The code in the finally always runs. If you return out of the try block, or even if you do a goto out of the try, the finally block always runs:
using System;
class main
{
public static void Main()
{
try
{
Console.WriteLine(\"In Try block\");
return;
}
finally
{
Console.WriteLine(\"In Finally block\");
}
}
}

Both In Try block and In Finally block will be displayed. Whether the return is in the try block or after the try-finally block, performance is not affected either way. The compiler treats it as if the return were outside the try block anyway. If it’s a return without an expression (as it is above), the IL emitted is identical whether the return is inside or outside of the try. If the return has an expression, there’s an extra store/load of the value of the expression (since it has to be computed within the try block).

No. STATIC INDEXERS are not

No. Static indexers are not

No. The access modifier on a PROPERTY applies to both its get and set ACCESSORS. What you NEED to do if you want them to be different is MAKE the property read-only (by only providing a get accessor) and create a private/internal set method that is separate from the property.

No. The access modifier on a property applies to both its get and set accessors. What you need to do if you want them to be different is make the property read-only (by only providing a get accessor) and create a private/internal set method that is separate from the property.

No.

No.

C# (pronounced C-sharp) is a new object oriented LANGUAGE from Microsoft and is derived from C and C++. It also borrows a LOT of concepts from JAVA too including garbage COLLECTION.

C# (pronounced C-sharp) is a new object oriented language from Microsoft and is derived from C and C++. It also borrows a lot of concepts from Java too including garbage collection.

DISPOSE PLACES the CONNECTION backing the MANAGED POOL. So that other objects/class can use the connection for further use.

Dispose places the connection backing the managed pool. So that other objects/class can use the connection for further use.

Windows Authentication is trusted because the username and password are checked with the ACTIVE Directory, the SQL Server authentication is UNTRUSTED, since SQL Server is the only VERIFIER participating in the TRANSACTION.

Windows Authentication is trusted because the username and password are checked with the Active Directory, the SQL Server authentication is untrusted, since SQL Server is the only verifier participating in the transaction.

Let’s say you want to QUERY DATABASE with LIKE for all employees whose NAME STARTS with La. The wildcard character is %, the proper query with LIKE would involve ‘La%’.

Let’s say you want to query database with LIKE for all employees whose name starts with La. The wildcard character is %, the proper query with LIKE would involve ‘La%’.

DOCUMENTATION LOOKS the same. USE Debug class for debug builds, use Trace class for both debug and release builds.

Documentation looks the same. Use Debug class for debug builds, use Trace class for both debug and release builds.

In debug compilation, assert takes in a Boolean CONDITION as a parameter, and SHOWS the ERROR dialog if the condition is false. The PROGRAM proceeds without any INTERRUPTION if the condition is true.

In debug compilation, assert takes in a Boolean condition as a parameter, and shows the error dialog if the condition is false. The program proceeds without any interruption if the condition is true.

Yes, just place a COLON, and then KEYWORD base (parameter LIST to invoke the appropriate CONSTRUCTOR) in the overloaded constructor definition inside the inherited class.

Yes, just place a colon, and then keyword base (parameter list to invoke the appropriate constructor) in the overloaded constructor definition inside the inherited class.