C#

// 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;
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace ConsoleApplication9
{
    class Program
    {
        static string m1 = "\nType a string of text then press Enter. " +
                 "Type '+' anywhere in the text to quit:\n";
        static string m2 = "Character '{0}'";
        static string m3 = "Character     ";

        public  struct ThreadFuncParameters
        {
           public static char ch;
           public static int x;

           public static bool isM1 ;
           public static bool isM2 ;
           public static bool isM3 ;
        }

        static void Main(string[] args)
        {
            Console.WriteLine(m1);

               ThreadFuncParameters pas = new ThreadFuncParameters();
               pas.ch = 'a' ;
               pas.x = 0;
               pas.isM1 = false;
               pas.isM2 = false;
               pas.isM3 = false;

               Thread t1 = new Thread(new ParameterizedThreadStart(Program.ReadInput));
               Thread t2 = new Thread(new ParameterizedThreadStart(Program.ReadOutput));

               Console.WriteLine("Thread 1 starting...");
               t1.Start(pas);
               Console.WriteLine("Thread 2 starting...");
               t2.Start(pas);

               //Thread.Sleep(80 * 1000);
        }


        public static void ReadInput(object paramALL)
        {
                ThreadFuncParameters par = (ThreadFuncParameters)paramALL;
                char p1 = par.ch;
                int p2 = par.x;
                bool p3 = par.isM1;
                bool p4 = par.isM2;
                bool p5 = par.isM3;

            do
            {
                p2 = Console.Read();

                try
                {
                    p1 = Convert.ToChar(p2);
                    if (Char.IsWhiteSpace(p1))
                    {
                        //Console.WriteLine(m3, input);
                        p5 = true;
                        if (p1== 0x0a)
                            //Console.WriteLine(m1);
                            p3= true;
                    }
                    else
                        //Console.WriteLine(m2, ch, input);
                        p4 = true;
                }
                catch (OverflowException e)
                {
                    Console.WriteLine("{0} Value read = {1}.", e.Message, p2);
                    p1 = Char.MinValue;
                    Console.WriteLine(m1);
                }
            } while (p1!= '+');


            ch = p1;
            x = p2;
            isM1 = p3;
            isM2 = p4;
            isM3 = p5;
        }


        public static void ReadOutput(object paramALL)
        {
            ThreadFuncParameters par = (ThreadFuncParameters)paramALL;
            char p1 = par.ch;
            int p2 = par.x;
            bool p3 = par.isM1;
            bool p4 = par.isM2;
            bool p5 = par.isM3;

            //int output = (int)param1;
            //bool isM2Bool = (bool)param2;

            if (p5)
            {
                Console.WriteLine(m3, p2);
            }

            if (p3)
            {
                Console.WriteLine(m1);
            }

            if (p4)
            {
                Console.WriteLine(m2, p1, p2);
            }

        }
    }
}

private void textBox1_Enter(object sender, System.EventArgs e)
{
   this.textBox1.BeginInvoke( new MethodInvoker( this.textBox1.SelectAll ) );
}

private void myTextbox_Enter( object sender, MouseEventArgs args )
{
   myTextBox.SelectAll();
}