C # processo classe esperaforexit

classe de processo C # waitforexit
Obter através da App Store Leia esta publicação em nosso aplicativo!
process. WaitForExit () de forma assíncrona.
Quero aguardar um processo para terminar, mas process. WaitForExit () trava minha GUI. Existe uma maneira baseada em eventos, ou eu preciso gerar um segmento para bloquear até sair, depois delegar o evento eu mesmo?
A partir de 4.0 / C # 5, é melhor representar isso usando o padrão assíncrono.
Se você escolher a resposta @MgSam, esteja ciente, se você passar por WaitForExitAsync algum CancelamentoToken, que será automaticamente cancelado após o atraso especificado, você pode obter uma InvalidOperationException. Para corrigir isso, você precisa mudar.
P. S .: não esqueça de dispor o seu CancelamentoTokenSource no tempo.
De acordo com este link, o método WaitForExit () é usado para fazer o thread atual aguardar até o processo associado terminar. No entanto, o processo possui um evento Exitado ao qual você pode se conectar.

Exemplo de uso.
Resolvi assim:
Eu redirecionava a entrada, a saída e o erro e administrai a leitura dos fluxos de saída e erro. Esta solução funciona para o SDK 7- 8.1, tanto para o Windows 7 como para o Windows 8.
Eu tentei fazer uma aula que resolva seu problema usando a leitura de fluxo assíncrono, levando em conta Mark Byers, Rob, Stevejay responde. Ao fazê-lo, percebi que existe um erro relacionado à leitura assíncrona do fluxo de saída do processo.
Você não pode fazer isso:
Você receberá System. InvalidOperationException: StandardOut não foi redirecionado ou o processo ainda não começou.
Então, você deve iniciar a saída assíncrona lida após o processo ser iniciado:
Fazendo isso, faça uma condição de corrida porque o fluxo de saída pode receber dados antes de configurá-lo como assíncrono:
Então algumas pessoas podem dizer que você só precisa ler o fluxo antes de configurá-lo como assíncrono. Mas o mesmo problema ocorre. Haverá uma condição de corrida entre a leitura síncrona e configurará o fluxo em modo assíncrono.
Não há como conseguir uma leitura assíncrona segura de um fluxo de saída de um processo na forma real "Processo" e "ProcessStartInfo" foi projetado.
Você provavelmente está melhor usando a leitura assíncrona, como sugerido por outros usuários para o seu caso. Mas você deve estar ciente de que você pode perder algumas informações devido à condição de corrida.
Nenhuma das respostas acima está fazendo o trabalho.
A solução Rob trava e a solução 'Mark Byers' obtém a exceção descarta. (Eu tentei as "soluções" das outras respostas).
Então eu decidi sugerir outra solução:
Este código é depurado e funciona perfeitamente.
Eu acho que isso é uma abordagem simples e melhor (não precisamos do AutoResetEvent):
Eu estava tendo o mesmo problema, mas a razão era diferente. No entanto, isso aconteceria no Windows 8, mas não no Windows 7. A seguinte linha parece ter causado o problema.
A solução era NÃO desativar UseShellExecute. Agora recebi uma janela popup do Shell, que é indesejável, mas muito melhor do que o programa esperando que nada de particular aconteça. Então eu adicionei o seguinte trabalho para isso:
Agora, o único problema que me incomoda é o porquê isso está acontecendo no Windows 8, em primeiro lugar.
Introdução.
A resposta atualmente aceita não funciona (lança exceção) e há muitas soluções alternativas, mas nenhum código completo. Isso é, obviamente, desperdiçando muito tempo das pessoas porque esta é uma questão popular.
Combinando a resposta de Mark Byers e a resposta de Karol Tyl, escrevi um código completo baseado em como eu quero usar o método Process. Start.
Eu usei-o para criar um diálogo de progresso em torno dos comandos git. É assim que eu usei isso:
Em teoria, você também pode combinar stdout e stderr, mas não testei isso.
Eu sei que isso é velho, mas, depois de ler toda essa página, nenhuma das soluções estava funcionando para mim, embora eu não tentei Muhammad Rehan porque o código era um pouco difícil de seguir, embora eu acho que ele estava no caminho certo . Quando eu digo que não funcionou, isso não é inteiramente verdade, às vezes funcionaria bem, acho que é algo a ver com a duração da saída antes de uma marca EOF.
De qualquer forma, a solução que funcionou para mim era usar diferentes threads para ler o StandardOutput e StandardError e escrever as mensagens.
Espero que isso ajude alguém, que pensou que isso poderia ser tão difícil!
As outras soluções (incluindo o EM0) ainda estão bloqueadas para o meu aplicativo, devido a tempos de espera internos e ao uso de StandardOutput e StandardError pela aplicação gerada. Aqui está o que funcionou para mim:
Editar: inicialização adicionada de StartInfo para codificar a amostra.
Este post talvez esteja desactualizado, mas descobri a principal causa por que normalmente ele trava é devido ao excesso de pilha para o redirectStandardoutput ou se você tem redirectStandarderror.
Como os dados de saída ou os dados de erro são grandes, isso causará um tempo de espera, pois ele ainda está processando por tempo indefinido.

Processo . Método WaitForExit (Int32)
A documentação de referência da API tem uma nova casa. Visite o navegador da API no docs. microsoft para ver a nova experiência.
Instrui o componente Processo a aguardar o número especificado de milissegundos para que o processo associado saia.
Assembly: System (no System. dll)
Parâmetros.
A quantidade de tempo, em milissegundos, para aguardar o encerramento do processo associado. O máximo é o maior valor possível de um inteiro de 32 bits, que representa infinito para o sistema operacional.
Valor de retorno.
é verdade se o processo associado tenha saído; caso contrário, falso.
A configuração de espera não pôde ser acessada.
Nenhum Id do processo foi configurado e um identificador do qual a propriedade Id pode ser determinada não existe.
Não existe nenhum processo associado a este objeto Processo.
Você está tentando chamar WaitForExit (Int32) para um processo que está sendo executado em um computador remoto. Este método está disponível somente para processos que estão sendo executados no computador local.
WaitForExit (Int32) faz o thread atual aguardar até o processo associado terminar. Ele deve ser chamado após todos os outros métodos serem chamados no processo. Para evitar o bloqueio do segmento atual, use o evento Exitado.
Esse método instrui o componente Processo a aguardar um período finito de tempo para o processo sair. Se o processo associado não sair pelo final do intervalo porque a solicitação de término é negada, o falso é retornado ao procedimento de chamada. Você pode especificar um número negativo (Infinito) por milissegundos e Processar. WaitForExit (Int32) irá comportar-se da mesma forma que a sobrecarga WaitForExit (). Se você passar 0 (zero) para o método, ele retorna verdadeiro somente se o processo já foi encerrado; Caso contrário, ele retorna imediatamente falso.
No Quadro 3.5 e versões anteriores, se o milissegundo fosse -1, a sobrecarga WaitForExit (Int32) esperava milissegundos MaxValue (aproximadamente 24 dias), não indefinidamente.
Quando a saída padrão foi redirecionada para manipuladores de eventos assíncronos, é possível que o processamento de saída não seja concluído quando esse método retornar. Para garantir que o tratamento de eventos assíncrono tenha sido concluído, chame a sobrecarga WaitForExit () que não leva nenhum parâmetro depois de receber uma verdade dessa sobrecarga. Para ajudar a garantir que o evento Exited seja tratado corretamente nas aplicações Windows Forms, defina a propriedade SynchronizingObject.
Quando um processo associado é encerrado (é encerrado pelo sistema operacional através de uma terminação normal ou anormal), o sistema armazena informações administrativas sobre o processo e retorna ao componente que chamou WaitForExit (Int32). O componente Processo pode acessar a informação, que inclui o ExitTime, usando o Handle para o processo encerrado.
Como o processo associado saiu, a propriedade Handle do componente já não aponta para um recurso de processo existente. Em vez disso, o identificador pode ser usado apenas para acessar as informações do sistema operacional sobre o recurso do processo. O sistema está ciente de manipulações para processos que não foram lançados pelos componentes do Processo, portanto, mantém as informações ExitTime e Handle na memória até que o componente Processo liberte especificamente os recursos. Por esse motivo, sempre que você ligar para uma instância do Start for Process, chame Close quando o processo associado for encerrado e você não precisa mais de informações administrativas sobre isso. Fechar libera a memória alocada para o processo encerrado.
Consulte o exemplo de código para a propriedade ExitCode.
para uma confiança total para o chamador imediato. Este membro não pode ser usado por código parcialmente confiável.

Método Process. WaitForExit ()
Instrui o componente Processo a esperar indefinidamente para que o processo associado saia.
Exceções.
Não existe nenhum processo associado a este objeto Processo.
Você está tentando chamar WaitForExit para um processo em execução em um computador remoto. O método está disponível somente para processos que estão sendo executados no computador local.
WaitForExit é usado para fazer o thread atual aguardar até o processo associado terminar.
Essa sobrecarga do WaitForExit instrui o componente Processo a aguardar uma quantidade infinita de tempo para o processo sair. Isso pode fazer com que um aplicativo pare de responder. Por exemplo, se você chamar CloseMainWindow para um processo que tenha uma interface de usuário, a solicitação ao sistema operacional para encerrar o processo associado pode não ser tratada se o processo for gravado para nunca entrar no loop de mensagem.
Quando um processo associado sai (é desligado pelo sistema de operação através de um término normal ou anormal), o sistema armazena informações administrativas sobre o processo e retorna ao componente que chamou WaitForExit. O componente Processo pode acessar a informação, que inclui o ExitTime, usando o Handle para o processo encerrado.
Como o processo associado saiu, a propriedade Handle do componente já não aponta para um recurso de processo existente. Em vez disso, o identificador pode ser usado apenas para acessar as informações do sistema operacional sobre o recurso do processo. O sistema está ciente de manipulações para processos que não foram lançados pelos componentes do Processo, portanto, mantém as informações ExitTime e Handle na memória até que o componente Processo liberte especificamente os recursos. Por esse motivo, sempre que você ligar para uma instância do Start for Process, chame Close quando o processo associado for encerrado e você não precisa mais de informações administrativas sobre isso. Fechar libera a memória alocada para o processo encerrado.
Requisitos.
Plataformas: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, família Windows Server 2003.

Classe de processo.
A documentação de referência da API tem uma nova casa. Visite o navegador da API no docs. microsoft para ver a nova experiência.
Fornece acesso a processos locais e remotos e permite que você comece e pare processos locais do sistema.
Para procurar o código-fonte do Framework para este tipo, consulte a Fonte de Referência.
Assembly: System (no System. dll)
Inicializa uma nova instância da classe Process.
Obtém a prioridade básica do processo associado.
Obtém um valor que indica se o componente pode aumentar um evento. (Herdado de Component.)
Obtém o IContainer que contém o Componente. (Herdado do Componente.)
Obtém um valor que indica se o Componente está atualmente no modo de design. (Herdado do Componente).
Obtém ou define se o evento Exited deve ser gerado quando o processo termina.
Obtém a lista de manipuladores de eventos anexados a este Componente. (Herdado do Componente.)
Obtém o valor que o processo associado especificou quando terminou.
Obtém o tempo que o processo associado saiu.
Obtém o identificador nativo do processo associado.
Obtém o número de alças abertas pelo processo.
Obtém um valor indicando se o processo associado foi encerrado.
Obtém o identificador exclusivo para o processo associado.
Obtém o nome do computador em que o processo associado está sendo executado.
Obtém o módulo principal para o processo associado.
Obtém o identificador de janela da janela principal do processo associado.
Obtém a legenda da janela principal do processo.
Obtém ou define o tamanho de conjunto de trabalho máximo permitido, em bytes, para o processo associado.
Obtém ou define o tamanho de conjunto de trabalho mínimo permitido, em bytes, para o processo associado.
Obtém os módulos que foram carregados pelo processo associado.
Obsoleto. Obtém a quantidade de memória do sistema não paginada, em bytes, alocada para o processo associado.
Obtém a quantidade de memória do sistema não paginada, em bytes, alocada para o processo associado.
Obsoleto. Obtém a quantidade de memória paginada, em bytes, alocada para o processo associado.
Obtém a quantidade de memória paginada, em bytes, alocada para o processo associado.
Obsoleto. Obtém a quantidade de memória do sistema pagável, em bytes, alocada para o processo associado.
Obtém a quantidade de memória do sistema pagável, em bytes, alocada para o processo associado.
Obsoleto. Obtém a quantidade máxima de memória no arquivo de paginação de memória virtual, em bytes, usado pelo processo associado.
Obtém a quantidade máxima de memória no arquivo de paginação de memória virtual, em bytes, usado pelo processo associado.
Obsoleto. Obtém a quantidade máxima de memória virtual, em bytes, usada pelo processo associado.
Obtém a quantidade máxima de memória virtual, em bytes, usada pelo processo associado.
Obsoleto. Obtém o tamanho máximo do conjunto de trabalho para o processo associado, em bytes.
Obtém a quantidade máxima de memória física, em bytes, usada pelo processo associado.
Obtém ou define um valor indicando se a prioridade de processo associada deve ser impulsionada temporariamente pelo sistema operacional quando a janela principal tiver o foco.
Obtém ou define a categoria de prioridade geral para o processo associado.
Obsoleto. Obtém a quantidade de memória privada, em bytes, alocada para o processo associado.
Obtém a quantidade de memória privada, em bytes, alocada para o processo associado.
Obtém o tempo de processador privilegiado para esse processo.
Obtém o nome do processo.
Obtém ou define os processadores nos quais os segmentos neste processo podem ser agendados para serem executados.
Obtém um valor indicando se a interface do usuário do processo está respondendo.
Obtém o identificador nativo para esse processo.
Obtém o identificador de sessão do Terminal Services para o processo associado.
Obtém ou define o ISite do Componente. (Herdado de Component.)
Obtém um fluxo usado para ler a saída de erro do aplicativo.
Obtém um fluxo usado para escrever a entrada do aplicativo.
Obtém um fluxo usado para ler o resultado textual da aplicação.
Obtém ou define as propriedades para passar para o método Start do Processo.
Obtém o tempo que o processo associado foi iniciado.
Obtém ou define o objeto usado para organizar as chamadas do manipulador de eventos que são emitidas como resultado de um evento de saída do processo.
Obtém o conjunto de threads que estão sendo executados no processo associado.
Obtém o tempo total do processador para esse processo.
Obtém o tempo do processador do usuário para esse processo.
Obsoleto. Obtém o tamanho da memória virtual do processo, em bytes.
Obtém a quantidade de memória virtual, em bytes, alocada para o processo associado.
Obsoleto. Obtém o uso da memória física do processo associado, em bytes.
Obtém a quantidade de memória física, em bytes, alocada para o processo associado.
Inicia operações de leitura assíncronas no fluxo StandardError redirecionado do aplicativo.
Inicia operações de leitura assíncrona no fluxo de StandardOutput redirecionado do aplicativo.
Cancela a operação de leitura assíncrona no fluxo de padrão StandardError redirecionado de um aplicativo.
Cancela a operação de leitura assíncrona no fluxo de StandardOutput redirecionado de um aplicativo.
Libera todos os recursos associados a este componente.
Fecha um processo que possui uma interface de usuário enviando uma mensagem fechada para a janela principal.
Cria um objeto que contém todas as informações relevantes necessárias para gerar um proxy usado para se comunicar com um objeto remoto. (Herdado de MarshalByRefObject.)
Libera todos os recursos usados ​​pelo Componente. (Herdado do Componente.)
Esta API suporta a infra-estrutura do produto e não se destina a ser usada diretamente do seu código. Libere todos os recursos usados ​​por este processo. (Substitui Componente. Descarte (Booleano).)
Coloca um componente de Processo no estado para interagir com os processos do sistema operacional que são executados em um modo especial ao ativar a propriedade nativa SeDebugPrivilege no tópico atual.
Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object).
Libera recursos não gerenciados e executa outras operações de limpeza antes que o Componente seja recuperado por coleta de lixo (Herdado do Componente).
Obtém um novo componente do Processo e o associa ao processo atualmente ativo.
Serve como a função hash padrão. (Herdado de Object.)
Recupera o objeto de serviço de vida útil atual que controla a política de vida para esta instância. (Herdado de MarshalByRefObject.)
Retorna um novo componente Processo, dado o identificador de um processo no computador local.
Retorna um novo componente de Processo, dado um identificador de processo e o nome de um computador na rede.
Cria um novo componente de Processo para cada recurso de processo no computador local.
Cria um novo componente de Processo para cada recurso de processo no computador especificado.
Cria uma série de novos componentes do Processo e os associa a todos os recursos do processo no computador local que compartilham o nome do processo especificado.
Cria uma série de novos componentes do Processo e os associa a todos os recursos do processo em um computador remoto que compartilha o nome do processo especificado.
Retorna um objeto que representa um serviço fornecido pelo Componente ou pelo seu Recipiente. (Herdado do Componente.)
Obtém o Tipo da instância atual. (Herdado de Object.)
Obtém um objeto de serviço ao longo da vida para controlar a política de vida para esta instância. (Herdado de MarshalByRefObject.)
Imediatamente para o processo associado.
Obtém um componente de processo fora do estado que permite interagir com os processos do sistema operacional que são executados em um modo especial.
Cria uma cópia superficial do Objeto atual. (Herdado de Object).
Cria uma cópia superficial do objeto MarshalByRefObject atual. (Herdado de MarshalByRefObject.)
Eleva o evento Exited.
Rejeita qualquer informação sobre o processo associado que foi armazenado em cache dentro do componente do processo.
Inicia (ou reutiliza) o recurso de processo que é especificado pela propriedade StartInfo desse componente do Processo e o associa ao componente.
Inicia o recurso de processo que é especificado pelo parâmetro que contém as informações de início do processo (por exemplo, o nome do processo para iniciar) e associa o recurso a um novo componente do Processo.
Inicia um recurso de processo especificando o nome de um documento ou arquivo de aplicativo e associa o recurso com um novo componente de Processo.
Inicia um recurso de processo especificando o nome de um aplicativo e um conjunto de argumentos de linha de comando e associa o recurso a um novo componente de Processo.
Inicia um recurso de processo especificando o nome de um aplicativo, um nome de usuário, uma senha e um domínio e associa o recurso com um novo componente do Processo.
Inicia um recurso de processo especificando o nome de um aplicativo, um conjunto de argumentos de linha de comando, um nome de usuário, uma senha e um domínio e associa o recurso com um novo componente de Processo.
Formata o nome do processo como uma seqüência de caracteres, combinada com o tipo de componente principal, se aplicável. (Substitui Componente. ToString ().)
Instrui o componente Processo a esperar indefinidamente para que o processo associado saia.
Instrui o componente Processo a aguardar o número especificado de milissegundos para que o processo associado saia.
Causa o componente Process para esperar indefinidamente para que o processo associado entre no estado ocioso. Essa sobrecarga se aplica apenas a processos com uma interface de usuário e, portanto, a um loop de mensagem.
Causa o componente Process para aguardar o número especificado de milissegundos para que o processo associado entre no estado ocioso. Essa sobrecarga se aplica apenas a processos com uma interface de usuário e, portanto, a um loop de mensagem.
Ocorre quando o componente é descartado por uma chamada para o método Dispose. (Herdado do componente).
Ocorre quando uma aplicação escreve no seu fluxo StandardError redirecionado.
Ocorre quando um processo sai.
Ocorre cada vez que um aplicativo grava uma linha em seu fluxo de saída StandardOutput redirecionado.
Para visualizar o código-fonte do Framework para este tipo, consulte a Fonte de Referência. Você pode navegar pelo código-fonte on-line, baixar a referência para exibição off-line e passar pelas fontes (incluindo patches e atualizações) durante a depuração; veja as instruções.
Um componente do Processo fornece acesso a um processo que está sendo executado em um computador. Um processo, nos termos mais simples, é um aplicativo em execução. Um segmento é a unidade básica à qual o sistema operacional aloca o tempo do processador. Um segmento pode executar qualquer parte do código do processo, incluindo partes que estão sendo executadas por outro segmento.
O componente Processo é uma ferramenta útil para iniciar, parar, controlar e monitorar aplicativos. Você pode usar o componente Processo, para obter uma lista dos processos que estão sendo executados, ou você pode iniciar um novo processo. Um componente de processo é usado para acessar os processos do sistema. Depois que um componente do Processo foi inicializado, ele pode ser usado para obter informações sobre o processo em execução. Essas informações incluem o conjunto de threads, os módulos carregados (arquivos. dll e. exe) e informações de desempenho, como a quantidade de memória que o processo está usando.
Esse tipo implementa a interface IDisposable. Quando você terminar de usar o tipo, você deve descartá-lo, direta ou indiretamente. Para descartar o tipo diretamente, chame seu método Dispose em um bloco try / catch. Para descartar indiretamente, use uma construção de idioma, como usar (em C #) ou Usar (no Visual Basic). Para obter mais informações, consulte a seção "Usando um objeto que implementa IDisposable" no tópico da interface IDisposable.
Os processos de 32 bits não podem acessar os módulos de um processo de 64 bits. Se você tentar obter informações sobre um processo de 64 bits a partir de um processo de 32 bits, você receberá uma exceção Win32Exception. Um processo de 64 bits, por outro lado, pode acessar os módulos de um processo de 32 bits.
O componente do processo obtém informações sobre um grupo de propriedades ao mesmo tempo. Depois que o componente Process obteve informações sobre um membro de qualquer grupo, armazenará os valores das outras propriedades nesse grupo e não obterá novas informações sobre os outros membros do grupo até você chamar o método Refresh. Portanto, um valor de propriedade não é garantido para ser mais novo do que a última chamada para o método Refresh. As quebras do grupo dependem do sistema operacional.
Se você tiver uma variável de caminho declarada em seu sistema usando aspas, você deve qualificar completamente esse caminho ao iniciar qualquer processo encontrado nesse local. Caso contrário, o sistema não encontrará o caminho. Por exemplo, se c: \ mypath não estiver no seu caminho, e você adicioná-lo usando aspas: path =% path%; "c: \ mypath", você deve qualificar completamente qualquer processo em c: \ mypath ao iniciá-lo.
Um processo do sistema é identificado de forma exclusiva no sistema pelo seu identificador de processo. Como muitos recursos do Windows, um processo também é identificado pelo identificador, que pode não ser exclusivo no computador. Um identificador é o termo genérico para um identificador de um recurso. O sistema operacional persiste no identificador do processo, acessado através da propriedade Handle do componente Process, mesmo quando o processo foi encerrado. Assim, você pode obter as informações administrativas do processo, como o ExitCode (geralmente zero para o sucesso ou um código de erro diferente de zero) e o ExitTime. As alças são um recurso extremamente valioso, de modo que as alças vazadas são mais virulentas do que a perda de memória.
Esta classe contém uma demanda de link e uma demanda de herança no nível de classe que se aplica a todos os membros. Uma SecurityException é lançada quando o chamador imediato ou a classe derivada não possui permissão de confiança total. Para obter detalhes sobre as demandas de segurança, consulte Demandas de links.
No Framework na área de trabalho, a classe Process por padrão usa codificações do console, que normalmente são codificações de página de código, para a entrada, saída e fluxos de erro. Por exemplo, código, em sistemas cuja cultura é o inglês (Estados Unidos), a página de códigos 437 é a codificação padrão para a classe Console. No entanto, o Core pode fazer apenas um subconjunto limitado dessas codificações disponíveis. Se este for o caso, ele usa Encoding. UTF8 como a codificação padrão.
Se um objeto Process depende das codificações específicas da página de códigos, você ainda pode disponibilizá-las fazendo o seguinte antes de chamar qualquer método de Processo:
Adicione uma referência ao assembly System. Text. Encoding. CodePages. dll ao seu projeto.
Passe o objeto EncodingProvider para a codificação. Método RegisterProvider para disponibilizar as codificações adicionais suportadas pelo provedor de codificação.
A classe Processo usará automaticamente a codificação padrão do sistema em vez de UTF8, desde que você tenha registrado o provedor de codificação antes de chamar qualquer método de Processo.
O exemplo a seguir usa uma instância da classe Process para iniciar um processo.
O exemplo a seguir usa a própria classe de processo e um método de início estático para iniciar um processo.
O seguinte exemplo F # define uma função runProc que inicia um processo, captura todas as informações de saída e erro e registra o número de milissegundos que o processo executou. A função runProc possui três parâmetros: o nome do aplicativo para iniciar, os argumentos para fornecer ao aplicativo e o diretório inicial.
O código para a função runProc foi escrito pelo ImaginaryDevelopment e está disponível sob a Licença Pública da Microsoft.
para uma confiança total para o chamador imediato. Esta classe não pode ser usada por código parcialmente confiável.
para uma confiança total para os herdeiros. Essa classe não pode ser herdada por código parcialmente confiável.
Disponível desde 1.1.
Qualquer público estático (Shared no Visual Basic) membros desse tipo são thread-safe. Todos os membros da instância não são garantidos para serem seguros por thread.