Find the best matching product version from a list of available product versions

You can use the build-in Version class, since it already implements the <= operator you are basically looking for, and also can handle the string parsing for you:

var data = new List<Version>()
{
     new Version(3,0,1),
     new Version(4,10,5),
     new Version(6,2,1),
     new Version(7,5,1),
     new Version(10,7,1),
     new Version(11,10,10)
};

var case1 = new Version("10.10.20");
// match1 is 5; the index of a List is 0-based, so we add 1
var match1 = data.FindLastIndex(d => d <= case1) + 1;

var case2 = new Version("7.0.0");
// match2 is 3
var match2 = data.FindLastIndex(d => d <= case2) + 1;

var case3 = new Version("7.5.1");
// match3 is 4
var match3 = data.FindLastIndex(d => d <= case3) + 1;

It should be trivial to convert your sequence of ProductVersions to a list of Version objects.

If you don't want to use the Version class for whatever reason, you can implement the <= (and all other missing operators) yourself:

public class ProductVersions
{
   //TODO error checking
   public int Version_Id { get; set; }
   public int Major { get; set; }
   public int Minor { get; set; }
   public int Build { get; set; }

   public ProductVersions(int major, int minor, int build)
   {
        Major=major;
        Minor=minor;
        Build=build;
   }

   public ProductVersions(string version)
   {
        var tmp = version.Split('.');
        Major = Int32.Parse(tmp[0]);
        Minor = Int32.Parse(tmp[1]);
        Build = Int32.Parse(tmp[2]);
   }

   public static bool operator == (ProductVersions a, ProductVersions b)
   {
        return a.Major==b.Major && a.Minor==b.Minor && a.Build==b.Build;
   }

   public static bool operator != (ProductVersions a, ProductVersions b)
   {
        return !(a==b);
   }

   public static bool operator <= (ProductVersions a, ProductVersions b)
   {
        if (a == b)
            return true;
        return a < b;
   }

   public static bool operator >= (ProductVersions a, ProductVersions b)
   {
        if (a == b)
            return true;
        return a > b;
   }

   public static bool operator < (ProductVersions a, ProductVersions b)
   {
        if(a.Major==b.Major)
            if(a.Minor==b.Minor)
                return a.Build < b.Build;
            else
                return a.Minor < b.Minor;
        else
            return a.Major < b.Major;
   }

   public static bool operator > (ProductVersions a, ProductVersions b)
   {
        if(a.Major==b.Major)
            if(a.Minor==b.Minor)
                return a.Build > b.Build;
            else
                return a.Minor > b.Minor;
        else
            return a.Major > b.Major;
   }

And a simple test:

var data = new List<ProductVersions>()
{
     new ProductVersions(3,0,1)    { Version_Id = 1},
     new ProductVersions(4,10,5)   { Version_Id = 2},
     new ProductVersions(6,2,1)    { Version_Id = 3},
     new ProductVersions(7,5,1)    { Version_Id = 4},
     new ProductVersions(10,7,1)   { Version_Id = 5},
     new ProductVersions(11,10,10) { Version_Id = 6}
};

// ensure data is sorted by version
data.Sort((a,b) => a > b ? 1 : a < b ? -1 : 0);

var case1 = new ProductVersions("10.10.20");
// match1 is 5
var match1 = data.Last(d => d <= case1).Version_Id;

var case2 = new ProductVersions("7.0.0");
// match2 is 3
var match2 = data.Last(d => d <= case2).Version_Id;

var case3 = new ProductVersions("7.5.1");
// match3 is 4
var match3 = data.Last(d => d <= case3).Version_Id;