विभाजन फ़ंक्शन का उपयोग किए बिना संस्करण संख्याओं की तुलना करें

Question

मैं संस्करण संख्याओं की तुलना कैसे करूं?

उदाहरण के लिए:

x = 1.23.56.1487.5

y = 1.24.55.487.2

Comments

आप परिणाम क्या चाहते हैं?

— BoltClock

5 भागों के साथ एक संस्करण? यदि आप विशिष्ट 4 भाग संस्करण का उपयोग कर रहे थे, तो आप System.Version वर्ग का उपयोग कर सकते हैं, जिसमें संस्करण की तुलना करने के तरीके और संस्करण स्ट्रिंग पार्स करना शामिल है

— psousa

X और y के प्रकार क्या हैं?

— Gleno

जब भी कोई कहता है "उपयोग न करें X, Yया Z", यह हमेशा मुझे आश्चर्यचकित करता है कि क्यों। आप splitफ़ंक्शन का उपयोग क्यों नहीं करना चाहते हैं ? splitसमारोह एक अच्छा तरीका है अगर आप का उपयोग नहीं करने जा रहे हैं यह करने के लिए की तरह लगता है System.Versionवर्ग।

— Bob2Chiv

Answer 1

क्या आप संस्करण वर्ग का उपयोग कर सकते हैं?

http://msdn.microsoft.com/en-us/library/system.version.aspx

इसमें एक IComparable इंटरफ़ेस है। ध्यान रखें कि यह आपके द्वारा दिखाए गए 5-भाग संस्करण स्ट्रिंग के साथ काम नहीं करेगा (क्या यह वास्तव में आपका संस्करण स्ट्रिंग है?)। मान लें कि आपके इनपुट स्ट्रिंग्स हैं, यहां सामान्य .NET 4-पार्ट संस्करण स्ट्रिंग के साथ एक कार्य नमूना है:

static class Program
{
    static void Main()
    {
        string v1 = "1.23.56.1487";
        string v2 = "1.24.55.487";

        var version1 = new Version(v1);
        var version2 = new Version(v2);

        var result = version1.CompareTo(version2);
        if (result > 0)
            Console.WriteLine("version1 is greater");
        else if (result < 0)
            Console.WriteLine("version2 is greater");
        else
            Console.WriteLine("versions are equal");
        return;

    }
}

Comments

केवल अगर संस्करण 2-4 भागों से होता है

— यूज़र

@dev_Boston केवल एक अपवाद ... बस इन मानों के साथ करें v1 = 1.0001 और v2 = 1.1। यह मुझे बराबर देता है।

— शक एम

हां, संस्करण स्ट्रिंग्स दशमलव तार नहीं हैं, और संस्करण संख्या के एक हिस्से के लिए ज़ीरो को प्रीपरेंडिंग करना अप्रासंगिक है। दूसरे शब्दों में, "00001" संस्करण स्ट्रिंग के दूसरे भाग में "1" के बराबर है।

— जॉनडी

आप अधिक आसानी से तुलना कर सकते हैं Version.Parse(v1) < Version.Parse(v2), क्योंकि operator >(Version v1, Version v2)इसे लागू किया गया है।

— एंड्री मोइसेव

विदित हो कि Version.Parse ("6.0.0") (<) Version.Parse ("6.0.0.0") से कम है (अर्थात बराबर नहीं हैं)। Debug.Assert(new Version("6.0.0") < new Version("6.0.0.0"));

— 14

Answer 2

यदि आप प्रमुख .minor.build.revision स्कीम के साथ रह सकते हैं तो आप .Net संस्करण वर्ग का उपयोग कर सकते हैं । अन्यथा आपको कुछ प्रकार के पार्सिंग को बाएं से दाएं पर लागू करना होगा और तब तक जारी रखना होगा जब तक कि आपके पास कोई अंतर या वापसी न हो कि दो संस्करण समान हों।

Answer 3

@JohnD के उत्तर के अलावा स्प्लिट ('।') या अन्य स्ट्रिंग <-> इंट कन्वर्शन ब्लोट का उपयोग किए बिना केवल आंशिक संस्करण संख्याओं की तुलना करने की आवश्यकता हो सकती है। मैंने सिर्फ 1 अतिरिक्त तर्क के साथ एक विस्तार विधि तुलना लिखी है - तुलना करने के लिए संस्करण संख्या के महत्वपूर्ण भागों की संख्या (1 और 4 के बीच)।

public static class VersionExtensions
{
    public static int CompareTo(this Version version, Version otherVersion, int significantParts)
    {
        if(version == null)
        {
            throw new ArgumentNullException("version");
        }
        if(otherVersion == null)
        {
            return 1;
        }

        if(version.Major != otherVersion.Major && significantParts >= 1)
            if(version.Major > otherVersion.Major)
                return 1;
            else
                return -1;

        if(version.Minor != otherVersion.Minor && significantParts >= 2)
            if(version.Minor > otherVersion.Minor)
                return 1;
            else
                return -1;

        if(version.Build != otherVersion.Build && significantParts >= 3)
            if(version.Build > otherVersion.Build)
                return 1;
            else
                return -1;

        if(version.Revision != otherVersion.Revision && significantParts >= 4)
            if(version.Revision > otherVersion.Revision)
                return 1;
            else
                return -1;

        return 0; 
    }
}

Answer 4

public int compareVersion(string Version1,string Version2)
    {
        System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex(@"([\d]+)");
        System.Text.RegularExpressions.MatchCollection m1 = regex.Matches(Version1);
        System.Text.RegularExpressions.MatchCollection m2 = regex.Matches(Version2);
        int min = Math.Min(m1.Count,m2.Count);
        for(int i=0; i<min;i++)
        {
            if(Convert.ToInt32(m1[i].Value)>Convert.ToInt32(m2[i].Value))
            {
                return 1;
            }
            if(Convert.ToInt32(m1[i].Value)<Convert.ToInt32(m2[i].Value))
            {
                return -1;
            }               
        }
        return 0;
    }

Comments

खबरदार है कि इस के लिए बराबर वापसी होगीcompareVersion("1.3", "1.3.1")

— Ozgur Ozcitak

Answer 5

यदि किसी कारण से आपको सीधे संस्करण की तुलना-विधि का उपयोग करने की अनुमति नहीं है (उदाहरण के लिए क्लाइंट-सर्वर परिदृश्य में), तो दूसरा तरीका संस्करण से लंबी संख्या निकालना और फिर एक दूसरे के साथ संख्याओं की तुलना करना है। हालाँकि, संख्या के लिए निम्न प्रारूप की आवश्यकता है: मेजर, माइनर और रिवीजन के लिए दो अंक और बिल्ड के लिए चार।

संस्करण संख्या कैसे निकालें:

var version = Assembly.GetExecutingAssembly().GetName().Version;

long newVersion = version.Major * 1000000000L + 
                   version.Minor * 1000000L + 
                   version.Build * 1000L + 
                   version.Revision;

और फिर कहीं और आप बस तुलना कर सकते हैं:

if(newVersion > installedVersion)
{
  //update code
}

नोट: इनस्टॉल वर्जन पहले से निकाली गई लंबी संख्या है

Comments

सभी अंकों को 3 स्थान देने के लिए, कोड वास्तव में होना चाहिए: "version.Major * 1000000000L + version.Minor * 1000000L + version.Bild" 1000L + version.Revision "

— Stef Heyenrath

@StefHeyenrath यह सही है, उपरोक्त कोड को अपनी आवश्यकताओं के अनुसार समायोजित करने के लिए स्वतंत्र महसूस करें।

— फैबियन बिगलर