संरचनाओं की तुलना करते समय यह एक प्रारूप अपवाद क्यों फेंकता है?

Question

मैं दो System.Drawing.Size संरचनाओं की समानता पर जोर देने की कोशिश कर रहा हूं, और मुझे अपेक्षित जोर विफलता की बजाय प्रारूप अपवाद मिल रहा है।

[TestMethod] 
public void AssertStructs() 
{ 
    var struct1 = new Size(0, 0); 
    var struct2 = new Size(1, 1); 

    //This throws a format exception, "System.FormatException: Input string was not in a correct format." 
    Assert.AreEqual(struct1, struct2, "Failed. Expected {0}, actually it is {1}", struct1, struct2); 

    //This assert fails properly, "Failed. Expected {Width=0, Height=0}, actually it is {Width=1, Height=1}". 
    Assert.AreEqual(struct1, struct2, "Failed. Expected " + struct1 + ", actually it is " + struct2); 
} 

क्या यह इरादा व्यवहार है? क्या मुझसे यहां कुछ गलत हो रहा है?

Answer 1

मुझे यह मिल गया है। और हाँ, यह एक बग है।

समस्या यह है कि string.Format के दो स्तर यहां जा रहे हैं।

पहले स्वरूपण का स्तर है कुछ की तरह:

string template = string.Format("Expected: {0}; Actual: {1}; Message: {2}", 
           expected, actual, message); 

फिर हम पैरामीटर आपके द्वारा बताये गये हैं, उनके साथ string.Format का उपयोग करें:

string finalMessage = string.Format(template, parameters); 

(जाहिर है संस्कृतियों प्रदान की जा रही है, और है कुछ स्वच्छता के प्रकार ... लेकिन पर्याप्त नहीं है।)

यह ठीक दिखता है - जब तक अपेक्षित और वास्तविक मान स्वयं स्ट्रिंग में परिवर्तित होने के बाद ब्रेसिज़ के साथ समाप्त नहीं होते हैं - जो वे Size के लिए करते हैं। उदाहरण के लिए, अपने पहले आकार समाप्त होता है में बदला जा रहा:

{Width=0, Height=0} 

तो स्वरूपण के दूसरे स्तर की तरह कुछ है:

string.Format("Expected: {Width=0, Height=0}; Actual: {Width=1, Height=1 }; " + 
       "Message = Failed expected {0} actually is {1}", struct1, struct2); 

... और वह है क्या नाकाम रहने रहा है। आउच।

वास्तव में, हमने स्वरूपण बेवकूफ बनाना उम्मीद है और वास्तविक भागों के लिए हमारे पैरामीटर का उपयोग करने से वास्तव में आसानी से यह साबित कर सकते हैं:

var x = "{0}"; 
var y = "{1}"; 
Assert.AreEqual<object>(x, y, "What a surprise!", "foo", "bar"); 

परिणाम है:

Assert.AreEqual failed. Expected:<foo>. Actual:<bar>. What a surprise! 

जाहिर टूट, हम के रूप में foo की उम्मीद नहीं थी और न ही वास्तविक मूल्य bar था!

असल में यह एक एसक्यूएल इंजेक्शन हमले की तरह है, लेकिन string.Format के कम डरावनी संदर्भ में है।

एक कामकाज के रूप में, आप string.Format का उपयोग कर सकते हैं क्योंकि स्ट्राइप्लिंगवायरियर सुझाव देता है। यह वास्तविक/अपेक्षित मानों के साथ स्वरूपण के परिणामस्वरूप स्वरूपण के दूसरे स्तर से परहेज करता है।

Answer 2

मुझे लगता है कि पहला दावा गलत है।

उपयोग इस बजाय:

Assert.AreEqual(struct1, 
       struct2, 
       string.Format("Failed expected {0} actually is {1}", struct1, struct2)); 

Answer 3

मैं तुम्हें एक बग पाया है लगता है।

यह काम करता है (एक ज़ोर अपवाद फेंकता):

var a = 1; 
var b = 2; 
Assert.AreEqual(a, b, "Not equal {0} {1}", a, b); 

और यह काम करता है (संदेश आउटपुट):

var a = new{c=1}; 
var b = new{c=2}; 
Console.WriteLine(string.Format("Not equal {0} {1}", a, b)); 

लेकिन यह काम नहीं करता है (फेंकता एक FormatException):

var a = new{c=1}; 
var b = new{c=2}; 
Assert.AreEqual(a, b, "Not equal {0} {1}", a, b); 

मैं किसी भी कारण से सोच नहीं सकता कि यह व्यवहार की अपेक्षा की जाएगी। मैं एक बग रिपोर्ट जमा करूंगा।

var a = new{c=1}; 
var b = new{c=2}; 
Assert.AreEqual(a, b, string.Format("Not equal {0} {1}", a, b)); 

Answer 4

मैं @StriplingWarrior साथ सहमत हैं कि यह वास्तव में कम से कम 2 भार के पर विधि Assert.AreEqual() के साथ एक बग प्रतीत होता है: इस बीच, यहाँ एक समाधान है। जैसा कि StiplingWarrior पहले ही इंगित कर चुका है, निम्नलिखित विफल रहता है;

var a = new { c = 1 }; 
var b = new { c = 2 }; 
Assert.AreEqual(a, b, "Not equal {0} {1}", a, b); 

मैं कोड उपयोग में थोड़ी अधिक स्पष्ट होने पर इस पर थोड़ा प्रयोग कर रहा हूं। निम्नलिखित या तो काम नहीं करता है;

// specify variable data type rather than "var"...no effect, still fails 
Size a = new Size(0, 0); 
Size b = new Size(1, 1); 
Assert.AreEqual(a, b, "Not equal {0} {1}", a, b); 

और

// specify variable data type and name the type on the generic overload of AreEqual()...no effect, still fails 
Size a = new Size(0, 0); 
Size b = new Size(1, 1); 
Assert.AreEqual<Size>(a, b, "Not equal {0} {1}", a, b); 

यह मैं सोच मिला है। सिस्टम। ड्रॉइंग .इज एक संरचना है। वस्तुओं के बारे में क्या? Param सूची निर्दिष्ट करता है कि string संदेश के बाद सूची params object[] है। तकनीकी रूप से, हाँ structs ऑब्जेक्ट्स हैं ... लेकिन विशेष प्रकार वस्तुओं, यानी मूल्य प्रकार। मुझे लगता है कि यह वह जगह है जहां बग झूठ बोलता है। यदि हम Size पर समान उपयोग और संरचना के साथ अपनी स्वयं की वस्तु का उपयोग करते हैं, तो वास्तव में कार्य करता है;

private class MyClass 
{ 
    public MyClass(int width, int height) 
     : base() 
    { Width = width; Height = height; } 

    public int Width { get; set; } 
    public int Height { get; set; } 
} 

[TestMethod] 
public void TestMethod1() 
{ 
    var test1 = new MyClass(0, 0); 
    var test2 = new MyClass(1, 1); 
    Assert.AreEqual(test1, test2, "Show me A [{0}] and B [{1}]", test1, test2); 
}