C#

class Practice
{
    public static string human;
    public static int mind;

    public static void Main()
    {
        human = "Walking & talking life";
        mind = 100;
    }
}

class Continued
{
    public static void notMain()
    {
        MessageBox.Show(Practice.human);
        MessageBox.Show(Practice.mind);
    }
}

using System.Reflection;

Assembly assembly = Assembly.LoadFile("C:\\MyDll.dll");
MyBaseClass cls = assembly.CreateInstance("CLib.Class1");
//do something with cls

<br />
// assuming you load-up the assembly dynamically depending upon the menu press<br />
// i've used mod name 'cause i called the main form of the desired assembly directly and as my assembly is a dll so don't have an entry point exactly so i needed to make one entry point(virtually)<br />
public void invokeProcess (string assemblyName, string strModName) <br />
{<br />
    Assembly assembly = Assembly.LoadFrom (assemblyName);<br />
   <br />
    // Walk through each type in the assembly<br />
    foreach (Type type in assembly.GetTypes ()) <br />
    {<br />
	// Pick up a class<br />
	if (type.IsClass == true) <br />
	{<br />
	    // if it's not using right class skip it<br />
	    if (type.FullName != strModName + "." + strModClass) <br />
	    {<br />
		continue;<br />
	    }<br />
     <br />
	   // create an instance of the object<br />
	   object ibaseObject = Activator.CreateInstance (type);<br />
	   <br />
           // this has been done 'cause i couldn't pass the ref. of main MDI 	directly		<br />
	   frmDummy frmParent = new frmDummy();<br />
	   frmParent.MdiParent = this;<br />
<br />
	   // Create the parameter list ('course without it we won't be able to determine our MDI parent)<br />
	   object[] arguments = new object [] {frmParent};<br />
					<br />
	   // Dynamically Invoke the Object                    <br />
	   foreach (MemberInfo mi in type.GetMember(strModEntry))<br />
	   {<br />
                type.InvokeMember (mi.Name.ToString(), <br />
		BindingFlags.Default | BindingFlags.InvokeMethod,<br />
		null,<br />
		ibaseObject,<br />
		arguments);<br />
	   }<br />
	}<br />
    }<br />
}

private void LoadDLL(string assemblyName)
{
    Assembly assembly = Assembly.LoadFrom (assemblyName);
    // Walk through each type in the assembly
    foreach (Type type in assembly.GetTypes ())
    {
        if (type.IsClass == true)
        {
            object ibaseObject = null ;
            if (type.Name == "frmMenu")
            {
                ibaseObject = Activator.CreateInstance(type);
                Form frmT = (Form)ibaseObject;
                frmT.MdiParent = this;
                frmT.Show();
            }
        }
    } // for each
}

root.SelectSingleNode("Order_Invoice_Outgoing_Array_Element/"
+ "Order_Invoice_Outgoing_Element/interface_transaction").Value

XmlNode firstNode = root.SelectSingleNode("Order_Invoice_Outgoing_Array_Element");
XmlNode secondNode = firstNode.SelectSingleNode("Order_Invoice_Outgoing_Element");
XmlNode thirdNode = secondNode.SelectSingleNode("interface_transaction");
Console.WriteLine(thirdNode.Value);

// Pass a value type by value.
int i = 5;
Test(i);
Debug.WriteLine(i); // prints 5, because a copy is passed to the Test method

void Test(int param)
{
    param = 10;
}

// Pass a reference type by value.
string str = "hello";
Test(str);
Debug.WriteLine(str); // prints hello, because a copy of the reference to the "hello" string was passed to the Test method.

void Test(string param)
{
    param = "world";
}

// Pass a value type by reference
int i = 5;
Test(ref i);
Debug.WriteLine(ref i); // prints 10, because the reference to i was passed to the Test method

void Test(ref int param)
{
    param = 10;
}

// Pass a reference type by reference
string str = "hello";
Test(ref str);
Debug.WriteLine(str); // prints world, because the actual reference to str was passed to the Test method

void Test(ref string param)
{
   param = "world";
}

Tech, life, family, faith: Give me a visit.
I'm currently blogging about: I luv teh choco
The apostle Paul, modernly speaking: Epistles of Paul

Judah Himango

public void DoSomething(int[] values)
{
   values = new int[] { 1, 2, 3 };
   //you are changing the reference of values 
   //so the caller won't notice any difference
}

public void DoSomething(int[] values)
{
   values[0] = 1;
   values[1] = 2;
   values[2] = 3;
   //you are changing the contents of values
   //so the caller will notice the difference
}

public void DoSomething(ref int[] values)
{
   values = new int[] { 1, 2, 3 };
   //you are changing the reference of values and because 
   //of ref the caller will notice the difference
}

public void StartMyThread() 
{
   int param1 = 0;
   bool param2 = false;
   string param3 = "Hello World!";
   t2.Start(new object[] { param1, param2, param3 } );
}

public static void MyThreadFunction(object paramAll)
{
   object[] paramArray = (object[])paramAll;
   int param1 = (int)paramArray[0];
   int param2 = (bool)paramArray[1];
   int param3 = (string)paramArray[2];
}

public struct ThreadFuncParameters
{
   public int Param1;
   public bool Param2;
   public string Param3;
}

public void StartMyThread() 
{
   ThreadFuncParameters params = new ThreadFuncParameters();
   params.Param1 = 0;
   params.Param2 = false;
   params.Param3 = "Hello World!";
   t2.Start(params);
}

public static void MyThreadFunction(object paramAll)
{
   ThreadFuncParameters params = (ThreadFuncParameters)paramAll;
   int param1 = params.Param1;
   int param2 = params.Param2;
   int param3 = params.Param3;
}