Passo a passo: Usando F# Visual para criar, depurar e implantar um aplicativo

Esse guia passo a passo apresenta a experiência de usar o F# no Visual Studio juntamente com o .NET Framework 4.5.

Nesse guia, você aprenderá como começar a usar o Visual Studio para escrever aplicativos F# através do exemplo de uma análise histórica de dados da taxa de juros da tesouraria dos Estados Unidos.Você começará com uma análise rápida dos dados usando a janela interativa do F#, então escreva e teste algum código para analisar os dados, em seguida, adicione um front end do C# para explorar a integração do seu código F# com outras linguagens .NET.

Pré-requisitos

Para completar este passo-a-passo, são necessários os seguintes componentes:

• Visual Studio

Observação
Seu computador pode mostrar nomes ou locais diferentes para alguns dos elementos da interface do usuário do Visual Studio nas instruções a seguir. A edição do Visual Studio que você possui e as configurações que você usa determinam esses elementos. Para obter mais informações, consulte Configurações de Visual Studio.

Para criar um script F#

1. Primeiro, crie um script F#.No menu Arquivo, aponte para Novo, e em seguida, clique em Arquivo.Na caixa de diálogo Novo Arquivo, selecione Script na categoria Geral em baixo da lista de modelos Instalada e então selecione Arquivo de script F#.Clique em Abrir para criar o arquivo, e então salve o arquivo como RateAnalysis.fsx.

2. Use APIs .NET e F# para acessar dados do site da Reserva Federal dos Estados Unidos.Digite o código a seguir.

   open System.Net
   open System.IO
   
   let url = sprintf "http://www.federalreserve.gov/datadownload/Output.aspx?rel=H15&series=bcb44e57fb57efbe90002369321bfb3f&lastObs=&from=&to=&filetype=csv&label=include&layout=seriescolumn"
   let req = WebRequest.Create(url, Timeout = 10000000)
   let resp = req.GetResponse()
   let stream = resp.GetResponseStream()
   let reader = new StreamReader(stream)
   let csv = reader.ReadToEnd()
   

   Observe o seguinte:

   • As cadeias de caracteres e as palavras-chave estão coloridas.

   • As listas de conclusão aparecem depois que você digita cada ponto final (.).

   • Você pode ter nomes completos do método do Visual Studio e outros identificadores usando o atalho de teclado CTRL + ESPAÇO ou CTRL+J no meio de um identificador.Uma lista de conclusão aparece quando você usa CTRL+J.

   • Quando você posiciona o ponteiro do mouse sobre qualquer identificador no código, você verá uma dica de ferramenta que contém informações sobre o identificador.

   • Se você pressionar F1 quando o cursor está em WebRequest, a documentação esperada aparece.

   • Se você pressionar F1 quando o cursor está em let, a documentação esperada aparece.

   • Os tipos e namespaces do mscorlib.dll, System.dll, e do System.Windows.Forms.dll são referenciados por padrão.

   • O valor Timeout que está sendo definido aqui é uma propriedade, não um argumento do construtor.F# permite que você defina valores de propriedade dessa maneira.

   • Se você copiar o URL do exemplo em um navegador, você obtém a uma lista de valores separados por vírgulas que contêm datas e taxas de juros, publicados pela Reserva Federal dos Estados Unidos.

3. Agora você irá executar o código usando o F# interativo.Selecione todo o código (usando o mouse ou pressionando CTRL+A) e clique com o botão direito do mouse e, em seguida, clique em Executar no Interativo.(Alternativamente, pressione ALT+ENTER.)

   • Se já não estava visível, a janela do F# interativo aparece.

   • O Código é executado com êxito.

   • Na janela do F# Interativo irá aparecer o seguinte.

     val url : string =
       "http://www.federalreserve.gov/datadownload/Output.aspx?rel=H1"+[107 chars]
     val req : System.Net.WebRequest
     val resp : System.Net.WebResponse
     val stream : System.IO.Stream
     val reader : System.IO.StreamReader
     
     val csv : string =
       ""Series Description","Market yield on U.S. Treasury securities"+[224219 chars]
     
     >
     

4. Em seguida, inspecione os dados usando o F# interativo.No prompt do F# Interativo, digite csv;; e pressione ENTER.Digite csv.Length;; e pressione ENTER.Observe o seguinte:

   • Os dados são atuais.

   • F# Interativo exibe o valor da cadeia de caracteres csv e o seu comprimento, como mostrado aqui.

     07/10/2009, 3.32
     07/13/2009, 3.38
     07/14/2009, 3.50
     07/15/2009, 3.63
     "
     > csv.Length;;
     val it : int = 224513
     

   • A ilustração a seguir mostra a janela do F# Interativo.

     Janela do F# Interativo

     

5. Agora você irá escrever um código de F# para analisar dados CSV (Valores Separados por Vírgula).Um arquivo CSV é nomeado dessa forma porque contém valores separados por vírgulas.No Editor de Código, adicione o seguinte código.Além de isso, adicione open System.Globalization na parte superior do arquivo.A medida que você adiciona cada linha, selecione o código adicionado nesta seção para essa linha e pressione ALT+ENTER para ver os resultados parciais.Observe o seguinte:

   • O IntelliSense fornece informações úteis após você digitar um ponto final, mesmo no meio de complexas expressões aninhadas.

   • Quando o código está incompleto (ou incorreto), traços ondulados vermelhos indicam que erros semânticos e sintáticos aparecem no código.

   • Você cria pipelines usando o operador barra vertical (|>).O operador barra vertical recebe o valor de retorno de uma expressão e o usa como o argumento para a função na próxima linha.Pipelines e F# Interativos permitem uma fácil execução parcial de código de processo de dados.

   let interest = 
       csv.Split([|'\n'|])
       |> Seq.skip 8
       |> Seq.map (fun line -> line.Trim())
       |> Seq.filter (fun line -> not (line.EndsWith("ND")))
       |> Seq.filter (fun line -> not (line.Length = 0))
       |> Seq.map (fun line -> line.Split([|','|]))
       |> Seq.map ( fun values ->
           System.DateTime.Parse(values.[0], CultureInfo.CreateSpecificCulture("en-US")),
           float values.[1])
   

6. Agora você dará a essa funcionalidade um nome.Remova a ID das series bcb44e57fb57efbe90002369321bfb3f da definição de url, e substitua-o por %s para fazer com que a cadeia de caracteres seja literalmente uma cadeia de formato.Adicione seriesID após a cadeia de formato.Selecione todo o código com exeção das diretivas abertas, e pressione TAB.Acima do bloco de código indentado, adicione as seguintes linhas de código.

   let loadRates maturity =
       // The following tuples associate various maturity durations, in years,
       // with codes defined for treasury bills by the Federal Reserve.
       let maturitiesMap = Map.ofList [(1, "e30653a4b627e9d1f2490a0277d9f1ac")
                                       (2, "c66ea77a2e8f0919c5133c7633065908")
                                       (5, "fbb02942bfdbff31a479e98bcbe26388")
                                       (10, "bcb44e57fb57efbe90002369321bfb3f")
                                       (20, "a1ebeb6e84ca6389772dd054dc980191")]
       let seriesID = Map.find maturity maturitiesMap
   

   Ao final do bloco indentado, adicione interest.Observe o seguinte:

   • A indentação é importante no F#.A indentação indica nível de aninhamento.

   • TAB é quase como Extrair método refatoração (C#).

   O código, agora, é semelhante ao seguinte.

   open System.Net
   open System.IO
   
   let loadRates maturity =
       // The following tuples associate various maturity durations, in years,
       // with codes defined for treasury bills by the Federal Reserve.
       let maturitiesMap = Map.ofList [(1, "e30653a4b627e9d1f2490a0277d9f1ac")
                                       (2, "c66ea77a2e8f0919c5133c7633065908")
                                       (5, "fbb02942bfdbff31a479e98bcbe26388")
                                       (10, "bcb44e57fb57efbe90002369321bfb3f")
                                       (20, "a1ebeb6e84ca6389772dd054dc980191")]
       let seriesID = Map.find maturity maturitiesMap
       let url = sprintf "http://www.federalreserve.gov/datadownload/Output.aspx?rel=H15&series=%s&lastObs=&from=&to=&filetype=csv&label=include&layout=seriescolumn" seriesID
       let req = WebRequest.Create(url, Timeout = 10000000)
       let resp = req.GetResponse()
       let stream = resp.GetResponseStream()
       let reader = new StreamReader(stream)
       let csv = reader.ReadToEnd()
   
   
       let interest = 
           csv.Split([|'\n'|])
           |> Seq.skip 8
           |> Seq.map (fun line -> line.Trim())
           |> Seq.filter (fun line -> not (line.EndsWith("ND")))
           |> Seq.filter (fun line -> not (line.Length = 0))
           |> Seq.map (fun line -> line.Split([|','|]))
           |> Seq.map ( fun values ->
               System.DateTime.Parse(values.[0], CultureInfo.CreateSpecificCulture("en-US")),
               float values.[1])
       interest
   

7. Agora você irá utilizar essa funcionalidade em novas entradas.Selecione todo o código e pressione ALT+ENTER para executá-lo usando o F# Interativo.No prompt do F# Interativo, chame a nova função loadRates em outras taxas de maturidade: 1, 2, e 5, em anos.Observe o seguinte:

   • Definições anteriores não são perdidas no F# Interativo, mas novas definições estão disponíveis.

   • Dados estruturados complexos são processados pela funcionalidade de impressão especial.

Para desenvolver um componente usando F#

• Crie um projeto de biblioteca para expor a funcionalidade que você criou.No menu File, aponte para New e clique Project.Na caixa de diálogo Novo Projeto, selecione F# visual na lista Instalado e em seguida Biblioteca F# para criar um novo projeto de biblioteca.Dê o nome RateAnalysis ao projeto.Copie o código que você criou anteriormente de RateAnalysis.fsx e cole-o no Library1.fs.Adicione uma declaração de módulo para a parte superior do arquivo: module RateLoader.No Gerenciador de Soluções, renomeie Library1.fs para RateLoader.fs, e salve o arquivo.Observe o seguinte:

  • O modelo padrão da biblioteca F# fornece um arquivo de código que possui a extensão .fs e um script que possui a extensão .fsx.Você pode usar o arquivo de script para testar interativamente o seu código da biblioteca.

1. Agora você irá criar uma classe F# que expõe a funcionalidade desejada.Clique com o botão direito do mouse no seu projeto de teste no Solution Explorer, aponte para Add e depois clique em New Item.Na caixa de diálogo Adicionar Novo Item, selecione Arquivo fonte do F#.Dê o nome Analyzer.fs para o arquivo.Clique com o botão direito do mouse em Script.fsx no Gerenciador de Soluções e clique em Mover para Baixo.(Alternativamente, pressione ALT+SETA para BAIXO.) Cole o seguinte código em Analyzer.fs:

   module RateAnalysis.Analyzer
   
   open RateLoader
   
   /// Provides analysis of historical interest rate data.
   type Analyzer(ratesAndDates) = 
       let rates = 
           ratesAndDates
           |> Seq.map snd
   
       /// Construct Analyzer objects for each maturity category.
       static member GetAnalyzers(maturities) = 
           maturities
           |> Seq.map loadRates
           |> Seq.map (fun ratesAndDates -> new Analyzer(ratesAndDates))
   
       member sa.Min =
           let date, minRate = (Seq.minBy (fun (_, rate) -> rate) ratesAndDates)
           (minRate, date.ToString("d"))
   
       member sa.Max = 
           let date, maxRate = (Seq.maxBy (fun (_, rate) -> rate) ratesAndDates)
           (maxRate, date.ToString("d"))
   
       member sa.Current =
           rates |> List.ofSeq |> List.rev |> List.head 
   

   Observe o seguinte:

   • F# suporta conceitos de programação orientada a objeto.Para obter mais informações, consulte Classes (F#), Herança (F#), e outros tópicos relevantes na Referência de Linguagem do F#.

2. Para compilar o projeto, pressione CTRL+SHIFT+B ou F6.Observe o seguinte:

   • O projeto é compilado com êxito.

   • A janela de lista de erros não mostra nenhum erro.

   • O diretório de saída contém arquivos .dll, .pdb, e .xml.

   • A janela de saída exibe o seguinte:

     ------ Build started: Project: RateAnalysis, Configuration: Debug Any CPU ------
         C:\Program Files (x86)\Microsoft F#\v4.0\fsc.exe -o:obj\Debug\RateAnalysis.exe -g --debug:full --noframework --define:DEBUG --define:TRACE --optimize- --tailcalls- -r:"C:\Program Files (x86)\Microsoft F#\v4.0\FSharp.Core.dll" -r:"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\mscorlib.dll" -r:"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\System.Core.dll" -r:"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\System.dll" --target:exe --warn:3 --warnaserror:76 --vserrors --utf8output --fullpaths --flaterrors Program.fs RateLoader.fs ValueAnalyzer.fs 
         RateAnalysis -> C:\Users\ghogen\Documents\Visual Studio 10\Projects\RateAnalysis\RateAnalysis\bin\Debug\RateAnalysis.exe
     ========== Build: 1 succeeded or up-to-date, 0 failed, 0 skipped ==========
     

3. Para adicionar um aplicativo cliente do C#, abra o menu de atalho para o nó da solução, clique em Adicionar, e então Novo Projeto.Na caixa de diálogo Adicionar Novo Projeto, clique em Visual C# na lista Modelos Instalados, e então clique em Aplicativo de Console.Talvez você precise expandir o nó Outras linguagens.Dê o nome CSharpDriver para o projeto e clique no botão OK.Abra o menu de atalho no nó Referências desse projeto, e então clique em Adicionar Referência.Escolha o nó Solução, e então escolha o nó Projetos.Selecione a caixa de seleção próxima ao projeto RateAnalysis, e então clique no botão OK.Abra o menu de atalho para o nó de projeto CSharpDriver, clique em Definir como Projeto de Inicialização.Digite o seguinte código no corpo do método Main do aplicativo C#.

   var maturities = new[] { 1, 2, 5, 10 };
   var analyzers = RateAnalysis.Analyzer.Analyzer.GetAnalyzers(maturities);
   
   foreach (var item in analyzers)
   {
       Console.WriteLine("Min = {0}, \t Max = {1}, \t Current = {2}", item.Min, item.Max, item.Current);
   }
   Console.WriteLine("Press Enter to exit.");
   Console.ReadLine();
   

   Observe o seguinte:

   • Você pode adicionar referências projeto-a-projeto do e no C# e F#.

   • Você pode usar namespaces definidos do F# e tipos do C# como qualquer outro tipo.

   • Comentários da documentação do F# estão disponíveis no IntelliSense do C#.

   • C# pode acessar, do API do F#, valores de retorno da tupla.As tuplas são valores Tuple no .NET Framework 4.5.

4. Para depurar o aplicativo, pressione F11 para compilar o aplicativo, inicie o aplicativo no depurador, e vá para a primeira linha do código executado.Pressione F11 várias vezes até que você entre no código F# no corpo do membro GetAnalyzers.Observe o seguinte:

   • Você pode facilmente ir do código C# para o código F#.

   • Cada expressão no F# é uma etapa no depurador.

   • A janela de Locais mostra os valores de maturities.

   • Continuar a pressionar F11 anda pela avaliação do restante do aplicativo.

   • Comandos do depurador, como Executar até o Cursor, Definir Próxima Declaração, Inserir Ponto de Interrupção, Adicionar Inspeção, e Ir para Desmontagem funcionam como esperado.

Para Implantar o Aplicativo

1. Se você ainda estiver depurando, para a depuração pressionando as teclas SHIFT + F5 ou abrindo o menu Depurar e então clicando em Parar Depuração.

2. Abra o menu de atalho do projeto CSharpDriver, e clique em Propriedades.

3. No designer do projeto, escolha a guia Publicar, que mostra opções para implantar o seu app.

4. Clique no botão Assistente de Publicação.

   O Assistente de Publicação inicia, e a primeira tela pergunta onde você deseja que os arquivos publicados sejam colocados.

5. Na caixa de texto, especifique um local de arquivo no seu disco local onde você deseja que os arquivos de instalação do seu app sejam colocados quando você publicar, ou clique no botão Procurar para navegar para um local.

6. Clique no botão Concluir para aceitar que todos os padrões construam uma configuração padrão que pode ser distribuida para máquinas clientes, ou clique no botão Avançar para ver outras opções de publicação.

   Um executável de instalação e arquivos de suporte são publicados na localidade que você especificou.

Próximas etapas

Comece a escrever códigos F# lendo Passo a passo: Seu primeiro F# programa, ou aprenda sobre funções em F# lendo Funções como valores de primeira classe (F#).Você pode explorar a linguagem F# lendo Referência de linguagem do F#.

Consulte também

Outros recursos

Visual F# exemplos e explicações passo a passo

Visual F# exemplos e explicações passo a passo