c# questions

81 Is it possible to have different access modifiers on the get/set methods of a 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.

82 Is it possible to have a static indexer in C#?
No. Static indexers are not allowed in C#.

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

84 I was trying to use an "out int" parameter in one of my functions. How should I declare the
variable that I am passing to it?
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) { }

85 How does one compare strings in C#?
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

86 How do you specify a custom attribute for the entire assembly (rather than for a class)?
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.

87 How do you mark a method obsolete?
Assuming you've done a "using System;": [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 capitalized.

88 How do you implement thread synchronization (Object.Wait, Notify,and CriticalSection) in
C#?
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);
}

89 How do you directly call a native function exported from a DLL?
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 MessageBoxA.
For more information, look at the Platform Invoke tutorial in the documentation.

90 How do I simulate optional parameters to COM calls?
You must use the Missing class and pass Missing.Value (in System.Reflection) for any values
that have optional parameters.

91 How do I register my code for use by classic COM clients?
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.

92 How do I port "synchronized" functions from Visual J++ to C#?
Original Visual J++ code: public synchronized void Run()
{
// function body
}
Ported C# code: class C
{
public void Run()
{
lock(this)
{
// function body
}
}
public static void Main() {}
}

93 How do I make a DLL in C#?
You need to use the /target:library compiler option.

94 How do I get deterministic finalization in C#?
In a garbage collected environment, it's impossible to get true determinism. However, a design
pattern that we recommend is implementing IDisposable on any class that contains a critical
resource. Whenever this class is consumed, it may be placed in a using statement, as shown in
the following example:
using(FileStream myFile = File.Open(@"c:temptest.txt",
FileMode.Open))
{
int fileOffset = 0;
while(fileOffset < myFile.Length)
{
Console.Write((char)myFile.ReadByte());
fileOffset++;
}
}
When myFile leaves the lexical scope of the using, its dispose method will be called.

95 How do I do implement a trace and assert?
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.

96 How do I declare inout arguments in C#?
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.

97 How do I create a multilanguage, single-file assembly?
This is currently not supported by Visual Studio .NET.
98 How do I create a multilanguage, multifile assembly?
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.

99 How do I create a Delegate/MulticastDelegate?
C# requires only a single parameter for delegates: the method address. Unlike other languages,
where the programmer must specify an object reference and the method to invoke, C# can infer both pieces of information by just specifying the method's name. For example, let's use
System.Threading.ThreadStart: Foo MyFoo = new Foo();
ThreadStart del = new ThreadStart(MyFoo.Baz);
This means that delegates can invoke static class methods and instance methods with the exact
same syntax!

100 How do I convert a string to an int in C#?
Here's an example: using System;
class StringToInt
{
public static void Main()
{
String s = "105";
www.freshersparadise.com
int x = Convert.ToInt32(s);
Console.WriteLine(x);
}
}