C#

int[] i = {9, 2, 7, 6, 1, 3, 5, 4, 8};
   int[] j = (int[])i.Clone();
   
   int P01 = 0;
   int P02 = 0;
   int P03 = 0;
   int P04 = 0;
   int P05 = 0;
   int P06 = 0;
   int P07 = 0;
   int P08 = 0;
   int P09 = 0;
   
   int va = 0;
   int vp = 0;

   bool swapped = true;

   while (swapped) {

     swapped=false;
     va = 0;
	 
  //loop through all numbers in the array.
   while (va < i.Length -1)
   {
          //compare the two values.
           if (i[va] > i[va+1]) {

               int swap = i[va];
               i[va] = i[va+1];
               i[va+1] = swap;
               swapped=true;
           }

       //increment
       va++;  
   }
}

//loop through all numbers comparing original input array values vs. newly sorted array to determine position.
// Position 1
vp = 0;

while (vp < j.Length -1)
{
    if (j[0] = i[vp]) {
        P01 := vp + 1;
    }

       //increment
       vp++; 

}

// Position 2
vp = 0;

while (vp < j.Length -1)
{
    if (j[1] = i[vp]) {
        P02 := vp + 1;
    }

       //increment
       vp++; 

}

// Position 3
vp = 0;

while (vp < j.Length -1)
{
    if (j[2] = i[vp]) {
        P03 := vp + 1;
    }

       //increment
       vp++; 

}

// Position 4
vp = 0;

while (vp < j.Length -1)
{
    if (j[3] = i[vp]) {
        P04 := vp + 1;
    }

       //increment
       vp++; 

}

/* required
using System;
using System.Collections.Generic;
using System.ComponentModel;
*/
public static class ConversionExtensions
{
    public enum ConversionType
    {
        SByte, Byte, Int16, Int32, Int64,
        UInt32, UInt64, Single, Double,
        Guid
    }

    static Dictionary<Type, TypeConverter> TypeToConverter = null;

    public static T? TryParse<T>(this string str) where T : struct
    {
        if (TypeToConverter == null)
        {
            TypeToConverter = new Dictionary<Type, TypeConverter>();

            foreach (string ct in Enum.GetNames(typeof(ConversionType)))
            {
                var t = Type.GetType("System." + ct);

                TypeToConverter.Add(t, TypeDescriptor.GetConverter(t));
            }
        }

        Type type = typeof(T);

        // using C# 7 syntax for in-line out variable
        if (TypeToConverter.TryGetValue(type, out TypeConverter tc))
        {
// tbd: use 'TypeConverter.CanConvertFrom here rather than try/catch
            try
            {
                return (T) tc.ConvertFromString(str);
            }
            catch
            {
                return null;
            }
        }
        else
        {
            throw new KeyNotFoundException($"this converter does not handle Type: {type.FullName}");
        }

        return null;
    }
}