clsInBetweenRules myRules = new clsInBetweenRules();

  myRules.DealHand(cards, ref betResult, ref position);

 string [] cards = new string[3];

 public void DealHand(string[] hand, ref int outCome, ref int position)
    {
        ...
        SetCards(hand);
        ...
    }

    private void SetCards(string[] hand)
    {
        int temp;
        hand[0] = myDeck.getCardPip(lowCardIndex);
        hand[1] = myDeck.getCardPip(hiCardIndx);
        hand[2] = myDeck.getCardPip(dealtCardIndex);

        if (lowCard == hiCard || lowCard < hiCard)
        {
            hand[0] = myDeck.getCardPip(lowCardIndex);
            hand[1] = myDeck.getCardPip(hiCardIndx);
        }
        else
        {
            temp = hiCard;
            hiCard = lowCard;
            lowCard = temp;

            temp = hiCardIndx;
            hiCardIndx = lowCardIndex;
            lowCardIndex = temp;

            hand[0] = myDeck.getCardPip(lowCardIndex);
            hand[1] = myDeck.getCardPip(hiCardIndx);
        }
    }

string HandOne = hand[0]

using System;

namespace Testreferencetypes_stringandarray
{
	class ClsTstString
	{
		public void ChangeString(string strVar){
			strVar = "after";
		}

	}
	class MainClass
	{
		public static void Main (string[] args)
		{
			string strMain = "before";
			Console.WriteLine (strMain);

			ClsTstString TstStrObj = new ClsTstString ();
			TstStrObj.ChangeString (strMain);
			Console.WriteLine (strMain);

		}
	}
}

using System;

namespace Testreferencetypes_stringandarray
{
	class ClsTstString
	{
		public string strNv;
		public void ChangeString(string strVar){
			strVar = "after";
			strNv = strVar;
		}

	}
	class MainClass
	{
		public static void Main (string[] args)
		{
			string strMain = "before";
			Console.WriteLine (strMain);

			ClsTstString TstStrObj = new ClsTstString ();
	
			//strMain is changed which is understandable, value is newly assigned
			strMain = TstStrObj.strNv;
			Console.WriteLine (strMain);
		}
	}
}

namespace Program
{
    public class Class1
    {
        public string MyString { get; set; }
    }

    public class Program
    {
        static void Main( String[] args )
        {
            string testStr1 = "MainMethod String Value";
            string[] testStrArray = new string[] { testStr1 };
            Class1 testClass = new Class1( ) { MyString = "MainMethod String Value" };

            Console.WriteLine( "testStr1 = '{0}' before 'SetStringTest'", testStr1 );
            SetStringTest( testStr1 );   // this will not affect the value of 'testStr1'
            Console.WriteLine( "testStr1 = '{0}' after 'SetStringTest'", testStr1 );

            Console.WriteLine( "testClass.MyString = '{0}' before 'SetStringTest'", testClass.MyString );
            SetStringTest( testClass ); // this will affect the value of testClass.MyString
            Console.WriteLine( "testClass.MyString = '{0}' after 'SetStringTest'", testClass.MyString );


            Console.WriteLine( "testStrArray[0] = '{0}' before 'SetStringTest'", testStrArray[0] );
            SetStringTest( testStrArray ); // this will affect the value of testStrArray[0]
            Console.WriteLine( "testStrArray[0] = '{0}' after 'SetStringTest'", testStrArray[0] );

            Console.WriteLine( "\nHit enter to terminate" );
            Console.ReadLine( );



        }


        /*when declaring a function that takes premitive types as parameters what you are passing to the 
         *function via the local variable 'myString' is a pointer to the string that is referenced by
         *'testStr1' in the main class 
         *   
         * so when we set the local variable 'myString' to a new value what you are assinging to it a new is a pointer (aka reference) to a new string in memory with a value of "String Set From 'SetString' Method"
         *    
         * your not actually passing the variable 'testStr1' from main but the contents of it, and the 
         * contents are a pointer (aka reference) to an actual string stored in memory
         */
        static void SetStringTest( string myString )
        {
            // setting 'myString' to a new string value here does not affect 
            // the 'testStr1' variable in main because the 'myString' variable now 
            // points to a new instance of a string with the value seen below.
            myString = "String Set From 'SetString' Method";
        }

        /* when declaring a function that take class types as parameters what you are passing to 
         * the function via variable 'myClass' is a pointer to a an object in memory that represents
         * a Class1 object.
         * 
         * In this case it will be a refernece (aka pointer) to the object created by the new operator in the line
         * Class1 testClass = new Class1( ) { MyString = "MainMethod String Value" }; in main.
         * 
         * 
         * you are not actually passing the variable 'testCalss' but the contents of testClass which is a reference to 
         * a Class1 object 
         */
        static void SetStringTest( Class1 myClass )
        {
            // we can change the MyString property here and it will affect the 
            // 'testClass' in main because because the 'myClass' variabl here 
            // and the 'testClass' actually point to the same instance of the 
            // Class1 object in memory

            myClass.MyString = "String Set From 'SetString' Method";

            // if we were to do something like 
            // myClass = new Class1();
            // this would not affect the 'testClass' variable in main 
            // because the 'myClass' variable now points to a new Class1 object in memory
        }

        /* this carries the same primise as the Class version of Set String
         * the local variable contains a reference to an array in memory
         * 
         * 
         * through that reference we can set individual elements to value
         * 
         * 
         * 
         * 
         */
        static void SetStringTest( String[] values )
        {
            // this will affect the 'testStrArray' element 0 by pointint it to a new instance 
            // of a string with the below value.
            values[0] = "String Set From 'SetString' Method";

            // doing something like this would not affect 'testStrArray' from main
            //   values = new String[] { "Set inside 'SetStringTest' method" };
            // because values would then point to a new instance of a string[] in memory.
        }

    }
}