Cách chính xác để tạo một phiên bản .NET Exception tùy chỉnh là gì?

Cụ thể hơn, khi ngoại lệ chứa các đối tượng tùy chỉnh có thể tự hoặc không thể tuần tự hóa.

Lấy ví dụ này:

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; }
    }
}

Nếu Ngoại lệ này được tuần tự hóa và khử nối tiếp, hai thuộc tính tùy chỉnh ( ResourceNamevà ValidationErrors) sẽ không được giữ nguyên. Các tài sản sẽ trở lại null.

Có một mẫu mã phổ biến để thực hiện tuần tự hóa cho ngoại lệ tùy chỉnh không?

Cơ sở thực hiện, không có thuộc tính tùy chỉnh

SerializableExceptionWithoutCustomProperIES.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)
        {
        }
    }
}

Thực hiện đầy đủ, với các thuộc tính tùy chỉnh

Hoàn thành thực hiện một ngoại lệ tuần tự hóa tùy chỉnh ( MySerializableException) và sealedngoại lệ xuất phát ( MyDerivedSerializableException).

Những điểm chính về việc thực hiện này được tóm tắt ở đây:

1. Bạn phải trang trí cho mỗi lớp dẫn xuất bằng [Serializable]thuộc tính - Thuộc tính này không được kế thừa từ lớp cơ sở và nếu không được chỉ định, việc xê-ri hóa sẽ thất bại với thông SerializationExceptionbáo rằng "Loại X trong hội Y không được đánh dấu là tuần tự hóa".
2. Bạn phải thực hiện tuần tự hóa tùy chỉnh . Chỉ [Serializable]riêng thuộc tính là không đủ - Exceptionthực hiện ISerializableđiều đó có nghĩa là các lớp dẫn xuất của bạn cũng phải thực hiện tuần tự hóa tùy chỉnh. Điều này bao gồm hai bước:
   1. Cung cấp một hàm tạo tuần tự hóa . Hàm tạo này phải là privatenếu lớp của bạn sealed, nếu không nó sẽ protectedcho phép truy cập vào các lớp dẫn xuất.
   2. Ghi đè GetObjectData () và đảm bảo rằng bạn gọi đến base.GetObjectData(info, context)cuối, để cho lớp cơ sở lưu trạng thái của chính nó.

SerializableExceptionWithCustomProperIES.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);
        }
    }
}

DeruredSerializableExceptionWithAdditableCustomProperIES.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);
        }
    }
}

Bài kiểm tra đơn vị

Kiểm tra đơn vị MSTest cho ba loại ngoại lệ được xác định ở trên.

Đơn vị.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()");
        }
    }
}

Ngoại lệ đã được tuần tự hóa, nhưng bạn cần ghi đè GetObjectDataphương thức để lưu trữ các biến của mình và cung cấp một hàm tạo có thể được gọi khi hydrat hóa lại đối tượng của bạn.

Vì vậy, ví dụ của bạn trở thành:

[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>));
    }

}

Thực hiện ISerializable và theo mô hình bình thường để làm điều này.

Bạn cần gắn thẻ lớp với thuộc tính [Nối tiếp] và thêm hỗ trợ cho giao diện đó, đồng thời thêm hàm tạo hàm ý (được mô tả trên trang đó, tìm kiếm hàm ý hàm tạo ). Bạn có thể thấy một ví dụ về việc thực hiện nó trong mã bên dưới văn bản.

Để thêm vào các câu trả lời đúng ở trên, tôi phát hiện ra rằng tôi có thể tránh thực hiện công cụ tuần tự hóa tùy chỉnh này nếu tôi lưu trữ các thuộc tính tùy chỉnh của mình trong Databộ sưu tập của Exceptionlớp.

Ví dụ:

[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; }
    }

    // ...
}

Có lẽ điều này kém hiệu quả về mặt hiệu suất so với giải pháp do Daniel cung cấp và có lẽ chỉ hoạt động đối với các loại "tích phân" như chuỗi và số nguyên và tương tự.

Tuy nhiên, nó rất dễ dàng và rất dễ hiểu đối với tôi.

Đã từng có một bài viết xuất sắc từ Eric Gunnerson trên MSDN "Ngoại lệ nóng nảy" nhưng dường như nó đã được rút ra. URL là:

http://msdn.microsoft.com/l Library / default.asp? url = / l Library / en-us / dcsccol / html / csharp08162001.asp

Câu trả lời của Aydsman là chính xác, thông tin thêm ở đây:

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

Tôi không thể nghĩ ra bất kỳ trường hợp sử dụng nào cho Ngoại lệ với các thành viên không tuần tự hóa, nhưng nếu bạn tránh cố gắng tuần tự hóa / giải tuần tự hóa chúng trong GetObjectData và trình xây dựng giải tuần tự hóa thì bạn sẽ ổn. Đồng thời đánh dấu chúng bằng thuộc tính [NonSerialized], dưới dạng tài liệu hơn bất kỳ thứ gì khác, vì bạn đang tự thực hiện tuần tự hóa.

Đánh dấu lớp bằng [serializable], mặc dù tôi không chắc thành viên IList sẽ được xử lý bởi serializer như thế nào.

BIÊN TẬP

Bài viết dưới đây là chính xác, vì ngoại lệ tùy chỉnh của bạn có hàm tạo có tham số, bạn phải triển khai ISerializable.

Nếu bạn đã sử dụng một hàm tạo mặc định và hiển thị hai thành viên tùy chỉnh với các thuộc tính getter / setter, bạn có thể thoát khỏi chỉ bằng cách đặt thuộc tính.

Tôi phải nghĩ rằng muốn nối tiếp một ngoại lệ là một dấu hiệu mạnh mẽ cho thấy bạn đang sử dụng sai phương pháp tiếp cận một cái gì đó. Mục tiêu cuối cùng là gì? Nếu bạn chuyển ngoại lệ giữa hai quy trình hoặc giữa các lần chạy riêng biệt của cùng một quy trình, thì hầu hết các thuộc tính của ngoại lệ sẽ không có hiệu lực trong quy trình khác.

Có lẽ sẽ có ý nghĩa hơn khi trích xuất thông tin trạng thái bạn muốn tại câu lệnh Catch () và lưu trữ thông tin đó.