problema na instrução try

Question

Este é o uso de código I para configurar meu servidor TCP

    internal void Initialize(int port,string IP)
    {
        IPEndPoint _Point = new IPEndPoint(IPAddress.Parse(IP), port);
        Socket _Accpt = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        try
        {
            _Accpt.Bind(_Point);
        }
        catch (SocketException exc)
        {
            System.Windows.Forms.MessageBox.Show(exc.Message);

        }
        finally
        {
            _Accpt.Listen(2); //Second exception is here after the code continues after the catch block
            _Accpt.BeginAccept(null, 0, new AsyncCallback(Accept), _Accpt);
        }
    }

Se você chamar Bind no mesmo destino que você vai ter uma exceção, porque a porta já está em uso, de modo que eu recebo essa exceção quando eu chamar essa função duas vezes.

Problema - Depois catch {} declaração o código continua a seguir a fim {} mesmo que eu pego a exceção, por que isso acontece? Eu quero isso para sair da função após os messagebox.I tentado com o "retorno", mas ainda continua a seguir o bloco finally {}.

Answer 1

O bloco finally sempre executa, independentemente se uma exceção foi acionada ou o método estava saindo de dentro do bloco try / catch.

Answer 2

O bloco Finalmente é onde você colocar o código que devem ser executados independentemente do bloco try bem sucedida ou não. É onde você colocar o código "limpeza" que poderiam dispor objetos etc.

Então, é por-design que este código é executado independentemente do que aconteceu. Talvez você precisa mover esse código no bloco de tentar se você quiser só que em execução quando o Bind é bom.

Confira esta página ...

http://msdn.microsoft.com/ en-us / library / 6dekhbbc (VS.80) .aspx

... para obter detalhes sobre como isso funciona.

A tentativa de amostra / catch / finally segue (retirado do CLR de Jeffery Richter via C #, que deve estar em sua leitura obrigatória) ...

FileStream fs = null;

try
{
  fs = new FileStream(...)

  // process the data

}
catch (IOException)
{
  // inside this catch block is where you put code that recovers
  // from an IOException
}
finally
{
  // make sure the file gets closed
  if (fs != null) fs.Close();
}

Answer 3

Como os outros têm para fora pontas, o bloco finally sempre ocorrerá independentemente de uma exceção sendo lançada.

Alterar o código para

    try
    {
        _Accpt.Bind(_Point);
        _Accpt.Listen(2); //Second exception is here after the code continues after the catch block
        _Accpt.BeginAccept(null, 0, new AsyncCallback(Accept), _Accpt);
    }
    catch (SocketException exc)
    {
        System.Windows.Forms.MessageBox.Show(exc.Message);

    }
    finally
    {
        //Final logging
        //Disposal of initial objects etc...
    }

Answer 4

A idéia inteira com finally é que ele sempre será executado - exceções ou sem exceções. Use-o para a limpeza etc.

Answer 5

Finalmente blocos são sempre executadas. Esse é o ponto de finalmente.

Parece que as linhas que você tem no 'finalmente' talvez pertencem na tentativa?

Answer 6

finalmente é sempre executada.

Apenas o código que existe após a linha de código que lançou a exceção não será executado, até que uma exceção captura é encontrado que pode capturar a exceção.