Atrybut System.Serializable zniknął w aplikacjach Windows 10 UWP?

Question

Podczas próby przeniesienia biblioteki Open Source (Aforge.net) do UWP, odkryłem, że atrybut System.Serializable nie istnieje. Odnośniki do UWP działają nieco inaczej i wciąż staram się owijać głowę zmianami, więc mam nadzieję, że po prostu brakuje mi czegoś prostego.

Moje pytanie brzmi, czy ktoś może potwierdzić, czy atrybut System.Serializable działa/powinien działać w aplikacji UWP? Próbowałem przeglądać MSDN i różne inne źródła Google, ale nie mogę znaleźć żadnych dowodów w ten czy inny sposób.

Każda pomoc jest bardzo doceniana.

Aktualizacja
Wygląda na to może trzeba użyć DataContract/DataMember atrybutów zamiast Serializable jak wspomniano tutaj przenośnych bibliotek: Portable class library: recommended replacement for [Serializable]

Myśli?

Answer 1

Trzeba użyć następujące atrybuty:

oznaczyć klasy z

[DataContract] 

i oznaczyć właściwości z

[DataMember] 

lub

[IgnoreDataMember] 

Na przykład:

[DataContract] 
public class Foo 
{ 
    [DataMember] 
    public string Bar { get; set; } 

    [IgnoreDataMember] 
    public string FizzBuzz { get; set; } 
} 

Answer 2

W powyższym kodzie od Lance McCarthy:

[DataContract] 
public class Foo 
{ 
    [DataMember] 
    public string SomeText { get; set; } 

    // .... 

    [IgnoreDataMember] 
    public string FizzBuzz { get; set; } 
} 

Dodatkowo można użyć własnego rozszerzenia (!!! Zmień MemoryStream do FILESTREAM jeśli trzeba zapisać go do pliku zamiast do string):

public static class Extensions 
{ 
    public static string Serialize<T>(this T obj) 
    { 
     var ms = new MemoryStream(); 
     // Write an object to the Stream and leave it opened 
     using (var writer = XmlDictionaryWriter.CreateTextWriter(ms, Encoding.UTF8, ownsStream: false)) 
     { 
      var ser = new DataContractSerializer(typeof(T)); 
      ser.WriteObject(writer, obj); 
     } 
     // Read serialized string from Stream and close it 
     using (var reader = new StreamReader(ms, Encoding.UTF8)) 
     { 
      ms.Position = 0; 
      return reader.ReadToEnd(); 
     } 
    } 

    public static T Deserialize<T>(this string xml) 
    { 
     var ms = new MemoryStream(); 
     // Write xml content to the Stream and leave it opened 
     using (var writer = new StreamWriter(ms, Encoding.UTF8, 512, leaveOpen: true)) 
     { 
      writer.Write(xml); 
      writer.Flush(); 
      ms.Position = 0; 
     } 
     // Read Stream to the Serializer and Deserialize and close it 
     using (var reader = XmlDictionaryReader.CreateTextReader(ms, Encoding.UTF8, new XmlDictionaryReaderQuotas(), null)) 
     { 
      var ser = new DataContractSerializer(typeof(T)); 
      return (T)ser.ReadObject(reader); 
     } 
    } 
} 

a potem po prostu korzystać z tych extentions:

[TestClass] 
public class UnitTest1 
{ 
    [TestMethod] 
    public void TestSerializer() 
    { 
     var obj = new Foo() 
     { 
      SomeText = "Sample String", 
      SomeNumber = 135, 
      SomeDate = DateTime.Now, 
      SomeBool = true, 
     }; 

     // Try to serialize to string 
     string xml = obj.Serialize(); 

     // Try to deserialize from string 
     var newObj = xml.Deserialize<Foo>(); 

     Assert.AreEqual(obj.SomeText, newObj.SomeText); 
     Assert.AreEqual(obj.SomeNumber, newObj.SomeNumber); 
     Assert.AreEqual(obj.SomeDate, newObj.SomeDate); 
     Assert.AreEqual(obj.SomeBool, newObj.SomeBool); 
    } 
} 

Powodzenia kolego.

Answer 3

Jest trik,

Można zastąpić definicję klasy tych dwóch brakujących odniesień:

System.SerializableAttribute 
System.ComponentModel.DesignerCategoryAttribute 

Oto kod:

namespace System 
{ 
    internal class SerializableAttribute : Attribute 
    { 

    } 
} 
namespace System.ComponentModel 
{ 
    internal class DesignerCategoryAttribute : Attribute 
    { 
     public DesignerCategoryAttribute(string _) { } 
    } 
}