Question

我有一个文件夹，文件名如下：

v5.9.1.55
v5.9.2.34 
v5.9.2.65 
v5.9.5.12

我有一个Dropbox，我可以选择以下版本：5.9.1,5.9.2,5.9.3,5.9.4

所以，当我让我们说，5.9.1选择它在文件夹中搜索包含5.9.1的文件。当我有几个我排序他们得到文件与highes颠覆。假设我有5.9.1.12和5.9.1.44我会得到5.9.1.44。

但我的老板说，当这个版本没有文件时，我应该使用最接近该版本的文件。所以从顶部的例子来看，如果我在Dropbox中选择了5.9.3，我将无法找到包含5.9.3的文件，因为没有。现在预计下面的下一个文件，在这种情况下为5.9.2.34是targettet。

但我应该如何能够定位一个我无法搜索的文件，因为我不知道如果我想要的文件不在这里，所以我必须在下面搜索一个，以及最接近的文件版本是什么。这一切都必须以程序化的方式发生，但我现在没有想法。

我希望你们中的某些人可以帮助我解决这个问题，并且可能会提供一个想法，让我自己能够在这方面取得成功。

这将是我现在的代码，如果有一个适合所选版本的礼物，我可以找到正确的文件：

string ComboboxText = ComboBoxVersion.Text;
if (ComboboxText != "")
{
    string[] TempContainingDirectorys = new string[54];
    int containingdirectorysCount = 0;
    string[] directoryEntriesLibVersions = Directory.GetDirectories(SourcepathString + @"\Programm\xxx");
    for (int a = 0; a < directoryEntriesLibVersions.Length; a++)
    {
        if (directoryEntriesLibVersions[a].Contains(ComboBoxVersion.Text))
        {
            TempContainingDirectorys[containingdirectorysCount] = directoryEntriesLibVersions[a];
            containingdirectorysCount++;
        }
        else
        {
        }
    }
    IComparer revComparer = new ReverseComparer();
    Array.Sort(TempContainingDirectorys, revComparer);
    string newtestClient = TempContainingDirectorys[0];
}

UPDATE FIX：我想把它分成主要的，次要的，bugfix版本。然后，如果没有找到任何结果，请逐一减少它们。这是工作代码：

int FOUND = 0;
TempContainingDirectorys = new string[54];
containingdirectorysCount = 0;
string VersionPunkte = ComboBoxVersion.Text.Replace('_', '.');
while(FOUND == 0){

    directoryEntriesLibVersions = Directory.GetDirectories(SourcepathString + @"\Programm\xxx");
    for (int a = 0; a < directoryEntriesLibVersions.Length; a++)
    {
        if (directoryEntriesLibVersions[a].Contains(VersionPunkte))
        {
            TempContainingDirectorys[containingdirectorysCount] = directoryEntriesLibVersions[a];
            containingdirectorysCount++;
            FOUND = 1;
        }
    }
    if (containingdirectorysCount == 0)
    {
        char delimiter = '.';
        string[] substringsVersion = VersionPunkte.Split(delimiter);
        int found = 0;
        int Majorversion = Int32.Parse(substringsVersion[0]);
        int Minorversion = Int32.Parse(substringsVersion[1]);
        int Bugfixversion = Int32.Parse(substringsVersion[2]);

        if (Bugfixversion > 0)
        {
            Bugfixversion = Bugfixversion-1;
        }
        else
        {
        Minorversion = Minorversion-1;
        Bugfixversion = 9;
        }
        VersionPunkte = Majorversion.ToString() + "." + Minorversion.ToString() + "." + Bugfixversion.ToString();
    }
    Array.Sort(TempContainingDirectorys, revComparer);
}

string newtestPEnv = TempContainingDirectorys[0];

Answer 1

天真地你可以分开＆＃34; 5.9.3＆＃34; on＆＃39;。＆＃39;并获得不同的数值，例如majorVersion = 5，minorVersion = 9，buggFixVersion = 3

然后按重要性的降序开始减少它们。对于每个版本，您搜索匹配的文件，如果找到，则停止并返回 -

直到你达到版本0.0.0为止，如果你还没有找到任何东西，那么就没有什么可做的了！

Answer 2

以下是关于如何使用Version：

进行操作的建议

首先创建一个Dictionary，其中包含所有具有关联版本的文件（您在示例中查找目录）。然后搜索确切的数字，如果找不到最近的版本：

//Your combobox string
Version loSelectedVersion = new Version("5.9.4");

Dictionary<Version, string> loVersionFiles = new Dictionary<Version, string>();
foreach (var lsFilename in Directory.GetFiles(@"E:\Temp\Version"))
{
    var loMatch = Regex.Match(lsFilename, @"(\d+.\d+.\d+.\d+)");
    if (loMatch.Success)
        loVersionFiles.Add(new Version(loMatch.Value), lsFilename);
}

//Excact match with your selectedVersion
var loEntry = loVersionFiles
    .OrderByDescending(item => item.Key)
    .FirstOrDefault(item => string.Format("{0}.{1}.{2}", item.Key.Major, item.Key.Minor, item.Key.Build) == loSelectedVersion.ToString());

if (loEntry.Key != null)
{
    Console.WriteLine(loEntry.Value);
}
else
{
    //Version Not Found -> look for the nearest
    loEntry = loVersionFiles
        .OrderByDescending(item => item.Key)
        .FirstOrDefault(item => item.Key < loSelectedVersion);
    if (loEntry.Key != null)
    {
        Console.WriteLine(loEntry.Value);
    }
}

Answer 3

我生成一个类来使用IComparable对版本进行排序。我还添加了一个Floor方法来获取所需版本之下的版本。看看这是否有效。我在调试代码时添加了一些示例测试数据：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace ConsoleApplication7
{
    class Program
    {
        static void Main(string[] args)
        {

           string[] inputs = { "v5.9.1.55", "v5.9.2.34", "v5.9.2.65",  "v5.9.5.12"};
            //demonstrates order by works
           string[] orderResults = inputs.OrderBy(x => new VersionSort(x)).ToArray();


            //sample test data to check class
           string[] testinputs = { "v4.9", "v5", "v5.9.1.2", "v5.9.2.65", "v5.10" };

            VersionSort testVersion = new VersionSort();
           foreach (string test in testinputs)
           {
               string floor = testVersion.Floor(test, inputs);

               Console.WriteLine("Version : '{0}', Floor : '{1}'", test, floor);
           }
           Console.ReadLine();

        }

    }
    public class VersionSort : IComparable 
    {
        int[] versionNumbers = null;

        public VersionSort() { }
        public VersionSort(string str)
        {
            //skip the first character v
            versionNumbers = str.Substring(1).Split(new char[] { '.' }).Select(x => int.Parse(x)).ToArray();
        }

        public int CompareTo(object other)
        {
            VersionSort version = (VersionSort)other;

            int minlength = versionNumbers.Length < version.versionNumbers.Length ? versionNumbers.Length : version.versionNumbers.Length;

            for (int i = 0; i < minlength; i++)
            {
                if (versionNumbers[i] == version.versionNumbers[i]) continue;
                return versionNumbers[i].CompareTo(version.versionNumbers[i]);
            }
            return versionNumbers.Length.CompareTo(version.versionNumbers.Length);
        }
        public string Floor(string compareVersionStr, string[] inputArray)
        {
            VersionSort compareversion = new VersionSort(compareVersionStr);
            VersionSort[] sortedVersions = inputArray.Select( x => new VersionSort(x)).OrderBy(x => x).ToArray();

            if(compareversion.CompareTo(sortedVersions[0]) == -1) return string.Empty;


            int index = 0;
            for (; index < sortedVersions.Length; index++ )
            {
                int comparResults = compareversion.CompareTo(sortedVersions[index]);
                if (comparResults == 0) return inputArray[index];
                if (comparResults < 0) return inputArray[index - 1];
            }

            return inputArray.LastOrDefault();
        }
    }


}

自动在文件夹中查找文件名

3 个答案: