Platform Invoke – C#

A platform invoke call to an unmanaged DLL function

When platform invoke calls an unmanaged function, it performs the following sequence of actions:

1. Locates the DLL containing the function.
2. Loads the DLL into memory.
3. Locates the address of the function in memory and pushes its arguments onto the stack, marshaling data as required.
   

   Note   Locating and loading the DLL, and locating the address of the function in memory occur only on the first call to the function.

4. Transfers control to the unmanaged function.

Platform Invoke example below :

using System.Runtime.InteropServices;

public class Win32 {
     [DllImport(“user32.dll”, CharSet=CharSet.Auto)]
     public static extern int MessageBox(int hWnd, String text,
                     String caption, uint type);
}

public class HelloWorld {
    public static void Main() {
       Win32.MessageBox(0, “Hello World”, “Platform Invoke Sample”, 0);
    }
}     

Why C# does not support multiple class inheritance ?

Multiple inheritances are not supported in C#.

Consider the below example.

public class Class1
    {
        public string GetClass()
        {
            return "This is Class1";
        }
    }
    public class Parent2
    {
        public string GetClass()
        {
            return "This is Class2";
        }
    }

    public class SubClass: Class1, Class2
    {
        public string GetCorrectClass()
        {
            return this.GetClass();
        }
    }

Here there are two Parent class Class1 and Class2. This is inherited by Child class SubClass.

In GetCorrectClass method, child class calls the parent class method GetClass(). In such case which method will be executed?

It is very difficult for CLR to identify which method to call. It shows that multiple inheritance will create ambiguity to oops concept. In order to avoid this ambiguity we do not have multiple class inheritance and we have  multiple interface implementations in C#.

What is use of private constructor in C# ?

If a class contains only static members and isn’t intended to be instantiated, adding an empty private instance constructor will prevent instantiation.

CharEnumerator is an object in C# that can be used to enumerate through all the characters of a string.

Sample Code :

string str = “santosh”;
CharEnumerator chs = str.GetEnumerator();
while(chs.MoveNext())
{
Response.Write(chs.Current);
}

The params keyword lets you specify a method parameter that takes a variable number of arguments.

No additional parameters are permitted after the params keyword in a method declaration, and only one params keyword is permitted in a method declaration.

You can send a comma-separated list of arguments of the type specified in the parameter declaration, or an array of arguments of the specified type. You also can send no arguments

Example :
public static void UseParams(params int[] list)
{
for (int i = 0; i < list.Length; i++)
{
Console.Write(list[i] + ” “);
}
Console.WriteLine();
}
We can call above method

Way 1 :
// You can send a comma-separated list of arguments of the specified type.
UseParams(1, 2, 3, 4);

Way 2 :
// An array argument can be passed, as long as the array
// type matches the parameter type of the method being called.

int[] myIntArray = { 5, 6, 7, 8, 9 };
UseParams(myIntArray);

Way 3:
UseParams();