Deus existe, e nos não damos o seu real e devido valor.

Deus existe, e nos não damos o seu real e devido valor.

Sempre na hora que mais precisamos ele esta ali do nosso lado para nos ajudar, não necessariamente o chame nesta hora com palavras porque ele não escuta, e sim sinta ele no seu coração e com o seu coração mostre a ele que esta sempre com ele ao seu lado, e esta sempre acreditando nele que ele exite, tem muita gente que chamam seu santo nome em vão sabendo que ele não escutar e não vai ajudar.

Deus sabe quem realmente necessita de sua presença, e livra nos do mal, e nos ajuda na hora que mais precisarmos e na hora que estamos mais aflito.

Perdoe a mim e aos meus amigos e familiares, o mal que fazemos aos próximos, a ganancia a luxuria não leva a nada porque quando morremos sabemos que isso fica para outras pessoas brigarem e maltratarem a quem esta perto deles e aquém eles amam por objetos que não levam para o caixão.

Vou falar com palavras, não para Deus e sim para as pessoas que estão ao meu redor, obrigado por todas as vezes que mim livraste de um grande aperreio na minha vida e que minhas lagrimas sirva para mim e para ti de exemplo que o senhor e nosso pastor e nada nos faltara.

AMÉM

[Leia um pouco sobre] As melhorias de produtividade para o Entity Framework!

As melhorias de produtividade para o Entity Framework

Antecedentes

     Temos ouvido muito bom feedback sobre a atualização recém-lançado para o Entity Framework no .NET 4. Este lançamento marca um avanço significativo a partir do primeiro lançamento que acompanha o .NET 3.5 SP1. Eu não estou indo para passar o tempo aqui falando sobre o que há de novo, mas você pode conferir aqui para ver por si mesmo.

     Com tudo o que disse, ainda há uma série de coisas que podemos fazer para simplificar o processo de escrever código de acesso a dados com o Entity Framework. Temos vindo a prestar atenção aos padrões mais comuns que vemos os desenvolvedores que usam com a EF e foram fabricam cerveja acima de um conjunto de melhorias para o Entity Framework projetado para permitir que desenvolvedores para realizar as mesmas tarefas com menos código e menos conceitos.

  

     Estas melhorias oferecem uma superfície mais limpa e mais simples API que se concentra a sua atenção sobre os cenários mais comuns, mas ainda lhe permite detalhar a funcionalidade mais avançada quando é necessário. Nós esperamos que você vai desfrutar desta experiência simples, mas devemos ser rápidos para assegurar-lhe que esta não é uma nova tecnologia de acesso a dados. Estas melhorias são construídos sobre a mesma tecnologia para mapeamento, LINQ, prestadores e todas as outras partes do Entity Framework. Pense nisso como um caminho rápido para escrever código de acesso a dados usando as convenções sobre configuração, APIs melhor sintonizado e outras técnicas destinadas a reduzir o tempo de desenvolvimento ao usar o EF.

     Nesta fase, temos trabalhado através do que nós pensamos que a API do núcleo e funcionalidade deve ser semelhante e gostaria que seu feedback. Existem ainda algumas capacidades, tais como ligação de dados e resolução de simultaneidade que fará com que a API a evoluir à medida que continuamos o processo de design, mas os principais conceitos estão no lugar, por isso é um bom momento para o gabarito.

Apresentando DbContext & DbSet

     No coração do Entity Framework melhorias de produtividade são dois novos tipos, DbContext e DbSet . DbContext é uma alternativa simplificada para ObjectContext e é o objecto principal para interagir com uma base de dados usando um modelo específico. DbSet é uma alternativa simplificada para ObjectSet e é utilizado para realizar operações CRUD contra um tipo específico a partir do modelo. Estes novos tipos podem ser usados ​​independentemente de se você criou o seu modelo usando o Entity Designer ou código.

     A pergunta óbvia é 'Por que não simplificar ObjectContext e ObjectSet ?' Estamos optando por introduzir esses novos tipos, a fim de, por um lado, preservar a compatibilidade retroativa total com aplicações EF existentes e continuar a tratar toda a avançado cenários que são possíveis dada a flexibilidade existente da EF, enquanto por outro lado simplificar a experiência de usar o EF e sintonizá-la para os casos mais comuns. Nós acreditamos que é fundamental que a experiência de programação EF melhorar em alguns aspectos fundamentais, e ao mesmo tempo estamos absolutamente comprometidos com nossos clientes existentes. O estabelecimento de uma relação de colaboração entre os tipos existentes e os novos tipos nos permite alcançar ambos os requisitos. Além disso, existem maneiras fáceis de obter a ObjectContext e ObjectSet a partir DbContext e DbSet caso você queira mais controle para uma determinada tarefa.

     Um ponto que queremos ser muito claros sobre é que esses novos tipos não estão substituindo quaisquer tipos existentes; eles são uma alternativa simplificada que construir sobre os tipos existentes, e como adicionar recursos para o Entity Framework eles estarão sempre disponíveis no ObjectContext / ObjectSet, e eles também estarão disponíveis em DbContext / DbSet se for caso disso.

     Vamos perfurar na superfície da API mais tarde, mas primeiro vamos dar uma olhada na experiência de codificação usando esses novos tipos.

Code First Experience

     DbContext fornece um padrão simplificado Code First que requer menos código e cuida de algumas preocupações comuns, tais como modelo de caching, provisionamento de banco de dados, criação de esquema e de gerenciamento de conexão. Este padrão simplificada utiliza uma série de convenções para cuidar dessas tarefas e permite ajustes ou primordial deste comportamento quando necessário. Vamos começar usando estas convenções para escrever o código necessário para construir um aplicativo de console que executa acesso a dados usando um modelo:

using System.Collections.Generic;

using System.Data.Entity;

namespace MyDataAccessDemo

{

    class Program

    {

        static void Main(string[] args)

        {

            using (var context = new ProductContext())

            {

                var food = new Category { CategoryId = "FOOD" };

                context.Categories.Add(food);

                var cheese = new Product { Name = "Cheese" };

                cheese.Category = context.Categories.Find("FOOD");

                context.Products.Add(cheese);

                context.SaveChanges();

            }

        }

    }

    public class ProductContext : DbContext

    {

        public DbSet<Product> Products { get; set; }

        public DbSet<Category> Categories { get; set; }

    }

    public class Product

    {

        public int ProductId { get; set; }

        public string Name { get; set; }

        public Category Category { get; set; }

    }

    public class Category

    {

        public string CategoryId { get; set; }

        public string Name { get; set; }

        public ICollection<Product> Products { get; set; }

    }

}

     Que é 100% do código que você escreveria para obter este programa em execução. Sem definição de modelo separada, metadados XML, arquivo de configuração ou qualquer outra coisa é necessária. Convenções são usados para preencher todas estas informações. Obviamente há um pouco acontecendo debaixo das cobertas por isso vamos dar uma olhada em algumas das coisas que está fazendo DbContext automaticamente.

Modelo Descoberta

      Durante a construção que digitalizar o contexto derivado para propriedades DbSet e incluir os tipos do modelo. Modelo Descoberta usa a funcionalidade Code First existente para as novas convenções padrão que recentemente escrevi sobre são processados durante a descoberta. Você pode optar por sair de descoberta conjunto, especificando um atributo nas propriedades do conjunto que devem ser ignorados.

      É claro que haverá momentos em que você quer para descrever um modelo ou mudar o que foi detectado por convenção. Por exemplo, dizer que você tem uma entidade Livro cuja propriedade ISBN é a chave primária, este não será detectado por convenção. Há duas opções aqui; você pode usar anotações de dados para anotar a propriedade em sua definição de classe:

public class Book

{

    [Key]

    public string ISBN { get; set; }

    public string Title { get; set; }

}

Alternativamente DbContext inclui um método virtual que pode ser substituído a usar o Código Primeira API fluente em ModelBuilder para configurar ainda mais o modelo:

public class ProductContext : DbContext

{

    public DbSet<Book> Books { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)

    {

        modelBuilder.Entity<Book>().HasKey(b => b.ISBN);

    }

}

Modelo Caching

     Há alguns custos envolvidos em descobrir o modelo, o processamento de anotações de dados e aplicação de configuração API fluente. Para evitar incorrer esse custo cada vez que um DbContext derivado é instanciado o modelo é armazenado em cache durante a primeira inicialização. O modelo em cache é então re-utilizado cada vez que o mesmo contexto derivado é construído no mesmo domínio de aplicação. Caching modelo pode ser desligado, definindo a propriedade CacheForContextType em ModelBuilder para "falso" no método OnModelCreating.

DbSet Inicialização

     Você notará na amostra que nós não atribuir um valor a uma das propriedades DbSet no contexto derivada. Durante a construção DbContext irá verificar o contexto derivado para propriedades DbSet e, se eles expõem um setter público, vai construir uma nova DbSet e atribuí-lo à propriedade. Você pode optar por sair de inicialização conjunto, especificando um atributo sobre as propriedades do conjunto de que não devem ser inicializados.

Você também pode criar instâncias DbSet usando o método () o DbContext.Set se você não deseja expor setters públicas para as propriedades DbSet.

Provisioning banco de dados

     Por padrão, o banco de dados é criado e fornecido utilizando SqlClient contra localhost \ SQLEXPRESS e tem o mesmo nome que o contexto derivada. Esta convenção é configurável e é controlado por uma configuração AppDomain que pode ser ajustado ou substituído. Você pode ajustar a convenção SqlClient padrão para se conectar a um banco de dados diferente, substitua-a por uma convenção Sqlce que incluir ou definir sua própria convenção implementando a interface IDbConnectionFactory.

public interface IDbConnectionFactory

{

    DbConnection CreateConnection(string databaseName);

}

     O IDbConnectionFactory ativo pode ser recuperada ou definida através da propriedade estática, Database.DefaultConnectionFactory.

      DbContext também inclui um construtor que aceita uma cadeia para controlar o valor que é passado para a convenção, as fábricas SqlClient e Sqlce permitem que você especifique um nome de banco de dados ou toda a cadeia de conexão.

Antes de ligar para a convenção, DbContext irá verificar no arquivo app / web.config para uma cadeia de conexão com o mesmo nome de seu contexto (ou o valor da cadeia se você usou o construtor que especifica uma string). Se houver uma entrada correspondente, vamos usar isso ao invés de chamar a convenção. Como as entradas de cadeia de conexão também incluem informações sobre o provedor isso permite-lhe atingir vários fornecedores em um único aplicativo.

Finalmente, se você quer controle total sobre suas conexões existe um construtor em DbContext que aceita um DbConnection.

Primeiro banco de dados e Modelo Primeira Experiência

     Na última versão do Entity Framework que acompanha o .Net Framework 4.0 e Visual Studio 2010, introduzimos a geração de código baseada T4. T4 permite que você personalize o código que é gerado com base em um modelo que você definiu usando o designer em qualquer banco de dados ou Modelo Primeira, Primeira abordagem. O modelo padrão gera um ObjectContext derivada com um ObjectSet para cada conjunto de entidades no seu modelo.

As melhorias de produtividade também irá incluir um modelo que gera uma DbContext determinada com uma DbSet para cada conjunto de entidades no seu modelo. Isto permite Modelo Primeira e banco de dados primeiro desenvolvedores para fazer uso da superfície API simplificado descrito na próxima seção.

Superfície API

     DbContext é o ponto de partida para interagir com o seu modelo. Em comparação com ObjectContext que tem um número muito reduzido de métodos e propriedades que são expostas no nível de raiz. O objetivo é expor apenas os métodos mais comumente usados ​​em DbContext e têm a capacidade de perfurar até APIs mais avançadas. Um exemplo disso é a propriedade de banco de dados que expõe APIs banco de dados relacionados. Nós vamos adicionar mais um par de membros, enquanto trabalhamos através de adicionar o resto da funcionalidade avançada, mas nós queremos mantê-lo o mínimo possível. Na maioria dos casos, você iria trabalhar com um contexto que deriva de DbContext e expõe fortemente digitado propriedades DbSet para os tipos em seu modelo. 

public class DbContext : IDisposable

{

    public DbContext(DbModel model, string nameOrConnectionString);

    public DbContext(DbModel model, DbConnection existingConnection);
    public DbContext(ObjectContext objectContext);

    protected DbContext();

    protected DbContext(string nameOrConnectionString);

    protected DbContext(DbConnection existingConnection);

    public Database Database { get; }

    protected ObjectContext ObjectContext { get; }

   

    protected virtual void OnModelCreating(ModelBuilder modelBuilder);

    public virtual int SaveChanges();

    public DbSet Set() where TEntity : class;

    public void Dispose();

}

DbModel Construtores

     Esses construtores podem ser utilizados com Banco de Dados Primeiro, Modelo Primeira e Code First desenvolvimento. Eles são utilizados pelo nosso modelo de T4 para banco de dados e Primeiro Modelo primeiro desenvolvimento e também pode ser usado em cenários de código primeiro em que um modelo é construído usando Modelbuilder externamente.

Code First anteriormente continha um tipo ContextBuilder que temos agora dividido em dois componentes, ModelBuilder e DbModel. ModelBuilder é mutável e expõe a API fluente para definir o seu modelo. Modelbuilder cria um tipo de DbModel imutável que pode ser utilizado para construir um ObjectContext ou DbContext. DbModel também pode ser construído a partir de um banco de dados Primeiro ou Modelo Primeira abordagem em que um arquivo edmx é gerado.

ObjectContext Constructor

     Se você tiver uma base de código existente que usa ObjectContext e quiser fazer uso da superfície suplente do DbContext em algumas partes de seu código, em seguida, esse construtor permite que você enrole o ObjectContext com a superfície mais simples.

Construtores protegidos

     Os três construtores protegidas podem ser expostos ou utilizados dentro de um contexto derivado onde você quiser fazer uso do Código Primeira experiência simplificada, que foi explicado na seção "Code First Experience '. Eles são protegidos porque os mecanismos de descoberta modelo, provisionamento de banco de dados e modelo de cache dependem de ter um contexto derivada.

Banco de dados

     A propriedade de banco de dados expõe um exemplo do novo tipo de banco de dados que contém métodos para interagir com o banco de dados subjacente.

public class Database

{

    public DbConnection Connection { get; }

    public void Create ();

    public bool CreateIfNotExists();

    public bool Exists();

    public static bool Exists(string nameOrConnectionString);

    public static bool Exists(DbConnection existingConnection);

    public void Delete ();

    public static void Delete (string nameOrConnectionString);

    public static void Delete (DbConnection existingConnection);

    public bool DeleteIfExists();

    public static bool DeleteIfExists(string nameOrConnectionString);

    public static bool DeleteIfExists(DbConnection existingConnection);

}

ObjectContext

      DbContext usa um ObjectContext internamente e nós torná-lo disponível como uma propriedade protegida apenas no caso de você precisar cair para a API de nível inferior. Você pode usar ou expor a funcionalidade necessária de um DbContext derivada.

OnModelCreating

      Este membro protegida pode ser substituído ao definir um contexto derivado em desenvolvimento CodeFirst e permite que você ajustar o formato do seu modelo que foi detectado por convenção.

SaveChanges

      Este método expõe a mesma funcionalidade que SaveChanges sobre ObjectContext e persiste todas as alterações pendentes no banco de dados. Ele representa a unidade de trabalho para o contexto.

Defina

      Este método irá criar um DbSet para um tipo de entidade que faz parte de seu modelo, semelhante ao CreateObjectSet em ObjectContext.
DbSet representa uma coleção de um determinado tipo de entidade em seu modelo, semelhante ao ObjectSet , exceto que este novo tipo também suporta tipos derivados Considerando ObjectSet tipos de base unicamente suportados.

public class DbSet : IDbSet, IQueryable where TEntity : class

{

    public void Add(TEntity entity);

    public void Remove(TEntity entity);

    public void Attach(TEntity entity);

    public TEntity Find(params object[] keyValues);

}

Adicionar, Remover e anexar

     Adicionar, Remover e anexar são semelhantes aos AddObject, ExcluirObjeto e Anexar em ObjectSet . Temos renomeado Adicionar e remover para manter DbSet consistente com outros conjuntos no quadro.

Adicionar e anexar agora pode ser chamado em objetos que já são controlados pelo contexto, Adicionar garantirá o objeto está no estado adicionado e anexar o estado inalterado. Isso é útil em n-tier e Web cenários onde você tem um gráfico separado contendo entidades existentes e novos que precisam ser ligado a um contexto.

Por exemplo supor que você tem um novo produto que está ligada a uma categoria existente, nem instância é anexado a um contexto (que podem ter sido devolvido a partir de um cliente distribuído através de uma chamada de serviço web ou construídos a partir de um posto de volta em uma aplicação web). Porque Adicionar e anexar são as operações de gráficos, chamando Adicionar no produto também irá adicionar a categoria. Anteriormente você precisaria cair para APIs de nível inferior (ObjectStateManager.ChangeObjectState) para marcar a categoria como inalterada. Agora, no entanto isto pode ser conseguido chamando Anexar:

public void AddProduct(Product product)

{

    using (var context = new ProductContext())

    {

        context.Products.Add(product);

        context.Categories.Attach(product.Category);

        context.SaveChanges();

    }

}

Encontrar

      O novo método Find irá localizar um objeto com o valor da chave primária fornecido (s). Encontre inicialmente verifica os objetos em memória antes de consultar o banco de dados e é capaz de encontrar entidades adicionais que não foram persistiram até a loja ainda. Se encontrar não localizar uma entidade com a correspondente chave que ela retorna null.

IDbSet

      DbSet implementa IDbSet para facilitar a criação de aplicativos testáveis.

public interface IDbSet : IQueryable where TEntity : class

{

    void Add(TEntity entity);

    void Attach(TEntity entity);

    void Remove(TEntity entity);

    TEntity Find(params object[] keyValues);

}

IDbSet permite definir uma interface que pode ser implementado por seu contexto derivado, semelhante ao exemplo mostrado abaixo. Isto permite que o contexto para ser substituído com um duplo ensaio de memória para o teste. DbContext ainda irá realizar conjunto descoberta e inicialização, descrito na seção "Code First Desenvolvimento", para propriedades digitadas como IDbSet .

public interface IProductContext

{

    IDbSet<Product> Products { get; }

    IDbSet<Category> Categories { get; }

}

public class ProductContext : DbContext, IProductContext

{

    public IDbSet<Product> Products { get; set; }

    public IDbSet<Category> Categories { get; set; }

}

Resumo
      Estas melhorias são projetados para fornecer uma superfície de API mais limpa e mais simples que lhe permite alcançar cenários comuns com facilidade enquanto também permite que você para detalhar a funcionalidade mais avançada, quando necessário. As melhorias construir em cima dos componentes do Entity Framework existentes usando convenções sobre configuração e uma superfície API simplificada.
Nós gostaríamos de ouvir qualquer feedback que você tem sobre a funcionalidade e API superfície proposto.

Rowan Miller
Gerenciador de programa
Equipe ADO.NET Entity Framework

Tradução Alexssandro Lima, +Alexssandrolima Dutra
Link traduzido:
http://blogs.msdn.com/b/efdesign/archive/2010/06/21/productivity-improvements-for-the-entity-framework.aspx?wa=wsignin1.0

Leia um pouco sobre - Empresas devem ser penalizadas por não emitirem NFC-e.

Empresas devem ser penalizadas por não emitirem NFC-e.

Apesar de ser um projeto em nível nacional, a NFC-e (Nota Fiscal do Consumidor Eletrônica)  vem sendo massificada nos estados brasileiros de forma distinta em cada estado. Alguns adotaram uma política mais amena, entretanto, outros criaram um sistema mais rígido para fazer cumprir o calendário de obrigatoriedade .

De todo modo, o que temos visto é que, grande parte dos estados que iniciaram o projeto piloto em 2012 , já estão em fase de cumprimento do cronograma de obrigatoriedade . No estado do Amazonas por exemplo, a Secretaria de Fazenda informou no dia 25/11/2015 por meio do seu portal de notícias , que os contribuintes que não cumprirem a obrigatoriedade de emissão prevista para 01/12/2015 , estarão sujeitos a penalização como:  restrições administrativas, inclusive com suspensão de sua Inscrição Estadual .

Considerando que o estado foi um dos primeiros a avançar na massificação em nível de obrigatoriedade, e mesmo assim, somente agora, deve iniciar sansões mais rígidas aos contribuintes que estiverem em desconformidade com tal obrigação, podemos observar que esta deve ser uma tendência seguida pelos demais estados.

Por isso, a implantação da NFC-e já pode ser considerada um caminho sem volta nos estados que aderiram ao projeto, pois fica claro que a estratégia de massificação baseado no calendário da obrigatoriedade, contará também com outros meios que mitigarão o não cumprimento de tal cronograma.

link Original:
https://ciranda.me/tsdn/blog-da-tecnospeed/post/empresas-devem-ser-penalizadas-por-nao-emitirem-nfc-e

Defeito, Bug ou Erro e Falhas em Teste de Software Veja a definição?

Qual o significado de Defeito, Bug ou Erro e Falhas em Teste de Software?

http://peripeciasdesenvolvedor.blogspot.com.br/2015/09/o-significado-de-defeito-bug-falha.html

Regra Básica:

Um regrinha rápida para compreender:

1) Erro é cometido por um ser humano

2) um Defeito é gerado no Sistema, quando programado de forma errada.

3) Falha é o que é retornado para o usuário através de um aviso na tela.

4) Bug é quando uma grande quantidade de erros, defeitos ou falhas são encontrados no Software. 

Para evitar essa dor de cabeça quando o seu Produto de Software for entregue, é muito útil que se use o Teste de Software, como já dissemos, durante todo o seu ALM.
Agora, vamos de definição.

Definição:

• Um defeito é um erro ou um bug, dentro da aplicação quando ela é criada. Um desenvolvedor quando está modelando e construindo o Sistema, pode cometer enganos ou erro. Esses enganos ou erros significam que existem falhas no Sistema, tais falhas são chamadas de defeitos.
• Quando o resultado atual desvia do resultado esperado durante os testes então isso é um defeito. Consequentemente, qualquer desvio da especificação mencionado no Documento de Especificação funcional do produto é considerado um defeto. Em empresas diferentes isso é frequentemente chamado de bug, issue, problema ou incidente.
• Quando a Produto final não supre a expectativa do usuario final ou não respeita os Requistos Modelados, então isso resultado em um Bug ou Defeito. Esses defeitos, ou bug, ocorrem porque houve um erro de lógica ou erro no código que resulta em uma falha ou resultado imprevisivel ou imprevisto.

Informações adicionais sobre Defeitos/Bugs:

Quando uma aplicação ou um Produto de Software é testado, se um grande número de defeitos são encontrados então ela é considerada "Bugada" ou que contém um "Bug".

Quando um testador encontra um Bug ou um Defeito,é necessário informar sobre os mesmos com os desenvolvedores. Para tal, ele coloca tais defeitos em um Relatório detalhando os passos efetuados até chegar no defeito encontrado, esse Relatório tem vários nomes: Relatório de Bugs, Relatório de Issues, Relatório de Defeitos, Relatório de Problemas e etc.

Este Relatório consiste, basicamente, em conter a seguinte informação:

• ID do Defeito – Todo Bug ou Defeito tem um número de identificação único.
• Descrição do Defeito – A explicação sobre o que foi encontrado.
• Versão do Produto – A versão do Produto, aplicação, no qual o defeito é encontrado.
• Detalhes Passo a passo – Os passos detalhados do problema com prints de tela anexados para que os desenvolvedores possam simular o mesmo em seu ambiente.
• Data do Ocorrido – A data de quando o Bug foi encontrado e relatado.
• Reportado Por – As informações do Testador que encontrou e reportou o Problema, tais como o nome e o Id do Testador.
• Estado – O Estado do defeito como: Novo, Encaminhado à alguém, Aberto, Retestado, Verificação, Fechado, Falho, Igorado ou Deferred e etc.
• Corrigido por – Os detalhes do desenvolvedor que corrigiu o defeito como Id e Nome do Desenvolvedor.
• Data de Finalização – A data em que o defeito foi resolvido e a entrada finalizada.
• Severidade – Baseado na severidade (Crítica, Principal, Menor), nos diz sobre o impacto do defeito ou bug na aplicação.
• Prioridade – Baseado em um conjunto de prioridades (Alta, Média, Baixa), a ordem de corrigir o defeito pode ser dada

Programa para Reiniciar o Tef_Dial no Computador, Usando o instalador, mostrando o Código C#.

Aplicativo, Reiniciar Tef_Dial e o serviço Vpn no Windows.

Demostração da aplicação

     Vou mostra como fiz para construir um programa que desligue o TEF_DIAL, reinicie o serviço do Windows chamado de OPENVPNSERVICE, e ligue novamente o TEF_DIAL para corrigir erros no momento que esta passando cartão.

tela principal do aplicativo:

Figura - 01

     Como ver na tela principal da aplicação o nome principal "RETARTANDO GETCARD E SERVIÇO", o intuito como o próprio nome diz, e assim, foi construído a aplicação para reiniciar dois executáveis distintos no Windows, na tela foi criado um textbox para mostra o que esta sendo feito a cada momento de execução da aplicação.

Figura - 02

ao mesmo tempo foi colocado um botão grande para que o serviço seja reiniciado e o cliente seja liberado para sua venda.

Figura - 03

 Assim também foram criados trés chekbox para que o usuário necessite de algumas configurações amais,

Figura - 04

     O primeiro checkbox criado para ligar o Tef_Dial no processo que vai dar o stop de parada no mesmo, caso o sistema de automação tenha o comando que reinicie o mesmo como o paf-ecf devidamente homologado pelo fiscal do estado, o próximo checkbox foi criado para que o serviço da vpn seja reiniciado ou não, dependendo do Windows onde o aplicativo foi instalado e tem muito problema de conexão com o servidor que foi configurado o VPN, o outro checkbox Automaticamente ao reiniciar foi criado para que seja executado a aplicação de reinicialização não tenha a necessidade de clique no botão de "reiniciar o serviço", com isso rele automaticamente executa o que foi configurado.

Continuando com a explicação da aplicação temos um local de configuração para configurar os executáveis e o serviço que vai ser reiniciado.

clique no "<>" na parte superior da tela, como a imagem abaixo.

Figura - 05

 veja então que aparecera a tela principal de configuração como na figura abaixo.

Figura - 06

Nesta tela de configuração tem um botão "..." para procurar o executável do Tef_Dial.exe no computador que vai ser executado o programa do tef.

Figura - 07

O intuído foi para que não seja esquecido o local correto do executável Tef_Dial.exe e assim não ocorrer erros na aplicação, o próximo foi o nome do serviço no Windows para que não seja esquecido e ocasione erros na aplicação.

Caso o Ícone não seja configurado para iniciar como administrador do windows acarretar o seguinte erro na tela de apresentação da aplicação.

Figura - 08

Sua configuração deverá ser feita diretamente no ícone na área de trabalho como vou mostra a seguir.

Figura - 09

veja como deve ser feito nas propriedades do ícone acima.

Figura - 10

Caso esta configuração não seja executada o serviço do Windows não reiniciara e ao mesmo tempo ocorrera um erro na tela.

Continuando o processo de reinicialização do executável Tef_Dial, aparecera a seguinte mensagem que ele esta sendo iniciado.

Figura - 11

 Ao concluir todo o processo clique no botão de sair e a qualquer momento poderar ser iniciado novamente no ícone do Windows.

Figura - 12

Finalizando a execução da aplicação no computador do cliente.

Verificaremos agora com fazer a instalação da aplicação.

     Baixe a aplicação no seguinte endereço abaixo.

http://vciga.dyndns.org/siga1/syspaf_download/Restart_GetCard_Install_Atualizado_em_25-10-2015.exe

     Pronto agora vamos inicia o processo de instalação, ao executar o arquivo baixado aparecera a seguinte tela de apresentação.

Figura - 13

Selecione "ok" e continue em "Avançar" como na tela abaixo.

Figura - 14

Selecione aceito a instalação da aplicação.

Figura - 15

Selecione em avançar para continuar a instalação da aplicação.

Figura - 16

Caso existir a pasta Tef-Dial o sistema perguntara se a instalação sera na pasta existente.

Figura - 17

Veja que será instalado no computador, clique em avançar.

Figura - 18

Mostrando o que a instalação vai alterar no computador.

Figura - 19

Instale o "DotNetFrameWork Setup 4.0" para que a aplicação seja executada no Windows e assim concluir a instalação.

Figura - 20

Pronto agora o seu computador estará pronto para executar a aplicação de Reiniciar o Tef_Dial e o serviço do OPENVPNSERVICE.

Alguns detalhes do código fonte da aplicação.

     Vou colocar o condigo completo no GitHub no endereço.:
https://github.com/Alexssandrolima/estudos


using System.ServiceProcess;
using System.Diagnostics;
using System.IO;
using RestartGetCardServicos.Properties;


public bool Automaticamente { get; set; }
public bool Ligadosim { get; set; }

readonly string _username = Environment.ExpandEnvironmentVariables("%USERNAME%");
readonly string _userdomain = Environment.ExpandEnvironmentVariables("%USERDOMAIN%");
readonly string _varSourcePath = Environment.CurrentDirectory + "\\";
readonly string _varMachineName = Environment.MachineName;

        private void buttonSair_Click(object sender, EventArgs e)
        {
            Settings.Default.Automatica = checkBoxAutomatica.Checked;
            Settings.Default.ReiniciarVpn = checkBoxReiniciarVpn.Checked;
            Settings.Default.LigarTefDial = checkBoxLigarTefDialReiniciar.Checked;
            Settings.Default.Save();

                    listBoxPrincipal.Items.Add("Desligando o sistema ... ");
                    if (MessageBox.Show(Resources.Desejasairdosistema, Resources.SaindodoSistema, MessageBoxButtons.YesNo, MessageBoxIcon.Question).Equals(DialogResult.Yes))
                    {
                        Checharboxautomaticoligadodesligado();
                        Application.Exit();
                    }
        }

        private void buttonCancelar_Click(object sender, EventArgs e)
        {

            Settings.Default.Automatica =  checkBoxAutomatica.Checked;
            Settings.Default.ReiniciarVpn = checkBoxReiniciarVpn.Checked;
            Settings.Default.LigarTefDial = checkBoxLigarTefDialReiniciar.Checked;
            Settings.Default.Save();
            Application.Restart();
        }

        private void FormPrincipal_Load(object sender, EventArgs e)
        {
            //MessageBox.Show("_varMachineName >> " + _varMachineName);

            listBoxPrincipal.Items.Add(" Bom dia! " + _username);
            listBoxPrincipal.Items.Add(" Pressione Reiniciar Serviço no " + _userdomain);
            listBoxPrincipal.Items.Add(" ou Selecione \" Reiniciar Automaticamento ao iniciar na proxima vez! \" ");
            listBoxPrincipal.Items.Add(" Executando em: " + _varSourcePath);
            if (Automaticamente == Settings.Default.Automatica)
            {
                Ligadosim = true;
                listBoxPrincipal.Items.Add("Automatico já esta ligado ... ");
                checkBoxAutomatica.Checked = Automaticamente;
                RestartartandoServicosExecutaveis();
            }
            if(Automaticamente = Settings.Default.ReiniciarVpn)
            {
                checkBoxReiniciarVpn.Checked = true;
            }
            else
            {
                checkBoxReiniciarVpn.Checked = false;
               
            }
            if(Automaticamente = Settings.Default.LigarTefDial)
            {
                checkBoxLigarTefDialReiniciar.Checked = true;
            }
            else
            {
                checkBoxLigarTefDialReiniciar.Checked = false;
            }
        }

        private void Checharboxautomaticoligadodesligado()
        {
            if (checkBoxAutomatica.Checked)
            {
                listBoxPrincipal.Items.Add("automatico ligado ... ");
                if (!Ligadosim)
                {
                    Ligadosim = true;
                    //MessageBox.Show(" configurando o check box " + ligadosim);
                }
            }
            else
            {
                Ligadosim = false;
                //MessageBox.Show(" desconfigurando o checkbox " + ligadosim);
            }

            Settings.Default.Automatica = Ligadosim;
            Settings.Default.Save();

        }

        private void buttonIniciarServiço_Click(object sender, EventArgs e)
        {
            RestartartandoServicosExecutaveis();
        }

        private void RestartartandoServicosExecutaveis()
        {
            Settings.Default.Automatica = checkBoxAutomatica.Checked;
            Settings.Default.ReiniciarVpn = checkBoxReiniciarVpn.Checked;
            Settings.Default.LigarTefDial = checkBoxLigarTefDialReiniciar.Checked;
            Settings.Default.Save();
            listBoxPrincipal.Items.Add("Iniciando ... ");
            Nomedoservicodowindows = Settings.Default.NomedoServicoWindows;
            Nomeextensaoservico = Path.GetFileNameWithoutExtension(Nomedoservicodowindows);
            Desligarexecutavel();
            if (Automaticamente = Settings.Default.ReiniciarVpn)
            {
                Desligandoservicodowindows();
                Ligandoservicodowindows();
            }
            if (Automaticamente = Settings.Default.LigarTefDial)
            {
                Ligandoexecutavel();
            }
        }

        private void Ligandoservicodowindows()
        {
            listBoxPrincipal.Items.Add("== Começando a ligar >>" + Nomedoservicodowindows + "==");
            StopService(Nomeextensaoservico, 100000);
            listBoxPrincipal.Items.Add("== Continuando a ligar>>" + Nomedoservicodowindows + "==");
        }

        private void StopService(string serviceName, int timeoutMilliseconds)
        {
            ServiceController service = new ServiceController(serviceName);
            try
            {
                TimeSpan timeout = TimeSpan.FromMilliseconds(timeoutMilliseconds);
                service.MachineName = _varMachineName;
                listBoxPrincipal.Items.Add("== service.Start >>" + service.Status.ToString() + "==");
                service.Start();
                listBoxPrincipal.Items.Add("== service.Start >>" + service.Status.ToString() + "==");
                service.WaitForStatus(ServiceControllerStatus.Running, timeout);
                listBoxPrincipal.Items.Add("== service.Start >>" + service.Status.ToString() + "==");
                listBoxPrincipal.Items.Add("== service.Start >>" + service.Status.ToString() + "==");
            }
            catch (Exception ex)
            {
                listBoxPrincipal.Items.Add("Erro! >>" + ex.InnerException.Message + " >> " + ex.Message);
                MessageBox.Show(Resources.FormPrincipal_StopService_ErrorEncontrado + ex.InnerException.Message + ex.Message);
            }
        }

        public void StartService(string serviceName, int timeoutMilliseconds)
        {
            listBoxPrincipal.Items.Add("== Começando >>" + serviceName + " T:" + timeoutMilliseconds + "==");
            ServiceController service = new ServiceController(serviceName);
            try
            {
                TimeSpan timeout = TimeSpan.FromMilliseconds(timeoutMilliseconds);
                service.MachineName = _varMachineName;
                listBoxPrincipal.Items.Add("== service.Stop >>" + service.Status.ToString() + "==");
                service.Stop();
                service.WaitForStatus(ServiceControllerStatus.Stopped, timeout);
                listBoxPrincipal.Items.Add("== service.Stop >>" + service.Status.ToString() + "==");
            }
            catch (Exception ex)
            {
                string nomemessagem = "Erro Encontrado no serviço. >>" + ex.InnerException.Message + " >> " + ex.Message;
                listBoxPrincipal.Items.Add(nomemessagem);
                MessageBox.Show(Resources.FormPrincipal_StopService_ErrorEncontrado + ex.InnerException.Message + ex.Message);
            }
        }

        private void Ligandoexecutavel()
        {
            listBoxPrincipal.Items.Add("== Ligando >> " + NomeLocalextensao + "==");
            if (NomeLocalextensao != string.Empty)
            {
                listBoxPrincipal.Items.Add("Entrando para Ligar o serviço >>" + NomeLocalextensao);
                try
                {
                    if(File.Exists(NomeLocalextensao))
                    {
                        ProcessStartInfo startInfo = new ProcessStartInfo(NomeLocalextensao);
                        startInfo.WorkingDirectory = NomeDiretorio;
                        listBoxPrincipal.Items.Add("Processando o arquivo " + startInfo.FileName);
                        Process.Start(startInfo);
                    }

               }
                catch (Exception erro)
                {
                    #if DEBUG
                    MessageBox.Show(erro.Message + "");
                    #else
                    listBoxPrincipal.Items.Add(erro.Message + " ");
                    #endif
                }
            }
        }

        private void Desligarexecutavel()
        {
            listBoxPrincipal.Items.Add("== Desligando >> " + NomeLocalextensao + "==");
            NomeLocalextensao = Settings.Default.NomeLocalextensao;
            Nomeextensao = Path.GetFileNameWithoutExtension(NomeLocalextensao);
            NomeDiretorio = Path.GetDirectoryName(NomeLocalextensao);
            if (Nomeextensao != string.Empty)
            {
                listBoxPrincipal.Items.Add("desligando o executável >>" + Nomeextensao);
                try
                {
                    var processes = Process.GetProcessesByName(Nomeextensao);
                    foreach (var process in processes)
                    {
                        listBoxPrincipal.Items.Add("Parando o executavel " + process.ProcessName);
                        process.Kill();
                    }
                }
                catch (Exception error)
                {
                    listBoxPrincipal.Items.Add("Erro ao Finalizar programas encontrar o arquivo " + error.Message);
                }
            }
        }

        private void labelConfiguracao_Click(object sender, EventArgs e)
        {
            listBoxPrincipal.Items.Add("== Configurando o Sistema ==");

            var configurar = new FormConfigurar();
            configurar.ShowDialog();
        }

        public string Nomedoservicodowindows { get; set; }
        public string NomeLocalextensao { get; set; }
        public string Nomeextensao { get; set; }
        public string NomeDiretorio { get; set; }
        public string Nomeextensaoservico { get; set; }


}

Configurando o sistema com o FormConfigurar

using System.IO;
using RestartGetCardServicos.Properties;

        public string Filefilter = "tef_dial.exe|*.exe";
        public string FileTitle = "Pegando o arquivo executavel do tefdial.exe";
        public string FileService = "OpenVPNService.exe";
       
        private OpenFileDialog _openFile;

        private void buttonProcurarArquivo_Click(object sender, EventArgs e)
        {
            _openFile = new OpenFileDialog
            {
                InitialDirectory = "C:\\TEF_DIAL\\",
                Filter = Filefilter,
                Title = FileTitle,
                FileName = @"tef_dial.exe"
            };
            _openFile.ShowDialog();

            if (_openFile.FileName != null)
            {
                textBoxNomeLocalextensao.Text = _openFile.FileName; // aqui você pega o local + nome do arquivo completo.
                textBoxNomedoServicoWindows.Text = FileService;
            }
        }

        private void buttonCancelar_Click(object sender, EventArgs e)
        {
            Close();
        }

        private void buttonSalvar_Click(object sender, EventArgs e)
        {
            Settings.Default.NomeLocalextensao = textBoxNomeLocalextensao.Text;
            Settings.Default.NomedoServicoWindows = textBoxNomedoServicoWindows.Text;
            Settings.Default.Save();
            Close();
        }

        private void FormConfigurar_Load(object sender, EventArgs e)
        {
            textBoxNomeLocalextensao.Text = Settings.Default.NomeLocalextensao;
            textBoxNomedoServicoWindows.Text = Settings.Default.NomedoServicoWindows;
        }