Usando exceções (guia de programação translation from VPE for Csharp)
Em translation from VPE for Csharp, erros no programa em time de execução são propagados por meio do programa, usando um mecanismo chamado exceções.Exceções são lançadas por código encontra um erro e detectadas pelo código que pode corrigir o erro.Exceções podem ser geradas pelo .NET estrutura common linguagem tempo de execução (CLR) ou pelo código em um programa.Depois que uma exceção é lançada, ele propaga cima na pilha de chamadas até um catch demonstrativo para a exceção é encontrada. Exceções não capturadas são tratadas por um manipulador de exceção genérico fornecida pelo sistema que exibe uma caixa de diálogo.
Exceções são representadas por classes derivadas de Exception. Esta classe identifica o tipo de exceção e contém propriedades que possuem detalhes sobre a exceção.Lançando uma exceção envolve a criação de uma instância de uma classe derivada de exceção, opcionalmente Configurando as propriedades da exceção e, em seguida, lançando o objeto usando o throw palavra-chave. Por exemplo:
class CustomException : Exception
{
public CustomException(string message)
{
}
}
private static void TestThrow()
{
CustomException ex =
new CustomException("Custom exception in TestThrow()");
throw ex;
}
Depois que uma exceção é lançada, o tempo de execução verifica a demonstrativo corrente se ele está dentro de um try bloco. Se for, qualquer catch blocos associados com o try bloco são verificados para ver se eles podem capturar a exceção. Catch blocos geralmente especificam tipos de exceção; se o tipo da catch bloco é o mesmo tipo que a exceção ou uma classe base da exceção, o catch bloco pode lidar com o método. Por exemplo:
static void TestCatch()
{
try
{
TestThrow();
}
catch (CustomException ex)
{
System.Console.WriteLine(ex.ToString());
}
}
Se a demonstrativo que lança uma exceção não estiver dentro de um try bloco ou se a try bloco que engloba ele tem nenhuma correspondência catch bloco, o tempo de execução verifica o método de chamada para um try demonstrativo e catch blocos. O tempo de execução continua na pilha de chamada, procurando por um compatível catch bloco. Após o catch bloco é localizado e executado, controle é passado para a próxima demonstrativo depois que catch bloco.
A try demonstrativo pode conter mais de uma catch bloco. O primeiro catch demonstrativo que pode tratar a exceção é executada; qualquer seguinte catch instruções, mesmo que sejam compatível, são ignoradas. Portanto, catch blocos sempre devem ser ordenados da mais específica (ou derivado de mais) para menos específico.Por exemplo:
static void TestCatch2()
{
System.IO.StreamWriter sw = null;
try
{
sw = new System.IO.StreamWriter(@"C:\test\test.txt");
sw.WriteLine("Hello");
}
catch (System.IO.FileNotFoundException ex)
{
System.Console.WriteLine(ex.ToString()); // put the more specific exception first
}
catch (System.IO.IOException ex)
{
System.Console.WriteLine(ex.ToString()); // put the less specific exceptions last
}
finally
{
sw.Close();
}
System.Console.WriteLine("Done"); // this statement is executed after the catch block
}
Antes do catch bloco é executado, o tempo de execução verifica se há finally blocos. Finally blocos de habilitar o programador limpar qualquer estado ambíguo que poderia ser de um anulado try bloco, ou para liberar sistema autônomo recursos externos (sistema autônomo alças de elementos gráficos, conexões de banco de dados ou fluxos de arquivo) sem precisarem aguardar até que o coletor de lixo em tempo de execução finalizar sistema autônomo objetos. Por exemplo:
static void TestFinally()
{
System.IO.FileStream file = null;
//Change the path to something that works on your machine
System.IO.FileInfo fileInfo = new System.IO.FileInfo(@"C:\file.txt");
try
{
file = fileInfo.OpenWrite();
file.WriteByte(0xF);
}
finally
{
// Closing the file allows you to reopen it immediately - otherwise IOException is thrown.
if (file != null)
{
file.Close();
}
}
try
{
file = fileInfo.OpenWrite();
System.Console.WriteLine("OpenWrite() succeeded");
}
catch (System.IO.IOException)
{
System.Console.WriteLine("OpenWrite() failed");
}
}
If WriteByte() gerou uma exceção, o código na segunda try bloco que tente reabrir o arquivo falhará se file.Close() não é chamado e o arquivo seria permanecem bloqueado. Porque finally blocos são executados, mesmo se uma exceção for lançada, a finally bloco no exemplo anterior permite que o arquivo a ser fechado corretamente e ajuda a evitar um erro.
Se nenhum compatível catch bloco é encontrado na telefonar pilha após uma exceção é lançada, um dos três fatos ocorre:
Se a pilha de chamadas contiver um construtor estático, ou um inicializador Campo estático, é acionada, com a exceção original atribuída à propriedade InnerException da Nova Exceção. um TypeInitializationException
Se o telefonar pilha contém um construtor estático ou um inicializador de campo estático, um TypeInitializationException é lançada, com a exceção original atribuída à InnerException propriedade da nova exceção.
Se o início do thread é alcançado, o thread será encerrado.