Was ist der richtige Weg, ein benutzerdefiniertes .NET Exception serializable zu machen?

Question

Genauer gesagt, wenn die Ausnahme benutzerdefinierte Objekte enthält, die sich möglicherweise nicht serialisierbar sein.

Nehmen Sie dieses Beispiel:

public class MyException : Exception
{
    private readonly string resourceName;
    private readonly IList<string> validationErrors;

    public MyException(string resourceName, IList<string> validationErrors)
    {
        this.resourceName = resourceName;
        this.validationErrors = validationErrors;
    }

    public string ResourceName
    {
        get { return this.resourceName; }
    }

    public IList<string> ValidationErrors
    {
        get { return this.validationErrors; }
    }
}

Wenn diese Ausnahme serialisiert und de-serialisiert, die zwei benutzerdefinierten Eigenschaften (ResourceName und ValidationErrors) nicht erhalten werden. Die Eigenschaften werden null zurück.

Gibt es eine gemeinsame Codemuster Serialisierung für benutzerdefinierte Ausnahme für die Implementierung?

Answer 1

Basisimplementierung, ohne benutzerdefinierte Eigenschaften

SerializableExceptionWithoutCustomProperties.cs:

namespace SerializableExceptions
{
    using System;
    using System.Runtime.Serialization;

    [Serializable]
    // Important: This attribute is NOT inherited from Exception, and MUST be specified 
    // otherwise serialization will fail with a SerializationException stating that
    // "Type X in Assembly Y is not marked as serializable."
    public class SerializableExceptionWithoutCustomProperties : Exception
    {
        public SerializableExceptionWithoutCustomProperties()
        {
        }

        public SerializableExceptionWithoutCustomProperties(string message) 
            : base(message)
        {
        }

        public SerializableExceptionWithoutCustomProperties(string message, Exception innerException) 
            : base(message, innerException)
        {
        }

        // Without this constructor, deserialization will fail
        protected SerializableExceptionWithoutCustomProperties(SerializationInfo info, StreamingContext context) 
            : base(info, context)
        {
        }
    }
}

Die vollständige Umsetzung mit benutzerdefinierten Eigenschaften

Vollständige Implementierung eines benutzerdefinierten serializable Ausnahme (MySerializableException) und eine abgeleitete sealed Ausnahme (MyDerivedSerializableException).

Die wichtigsten Punkte über diese Umsetzung sind hier zusammengefasst:

1. Sie müssen jede abgeleitete Klasse mit dem [Serializable] Attribut schmücken - Dieses Attribut wird nicht von der Basisklasse geerbt, und wenn es nicht angegeben ist, Serialisierung wird fehlschlagen mit einem SerializationException besagen, dass „Type X in Y Assembly ist nicht als serialisierbar markiert.“
2. Sie müssen benutzerdefinierte Serialisierung implementieren. Das [Serializable] Attribut allein reicht nicht aus - Exception ISerializable implementiert, die Ihre abgeleiteten Klassen bedeutet, müssen auch benutzerdefinierte Serialisierung implementieren. Dies erfolgt in zwei Schritten:
   1. Geben Sie eine Serialisierung Konstruktor . Dieser Konstruktor soll private werden, wenn Ihre Klasse sealed ist, sonst sollte es den Zugriff auf abgeleitete Klassen ermöglichen protected werden.
   2. Ignoriere GetObjectData () und stellen Sie sicher, dass Sie am Ende base.GetObjectData(info, context) rufen durch, um die Basisklasse speichert seinen eigenen Zustand zu lassen.

SerializableExceptionWithCustomProperties.cs:

namespace SerializableExceptions
{
    using System;
    using System.Collections.Generic;
    using System.Runtime.Serialization;
    using System.Security.Permissions;

    [Serializable]
    // Important: This attribute is NOT inherited from Exception, and MUST be specified 
    // otherwise serialization will fail with a SerializationException stating that
    // "Type X in Assembly Y is not marked as serializable."
    public class SerializableExceptionWithCustomProperties : Exception
    {
        private readonly string resourceName;
        private readonly IList<string> validationErrors;

        public SerializableExceptionWithCustomProperties()
        {
        }

        public SerializableExceptionWithCustomProperties(string message) 
            : base(message)
        {
        }

        public SerializableExceptionWithCustomProperties(string message, Exception innerException)
            : base(message, innerException)
        {
        }

        public SerializableExceptionWithCustomProperties(string message, string resourceName, IList<string> validationErrors)
            : base(message)
        {
            this.resourceName = resourceName;
            this.validationErrors = validationErrors;
        }

        public SerializableExceptionWithCustomProperties(string message, string resourceName, IList<string> validationErrors, Exception innerException)
            : base(message, innerException)
        {
            this.resourceName = resourceName;
            this.validationErrors = validationErrors;
        }

        [SecurityPermissionAttribute(SecurityAction.Demand, SerializationFormatter = true)]
        // Constructor should be protected for unsealed classes, private for sealed classes.
        // (The Serializer invokes this constructor through reflection, so it can be private)
        protected SerializableExceptionWithCustomProperties(SerializationInfo info, StreamingContext context)
            : base(info, context)
        {
            this.resourceName = info.GetString("ResourceName");
            this.validationErrors = (IList<string>)info.GetValue("ValidationErrors", typeof(IList<string>));
        }

        public string ResourceName
        {
            get { return this.resourceName; }
        }

        public IList<string> ValidationErrors
        {
            get { return this.validationErrors; }
        }

        [SecurityPermissionAttribute(SecurityAction.Demand, SerializationFormatter = true)]
        public override void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            if (info == null)
            {
                throw new ArgumentNullException("info");
            }

            info.AddValue("ResourceName", this.ResourceName);

            // Note: if "List<T>" isn't serializable you may need to work out another
            //       method of adding your list, this is just for show...
            info.AddValue("ValidationErrors", this.ValidationErrors, typeof(IList<string>));

            // MUST call through to the base class to let it save its own state
            base.GetObjectData(info, context);
        }
    }
}

DerivedSerializableExceptionWithAdditionalCustomProperties.cs:

namespace SerializableExceptions
{
    using System;
    using System.Collections.Generic;
    using System.Runtime.Serialization;
    using System.Security.Permissions;

    [Serializable]
    public sealed class DerivedSerializableExceptionWithAdditionalCustomProperty : SerializableExceptionWithCustomProperties
    {
        private readonly string username;

        public DerivedSerializableExceptionWithAdditionalCustomProperty()
        {
        }

        public DerivedSerializableExceptionWithAdditionalCustomProperty(string message)
            : base(message)
        {
        }

        public DerivedSerializableExceptionWithAdditionalCustomProperty(string message, Exception innerException) 
            : base(message, innerException)
        {
        }

        public DerivedSerializableExceptionWithAdditionalCustomProperty(string message, string username, string resourceName, IList<string> validationErrors) 
            : base(message, resourceName, validationErrors)
        {
            this.username = username;
        }

        public DerivedSerializableExceptionWithAdditionalCustomProperty(string message, string username, string resourceName, IList<string> validationErrors, Exception innerException) 
            : base(message, resourceName, validationErrors, innerException)
        {
            this.username = username;
        }

        [SecurityPermissionAttribute(SecurityAction.Demand, SerializationFormatter = true)]
        // Serialization constructor is private, as this class is sealed
        private DerivedSerializableExceptionWithAdditionalCustomProperty(SerializationInfo info, StreamingContext context)
            : base(info, context)
        {
            this.username = info.GetString("Username");
        }

        public string Username
        {
            get { return this.username; }
        }

        public override void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            if (info == null)
            {
                throw new ArgumentNullException("info");
            }
            info.AddValue("Username", this.username);
            base.GetObjectData(info, context);
        }
    }
}

---

Unit Tests

MSTest Unit-Tests für die drei Ausnahmetypen vorstehend definiert ist.

UnitTests.cs:

namespace SerializableExceptions
{
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Runtime.Serialization.Formatters.Binary;
    using Microsoft.VisualStudio.TestTools.UnitTesting;

    [TestClass]
    public class UnitTests
    {
        private const string Message = "The widget has unavoidably blooped out.";
        private const string ResourceName = "Resource-A";
        private const string ValidationError1 = "You forgot to set the whizz bang flag.";
        private const string ValidationError2 = "Wally cannot operate in zero gravity.";
        private readonly List<string> validationErrors = new List<string>();
        private const string Username = "Barry";

        public UnitTests()
        {
            validationErrors.Add(ValidationError1);
            validationErrors.Add(ValidationError2);
        }

        [TestMethod]
        public void TestSerializableExceptionWithoutCustomProperties()
        {
            Exception ex =
                new SerializableExceptionWithoutCustomProperties(
                    "Message", new Exception("Inner exception."));

            // Save the full ToString() value, including the exception message and stack trace.
            string exceptionToString = ex.ToString();

            // Round-trip the exception: Serialize and de-serialize with a BinaryFormatter
            BinaryFormatter bf = new BinaryFormatter();
            using (MemoryStream ms = new MemoryStream())
            {
                // "Save" object state
                bf.Serialize(ms, ex);

                // Re-use the same stream for de-serialization
                ms.Seek(0, 0);

                // Replace the original exception with de-serialized one
                ex = (SerializableExceptionWithoutCustomProperties)bf.Deserialize(ms);
            }

            // Double-check that the exception message and stack trace (owned by the base Exception) are preserved
            Assert.AreEqual(exceptionToString, ex.ToString(), "ex.ToString()");
        }

        [TestMethod]
        public void TestSerializableExceptionWithCustomProperties()
        {
            SerializableExceptionWithCustomProperties ex = 
                new SerializableExceptionWithCustomProperties(Message, ResourceName, validationErrors);

            // Sanity check: Make sure custom properties are set before serialization
            Assert.AreEqual(Message, ex.Message, "Message");
            Assert.AreEqual(ResourceName, ex.ResourceName, "ex.ResourceName");
            Assert.AreEqual(2, ex.ValidationErrors.Count, "ex.ValidationErrors.Count");
            Assert.AreEqual(ValidationError1, ex.ValidationErrors[0], "ex.ValidationErrors[0]");
            Assert.AreEqual(ValidationError2, ex.ValidationErrors[1], "ex.ValidationErrors[1]");

            // Save the full ToString() value, including the exception message and stack trace.
            string exceptionToString = ex.ToString();

            // Round-trip the exception: Serialize and de-serialize with a BinaryFormatter
            BinaryFormatter bf = new BinaryFormatter();
            using (MemoryStream ms = new MemoryStream())
            {
                // "Save" object state
                bf.Serialize(ms, ex);

                // Re-use the same stream for de-serialization
                ms.Seek(0, 0);

                // Replace the original exception with de-serialized one
                ex = (SerializableExceptionWithCustomProperties)bf.Deserialize(ms);
            }

            // Make sure custom properties are preserved after serialization
            Assert.AreEqual(Message, ex.Message, "Message");
            Assert.AreEqual(ResourceName, ex.ResourceName, "ex.ResourceName");
            Assert.AreEqual(2, ex.ValidationErrors.Count, "ex.ValidationErrors.Count");
            Assert.AreEqual(ValidationError1, ex.ValidationErrors[0], "ex.ValidationErrors[0]");
            Assert.AreEqual(ValidationError2, ex.ValidationErrors[1], "ex.ValidationErrors[1]");

            // Double-check that the exception message and stack trace (owned by the base Exception) are preserved
            Assert.AreEqual(exceptionToString, ex.ToString(), "ex.ToString()");
        }

        [TestMethod]
        public void TestDerivedSerializableExceptionWithAdditionalCustomProperty()
        {
            DerivedSerializableExceptionWithAdditionalCustomProperty ex = 
                new DerivedSerializableExceptionWithAdditionalCustomProperty(Message, Username, ResourceName, validationErrors);

            // Sanity check: Make sure custom properties are set before serialization
            Assert.AreEqual(Message, ex.Message, "Message");
            Assert.AreEqual(ResourceName, ex.ResourceName, "ex.ResourceName");
            Assert.AreEqual(2, ex.ValidationErrors.Count, "ex.ValidationErrors.Count");
            Assert.AreEqual(ValidationError1, ex.ValidationErrors[0], "ex.ValidationErrors[0]");
            Assert.AreEqual(ValidationError2, ex.ValidationErrors[1], "ex.ValidationErrors[1]");
            Assert.AreEqual(Username, ex.Username);

            // Save the full ToString() value, including the exception message and stack trace.
            string exceptionToString = ex.ToString();

            // Round-trip the exception: Serialize and de-serialize with a BinaryFormatter
            BinaryFormatter bf = new BinaryFormatter();
            using (MemoryStream ms = new MemoryStream())
            {
                // "Save" object state
                bf.Serialize(ms, ex);

                // Re-use the same stream for de-serialization
                ms.Seek(0, 0);

                // Replace the original exception with de-serialized one
                ex = (DerivedSerializableExceptionWithAdditionalCustomProperty)bf.Deserialize(ms);
            }

            // Make sure custom properties are preserved after serialization
            Assert.AreEqual(Message, ex.Message, "Message");
            Assert.AreEqual(ResourceName, ex.ResourceName, "ex.ResourceName");
            Assert.AreEqual(2, ex.ValidationErrors.Count, "ex.ValidationErrors.Count");
            Assert.AreEqual(ValidationError1, ex.ValidationErrors[0], "ex.ValidationErrors[0]");
            Assert.AreEqual(ValidationError2, ex.ValidationErrors[1], "ex.ValidationErrors[1]");
            Assert.AreEqual(Username, ex.Username);

            // Double-check that the exception message and stack trace (owned by the base Exception) are preserved
            Assert.AreEqual(exceptionToString, ex.ToString(), "ex.ToString()");
        }
    }
}

Answer 2

Ausnahme ist bereits serializable, aber Sie müssen die GetObjectData Methode außer Kraft setzen Ihre Variablen zu speichern und einen Konstruktor bereitzustellen, die genannt werden können, wenn wieder feuchtigkeitsspendende Ihr Objekt.

So Ihr Beispiel wird:

[Serializable]
public class MyException : Exception
{
    private readonly string resourceName;
    private readonly IList<string> validationErrors;

    public MyException(string resourceName, IList<string> validationErrors)
    {
        this.resourceName = resourceName;
        this.validationErrors = validationErrors;
    }

    public string ResourceName
    {
        get { return this.resourceName; }
    }

    public IList<string> ValidationErrors
    {
        get { return this.validationErrors; }
    }

    [SecurityPermissionAttribute(SecurityAction.Demand, SerializationFormatter=true)]
    protected MyException(SerializationInfo info, StreamingContext context) : base (info, context)
    {
        this.resourceName = info.GetString("MyException.ResourceName");
        this.validationErrors = info.GetValue("MyException.ValidationErrors", typeof(IList<string>));
    }

    [SecurityPermissionAttribute(SecurityAction.Demand, SerializationFormatter=true)]
    public override void GetObjectData(SerializationInfo info, StreamingContext context)
    {
        base.GetObjectData(info, context);

        info.AddValue("MyException.ResourceName", this.ResourceName);

        // Note: if "List<T>" isn't serializable you may need to work out another
        //       method of adding your list, this is just for show...
        info.AddValue("MyException.ValidationErrors", this.ValidationErrors, typeof(IList<string>));
    }

}

Answer 3

Implementieren ISerializable, und folgen Sie den

auf die richtigen Antworten oben hinzuzufügen, entdeckte ich, dass ich vermeiden können diese benutzerdefinierte Serialisierung Sachen zu tun, wenn ich meine benutzerdefinierten Eigenschaften speichern in der Data Sammlung der Exception Klasse.

Z. B:.

[Serializable]
public class JsonReadException : Exception
{
    // ...

    public string JsonFilePath
    {
        get { return Data[@"_jsonFilePath"] as string; }
        private set { Data[@"_jsonFilePath"] = value; }
    }

    public string Json
    {
        get { return Data[@"_json"] as string; }
        private set { Data[@"_json"] = value; }
    }

    // ...
}

Wahrscheinlich ist dies weniger effizient in Bezug auf Leistung als die Lösung von Daniel zur Verfügung gestellt und wahrscheinlich funktioniert nur für „integral“ Typen wie Strings und ganze Zahlen und dergleichen.

Still war es sehr einfach und sehr verständlich für mich.

Es verwendet einen ausgezeichneten Artikel werden von Eric Gunnerson auf MSDN „Das wohltemperierte Ausnahme“, aber es scheint gezogen worden zu sein. Die URL war:

http: //msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp08162001.asp

Aydsman Antwort ist richtig, mehr Infos hier:

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

kann ich mir keinen Anwendungsfall für eine Ausnahme mit nicht-serializable Mitglieder, aber wenn Sie versuchen, vermeiden serialisiert / deserialisiert sie in GetObjectData und der Deserialisierungskonstruktor sollten Sie in Ordnung sein. Auch markieren sie mit dem [NonSerialized] Attribut, mehr als Dokumentation als alles andere, da Sie die Serialisierung selbst umsetzen.

Markieren Sie die Klasse mit [Serializable], obwohl ich nicht sicher bin, wie gut ein IList Mitglied wird von dem Serializer behandelt werden.

Bearbeiten

Der Beitrag unten ist richtig, weil Ihre benutzerdefinierte Ausnahme Konstruktor hat, die Parameter annimmt, müssen Sie ISerializable implementieren.

Wenn Sie ein Standard-Konstruktor verwendet und ausgesetzt, um die zwei benutzerdefinierten Elemente mit Getter / Setter-Eigenschaften, könnten Sie weg mit nur das Attribute festlegen.

Ich habe zu glauben, dass eine Ausnahme serialisiert will ein starker Hinweis darauf, dass Sie den falschen Ansatz zu etwas einnehmen. Was ist das ultimative Ziel, hier? Wenn Sie die Ausnahme zwischen zwei Prozessen vorbei sind, oder zwischen getrennten Durchläufen des gleichen Prozesses, dann den meisten Eigenschaften der Ausnahme wird nicht ohnehin in anderen Anwendungen.

Es wäre wahrscheinlich mehr Sinn machen, den Zustand Informationen, die Sie auf der catch () Anweisung extrahieren möchten, und zu archivieren, dass.

Answer 4

Answer 5

Answer 6

Answer 7

Answer 8

auf die richtigen Antworten oben hinzuzufügen, entdeckte ich, dass ich vermeiden können diese benutzerdefinierte Serialisierung Sachen zu tun, wenn ich meine benutzerdefinierten Eigenschaften speichern in der

Answer 9

Es verwendet einen ausgezeichneten Artikel werden von Eric Gunnerson auf MSDN „Das wohltemperierte Ausnahme“, aber es scheint gezogen worden zu sein. Die URL war:

http: //msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp08162001.asp

Aydsman Antwort ist richtig, mehr Infos hier:

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

kann ich mir keinen Anwendungsfall für eine Ausnahme mit nicht-serializable Mitglieder, aber wenn Sie versuchen, vermeiden serialisiert / deserialisiert sie in GetObjectData und der Deserialisierungskonstruktor sollten Sie in Ordnung sein. Auch markieren sie mit dem [NonSerialized] Attribut, mehr als Dokumentation als alles andere, da Sie die Serialisierung selbst umsetzen.

Answer 10

Markieren Sie die Klasse mit [Serializable], obwohl ich nicht sicher bin, wie gut ein IList Mitglied wird von dem Serializer behandelt werden.

Bearbeiten

Der Beitrag unten ist richtig, weil Ihre benutzerdefinierte Ausnahme Konstruktor hat, die Parameter annimmt, müssen Sie ISerializable implementieren.

Wenn Sie ein Standard-Konstruktor verwendet und ausgesetzt, um die zwei benutzerdefinierten Elemente mit Getter / Setter-Eigenschaften, könnten Sie weg mit nur das Attribute festlegen.

Answer 11

Ich habe zu glauben, dass eine Ausnahme serialisiert will ein starker Hinweis darauf, dass Sie den falschen Ansatz zu etwas einnehmen. Was ist das ultimative Ziel, hier? Wenn Sie die Ausnahme zwischen zwei Prozessen vorbei sind, oder zwischen getrennten Durchläufen des gleichen Prozesses, dann den meisten Eigenschaften der Ausnahme wird nicht ohnehin in anderen Anwendungen.

Es wäre wahrscheinlich mehr Sinn machen, den Zustand Informationen, die Sie auf der catch () Anweisung extrahieren möchten, und zu archivieren, dass.