Desenvolvimento de sistemas ordem de serviços

Prévia do material em texto

Sistema de Ensino Presencial Conectado
ANALISE E DESENVOLVIMENTO DE SISTEMAS
PEDRO RODRIGUES DA SILVA
ESTÁGIO CURRICULAR OBRIGATÓRIO II – TCC – 6º SEMESTRE
BOA VISTA - RR 
2014
PEDRO RODRIGUES DA SILVA
ESTÁGIO CURRICULAR OBRIGATÓRIO II – TCC – 6º SEMESTRE  
O TCC II apresentado à UNOPAR –
Universidade Norte do Paraná, como requisito para obtenção de titulo de Graduação em Análises e Desenvolvimento de Sistemas. 
Tutor Orientador: Junior Cezar Santiago de Souza
BOA VISTA - RR
2014
Sumário
INTRODUÇÃO	4
Justificativa	6
Objetivos	7
Objetivo Geral	7
Objetivos Específicos	7
REferencial teorico	8
RUP - Rational Unified Process	8
As Fases	8
Disciplinas	10
UML - Unified Modeling Language	13
C sharp	14
Banco de dados	14
Sql	15
Metodologia	16
cARACTERIZAÇÃO DA ORGANIZAÇÃO EM ESTUDO	18
tecnologia	19
Linguagem de programação	19
banco de dados	20
levantamento de requisitos	21
diagrama de caso de uso	22
diagrama de classe	23
diagrama de sequencia	24
diagrama de atividade	25
diagrama de entidade e relacionamneto	25
Telas	26
codigo fonte	29
Tela Splash	29
Cadastro de usuário	29
tela principal	32
cadastro de cliente	34
Cadastro de serviço	38
cadastro de ordem de serviço	41
cronograma	44
Conclusão	45
Referências Bibliograficas	46
	
	
INTRODUÇÃO 
O avanço da tecnologia nos últimos anos tem permitido o rápido crescimento em todos os seguimentos da tecnologia da informação. A necessidade de velocidade, consistência, e confiabilidade vem sendo um fator primordial na disputa dos mercados pela informação, para que tudo ocorra normalmente devemos ter sistemas preparados para qualquer tipo de problema, pensar em suporte e atualizações para evitar dificuldades após sua implementação.
Para melhorar o gerenciamento das ordens de serviço dentro da empresa, Governo do Estado de Roraima, Secretaria Estadual de Educação na Gerência de Tecnologia da Informação. De acordo com estagio I realizado, a empresa não oferece sistema automatizado para registro de entrada e saída de maquinas que dificulta o trabalho dos técnicos de informática da empresa. 
O presente projeto de estágio estabeleceu o desenvolvimento desta aplicação de gerenciamento de ordem de serviço para a empresa Governo do Estado de Roraima, Secretaria Estadual de Educação na Gerência de Tecnologia da Informação. 
Este projeto de estágio descreve os objetivos do trabalho, os requisitos da aplicação, propostas para solução das dificuldades atualmente enfrentadas, o foi definido junto ao orientador e as ferramentas a serem utilizadas para o desenvolvimento do sistema.
Com o desenvolvimento do sistema proposto, o setor de tecnologia da informação da empresa Governo do Estado de Roraima, Secretaria Estadual de Educação e todos os seus setores serão beneficiados, garantindo o total controle de suas ordens de serviço.
Atualmente as ordens de serviço são feitas a mão em folhas que são arquivadas, e muitas vezes deixadas de serem preenchidas corretamente por falta de tempo dos funcionários do setor, causando falta de informação e relatórios não relevantes pela inconsistência do método utilizado.
Governo do Estado de Roraima, Secretaria Estadual de Educação, que enviam seus equipamentos para serem feito a manutenção em sua sede, e a falta de consistência no método utilizado traz a necessidade de melhoria no processo das ordens de serviço, enfatizando a oportunidade por conta deste projeto de estagio tanto para a empresa e aluno uma grande parceria.
O presente projeto vai solucionar os problemas decorrentes as ordens de serviço. Por fim, a qual inicialmente deve-se considerar que há a extrema necessidade de melhoria.
Justificativa
Segundo KAPLAN (1997), às empresas da era da informação são exigidas agilidade e confiabilidade. Em um mercado cada vez mais competitivo não se pode conduzir as atividades sem um processo claro e bem estruturado com atribuições bem definidas e tarefas sequenciadas. 
Para auxiliar pequenas empresas a alcançar este grau de excelência, propomos um sistema para reger rotinas e procedimentos e acima de tudo um controle sobre a recepção e destinação dos equipamentos recebidos para manutenção, garantir qualidade e agilidade às demandas dos clientes. Durante o estudo de caso, foi percebido que grande parte dos problemas foram gerados pelo fluxo de informação que ineficiente dentro da própria indústria.
Neste contexto o trabalho terá grande valor para melhoria do fluxo de informações, já que servirá para facilitar o trabalho das pessoas que estão responsáveis pelo gerenciamento do sistema de ordem de serviço, melhorando a produtividade, deixando a empresa mais competitiva e terá também grande valia para o aprendizado não só na parte de desenvolvimento de sistemas, como também na parte de gerenciamento e fluxo de informações.
Objetivos
Objetivo Geral
Desenvolver sistema que efetua a informatização o processo completo com algumas prioridades, parte do principio em ser ágil e seguro, pois o maior problema é a falta de tempo para o preenchimento das ordens de serviço.
Objetivos Específicos
Cadastrar usuários, clientes e equipamentos;
Criar ordem de serviços e relatórios de usuários, clientes, equipamentos e ordem de serviços.
REferencial teorico
	Neste contexto descreveremos o processo de engenharia de software RUP, a linguagem para modelagem de sistemas UML, as linguagens de programação C#, os conceitos de Banco de dados e os SGBDs SQL, e o embasamento teórico que servirão de arcabouço para o desenvolvimento do sistema proposto.
RUP - Rational Unified Process
Segundo KRUCHTEN (2003), RUP é um processo de engenharia de software desenvolvido e comercializado pela Rational Software, bastante utilizado no desenvolvimento de software de alta qualidade e corresponde a um modo disciplinado de ordenar de gerenciar tarefas e responsabilidades em uma empresa de desenvolvimento. O objetivo desse processo é produzir, dentro de prazo e orçamento previstos, software de alta qualidade que satisfaça às necessidades de seus usuários finais.
As Fases 
Segundo KRUCHTEN (2003) O RUP é composto de 04 fases compreendidas em: 
Iniciação: Refere-se basicamente a definição do escopo; estimar o custo geral e os riscos em potencial. As atividades desenvolvidas são: definir os critérios de sucesso de projeto, riscos, recursos necessários e data de realização das principais etapas, delimitar o escopo do projeto, identificar os atores que interagem com o sistema, identificar as interações dos atores com o sistema (casos de uso). Os resultados (artefatos) esperados nesta fase são: documento de visão (visão geral dos requisitos, características e restrições essenciais do projeto); modelo inicial de casos de uso; glossário do projeto; definição de objetivos e viabilidade do projeto, critérios de sucesso, e prognóstico financeiro; avaliação inicial de riscos; plano de projeto, com fases e interações; modelo de negócios, se necessário; um ou vários protótipos. É também nesta fase que se obtêm a concordância quanto à definição de escopo, estimativa de custos e cronograma; 
Elaboração: Retrata como fazer; qual arquitetura será utilizada; em que ambiente a aplicação será executada; como os testes serão executados, é nesta fase que são analisados os riscos de requisitos, ricos tecnológicos, ou seja, a capacidade das ferramentas disponíveis, riscos de habilidade dos integrantes do projeto, objetivando minimizá-los. Construir protótipos executáveis, em uma ou mais interações; atacar os casos de uso críticos, que expõe os maiores riscos técnicos; construir protótipos evolucionários ou descartáveis, com objetivo de analisar custos-benefícios, demonstrar para investidores, clientes e usuários. Os resultados (artefatos) esperados são: modelo de casos de uso; requisitos não funcionais; descrição da arquitetura do software; protótipos arquiteturaisexecutáveis; revisão da visão de negócios e lista de riscos; plano detalhado de desenvolvimento do projeto, com interações e critérios de avaliação; plano de processo de desenvolvimento; manual de usuário preliminar. É nesta fase que algumas questões devem ser respondidas, tais como: A visão do produto é estável? A arquitetura é estável? A demonstração executável mostrou que os elementos de maior risco foram abordados satisfatoriamente? O plano de desenvolvimento está suficientemente detalhado e preciso? O plano é consistente e coerente? Todos os interessados concordam quanto à coerência entre visão, plano e arquitetura? Os custos planejados e executados são aceitáveis? Ao final desta fase a engenharia é considerada completa, por isso esta é considerada a fase mais crítica; 
Construção: Contempla o desenvolvimento ou a construção do software em si. Incluem-se nesta fase também, o desenvolvimento de versões demonstrativas ou beta. O principal objetivo da fase de construção é desenvolver de modo iterativo e incremental um produto completo que esteja pronto para a transição. Isso implica descrever os casos de uso restantes e outros requisitos, incrementar o projeto, concluir a implementação e testar o software. Essas atividades são baseadas na arquitetura definida na fase de elaboração e podem ser executadas com um certo paralelismo. O paralelismo pode acelerar bastante as atividades de desenvolvimento; mas também aumenta a complexidade do gerenciamento de recursos e da sincronização dos fluxos de trabalho. Uma arquitetura sofisticada é essencial para atingir um paralelismo significativo e pode ser obtidos com a aplicação dos padrões de requisitos, análise e projeto; 
Transição: Consiste na implantação da versão final do software ou produto. Nesta fase, o software é disponibilizado aos usuários. Após ter sido colocado em uso, surgem novas considerações que vão demandar a construção de novas versões para permitir ajustes do sistema, corrigir problemas ou concluir algumas características que foram postergadas. É importante realçar que dentro de cada fase, um conjunto de iterações, envolvendo planejamento, levantamento de requisitos, análise, projeto e implementação e testes, é realizado. Contudo, de uma iteração para outra e de uma fase para a próxima, a ênfase sobre as várias atividades muda, a fase de transição concentra-se nos testes, visando garantir que o sistema possui o nível adequado de qualidade. Além disso, os usuários devem ser treinados, características ajustadas e elementos esquecidos adicionados. 
Segundo KRUCHTEN (2003), cada fase tem uma ou mais iterações, com foco em disponibilizar os produtos e documentos necessários para alcançar seus objetivos.
Disciplinas 
Segundo KENDALL (2004), para usufruir das principais características do processo de desenvolvimento com o RUP devem ser observadas suas disciplinas: 
Modelagem do Negócio: Avalia a estrutura e a dinâmica da organização; identifica os problemas e respectivas melhorias e documentar os seus processos. Estes são documentos do modelo de Casos de Uso do Negócio (Business Use Cases). O objetivo desta disciplina é assegurar um entendimento comum entre todos os interessados a respeito de qual processo empresarial precisa receber apoio na organização. Os casos de uso do negócio são analisados para se entender como o negócio deve apoiar os processos empresariais. Muitos projetos podem não utilizar as atividades de modelagem do negócio no seu processo, principalmente nos casos em que o domínio do negócio já é muito bem conhecido por todos os participantes do projeto (principalmente os engenheiros) ou então, quando o negócio é simples e pequeno; 
Requisitos: Apura-se as necessidades do cliente para o projeto; define-se os limites do sistema. As atividades desta disciplina são realizadas a fim de se descrever o que o sistema deve fazer, assim como permitir aos desenvolvedores e clientes avaliarem esta descrição. Tais atividades englobam identificar, organizar, e documentar as funcionalidades exigidas, assim como rastrear e documentar mudanças e decisões. Assim como a Modelagem do Negócio, existe maior concentração de esforços para a realização das atividades inerentes a esta disciplina nas duas primeiras fases do processo, Concepção e Elaboração. Um documento de Visão é criado e a partir deste, são definidas as necessidades dos interessados no sistema e identificados os atores. Ao longo do projeto, cada caso de uso é descrito em detalhes, mostrando interação com atores e suas funcionalidades, assim como os fluxos das regras do negócio. São descritas exigências não-funcionais em especificações adicionais. Os casos de uso vão funcionar como um guia ao longo de todo o ciclo de desenvolvimento do produto de software; 
Análise e Design: Traduz os requisitos ou necessidades do projeto em um modelo de arquitetura de software. As atividades da disciplina de Análise & Projeto são executadas para demonstrar como o sistema será concebido na fase de implementação. O projeto de um sistema deve garantir que o sistema a ser construído execute as tarefas e funções especificadas nos casos de uso, contemple requisitos não-funcionais, e seja flexível às mudanças. As atividades desta disciplina resultam em um Modelo de Projeto e opcionalmente em um Modelo de Análise. O modelo de projeto serve como uma abstração do código fonte: um guia ou mapa de como o código deve ser estruturado e escrito. Todas as soluções de análise e projeto do sistema devem levar em conta a arquitetura do sistema, foco principal das primeiras iterações do ciclo de vida do sistema. Desde o início, deve-se estabelecer uma arquitetura robusta de forma que se possa projetar um sistema que seja fácil de manter, construir e evoluir. Deve-se então ajustar o projeto de forma que se adapte ao ambiente de implementação, projetando o sistema para apresentar bom desempenho, ser robusto, escalável, e ser facilmente testável, entre outras qualidades. O objetivo do projeto, por outro lado, é adaptar os resultados da análise às restrições impostas pelos requisitos não funcionais, pelo ambiente de implementação, pelos requisitos de desempenho, e assim por diante. O projeto é, portanto, um refinamento da análise e objetiva a otimização do projeto do sistema ao mesmo tempo em que garante a cobertura total dos requisitos; 
Implementação: As atividades desta disciplina compreendem definir a organização do código em subsistemas, implementar e testar componentes, e integrar os resultados, formando um sistema executável. O RUP propõe a prática de reutilização de componentes existentes, acelerando a produtividade. Componentes são estruturados em subsistemas da implementação, podendo ser heterogêneos (produzidos com diferentes tecnologias); 
Testes: Executar os testes do software; identifica e documenta as possíveis falhas encontradas; valida a construção do sistema de acordo com a arquitetura proposta. Esta atividade e responsável por verificar as funcionalidades do sistema, a integração de objetos e componentes, a validade dos requisitos implementados, assim como, assegurar que os defeitos encontrados sejam solucionados. De acordo com a abordagem iterativa proposta pelo RUP, os testes são realizados ao longo de todo ciclo de vida do software, e não apenas no final. Isto permite encontrar defeitos tão logo quanto possível, reduzindo custos de eventuais correções posteriores. Os testes são executados considerando as seguintes dimensões de qualidade: confiabilidade, funcionalidade, e desempenho da aplicação e do sistema. Uma prática importante quando se usa uma abordagem iterativa é a automatização de testes, pois permite regressão ao fim de cada iteração, assim como, validar cada nova versão do produto por meio de critérios estabelecidos; 
Implantação: esta disciplina agrupa as atividades relacionadas ao lançamento e implantação do software, tais como: produzir lançamentos externos (para o cliente); "empacotar", distribuir e instalar o software, e; oferecer ajuda e assistência aos usuários. Em muitoscasos, a disciplina também inclui atividades como planejar e gerenciar testes beta; migração de software ou dados existentes e, condução à aceitação formal do software pelos interessados; 
Gerência de Mudanças e Configuração: Controla os artefatos e códigos-fontes produzidos no projeto; controla as versões; controla as mudanças solicitadas pelo cliente. Esta disciplina engloba o controle dos diferentes artefatos produzidos em um projeto. Em conjunto com a disciplina de Ambiente, ela contém as atividades referentes ao gerenciamento de versão e configuração do software: base de conhecimentos, repositórios de dados e informações, e controle de mudanças do projeto; 
Gerência do Projeto: Realiza o planejamento e controle das atividades do projeto; realiza também o acompanhamento das atividades dos envolvidos no projeto e indica ao cliente o andamento do projeto. Esta disciplina inclui atividades como balancear objetivos, gerenciar riscos e contornar problemas a fim de que se possa entregar um software com sucesso. O Processo Unificado da Rational oferece alguns recursos para a realização das atividades: um framework de Gerência de Projetos, com diretrizes para planejar, alocar pessoal, executar e monitorar projetos, e; um framework de Gerência de Riscos. A disciplina não é uma receita para sucesso, mas apresenta uma abordagem que pode melhorar a tarefa; 
Ambiente: Mantém o ambiente de desenvolvimento de software disponível e adequado às necessidades. E também define como o RUP foi configurado para ser utilizado no projeto.
UML - Unified Modeling Language
Segundo GUEDES (2004), a “UML (Unified Modeling Language ou Linguagem de Modelagem Unificada) é uma linguagem visual utilizada para modelar sistemas computacionais por meio do paradigma de “Orientação a Objetos.”, a modelagem visual é o processo de se obter informação a partir do modelo e exibi-las graficamente, usando um conjunto de padrões de elementos gráficos. Para se atingir o objetivo primordial da modelagem visual, que é a comunicação, e usufruir de seus benefícios, é de fundamental importância a existência de padrões definidos e difundidos.
C sharp 
A linguagem C# faz parte do conjunto de ferramentas oferecidas na plataforma .NET e surge como uma linguagem simples, robusta, orientada a objetos, fortemente tipada e altamente escalável a fim de permitir que uma mesma aplicação possa ser executada em diversos dispositivos de hardware, independentemente destes serem PCs, handhelds ou qualquer outro dispositivo móvel.
O avanço das ferramentas de programação e dos dispositivos eletrônicos inteligentes, criou problemas e novas exigências. As novas versões de componentes compartilhados eram incompatíveis com o software antigo. Os desenvolvedores reconheceram a necessidade de software que fosse acessível para qualquer um e disponível por meio de praticamente qualquer tipo de dispositivo. Para tratar dessas necessidades, a Microsoft anunciou sua iniciativa .NET e a linguagem de programação C#. Criado pelo Anders Hejlsberg. 
Banco de dados 
Segundo a KORTH (1995), a finalidade básica dos bancos de dados é armazenar os dados de forma organizada. Isso faz com que os dados fiquem disponíveis para serem usados ou atualizados por todos que tenham acesso a estas informações. 
Segundo DATE (2004), um SGBD (Sistema Gerenciador de Banco de Dados) é um conjunto de dados que associados a um conjunto de programas proporcionam o acesso a esses dados. Como o banco de dados possui estrutura conhecida, o sistema que o armazena possui diversas ferramentas poderosas para prolongar sua utilização, e mecanismos para a manipulação dos dados armazenados.
Sql 
A primeira versão da linguagem SQL, chamada SEQUEL (Structured Query
English Language), surgiu em 1974 nos laboratórios da IBM (Califórnia).
Entre 1976 e 1977 ela foi revisada e ampliada, tendo então o seu nome
alterado para SQL. Devido ao sucesso da nova forma de consulta e manipulação de dados dentro de um ambiente de banco de dados, sua utilização tornou-se cada vez maior. Vários SGBD’s atuais utilizam o SQL como a linguagem padrão para o acesso às bases de dados. Entre eles podemos citar:
 SQL Server da Microsoft.
A linguagem SQL pode ter vários enfoques:
Linguagem interativa de consulta (query AdHoc)
Através de comandos SQL os usuários podem montar consultas poderosas, sem a necessidade da criação de um programa, podendo utilizar ferramentas front-end para a montagem de relatórios.
Linguagem de programação para acesso às bases de dados
Comandos SQL embutidos em programas de aplicação (escritos em C, C++, Java, Visual Basic e etc) acessam os dados armazenados em uma base de dados relacional.
Linguagem de administração de banco de dados
O responsável pela administração do banco de dados (DBA) pode utilizar comandos SQL para realizar tarefas relacionadas com a manutenção dos schemas do banco de dados.
Linguagem de consulta em ambiente cliente/servidor
Os programas sendo processados nos computadores dos clientes (front ends) usam comandos SQL para se comunicarem, através de uma rede, com um SGBD sendo processado em uma máquina servidora (back end);
Linguagem para bancos de dados distribuídos
A linguagem SQL é também a linguagem padrão para a manipulação de dados em uma base de dados distribuída.
Linguagem de definição de dados (DDL)
Permite ao usuário a definição da estrutura e organização dos dados armazenados, e das relações existentes entre eles.
Linguagem de manipulação de dados (DML)
Permite a um usuário, ou a um programa de aplicação, a execução de operações de inclusão, remoção, seleção ou atualização de dados previamente armazenados na base de dados.
Controle de acesso
Protege os dados de manipulações não autorizadas.
Integridade dos dados
Auxilia no processo de definição da integridade dos dados, protegendo contra corrupções e inconsistências geradas por falhas do sistema de computação, ou por erros nos programas de aplicação.
Metodologia
	A metodologia proposta para o desenvolvimento do software será o Espiral. Este modelo foi originalmente proposto por Boehm (1988). Uma maneira simplista de analisar este modelo é considerá-lo como um modelo cascata onde cada fase é precedida por uma análise de risco e sua execução é feita evolucionariamente (ou incrementalmente). 
A dimensão radial representa o custo acumulado atualizado e a dimensão angular representa o progresso através da espiral. Cada setor da espiral corresponde a uma tarefa (fase) do desenvolvimento. Um ciclo se inicia com a "Determinação de objetivos, alternativas e restrições "(primeira tarefa) onde ocorre o comprometimento dos envolvidos e o estabelecimento de uma estratégia para alcançar os objetivos. 
Na segunda tarefa "Avaliação de alternativas, identificação e solução de riscos", executa-se uma análise de risco. Prototipação é uma boa ferramenta para tratar riscos. Se o risco for considerado inaceitável, pode parar o projeto. Na terceira tarefa ocorre o desenvolvimento do produto. Neste quadrante pode-se considerar o modelo cascata. 
Na quarta tarefa o produto é avaliado e se prepara para iniciar um novo ciclo. 
Modelo Espiral Completo
A manutenção de um software utilizando este modelo de ciclo de vida é tratado da mesma forma que o desenvolvimento. Uma representação simplificada deste modelo esta ilustrada na Figura abaixo: 
A razão para se colocar em discussão este modelo está no fato dele chamar a atenção para vários pontos importantíssimos no desenvolvimento de software. 
Variações do modelo espiral consideram entre três e seis tarefas ou setores da espiral. Um exemplo são as regiões: 
Comunicação com o cliente; 
Planejamento; 
Análise de risco; 
Engenharia; 
Construção e liberação; e 
Avaliação do cliente. 
cARACTERIZAÇÃO DA ORGANIZAÇÃO EM ESTUDO
Nome da empresa: GOVERNO DO ESTADO DE RORIMA
Endereço completo: AVENIDA ENE GARCEZ 
Telefone / Fax: (95) 3621-3851
Website; e-mail: http://www.educacao.rr.gov.br 
Nome e cargo da chefia direta: RAIMUNDO NONATOCARNEIRO DE MESQUITA - SECRETÁRIO ESTADUAL DE EDUCAÇÃO E DESPORTOS.
Ramo de atividade e área de atuação: TI /suporte.
Números de empregados da empresa: 500
Categorias dos profissionais que atuam na empresa: Diversas
Organograma da empresa:
Todos os serviços do suporte técnico são prestados por profissionais especializados e giram em torno de garantir a otimização de tempo e recursos da sua empresa ou entidade. Nossa preocupação é trazer soluções e garantir a disposição das informações de forma eficaz, independentemente, do tamanho da sua organização ou área de atuação.
tecnologia 
Para a realização efetiva do projeto de controle de ordem de serviço para gerencia de tecnologia da informação da secretaria de educação, foram analisadas a seguintes tecnologias para desenvolvimento e implantação do sistema. A UML, linguagens de programação em (C#), banco de dados SQL esses serão adotados no desenvolvimento do sistema. 
Linguagem de programação
O C# (leia-se C-Sharp), é uma linguagem de programação  orientada a objetos, que foi desenvolvida pela Microsoft e faz parte da plataforma .NET. Embora a linguagem C# tenha sido criada do zero, foi baseada na linguagem C++ e tem muitos elementos da linguagem Pascal e Java.
A plataforma .NET teve suas bibliotecas inicialmente feitas em Simple Managed C (SMC), porém esta limitou muito o trabalho na plataforma. No inicio de 1999 foi montada uma equipe, liderada por Anders Hejlsberg, com o objetivo de criar uma nova linguagem para a plataforma .NET. Esta linguagem seria criada para desprender a plataforma .NET de outras linguagens, pois o código das linguagens já existentes limitava o desenvolvimento da plataforma.
Esta linguagem foi desenvolvida com o nome de Cool. No momento do lançamento da plataforma .NET, mudaram o nome da linguagem para C#. A criação da linguagem C# ajudou muito no desenvolvimento do .NET, pois a plataforma não precisou se adequar a nenhum código de alguma linguagem já existente. O C# foi criado especificamente para .NET, sendo que muitas outras linguagens tem suporte á C#. Algumas destas linguagens são VB.NET, C++ e J#. Embora a linguagem C# seja considerada muito semelhante ao Java, existem também varias diferenças:
	 
banco de dados
O MS SQL Server é um SGBD - sistema gerenciador de Banco de dados relacional desenvolvido pela Microsoft. Foi criado em parceria com a Sybase em 1988 inicialmente para a plataforma OS/21. Esta parceria durou até 1994, com o lançamento da versão para Windows NT e desde então a Microsoft mantém a manutenção do produto. Como um Banco de dados, é um produto de software cuja principal função é a de armazenar e recuperar dados solicitados por outras aplicações de software, seja aqueles no mesmo computador ou aqueles em execução em outro computador através de uma rede (incluindo a Internet). Há pelo menos uma dúzia de diferentes edições do Microsoft SQL Server destinadas a públicos diferentes e para diferentes cargas de trabalho (variando de pequenas aplicações que armazenam e recuperam dados no mesmo computador, a milhões de usuários e computadores que acessam grandes quantidades de dados a partir da Internet ao mesmo tempo). Suas linguagens de consulta primárias são T-SQL e ANSI SQL.
levantamento de requisitos
Segundo Zave [ZAV97], a engenharia de requisitos é a área da engenharia de software que se preocupa com as metas reais, funções e restrições de software. Ela também se preocupa com o relacionamento destes fatores com uma precisa especificação do comportamento do software e sua evolução através do tempo e das famílias de software. 
Na visão de Pressmann [PRE01], a engenharia de requisitos fornece os mecanismos apropriados para entender o que o cliente quer, analisar necessidades, analisar o que é possível ser feito, negociar uma solução razoável, especificar uma solução não ambígua, validar a especificação e gerenciar os requisitos conforme eles se transformam em um software operante. 
Thayer e Dorfman [THA00] definem engenharia de requisitos como a ciência e disciplina preocupada com a análise e documentação dos requisitos, incluindo análise das necessidades e análise e especificação dos requisitos. Além disso, a engenharia de requisitos fornece mecanismos apropriados para facilitar as atividades de análise, documentação e verificação.
diagrama de caso de uso
Figura 1: Diagrama de caso de uso Sistema de Controle de Ordem de serviço
 
Este diagrama de caso de uso sistema de controle de ordem de serviço proposto para gerencia de tecnologia da informação da secretaria estadual de educação, desenvolvido na ferramenta Jude Community.
diagrama de classe
Figura 2: Digrama de Classe Sistema de controle de ordem de serviço
 
Jude Community é uma Ferramenta essencial para iniciante na modelagem de projeto de sistemas, possui várias opções de operação facilitando a visualização com sistema proposto e seus relacionamentos.
diagrama de sequencia
diagrama de atividade
diagrama de entidade e relacionamneto
Cadastra
Gera Relatório
Equipamento
Funcionário
Telas 
	Abaixo a tela de login, onde o usuário deverá digitar o nome de usuário e a senha para se conectar ao sistema.
Tela de Login
Tela do Sistema
Tela Cadastro de Usuário
Tela de Cadastro e Relatório de Clientes e Serviços Prestados 
Tela Cadastro e Relatório de Serviços
Tela de Cadastro e Relatório de OS
codigo fonte
Tela Splash
namespace ProjectSistemaOS
{
 public partial class frmSplash : Form
 {
 public frmSplash()
 {
 InitializeComponent();
 }
 private void timer1_Tick(object sender, EventArgs e)
 {
 if (progressBar1.Value < 100)
 {
 progressBar1.Value = progressBar1.Value + 2;
 }
 else
 {
 timer1.Enabled = false;
 frmLogin frl = new frmLogin();
 frl.Show();
 this.Visible = false;
 }
 }
 private void progressBar1_Click(object sender, EventArgs e)
 {
 }
 }
}
 
Cadastro de usuário
namespace ProjectSistemaOS.Formularios
{
 public partial class frmUsuario : Form
 {
 public frmUsuario()
 {
 InitializeComponent();
 }
 SqlConnection cn = new SqlConnection(Properties.Settings.Default.ServicoConnectionString);
 SqlCommand cmd = null;
 private void tbUsuarioBindingNavigatorSaveItem_Click(object sender, EventArgs e)
 {
 this.Validate();
 this.tbUsuarioBindingSource.EndEdit();
 this.tableAdapterManager.UpdateAll(this.servicoDataSet);
 try
 {
 //Se os campos estiver preenchido faça
 if ((usuarioTextBox.Text != "") && (nivelAcessoComboBox.Text != "") && (senhaTextBox.Text != "") && (repitaSenhaTextBox.Text != ""))
 {
 //Se as senhas forem igual faça
 if (senhaTextBox.Text == repitaSenhaTextBox.Text)
 {
 //Mostrar a Data do Cadastro na Hora
 if (dataDiaTextBox.Text == "")
 {
 dataDiaTextBox.Text = DateTime.Now.ToString();
 }
 //Mostrar quem Cadastrou o usuario
 if (cadastradorPorTextBox.Text == "")
 {
 cadastradorPorTextBox.Text = frmLogin.usuarioConectado;
 }
 //Executar a aplicação
 this.Validate();
 this.tbUsuarioBindingSource.EndEdit();
 this.tbUsuarioTableAdapter.Update(this.servicoDataSet.tbUsuario);
 }
 else{
 //Caso as senhas são diferentes
 MessageBox.Show("As senhas estão diferentes");
 }
 }
 else
 {
 //Ser os campos não estiverem preenchido
 MessageBox.Show("Todos os campos não podem ficar vazio");
 }
 }
 catch (Exception ex)
 {
 //Caso haja uma exceção será tratada neste código
 MessageBox.Show("Não foi possível salvar pelo seguinte motivo: " + ex.Message);
 }
 }
 private void frmUsuario_Load(object sender, EventArgs e)
 {
 // TODO: This line of code loads data into the 'servicoDataSet.tbUsuario' table. You can move, or remove it, as needed.
 this.tbUsuarioTableAdapter.Fill(this.servicoDataSet.tbUsuario);
 }
 private void btnPesquisar_Click(object sender, EventArgs e)
 {
 try
 {
 if (cbmFiltrar.Text == "Codigo")
 {
 //Define a instrução Sql
 string sql = "SELECT * FROM tbUsuario WHERE idUsuario =" + txtPesquisar.Text + "";
 //Lê os dados da variavel sql e conectar no cn
 cmd = new SqlCommand(sql, cn);
 //Abre conexão
 cn.Open();
 //Define o valor da CommandType para cmd
 cmd.CommandType = CommandType.Text;
 /*Representa um conjunto de comandos de dados e uma conexão de banco de dados 
 que são usados para preencher o DataSet e atualizar um banco de dados SQL Server.*/
 SqlDataAdapter da = new SqlDataAdapter(cmd);
 //Representa uma tabela de dados na memória.
 DataTable usuario = new DataTable();
 /* Adiciona ou atualiza linhas em um DataTable para que correspondam na fonte de 
 * dados usando o DataTable.*/
 da.Fill(usuario);
 /*A tbUsuarioDataGridView recebe o DataTable usuario*/
 tbUsuarioDataGridView.DataSource = usuario;
 //Fechar a conexão
 }
 if (cbmFiltrar.Text == "Usuário")
 {
 //define a instrução SQL
 string sql = "SELECT * FROM tbUsuario WHERE usuario LIKE '%" + txtPesquisar.Text + "%'";
 cmd = new SqlCommand(sql, cn);
 cn.Open();
 cmd.CommandType = CommandType.Text;
 SqlDataAdapter da = new SqlDataAdapter(cmd);
 DataTable usuario = new DataTable();
 da.Fill(usuario);
 tbUsuarioDataGridView.DataSource = usuario;
 }
 }
 catch (Exception ex)
 {
 MessageBox.Show(ex.Message);
 }
 finally
 {
 cn.Close();
 }
 }
 private void LimparCampo()
 {
 idUsuarioTextBox.Clear();
 usuarioTextBox.Clear();
 senhaTextBox.Clear();
 repitaSenhaTextBox.Clear();
 nivelAcessoComboBox.Text = "";
 dataDiaTextBox.Text = "";
 cadastradorPorTextBox.Clear();
 }
 private void tbUsuarioDataGridView_MouseDoubleClick(object sender, MouseEventArgs e)
 {
 try
 {
 LimparCampo();
 idUsuarioTextBox.Text = tbUsuarioDataGridView.CurrentRow.Cells[0].Value.ToString();
 usuarioTextBox.Text = tbUsuarioDataGridView.CurrentRow.Cells[1].Value.ToString();
 senhaTextBox.Text = tbUsuarioDataGridView.CurrentRow.Cells[2].Value.ToString();
 repitaSenhaTextBox.Text = tbUsuarioDataGridView.CurrentRow.Cells[3].Value.ToString();
 nivelAcessoComboBox.Text = tbUsuarioDataGridView.CurrentRow.Cells[4].Value.ToString();
 dataDiaTextBox.Text = tbUsuarioDataGridView.CurrentRow.Cells[5].Value.ToString();
 cadastradorPorTextBox.Text = tbUsuarioDataGridView.CurrentRow.Cells[6].Value.ToString();
 }
 catch (Exception ex)
 {
 MessageBox.Show("Não foi possível Carregar os dados pelo motivo: " + ex.Message);
 }
 }
 private void btnSalvar_Click(object sender, EventArgs e)
 {
 tbUsuarioBindingNavigatorSaveItem_Click(sender, e);
 }
 private void btnCancelar_Click(object sender, EventArgs e)
 {
 this.Dispose();
 }
 }
}
tela principal
namespace ProjectSistemaOS.Formularios
{
 public partial class frmPrincipal : Form
 {
 public frmPrincipal()
 {
 InitializeComponent();
 }
 private void frmPrincipal_Load(object sender, EventArgs e)
 {
 }
 private void usuárioToolStripMenuItem1_Click(object sender, EventArgs e)
 {
 frmUsuario frmUsu = new frmUsuario();
 frmUsu.Show();
 
 }
 private void timer1_Tick(object sender, EventArgs e)
 {
 tsslData.Text = DateTime.Now.ToShortDateString();
 tsslHora.Text = DateTime.Now.ToShortTimeString();
 }
 private void clienteToolStripMenuItem_Click(object sender, EventArgs e)
 {
 frmCliente frmCli = new frmCliente();
 frmCli.Show();
 }
 private void serviçoToolStripMenuItem_Click(object sender, EventArgs e)
 {
 frmServico frmSer = new frmServico();
 frmSer.Show(); 
 }
 private void ordemDeServiçoToolStripMenuItem_Click(object sender, EventArgs e)
 {
 frmOS frmOs = new frmOS();
 frmOs.Show();
 }
 private void clienteToolStripMenuItem1_Click(object sender, EventArgs e)
 {
 frmRelCliente frmCli = new frmRelCliente();
 frmCli.Show();
 }
 private void sairToolStripMenuItem_Click(object sender, EventArgs e)
 {
 
 Application.Exit();
 
 }
 
 
 }
 }
cadastro de cliente
namespace ProjectSistemaOS.Formularios
{
 public partial class frmCliente : Form
 {
 public frmCliente()
 {
 InitializeComponent();
 }
 SqlConnection cn = new SqlConnection(Properties.Settings.Default.ServicoConnectionString);
 SqlCommand cmd = null;
 private void tbClienteBindingNavigatorSaveItem_Click(object sender, EventArgs e)
 {
 this.Validate();
 this.tbClienteBindingSource.EndEdit();
 this.tableAdapterManager.UpdateAll(this.servicoDataSet);
 MessageBox.Show("Cadastro realizado com sucesso","Sucesso",
 MessageBoxButtons.OK,
 MessageBoxIcon.Information);
 this.tbClienteTableAdapter.Fill(this.servicoDataSet.tbCliente);
 this.tbClienteBindingSource.MoveLast();
 
 }
 
 private void frmCliente_Load(object sender, EventArgs e)
 {
 // TODO: This line of code loads data into the 'servicoDataSet.tbOrdemServico' table. You can move, or remove it, as needed.
 this.tbOrdemServicoTableAdapter.Fill(this.servicoDataSet.tbOrdemServico);
 // TODO: This line of code loads data into the 'servicoDataSet.tbServico' table. You can move, or remove it, as needed.
 this.tbServicoTableAdapter.Fill(this.servicoDataSet.tbServico);// TODO: This line of code loads data into the 'servicoDataSet.tbCliente' table. You can move, or remove it, as needed.
 this.tbClienteTableAdapter.Fill(this.servicoDataSet.tbCliente);
 }
 private void btnPesquisar_Click(object sender, EventArgs e)
 {
 try
 {
 if (cbmFiltrar.Text == "Código")
 {
 //Define a instrução Sql
 string sql = "SELECT * FROM tbCliente WHERE idCliente =" + txtPesquisar.Text + "";
 //Lê os dados da variavel sql e conectar no cn
 cmd = new SqlCommand(sql, cn);
 //Abre conexão
 cn.Open();
 //Define o valor da CommandType para cmd
 cmd.CommandType = CommandType.Text;
 /*Representa um conjunto de comandos de dados e uma conexão de banco de dados 
 que são usados para preencher o DataSet e atualizar um banco de dados SQL Server.*/
 SqlDataAdapter da = new SqlDataAdapter(cmd);
 //Representa uma tabela de dados na memória.
 DataTable cliente = new DataTable();
 /* Adiciona ou atualiza linhas em um DataTable para que correspondam na fonte de 
 * dados usando o DataTable.*/
 da.Fill(cliente);
 /*A tbUsuarioDataGridView recebe o DataTable usuario*/
 tbClienteDataGridView.DataSource = cliente;
 //Fechar a conexão
 }
 if (cbmFiltrar.Text == "Nome")
 {
 //define a instrução SQL
 string sql = "SELECT * FROM tbCliente WHERE nome LIKE '%" + txtPesquisar.Text + "%'";
 cmd = new SqlCommand(sql, cn);
 cn.Open();
 cmd.CommandType = CommandType.Text;
 SqlDataAdapter da = new SqlDataAdapter(cmd);
 DataTable cliente = new DataTable();
 da.Fill(cliente);
 tbClienteDataGridView.DataSource = cliente;
 }
 if (cbmFiltrar.Text == "CPF")
 {
 //define a instrução SQL
 string sql = "SELECT * FROM tbCliente WHERE cpf ='" + txtPesquisar.Text + "'";
 cmd = new SqlCommand(sql, cn);
 cn.Open();
 cmd.CommandType = CommandType.Text;
 SqlDataAdapter da = new SqlDataAdapter(cmd);
 DataTable cliente = new DataTable();
 da.Fill(cliente);
 tbClienteDataGridView.DataSource = cliente;
 }
 }
 catch (Exception ex)
 {
 MessageBox.Show(ex.Message);
 }
 finally
 {
 cn.Close();
 }
 }
 private void cbmFiltrar_SelectedIndexChanged(object sender, EventArgs e)
 {
 {
 if (cbmFiltrar.Text == "Código")
 {
 txtPesquisar.Mask = "";
 
 }
 if (cbmFiltrar.Text == "Nome")
 {
 txtPesquisar.Mask = "";
 }
 if (cbmFiltrar.Text == "CPF")
 {
 txtPesquisar.Mask = "000,000,000-00";
 }
 if (cbmFiltrar.Text == "")
 {
 txtPesquisar.Mask = "";
 }
 }
 }
 private void timer1_Tick(object sender, EventArgs e)
 {
 try
 {
 //define a instrução SQL
 string sql = "SELECT * FROM tbOrdemServico WHERE idCliente ='" + idClienteTextBox.Text + "'";
 cmd = new SqlCommand(sql, cn);
 cn.Open();
 cmd.CommandType = CommandType.Text;
 SqlDataAdapter da = new SqlDataAdapter(cmd);
 DataTable os = new DataTable();
 da.Fill(os);
 tbOrdemServicoDataGridView.DataSource = os;
 }
 catch (Exception ex)
 {
 MessageBox.Show(ex.Message);
 }
 finally
 {
 cn.Close();
 }
 }
 private void LimparCampo()
 {
 idClienteTextBox.Clear();
 nomeTextBox.Clear();
 cpfMaskedTextBox.Clear();
 telefoneMaskedTextBox.Clear();
 enderecoTextBox.Clear();
 bairroTextBox.Clear();
 cidadeTextBox.Clear();
 estadoComboBox.SelectedIndex = -1;
 dataDiaTextBox.Clear();
 cadastradoPorTextBox.Clear();
 }
 private void bindingNavigatorAddNewItem_Click(object sender, EventArgs e)
 {
 
 // Desabilitar o botão excluir para quem nivel de acesso Operador
 if (frmLogin.NívelAcesso == "Operador")
 {
 bindingNavigatorDeleteItem.Enabled = false;
 }
 
 
 }
 private void tbClienteDataGridView_MouseDoubleClick(object sender, MouseEventArgs e)
 {
 {
 LimparCampo();
 idClienteTextBox.Text = tbClienteDataGridView.CurrentRow.Cells[0].Value.ToString();
 nomeTextBox.Text = tbClienteDataGridView.CurrentRow.Cells[1].Value.ToString();
 cpfMaskedTextBox.Text = tbClienteDataGridView.CurrentRow.Cells[2].Value.ToString();
 telefoneMaskedTextBox.Text = tbClienteDataGridView.CurrentRow.Cells[3].Value.ToString();
 enderecoTextBox.Text = tbClienteDataGridView.CurrentRow.Cells[4].Value.ToString();
 bairroTextBox.Text = tbClienteDataGridView.CurrentRow.Cells[5].Value.ToString();
 cidadeTextBox.Text = tbClienteDataGridView.CurrentRow.Cells[6].Value.ToString();
 estadoComboBox.Text = tbClienteDataGridView.CurrentRow.Cells[7].Value.ToString();
 dataDiaTextBox.Text = tbClienteDataGridView.CurrentRow.Cells[8].Value.ToString();
 cadastradoPorTextBox.Text = tbClienteDataGridView.CurrentRow.Cells[9].Value.ToString();
 }
 }
 }
}
Cadastro de serviço
namespace ProjectSistemaOS.Formularios
{
 public partial class frmServico : Form
 {
 public frmServico()
 {
 InitializeComponent();
 }
 SqlConnection cn = new SqlConnection(Properties.Settings.Default.ServicoConnectionString);
 SqlCommand cmd = null;
 private void tbServicoBindingNavigatorSaveItem_Click(object sender, EventArgs e)
 {
 this.Validate();
 this.tbServicoBindingSource.EndEdit();
 this.tableAdapterManager.UpdateAll(this.servicoDataSet);
 try
 {
 // Desabilita botao excluir para que tem vivel de de Acesso
 if (frmLogin.NívelAcesso == "Oprador")
 {
 bindingNavigatorDeleteItem.Enabled = false;
 }
 
 //Se os campos estiver preenchido faça
 if (nomeTextBox.Text != "")
 {
 
 //Mostrar a Data do Cadastro na Hora
 if (dataDiaMaskedTextBox.Text == "")
 {
 dataDiaMaskedTextBox.Text = DateTime.Now.ToString();
 }
 //Mostrar quem Cadastrou o usuario
 if (cadastradoPorTextBox.Text == ""){
 cadastradoPorTextBox.Text = frmLogin.usuarioConectado;
 }
 // Executar a aplicação
 this.Validate();
 this.tbServicoBindingSource.EndEdit();
 this.tbServicoTableAdapter.Update(this.servicoDataSet.tbServico);
 MessageBox.Show("Cadastro realizado com sucesso",
 "Sucesso",
 MessageBoxButtons.OK,
 MessageBoxIcon.Information);
 }
 
 else
 {
 //Ser os campos não estiverem preenchido
 MessageBox.Show("O Campo nome não pode ficar vazio");
 }
 }
 catch (Exception ex)
 {
 //Caso haja uma exceção será tratada neste código
 MessageBox.Show("Não foi possível salvar pelo seguinte motivo: " + ex.Message);
 }
 
 }
 private void frmServico_Load(object sender, EventArgs e)
 {
 // TODO: This line of code loads data into the 'servicoDataSet.tbServico' table. You can move, or remove it, as needed.
 this.tbServicoTableAdapter.Fill(this.servicoDataSet.tbServico);
 }
 private void btnPesquisar_Click(object sender, EventArgs e)
 {
 
 try
 {
 if (cbmFiltrar.Text == "Código")
 {
 //Define a instrução Sql
 string sql = "SELECT * FROM tbServico WHERE idServico =" + txtPesquisar.Text + "";
 //Lê os dados da variavel sql e conectar no cn
 cmd = new SqlCommand(sql, cn);
 //Abre conexão
 cn.Open();
 //Define o valor da CommandType para cmd
 cmd.CommandType = CommandType.Text;
 /*Representa um conjunto de comandos de dados e uma conexão de banco de dados 
 que são usados para preencher o DataSet e atualizar um banco de dados SQL Server.*/
 SqlDataAdapter da = new SqlDataAdapter(cmd);
 //Representa uma tabela de dados na memória.
 DataTable servico = new DataTable();
 /* Adiciona ou atualiza linhas em um DataTable para que correspondam na fonte de 
 * dados usando o DataTable.*/
 da.Fill(servico);
 /*A tbUsuarioDataGridView recebe o DataTable usuario*/
 tbServicoDataGridView.DataSource = servico;
 }
 if (cbmFiltrar.Text == "Nome")
 {
 //define a instrução SQL
 string sql = "SELECT * FROM tbServico WHERE nome LIKE '%" + txtPesquisar.Text + "%'";
 cmd = new SqlCommand(sql, cn);
 cn.Open();
 cmd.CommandType = CommandType.Text;
 SqlDataAdapter da = new SqlDataAdapter(cmd);
 DataTable servico = new DataTable();
 da.Fill(servico);
 tbServicoDataGridView.DataSource = servico;
 }
 }
 catch (Exception ex)
 {
 MessageBox.Show(ex.Message);
 }
 finally
 {
 cn.Close();
 }
 }
 private void LimparCampo()
 {
 idServicoTextBox.Clear();
 nomeTextBox.Clear();
 descricaoTextBox.Clear();
 valorTextBox.Clear();
 dataDiaMaskedTextBox.Clear();
 cadastradoPorTextBox.Clear();
 }
 private void bindingNavigatorAddNewItem_Click(object sender, EventArgs e)
 {
 }
 private void tbServicoDataGridView_DoubleClick(object sender, EventArgs e)
 
 {
 LimparCampo();
 idServicoTextBox.Text = tbServicoDataGridView.CurrentRow.Cells[0].Value.ToString();
 nomeTextBox.Text = tbServicoDataGridView.CurrentRow.Cells[1].Value.ToString();
 descricaoTextBox.Text = tbServicoDataGridView.CurrentRow.Cells[2].Value.ToString();
 observacaoTextBox.Text = tbServicoDataGridView.CurrentRow.Cells[3].Value.ToString();
 valorTextBox.Text = tbServicoDataGridView.CurrentRow.Cells[4].Value.ToString();
 dataDiaMaskedTextBox.Text = tbServicoDataGridView.CurrentRow.Cells[5].Value.ToString();
 cadastradoPorTextBox.Text = tbServicoDataGridView.CurrentRow.Cells[6].Value.ToString();
 }
 }
 }
cadastro de ordem de serviço
namespace ProjectSistemaOS.Formularios
{
 public partial class frmOS : Form
 {
 public frmOS()
 {
 InitializeComponent();
 }
 SqlConnection cn = new SqlConnection(Properties.Settings.Default.ServicoConnectionString);
 SqlCommand cmd = null;
 private void tbOrdemServicoBindingNavigatorSaveItem_Click(object sender, EventArgs e)
 {
 this.Validate();
 this.tbOrdemServicoBindingSource.EndEdit();
 this.tableAdapterManager.UpdateAll(this.servicoDataSet);
 try
 {
 // Desabilita botão excluir para quem tem nivel de acesso
 if (frmLogin.NívelAcesso == " Operador")
 {
 bindingNavigatorDeleteItem.Enabled = false;
 }
 if ((idClienteComboBox.Text != "") && (idServicoComboBox.Text != ""))
 {
 if (dataDiaMaskedTextBox.Text == "")
 {
 dataDiaMaskedTextBox.Text = DateTime.Now.ToString();
 }
 if (cadastradorPorTextBox.Text == "")
 {
 cadastradorPorTextBox.Text = frmLogin.usuarioConectado;
 }
 // Executar aplicação
 this.Validate();
 this.tbOrdemServicoBindingSource.EndEdit();
 this.tbOrdemServicoTableAdapter.Update(this.servicoDataSet.tbOrdemServico);
 MessageBox.Show("OS realizado com sucesso",
 "Sucesso",
 MessageBoxButtons.OK,
 MessageBoxIcon.Information);
 }
 else
 {
 MessageBox.Show("Todos os campos são obrigatorio");
 }
 }
 catch (Exception ex)
 {
 MessageBox.Show(ex.Message);
 }
 finally
 {
 cn.Close();
 }
 }
 
 private void frmOS_Load(object sender, EventArgs e)
 {
 // TODO: This line of code loads data into the 'servicoDataSet.tbCliente' table. You can move, or remove it, as needed.
 this.tbClienteTableAdapter.Fill(this.servicoDataSet.tbCliente);
 // TODO: This line of code loads data into the 'servicoDataSet.tbServico' table. You can move, or remove it, as needed.
 this.tbServicoTableAdapter.Fill(this.servicoDataSet.tbServico);
 // TODO: This line of code loads data into the 'servicoDataSet.tbOrdemServico' table. You can move, or remove it, as needed.
 this.tbOrdemServicoTableAdapter.Fill(this.servicoDataSet.tbOrdemServico);}
 private void btnPesquisar_Click(object sender, EventArgs e)
 {
 try
 {
 if (cbmFiltrar.Text == "Código OS")
 {
 //Define a instrução Sql
 string sql = "SELECT * FROM tbOrdemServico WHERE idOrdem =" + txtPesquisar.Text + "";
 
 //Lê os dados da variavel sql e conectar no cn
 cmd = new SqlCommand(sql, cn);
 //Abre conexão
 cn.Open();
 
 //Define o valor da CommandType para cmd
 cmd.CommandType = CommandType.Text;
 /*Representa um conjunto de comandos de dados e uma conexão de banco de dados 
 que são usados para preencher o DataSet e atualizar um banco de dados SQL Server.*/
 SqlDataAdapter da = new SqlDataAdapter(cmd);
 //Representa uma tabela de dados na memória.
 DataTable os = new DataTable();
 /* Adiciona ou atualiza linhas em um DataTable para que correspondam na fonte de 
 * dados usando o DataTable.*/
 da.Fill(os);
 /*A tbUsuarioDataGridView recebe o DataTable usuario*/
 tbOrdemServicoDataGridView.DataSource = os;
 //Fechar a conexão
 
 }
 if (cbmFiltrar.Text == "Código Cliente")
 { 
 //define a instrução SQL
 string sql = "SELECT * FROM tbOrdemServico WHERE idCliente =" + txtPesquisar.Text + "";
 cmd = new SqlCommand(sql, cn);
 cn.Open();
 cmd.CommandType = CommandType.Text;
 SqlDataAdapter da = new SqlDataAdapter(cmd);
 DataTable os = new DataTable();
 da.Fill(os);
 tbOrdemServicoDataGridView.DataSource = os;
 
 }
 if (cbmFiltrar.Text == "Código Serviço")
 {
 //define a instrução SQL
 string sql = "SELECT * FROM tbOrdemServico WHERE idServico=" + txtPesquisar.Text + "";
 cmd = new SqlCommand(sql, cn);
 cn.Open();
 cmd.CommandType = CommandType.Text;
 SqlDataAdapter da = new SqlDataAdapter(cmd);
 DataTable os = new DataTable();
 da.Fill(os);
 tbOrdemServicoDataGridView.DataSource = os;
 }
 }
 catch (Exception ex)
 {
 MessageBox.Show(ex.Message);
 }
 finally
 {
 cn.Close();
 }
 }
 private void LimparCampo()
 {
 idOrdemTextBox.Clear();
 idClienteComboBox.SelectedIndex = -1;
 idServicoComboBox.SelectedIndex = -1;
 dataDiaMaskedTextBox.Clear();
 cadastradorPorTextBox.Clear();
 }
 private void tbOrdemServicoDataGridView_MouseDoubleClick(object sender, MouseEventArgs e)
 {
 LimparCampo();
 idOrdemTextBox.Text = tbOrdemServicoDataGridView.CurrentRow.Cells[0].Value.ToString();
 idClienteComboBox.Text = tbOrdemServicoDataGridView.CurrentRow.Cells[1].Value.ToString();
 idServicoComboBox.Text = tbOrdemServicoDataGridView.CurrentRow.Cells[2].Value.ToString();
 dataDiaMaskedTextBox.Text = tbOrdemServicoDataGridView.CurrentRow.Cells[3].Value.ToString();
 cadastradorPorTextBox.Text = tbOrdemServicoDataGridView.CurrentRow.Cells[4].Value.ToString();
 }
 }
 }
cronograma 
	Partes do TCC
	Jul
	Ago
	Set
	Out
	Nov 
	Dez 
	Introdução do Trabalho
	 
	
	
	
	
	
	Redação da Monografia 
com base no referencial teórico
	
	
	
	
	
	
	Metodologia, características da Empresa 
e descrição tecnologia
	
	
	
	
	
	
	Levantamento d requisitos 
	
	
	
	
	
	
	Entrega Parcial do TCC
	
	
	
	
	
	
	Diagramas
	
	
	
	
	
	
	Desenvolvimento da 
Aplicação (implementação)
	
	
	
	
	
	
	Teste e Validação
	
	
	
	
	
	
	Revisão Final
	
	
	
	
	
	
	Entrega final do TCC
	
	
	
	
	
	
	Apresentação do TCC ( no Polo)
	
	
	
	
	
	
Conclusão
Esse trabalho foi de grande contribuição para a compreensão de como um projeto pode ser complexo, e como pode ser simplificado se seguido os passos de um cronograma, ou um ciclo de vida. O trabalho nos mostrou que devemos ser rigorosos com todo o cronograma para poupar tempo e custo, isso nos trás segurança como equipe de desenvolvimento e trás segurança para os clientes que poderá contar com o produto no prazo e com qualidade. A Metodologia de Desenvolvimento de Software proposta ajudara a padronizar, formalizar e descrever o processo de levantamento de requisitos, documentação, desenvolvimento, homologação, implantação e manutenção de sistemas adotados pela empresa. Ajudando assim o desenvolvimento do projeto de gerenciamento de estoque, arrumando a empresa e trazendo menos custos e tempo.
Após finalizar esse trabalho, conseguimos nos certificar que a Análise e Projeto de Sistemas de Informação ocupam um lugar essencial no que diz respeito ao desenvolvimento de Sistemas Informacionais. 
O processo de desenvolvimento de software, com suas fases e disciplinas bem definidas visando à construção de um sistema de forma interativa e incremental, define métodos e parâmetros para a formação sólida da real necessidade e dimensão do sistema em estudo, proporcionaram o desenvolvimento e acompanhamento do projeto.
Referências Bibliograficas
Livros
MATEUS, Eloá Jane F. Sistemas Operacionais: sistemas V. 1. ed. São Paulo: Pearson Education do Brasil. 2010. 183 p.
MACHADO, Francis B.; MAIA, Luiz Paulo. Arquitetura de sistemas operacionais. 4. ed. Rio de Janeiro: LTC, 2007. 324 p.
CRUZ, Vilma Aparecida G. Metodologia da pesquisa científica. 1. ed. São Paulo: Pearson Prentice Hall. 2010. 182 p.
COACHMAN, Erika. Segurança da informação. 1. ed. São Paulo: Pearson Education do Brasil. 2010. 177 p.
HISATOMI, Marco I. Projeto de sistemas. 1. ed. São Paulo: Pearson Education do Brasil. 2010. 181 p.
Sites 
http://gestaodeprojetos10.blogspot.com/2009/06/ciclo-de-vida-do-projeto.html
http://wpm.wikidot.com/conceito:caracteristicas-do-ciclo-de-vida-do-projeto
http://pt.wikipedia.org/wiki/RAID
http://www.portalphb.com.br/ARTIGOS/backup.doc
ZAVE, Pamela. Classification of Research Efforts in Requirements
Engineering. ACM Computing Surveys. v. 29, n. 4. Dev. 1997. p.
315-321.
PRESSMAN, Roger S. Software Engineering: a practitioner’s approach.
EUA: McGraw Hill, 2001. 860 p.
THAYER, Richard; DORFMAN, Merlin. System and Software
Requirements Engineering - Second Edition. Los Alamitos: IEEE
Computer Society Press Tutorial, 2000. 528p