Compartilhar via

Walkthrough: Usando o F# Visual para criar, depurar e implantar um aplicativo

  • Artigo

Esta explicação passo a passo apresenta a experiência de uso F# na Visual Studio 2010 junto com.NET Framework 4.

Nesta explicação, você aprenderá como começar com o uso de Visual Studio 2010 para escrever aplicativos de F# do exemplo de uma análise histórica dos dados de taxa de juros do Estados Unidos Tesouro. Você será iniciar com alguma análise rápida dos dados usando a F# janela interativa, e em seguida, escrever algum código para analisar os dados de teste e, em seguida, adicione um C# front-end para explorar a integrar seu código F# com os outros.NET idiomas.

Pré-requisitos

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

  • Visual Studio 2010
ObservaçãoObservaçã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 do Visual Studio.

Para criar um script F#

  1. Primeiro, crie um script F#. Sobre o arquivo , aponte para novae, em seguida, clique em arquivo. No Novo arquivo caixa de diálogo, selecione Script na Installed Templates lista e, em seguida, selecione O arquivo de Script F#. Clique em Abrir para criar o arquivo e salve o arquivo como RateAnalysis.fsx.

  2. Use.NET e F# APIs para acessar dados do site da Internet 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/releases/h15/data/business_day/H15_TCMNOM_Y10.txt"
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:

    • Seqüências de caracteres e palavras-chave são coloridas.

    • Listas de conclusão é exibida após digitar cada ponto (.).

    • Você pode ter nomes de método completo de Visual Studio e de outros identificadores usando o atalho de teclado CTRL + espaço ou CTRL + J no meio de um identificador. Uma lista de conclusão é exibida quando você usa CTRL + J.

    • Quando você posiciona o ponteiro do mouse sobre qualquer identificador no código, você pode ver uma dica de ferramenta que contém informações sobre esse 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.

    • Tipos e namespaces de mscorlib.dll, System.dll, e System.Windows.Forms.dll são referenciados por padrão.

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

    • Se você copiar a URL no exemplo em um navegador, você obter uma lista de valores separados por vírgula que contêm as datas e as taxas de juros, publicadas pela reserva Federal dos Estados Unidos.

  3. Agora, você executará o código usando o F# interativo. Selecione o código (usando um mouse ou pressionando CTRL + A) e com o botão direito e clique Enviar para interativo. (Como alternativa, pressione ALT + ENTER).

    • Se já não estiver visível, será exibida a janela F# interativo.

    • O código é executado com êxito.

    • Aparecerá o seguinte na janela F# interativo.

      val url : string =
  "http://www.federalreserve.gov/releases/h15/data/business_day/"+[18 chars]
val req : System.Net.WebRequest
val resp : System.Net.WebResponse
val stream : System.IO.Stream
val reader : System.IO.StreamReader
val csv : string =
  "  ,Instrument,"U.S. government securities/Treasury constant m"+[224452 chars]

>

  4. Em seguida, inspecione os dados usando o F# interativo. No prompt de F# interativo, digite csv; e pressione ENTER. Tipo de csv.Comprimento; e pressione ENTER. Observe o seguinte:

    • Os dados são atuais.

    • F# interativo exibe o valor da seqüência de caracteres csv e 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 de F# interativo.

      Janela F# interativo

      Janela interativa F#

  5. Agora você irá escrever o código de F# para analisar dados CSV (Comma-Separated valores). Um arquivo CSV assim chamado porque ele contém valores separados por vírgulas. No Editor de código, adicione o seguinte código. Conforme você adiciona cada linha, selecione o código adicionado nesta seção para aquela linha e pressione ALT + ENTER para ver os resultados parciais. Observe o seguinte:

    • IntelliSense fornece informações úteis após digitar um período, no meio de expressões complexas de aninhados.

    • Quando o código está incompleto (ou incorretos), ondulados em vermelho indicam que os erros sintáticos e semânticos aparecem no código.

    • Criar o tubulações usando o operador pipe (|>). O operador pipe assume o valor de retorno de uma expressão e o usa como argumento para a função na próxima linha. Pipelines e F# interativo permitem fácil execução parcial do código de processamento 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]),
        float values.[1])

  6. Você irá agora Nomeie esta funcionalidade. Remover 10 partir da definição de url e substituí-lo com %d para tornar a seqüência literal uma seqüência de caracteres de formato. Adicionar maturity após a seqüência de caracteres de formato. Selecione todo o código, exceto uma linha nova e pressione TAB. Acima do recuado bloco de código, adicione let loadRates maturity =. No final do bloco recuado, adicione interest. Observe o seguinte:

    Agora o código semelhante ao seguinte.

    open System.Net
open System.IO

let loadRates maturity = 
    let url = sprintf "http://www.federalreserve.gov/releases/h15/data/business_day/H15_TCMNOM_Y%d.txt" maturity
    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]),
            float values.[1])
    interest

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

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

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

Para desenvolver um componente usando o F#

  • Crie um projeto de biblioteca para expor a funcionalidade que você criou. No menu File, aponte para New e clique Project. No Novo projeto caixa de diálogo, selecione Visual F# na Modelos instalados lista e, em seguida F# biblioteca para criar um novo projeto de biblioteca. Dê o nome do projeto RateAnalysis. Copie o código que você criou anteriormente de RateAnalysis.fsx e colá-lo em Module1.fs. Altere a declaração do módulo no Module1.fs do módulo Module1 módulo de RateLoader. Em Solution Explorer, renomeie Module1.fs para RateLoader.fs. Observe o seguinte:

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

A ilustração a seguir mostra a Novo projeto caixa de diálogo com várias opções disponíveis para F#. O modelo de projeto de biblioteca de F# é selecionado.

Opções de modelo F#.

Caixa de diálogo Novo Projeto com a biblioteca F# selecionada

  1. Agora, você irá criar uma classe F# 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. No Add New Item caixa de diálogo, selecione O arquivo de origem F#. Nomeie o arquivo Analyzer.fs. Com o botão direito Script.fsx na Solution Explorer e, em seguida, clique em Mover para baixo. (Como alternativa, 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 os 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 a linguagem F#.

  2. Agora você irá gerar comentários da documentação XML. Em Solution Explorer, o botão direito do mouse no projeto e, em seguida, clique em Propriedades. No Build guia, selecione o arquivo de documentação XML caixa de seleção na parte inferior da página. Observe o seguinte:

    • Você pode gerar documentação XML para qualquer assembly F#.

    • Por padrão, a documentação XML é gerada para o caminho de saída.

  3. Para construir o projeto, pressione CTRL + SHIFT + B ou F6. Observe o seguinte:

    • O projeto é criado com êxito.

    • A janela Error List mostra sem erros.

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

    • A janela 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 ==========

  4. Para adicionar um aplicativo do cliente C#, clique com o botão direito no nó da solução, aponte para Adde em seguida, clique em Novo projeto. No Add New Project caixa de diálogo, selecione Visual C# na Modelos instalados lista e, em seguida, selecione Aplicativo de Console. Talvez você precise expandir a Outros idiomas nó. Nomeie o projeto CSharpDriver. Clique com o botão direito do projeto referências nó e clique Adicionar referência de. Sobre o projetos guia da Add Reference caixa de diálogo, selecione RateAnalysis e, em seguida, clique em OK. Com o botão direito do CSharpDriver nó de projeto e, em seguida, clique em Set as Startup Project. Digite o seguinte código no corpo do Main o método de C# aplicativo. Observe o seguinte:

    • Você pode adicionar referências de projeto para projeto e para C# e F#.

    • F# definido namespaces e tipos podem ser usados a partir de C# como qualquer outro tipo.

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

    • C# pode acessar os valores de retorno de tupla da API F#. As tuplas são.NET Framework 4 Tuple valores.

    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();

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

    • Você pode facilmente entrar no código do C# F# código.

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

    • A janela Locals mostra os valores de maturities.

    • Continue a pressionar F11, percorre a avaliação do restante do aplicativo.

    • Depurador de comandos, como Executar até o Cursor, Set Next Statement, Insert Breakpoint, Adicionar Inspeção de variáveis, e Ir para desmontagem tudo funciona como esperado.

Para implantar um aplicativo de F#:

  1. Nesta etapa, você irá definir o projeto de destino de uma versão diferente da.NET Framework. Em Solution Explorer, o botão direito do mouse no projeto F# RateAnalysis e em Propriedades. No aplicativo guia, altere o Target Framework como .NET Framework 3.5. Observe o seguinte:

    • F# permite direcionar a versões diferentes do.NET Framework.

    • Alterar a estrutura de destino, é necessário recarregar o projeto.

    • Depois de alterar a estrutura de destino, algumas referências de assembly não são mais habilitadas na Add Reference caixa de diálogo e eles não estão disponíveis.

  2. No projeto C#, você deve adicionar uma referência para a versão do conjunto deFSharp.Core que se destina.NET Framework 2.0, que também deve ser usado quando você direcionar versões 3.0 e 3.5 do.NET Framework. No Solution Explorer, com o botão direito do referências nó e clique Adicionar referência de. Sobre o .NET guia, selecione a versão 2.0.0.0 do FSharp.Core e clique OK. Recrie a solução.

  3. Para definir os pré-requisitos, clique duas vezes o Propriedades nó CSharpDriver. No Publicar , clique no pré-requisitos botão e, no pré-requisitos caixa de diálogo, selecione a caixa de seleção para Visual F# Microsoft de Runtime para.NET 2.0. Observe o seguinte:

    • F# tem um pacote de tempo de execução é separado da.NET Framework.

    • Este pacote de tempo de execução deve ser explicitamente adicionado como um pré-requisito ao implantar aplicativos que usam F#.

    • Existem dois pacotes de tempo de execução disponíveis: a versão 2.0 para.NET Framework versões 2.0, 3.0 e 3.5 e a versão 4.0.NET Framework 4.

  4. Implante o aplicativo C# usando ClickOnce. Clique com o botão direito no projeto CSharpDriver e clique em Publicar. No Publish Wizard, clique em Concluir. Execute o CSharpDriver.application resultante. Observe o seguinte:

    • O pacote de Runtime F# Visual é incluído com o aplicativo.

    • Executando o aplicativo instala o pacote de Runtime F# e executa o aplicativo com êxito.

Próximas etapas

Começar a escrever o código F# lendo Walkthrough: Seu primeiro programa F#, ou Saiba mais sobre funções em F# lendo Funções como valores de classe do primeiro-(F#). Você pode explorar a linguagem F# lendo o Referência de linguagem do F#.

Consulte também

Outros recursos

Visual F# passo a passo

Exemplos e explicações passo a passo (F#)