Comment utiliser Java style jette mot-clé dans C #?

Question

En Java, throws mot-clé permet une méthode à déclarer qu'il ne traitera pas une exception en soi, mais plutôt le jeter à la méthode d'appel.

Y at-il un mot clé similaire / attribut dans C #?

S'il n'y a pas d'équivalent, comment pouvez-vous faire la même (ou similaire) effet?

Answer 1

En Java, vous devez soit gérer une exception ou marquer la méthode comme celui qui peut le jeter en utilisant le mot-clé throws.

C # ne pas ce mot-clé ou un poste équivalent, comme en C #, si vous ne gérez pas une exception, il se propagera, jusqu'à ce que pris ou sinon il sera pris fin au programme.

Si vous voulez gérer ensuite re-jeter, vous pouvez faire ce qui suit:

try
{
  // code that throws an exception
}
catch(ArgumentNullException ex)
{
  // code that handles the exception
  throw;
}

Answer 2

L'op demande sur le C # équivalent de Java clause throws - pas le mot-clé throw. Il est utilisé dans les signatures de méthode en Java pour indiquer peut être jeté une exception vérifiée.

En C #, il n'y a pas d'équivalent direct d'un Java vérifié exception. C # a pas de clause de signature de méthode équivalente.

// Java - need to have throws clause if IOException not handled
public void readFile() throws java.io.IOException {
  ...not explicitly handling java.io.IOException...
}

se traduit

// C# - no equivalent of throws clause exceptions are unchecked
public void ReadFile() 
{
  ...not explicitly handling System.IO.IOException...
}

Answer 3

Oui, c'est un vieux fil, mais je trouve souvent vieux fils quand je suis googler réponses, donc je pensais que je voudrais ajouter quelque chose d'utile que j'ai trouvé.

Si vous utilisez Visual Studio 2012, est un outil intégré qui peut être utilisé pour permettre un niveau d'IDE « jette » équivalent.

Si vous utilisez Documentation Commentaires , comme mentionné ci-dessus, vous pouvez utiliser le < a href = « http://msdn.microsoft.com/en-us/library/w1htk11d.aspx »> balise pour spécifier le type d'exception lancée par la méthode ou la classe ainsi que des informations sur quand ou pourquoi il est jeté.

exemple:

    /// <summary>This method throws an exception.</summary>
    /// <param name="myPath">A path to a directory that will be zipped.</param>
    /// <exception cref="IOException">This exception is thrown if the archive already exists</exception>
    public void FooThrowsAnException (string myPath)
    {
        // This will throw an IO exception
        ZipFile.CreateFromDirectory(myPath);
    }

Answer 4

Voici une réponse à une question similaire que je viens de fonds sur bytes.com :

  

La réponse courte est non, il y a des exceptions non vérifiées en C #. le   concepteur de la langue discute cette décision dans cette interview:

     

http://www.artima.com/intv/handcuffs.html

     

Le plus proche que vous pouvez obtenir est d'utiliser les balises XML dans votre   documentation et distribuer docs générés ndoc avec votre   code / assemblées afin que d'autres puissent voir quelles exceptions vous jetez   (Ce qui est exactement ce que MS faire dans la documentation MSDN). Vous ne pouvez pas compter   sur le compilateur de vous dire au sujet des exceptions non gérées, cependant, comme   vous pouvez être utilisé pour en java.

Answer 5

Après avoir traversé la plupart des réponses ici, je voudrais ajouter quelques réflexions.

1. En se fondant sur XML Documentation Commentaires et attend d'autres compter sur un mauvais choix. La plupart du code C # Je suis venu à travers ne pas les méthodes de documents complètement et de manière cohérente avec XML Documentation commentaires. Et puis il y a le plus gros problème que sans exceptions vérifiées en C #, comment pourriez-vous documenter toutes les exceptions méthode édredons pour que le but de votre utilisateur API pour savoir comment les gérer tous individuellement? Rappelez-vous, vous savez seulement ceux que vous vous jetez pas avec le mot clé throw dans votre implémentation. API que vous utilisez dans votre implémentation de la méthode pourrait également lancer des exceptions que vous ne savez pas parce qu'ils pourraient ne pas être documentés et vous n'êtes pas les manipuler dans votre mise en œuvre, de sorte qu'ils vont exploser face à l'appelant de votre méthode. En d'autres termes, ces commentaires de documentation XML ne remplacent pas les exceptions vérifiées.

2. Andreas a associé un entretien avec Anders Hejlsberg dans les réponses ici pourquoi l'équipe de conception C # a décidé contre exceptions vérifiées. La réponse ultime à la question initiale est cachée dans cette interview:

  

Les programmeurs protègent leur code en écrivant essayer est enfin partout, donc ils vont revenir en arrière correctement si une exception se produit, mais ils ne sont pas réellement intéressés à gérer les exceptions.

En d'autres termes, personne ne devrait être intéressé par ce type d'exception peut être prévue pour une API particulière que vous allez toujours attraper tous partout. Et si vous voulez vraiment prendre soin des exceptions particulières, comment les gérer est à vous et non quelqu'un définir une signature de méthode avec quelque chose comme le Java jette mot-clé, forçant exception notamment la manipulation sur un utilisateur API.

-

Personnellement, je suis déchiré ici. Je suis d'accord avec Anders que d'avoir des exceptions contrôlé ne résout pas le problème sans ajouter de nouveaux problèmes différents. Tout comme avec les commentaires de documentation XML, je vois rarement le code C # avec tout enveloppé dans des blocs enfin essayer. Il me sent bien que ce soit bien votre seule option et quelque chose qui semble comme une bonne pratique.

Answer 6

En fait, ne pas avoir vérifié les exceptions en C # peut être considéré comme une bonne ou mauvaise chose.

Je me considère comme une bonne solution, car les exceptions vérifiées vous fournir les problèmes suivants:

1. Exceptions techniques fuirait la couche d'affaires / domaine parce que vous ne pouvez pas les gérer correctement le niveau bas.
2. Ils appartiennent à la signature de la méthode qui ne joue pas toujours agréable avec un design API.

A cause de cela dans la plupart des grandes applications, vous verrez le schéma suivant souvent lorsque des exceptions se produisent vérifiés:

try {
    // Some Code
} catch(SomeException ex){
    throw new RuntimeException(ex);
}

Ce qui signifie essentiellement émulant la voie C # /. NET poignées toutes les exceptions.

Answer 7

Vous demandez à ceci:

Re-lancer une exception

public void Method()
{
  try
  {
      int x = 0;
      int sum = 100/x;
  }
  catch(DivideByZeroException e)
  {
      throw;
  }
}

ou

static void Main() 
    {
        string s = null;

        if (s == null) 
        {
            throw new ArgumentNullException();
        }

        Console.Write("The string s is null"); // not executed
    }

Answer 8

Il y a quelques similitudes entre le fugaces .Net CodeContract EnsuresOnThrow<> et le descripteur de throws java, en ce que les deux peuvent signaler à l'appelant que le type d'exception qui peut être soulevée à partir d'une fonction ou d'une méthode, bien qu'il existe également des différences majeures entre les deux:

• EnsuresOnThrow<> va au-delà indiquant quelles exceptions peuvent être jetés, mais précise également les conditions dans lesquelles ils sont garantis pour être jetés - cela peut être un code assez onéreux dans la méthode appelée si la condition d'exception n'est pas trivial à identifier. Java throws fournit une indication des exceptions pourraient être lancées (c.-à-OMI, la mise au point en .Net est dans la méthode des contrats pour prouver l'throw, alors qu'en Java les changements de mise au point à l'appelant à reconnaître la possibilité de l'exception).
• .Net CC ne fait pas la distinction entre Vérifié vs Décoché exceptions Java a, bien que la section du manuel CC 2.2.2 fait mention à

  

"utiliser postconditions exceptionnelles uniquement pour les exceptions que l'appelant   devraient attendre dans le cadre de l'API "

• Dans .Net l'appelant peut déterminer si oui ou non à quoi que ce soit à l'exception (par exemple en désactivant des contrats). En Java, l'appelant doit faire quelque chose , même si elle ajoute une throws pour la même exception sur son interface.

Code des marchés ici manuel