एक ही वस्तु को क्रमबद्ध करने से विभिन्न धाराएं उत्पन्न हो सकती हैं?

Question

क्या कोई ऐसी स्थिति है जब एक ही ऑब्जेक्ट को क्रमबद्ध करने से अलग-अलग धाराएं उत्पन्न हो सकती हैं (माना जाता है कि .NET का प्रारूपण दोनों में सेरियलाइजेशन के लिए उपयोग किया जाता है)?

यह this post से नीचे की चर्चा में आया था। दावा किया गया था कि ऐसा हो सकता है, फिर भी कोई ठोस स्पष्टीकरण नहीं दिया गया था, इसलिए मैं सोच रहा था कि क्या कोई इस मुद्दे पर कुछ प्रकाश डाल सकता है?

Answer 1

जैसा कि मैंने उस SO प्रश्न की टिप्पणी में बताया है, स्ट्रिंग आउटपुट के अनुकूलन के कारण समस्या उत्पन्न हुई है (कम से कम मामला मैंने पाया है)। ऐसा लगता है कि तार एक ही संदर्भ हैं, तो यह इसे एक बार आउटपुट करेगा।

तो हम नमूना कोड किसी ऑब्जेक्ट के गुणों के लिए लंबी स्ट्रिंग का उपयोग करने के लिए क्या करते हैं और एक स्ट्रिंग और फिर धारावाहिक के संदर्भ को बदलते हैं। फिर ऑब्जेक्ट को फिर से स्ट्रीम करने के लिए स्ट्रीम को deserialise (और इस बार स्ट्रिंग इंटर्न किया गया है, उसी संदर्भ का उपयोग किया जाता है) और फिर फिर से serialise। इस बार स्ट्रीम छोटा है।

[Serializable] 
public class Proof 
{ 
    public string S1 { get; set; } 
    public string S2 { get; set; } 
    public string S3 { get; set; } 
} 

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

     const string LongString = 
      "A value that is going to change the world nad iasjdsioajdsadj sai sioadj sioadj siopajsa iopsja iosadio jsadiojasd "; 

     var proof = new Proof() { 
      S1 = LongString, 
      S2 = LongString, 
      S3 = LongString 
     }; 

     proof.S2 = LongString.Substring(0, 10) + LongString.Substring(10); // just add up first 10 character with the rest. 
       //This just makes sure reference is not the same although values will be 

     Console.WriteLine(proof.S1 == proof.S2); 
     Console.WriteLine(proof.S1 == proof.S3); 
     Console.WriteLine(proof.S2 == proof.S3); 
     Console.WriteLine("So the values are all the same..."); 

     BinaryFormatter bf = new BinaryFormatter(); 
     MemoryStream stream = new MemoryStream(); 
     bf.Serialize(stream, proof); 
     byte[] buffer = stream.ToArray(); 
     Console.WriteLine("buffer length is " + buffer.Length); // outputs 449 on my machine 
     stream.Position = 0; 
     var deserProof = (Proof) bf.Deserialize(new MemoryStream(buffer)); 
     deserProof.S1 = deserProof.S2; 
     deserProof.S3 = deserProof.S2; 
     MemoryStream stream2 = new MemoryStream(); 
     new BinaryFormatter().Serialize(stream2, deserProof); 

     Console.WriteLine("buffer length now is " + stream2.ToArray().Length); // outputs 333 on my machine!! 
     Console.WriteLine("What? I cannot believe my eyes! Someone help me ........"); 

     Console.Read(); 
    } 

Answer 2

जो आप 'वही' ऑब्जेक्ट कहते हैं उस पर थोड़ा निर्भर करता है।

लेकिन हाँ, 2 उदाहरण समान = सत्य के रूप में तुलना कर सकते हैं और अभी भी विभिन्न धाराओं का उत्पादन कर सकते हैं।

• बराबर
• क्योंकि normalizations या आपरेशन के आदेश की वजह से सूक्ष्म अंतर की की एक टूटी हुई या सीमित ओवरराइड के साथ बहुत तुच्छता।

मैंने सत्यापित किया कि एक अलग क्रम में एक शब्दकोश में एक ही तत्व जोड़ने से एक अलग धारा उत्पन्न होती है। मुझे लगता है कि आप एक ही सामग्री 'बराबर' के साथ 2 शब्दकोशों पर विचार करेंगे।

Answer 3

कुछ कोर प्रकार (DateTime - विशेष रूप से ध्यान देने योग्य बात "प्रकार", या Decimal पैमाने टिप्पण) मानों रिपोर्ट के रूप में बराबर हो सकता है, लेकिन जो अलग ढंग से क्रमानुसार; उदाहरण के लिए:

using System; 
using System.IO; 
using System.Runtime.Serialization.Formatters.Binary; 
[Serializable] 
class Foo 
{ 
    public decimal Bar { get; set; } 
    static void Main() 
    { 
     Foo foo = new Foo(); 
     foo.Bar = 123.45M; 
     var s = Serialize(foo); 

     Foo foo2 = new Foo(); 
     foo2.Bar = 123.4500M; 

     bool areSame = foo.Bar == foo2.Bar; // true 
     var s2 = Serialize(foo2); 

     bool areSerializedTheSame = s == s2; // false 
    } 
    static string Serialize(object obj) 
    { 
     using (var ms = new MemoryStream()) 
     { 
      new BinaryFormatter().Serialize(ms, obj); 
      return Convert.ToBase64String(ms.GetBuffer(), 0, (int)ms.Length); 
     } 
    } 
} 

सटीक एक ही वस्तु को अलग ढंग से क्रमानुसार कर सकता था कि करने के लिए के रूप में - अच्छी तरह से, कि नहीं आम तौर पर एक गारंटी नहीं है कि क्रमांकन के बारे में कोई दावा करता है है। सीरियलाइजेशन आपके डेटा/ऑब्जेक्ट्स को संग्रहीत करने और पुनर्प्राप्त करने के बारे में है - समानता साबित करने के बारे में नहीं। उदाहरण के लिए, एक्सएमएल में सभी प्रकार के व्हाइटस्पेस और नेमस्पेस सामान्यीकरण मुद्दे हैं जो तुलना के लिए अनुपयुक्त बनाते हैं। BinaryFormatter और अन्य बाइनरी धारावाहिक अधिक आकर्षक लगते हैं, लेकिन मुझे यकीन नहीं है कि वे उस व्यवहार की गारंटी देते हैं जिसे आप ढूंढ रहे हैं।

मैं वास्तव में ऐसे दृष्टिकोण के माध्यम से तुलना की तुलना में विश्वास नहीं करता जब तक कि धारावाहिक स्पष्ट रूप से ने यह गारंटी नहीं दी।