Zastępowanie funkcji "jest"

Question

Mam klasy, więc zawiera wyjątek, tak jak.

public class ExceptionWrapper 
{ 
    public string TypeName { get; set; } 
    public string Message { get; set; } 
    public string InnerException { get; set; } 
    public string StackTrace { get; set; } 

    public ExceptionWrapper() { } 

    public ExceptionWrapper(Exception ex) 
    { 
     TypeName = String.Format("{0}.{1}", ex.GetType().Namespace, ex.GetType().Name); 
     Message = ex.Message; 
     InnerException = ex.InnerException != null ? ex.InnerException.Message : null; 
     StackTrace = ex.StackTrace; 
    } 

    public bool Is(Type t) 
    { 
     var fullName = String.Format("{0}.{1}", t.Namespace, t.Name); 
     return fullName == TypeName; 
    } 
} 

Chcę zastąpić działania 'jest', więc robią tak

if (ex.Is(typeof(Validator.ValidatorException)) == true) 

zamiast Zrobię tak

if (ex is Validator.ValidatorException) 

Czy to możliwe? W jaki sposób?

Answer 1

Od Overloadable Operators, następujące podmioty mogą być przeciążone:

• Jednoargumentowy: +, -, !, ~, ++, --, true, false
• Binary: +, -, *, /, %, &, |, ^, <<, >>
• Porównanie: ==, !=, <, >, <=, >=

A te podmioty nie mogą być przeciążone:

• Logical: &&, ||
• Array indeksowania: []
• Obsada: (T)x
• Zadanie: +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=
• Inne: =, ., ?:, ??, ->, =>, f(x), as, checked, unchecked, default, delegate, is, new, sizeof, typeof

również operatory porównania muszą być przeładowany w parach, jeśli ciebie przeciąż jeden, musisz przeciążyć drugi:

• == i !=
• < i >
• <= i >=

Answer 2

is jest non-przeładowany słów kluczowych, ale można napisać przedłużeń metodę tak:

public static bool Is<T>(this Object source) where T : class 
{ 
    return source is T; 
} 

Answer 3

Prosta odpowiedź brzmi: Nie, is nie można nadpisać (ponieważ jest to słowo kluczowe).

Ale można zrobić coś bardziej eleganckiego za pomocą generycznych. Najpierw zdefiniować metodę Is() tak:

public bool Is<T>() where T: Exception 
{ 
    return typeof(T).FullName == this.TypeName; 
} 

Następnie można napisać porównanie takiego:

if (ex.Is<Validator.ValidatorException>())