Remplacer le " est " de la fonctionnalité

Question

J'ai une classe qui comporte une exception, comme l'a si.

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

Je veux remplacer le " est " de l'action, de Sorte qu'au lieu de le faire

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

Je vais le faire

if (ex is Validator.ValidatorException)

Est-il possible? Comment?

Answer 1

De Overloadable Opérateurs, les opérateurs suivants peuvent être surchargé:

• Unaire: +, -, !, ~, ++, --, true, false
• Binaire: +, -, *, /, %, &, |, ^, <<, >>
• Comparaison: ==, !=, <, >, <=, >=

Et ces opérateurs ne peuvent pas être surchargé:

• Logique: &&, ||
• Tableau D'Indexation: []
• Exprimés: (T)x
• Affectation: +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=
• Autres: =, ., ?:, ??, ->, =>, f(x), as, checked, unchecked, default, delegate, is, new, sizeof, typeof

Aussi, les opérateurs de comparaison doivent être surchargé par paires, si vous surchargez un, vous devez surcharger les autres:

• == et !=
• < et >
• <= et >=

Answer 2

La réponse est: Non, is ne peut pas être remplacée (parce que c'est un mot-clé).

Mais vous pourriez faire quelque chose de plus élégant par l'utilisation de génériques. D'abord définir votre Is() méthode comme suit:

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

Ensuite, vous pouvez écrire votre comparaison comme ceci:

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

Answer 3

is non surchargé mot-clé, mais vous pouvez écrire des extensions de la méthode comme ceci:

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

Answer 4

La façon la plus simple de faire ce que je peux penser est un cast-puis-test d' approche:

• Code

  public static partial class TestClass {
      public static void TestMethod() {
          try {
              throw new StackOverflowException();
          }
          catch(Exception ex) {
              ExceptionWrapper ew=new ExceptionWrapper(ex);
              Exception e=ew;
  
              Debug.Print("is? {0}", e is ArgumentNullException); // false
              Debug.Print("is? {0}", e is StackOverflowException); // true
          }
      }
  }
  
  public partial class ExceptionWrapper {
      public static implicit operator Exception(ExceptionWrapper ew) {
          return ew.m_exception;
      }
  
      public ExceptionWrapper(Exception ex) {
          this.m_exception=ex;
      }
  
      Exception m_exception;
  }