जब VB.NET कोड C#पर माइग्रेट कर रहा है तो लूप के लिए अलग तरीके से व्यवहार क्यों किया जाता है?




loops for-loop (3)

अब मेरा प्रश्न घूमता है कि कैसे VB स्ट्रिंग के लिए VV के संदर्भ में V # के संदर्भ में C # से भिन्न होता है। लूप के लिए हर बार लूप होने के बावजूद भी लूप में परिवर्तन की स्थिति होती है।

VB.NET प्रलेखन के अनुसार:

यदि आप लूप के अंदर counter का मान बदलते हैं, तो आपका कोड पढ़ना और डीबग करना अधिक कठिन हो सकता है। start , end , या step का मान बदलना उस मान को प्रभावित नहीं करता है जो निर्धारित किया गया था जब लूप पहली बार दर्ज किया गया था।

तो, To 10 - stringValue.Length से मूल्य To 10 - stringValue.Length का एक बार मूल्यांकन किया जाता है और छोरों से बाहर निकलने तक पुन: उपयोग किया जाता है।

हालाँकि, कथन के लिए c # को देखें

यदि for_condition मौजूद नहीं है या यदि मूल्यांकन true , तो नियंत्रण को एम्बेडेड स्टेटमेंट में स्थानांतरित कर दिया जाता है। कब और अगर नियंत्रण एम्बेडेड स्टेटमेंट के अंतिम बिंदु तक पहुंचता है (संभवतः एक जारी स्टेटमेंट के निष्पादन से), for_iterator के अभिव्यक्तियाँ, यदि कोई हो, का मूल्यांकन अनुक्रम में किया जाता है, और उसके बाद एक और पुनरावृत्ति की जाती है, for_condition का मूल्यांकन शुरू for_condition है ऊपर का कदम।

जिसका मूल रूप से मतलब है कि स्थिति ; i <= 10 - stringValueLength; ; i <= 10 - stringValueLength; हर बार फिर से मूल्यांकन किया जाता है।

इसलिए, जैसा कि आपने देखा, यदि आप कोड को दोहराना चाहते हैं, तो आपको लूप शुरू करने से पहले c # में अंतिम काउंटर घोषित करना होगा।

मैं विजुअल बेसिक से C # में किसी प्रोजेक्ट को माइग्रेट करने की प्रक्रिया में हूं और मुझे यह बदलना होगा कि कैसे इस्तेमाल किए जा for लूप को घोषित किया जाता है।

VB.NET में लूप के for नीचे घोषित किया गया है:

Dim stringValue As String = "42"

For i As Integer = 1 To 10 - stringValue.Length
   stringValue = stringValue & " " & CStr(i)
   Console.WriteLine(stringValue)
Next

कौन से आउटपुट:

42 1
42 1 2
42 1 2 3
42 1 2 3 4
42 1 2 3 4 5
42 1 2 3 4 5 6
42 1 2 3 4 5 6 7
42 1 2 3 4 5 6 7 8

C # में लूप के for नीचे घोषित किया गया है:

string stringValue = "42";

for (int i = 1; i <= 10 - stringValue.Length; i ++)
{
   stringValue = stringValue + " " + i.ToString();
   Console.WriteLine(stringValue);
}

और आउटपुट:

42 1
42 1 2
42 1 2 3

यह स्पष्ट रूप से सही नहीं है, इसलिए मुझे कभी भी कोड को थोड़ा बदलना पड़ा और इसमें एक पूर्णांक चर शामिल किया गया जो स्ट्रिंग की लंबाई को धारण करेगा।

कृपया नीचे कोड देखें:

string stringValue = "42";
int stringValueLength = stringValue.Length;

for (int i = 1; i <= 10 - stringValueLength; i ++)
{
   stringValue = stringValue + " " + i.ToString();
   Console.WriteLine(stringValue);
}

और आउटपुट:

42 1
42 1 2
42 1 2 3
42 1 2 3 4
42 1 2 3 4 5
42 1 2 3 4 5 6
42 1 2 3 4 5 6 7
42 1 2 3 4 5 6 7 8

अब मेरा प्रश्न यह है कि विजुअल बेसिक के संदर्भ में विजुअल बेसिक के संदर्भ में स्ट्रिंग # stringValue.Length का उपयोग करके कैसे भिन्न होता है। लूप के for हर बार लूप स्ट्रिंग परिवर्तन की लंबाई होने पर भी स्थिति। जबकि C # में अगर मैं stringValue.Length उपयोग करता हूं। लूप कंडीशन के लिए यह हर बार लूप होने पर शुरुआती स्ट्रिंग वैल्यू को बदल देता है। ऐसा क्यों है?


उदाहरण को और अधिक समझने के लिए, मैं लूप्स के लिए दोनों छोरों को C # में परिवर्तित करूंगा।

VB.NET

string stringValue = "42";

int min = 1;
int max = 10 - stringValue.Length;
int i = min;
while (i <= max)
{
    stringValue = stringValue + " " + stringValue.Length.ToString();
    Console.WriteLine(stringValue);
    i++;
}

सी#

string stringValue = "42";

int i = 1;
while (i <= 10 - stringValue.Length)
{
    stringValue = stringValue + " " + stringValue.Length.ToString();
    Console.WriteLine(stringValue);
    i++;
}

अंतर तब है:

VB.NET , i लिए अधिकतम मूल्य को कैश करता है, लेकिन C # इसे हर बार पुनः प्राप्त करता है।


सी # में, लूप सीमा की स्थिति का मूल्यांकन प्रत्येक पुनरावृत्ति पर किया जाता है। VB.NET में, यह केवल लूप में प्रवेश पर मूल्यांकन किया जाता है।

इसलिए, प्रश्न में C # संस्करण में, क्योंकि stringValue की लंबाई को लूप में बदला जा रहा है, अंतिम लूप वेरिएबल मान को बदल दिया जाएगा।

VB.NET में, अंतिम स्थिति समावेशी है, इसलिए आप < C के बजाय <= उपयोग करेंगे।

C # में अंतिम स्थिति मूल्यांकन में कोरोलरी है कि भले ही यह अलग-अलग न हो, लेकिन गणना करना महंगा है, फिर लूप से ठीक पहले इसकी गणना की जानी चाहिए।





for-loop