Este artigo foi traduzido por máquina.

Noções básicas sobre "Oslo"

Criar aplicativos com base em metadados com A plataforma “ Oslo ”

Chris Sells

Este artigo se baseia em uma versão de pré-lançamento da plataforma de "Oslo".Todas as informações estão sujeitas a alterações.

Este artigo discute:

  • ” Oslo ” e metadados
  • MGraph e MSchema
  • Scripts SQL, empacotamento e implantação
  • Integração do Studio Visual
Este artigo usa as seguintes tecnologias:
” Oslo, ” SQL Server 2008

Conteúdo

Os metadados
Criação em "Oslo"
MGraph e MSchema
Geração de SQL
Empacotamento e implantação
O Visual Studio Integration
Código de exemplo

um aplicativo baseado no Microsoft .NET Framework normalmente é definida por um conjunto de código compilado e um conjunto de recursos associados.Por exemplo, um aplicativo ASP.NET é definido por código compilado (assemblies) que fornecem a lógica do seu site da Web e os arquivos de recurso (arquivos .aspx) que definem próprias páginas.O código é executado pela CPU (após a compilação) e as páginas são interpretadas pelo tempo de execução do ASP.NET.Da mesma forma, o Windows Workflow Foundation (WF) permite que você definir comportamentos como uma série de atividades configuradas, tudo dos quais é apenas dados para ser interpretado pelo tempo de execução do WF.

Combinar ASP.NET no lado de interface do usuário e o WF no comportamento lado e você pode começar a imaginar a criar aplicativos de inteiros como quase totalmente dados, usando o código apenas para preencher comportamentos que não foram fornecidos pelos tempos de execução.

Os dados que unidades esses tempos de execução são chamados de metadados.Os metadados podem ser definidos como os dados que descreve um aplicativo, por exemplo, como uma home page é processada ou como o fluxo de trabalho compra funciona.Os dados de aplicativo representa o estado da execução de um aplicativo, como o que Bob coloca no seu carrinho de compras em seu site ou seu endereço de entrega no fluxo de trabalho check-out.

Para fornecer um conjunto comum de ferramentas para definir metadados para que possam ser armazenado em um local que fornece o mesmo conjunto de recursos como dados de aplicativo normal, a Microsoft está criando "Oslo," uma plataforma para a criação de aplicativos controlados por dados. "Oslo" é composto de três elementos: uma família de idiomas coletivamente chamados "M", uma ferramenta de manipulação de dados visual chamado "quadrante" e um armazenamento de dados chamado do repositório.

Neste artigo, apresentará você alguns dos conceitos da plataforma "Oslo".Eu também apresentará as ferramentas e tecnologias que você precisará empregar para colocar esses conceitos em prática.Em particular, discutirei como "Oslo" permite que você criar aplicativos orientados metadados, usando as ferramentas MSchema e MGraph e as noções básicas de definir os tipos e valores no "M" bem como implantá-los ao repositório.

“ Olso ”: uma nova forma de implementar uma idéia antiga

a idéia de estruturas de orientado a dados não é novidade.Considere um outro exemplo: Windows Presentation Foundation (WPF).A maneira que a maioria dos aplicativos WPF são escritos, grande parte do aplicativo é composto de XAML, que é carregado em tempo de execução e interpretada pelo analisador de XAML.Isso é os metadados que conduz a definição de um aplicativo WPF.Você mesmo pode alterar a definição de um aplicativo WPF por carregar ou gerar XAML em tempo de execução que o desenvolvedor não sabe sobre tempo de compilação.

No entanto, não há nada mágica sobre o XAML (compilado em um formulário conhecido como BAML) sendo agrupados em um recurso com o código do aplicativo — ele tão facilmente pôde ser carregado em um arquivo separado ou até mesmo em um banco de dados relacional.Se ele foi carregado em um banco de dados, o carregador WPF deve executar consultas SQL para acessar definições de aplicativo em vez de carregar recursos, mas o usuário caso contrário, seria sabem da diferença.E se uma definição de aplicativo seria carregados de um banco de dados, todos os que dados podem ser atualizados centralmente, fornecendo os desenvolvedores do aplicativo a capacidade para propagar alterações sem re-deploying o aplicativo para cada cliente que deseja executá-lo.Isso é, na verdade, o recurso matadora na Web e uma pena orientando na direção para todos os tipos de aplicativos, se eles executados no navegador ou não.

Agora, assim que você carregar um aplicativo em um local central, você vai quiser recursos multiusuário, como a replicação, securit, y e controle de versão.Você também desejará suporte para usuários desconectados e para usuários em diferentes localidades em todo o mundo.

E por fim, definições de aplicativo podem ser usadas para dirigir mais do que apenas uma instância de um aplicativo.Elas podem ser usadas no tempo de desenvolvimento para testar se determinado partes de um aplicativo estiverem executando o acordo com a especificações.Elas podem ser usadas em tempo de execução para mostrar que partes estão obtendo uso ou tendo problema.Elas podem ser usadas para problemas de marca para que os desenvolvedores possam ver especificamente o que está causando o problema.Com metadados do aplicativo fornece todas as a potência de consulta de modernos, indexado ligado replicado, protegido, versão, localizada, banco de dados offline capaz.

E isso é, essencialmente, que se trata o "Oslo" — usando o poder do SQL Server para armazenar metadados de um aplicativo.Usando os metadados para unidade que o comportamento de um aplicativo foi usado no Windows menos desde então, começamos binários com o bit de console para obter uma janela de console sem escrever o código de marcação. "Oslo" é simplesmente sobre formalização e generalizar os metadados do seu aplicativo e fornecer o mesmo poder e ferramentas usadas para os dados de seus aplicativos.

Os metadados

O que torna metadados diferentes de seus dados de aplicativo é que os metadados para um aplicativo raramente alterado — geralmente é algo que até mesmo nas reinicializações wildest altera somente uma vez por dia quando uma nova versão de um site da Web é enviada ao vivo.Por outro lado, os dados para um aplicativo normalmente são alterados bastante muita — é o que os usuários são manipular todos os dias, todos os dias em um site popular.

Levando mais, os metadados que descreve o processador que ESTOU usando para digitar este artigo não foi alterado desde 2007 quando ele foi lançado, mas os dados foram alterados milhares de vezes apenas atualmente como eu digitar caracteres e mova o mouse para manipular os documentos ESTOU trabalhando em.Na verdade, metadados é escrito portanto raramente que em muitos casos, que ele é entregue em pacotes de somente leitura, como as definições de classe em um .NET assembly ou os arquivos XAML pré-compilados incorporados como recursos em um assembly.Como os desenvolvedores geralmente escrevem seus aplicativos dependendo da natureza estático de metadados, como os manipuladores de evento para um botão de definição em uma página ASP.NET, alterar seldomly de metadados do aplicativo não é algo ruim.

No entanto, a coisa que é do tipo incorreta sobre nossa infra-estrutura atual de metadados é que as ferramentas para definir e ler metadados são tão diferentes daqueles que você usaria para dados de aplicativo.

Pode desenvolver um aplicativo para ler e gravar dados por meio de um banco de dados relacional, dando-me um poderoso conjunto de ferramentas para ações como consultar, proteger, replicação e versão.Mas se quiser consultar metadados do .NET Framework, tenho um conjunto mais limitado de ferramentas: a API de reflexão, basicamente.

Além disso, as ferramentas do .NET Framework para manipular os metadados são muito diferentes das ferramentas uso para violar abrir metadados SQL.Se eu quero consultar entre dados e metadados do aplicativo — consulta entre os fluxos de trabalho atualmente sendo executado com as definições desses fluxos de trabalho — recebi criar Meus próprio ferramentas porque as fontes de dados são diferentes: SQL versus arquivos XOML (linguagem de marcação extensível de objeto).

Criação em "Oslo"

Existem muitas coisas que você pode criar com Oslo. Quando falamos sobre cenários internamente, a discussão geralmente concentra-se em criação de aplicativos que envolvem dados.No entanto, você observará que, no conjunto de coisas que eu listado como parte de "Olso" não mencione os tempos de execução.Na verdade, arquivos .aspx não são muito úteis sem ASP.NET e arquivos XOML sem WF seria muito menos atraentes.

Há uma série de tempo de execução e serviços que está sendo desenvolvidos que irão tirar proveito da Oslo. Eles incluem linguagens específicas de domínio (DSLs) e designers de quadrante para aplicativos da Web do ASP.NET, o WCF Web Services e bancos de dados de FE.Você poderá carregar dados para o repositório e orientar os tempos de execução.

O repositório de "Oslo" é direcionado para aplicativos onde aos desenvolvedores corporativos tem criado suas próprias coisas como do repositório para armazenar metadados.Por exemplo, "Oslo" poderia ser uma boa plataforma para um repositório de informações de configuração de máquina que permitiria que a equipe de operações consultar e entender as configurações de máquina facilmente, ou da mesma forma, um repositório de scripts e procedimentos operacionais.Para desenvolvedores, como o repositório fornece um armazenamento unificado e queriable para metadados, seria possível para responder perguntas como "quais aplicativos e classes implementam um método?" e "irá alterar esse método afetar o desempenho"?

Outra área potencial para empregando "Oslo" pode ser para Noções básicas sobre aplicativos distribuídos.Combinação de perfilação, cobertura de código, carregar testes, e arquiteturais dados dentro do repositório permitirá que os desenvolvedores, por exemplo, rapidamente resolver problemas de desempenho navegando para o componente distribuído relacionado, examinando as configurações de vários parâmetros de configuração e exibir detalhes de implementação relevantes.Além disso, ele permitirá que para o desenvolvimento de ferramentas de análise estática que automaticamente defeitos em design do relatório.

Uma área particularmente tickles meu mandar é implantação e instalação.Definindo os pacotes de instalação em uma linguagem específica de domínio e carregá-los no repositório, um desenvolvedor obtém os serviços de idioma de qualquer linguagem moderno juntamente com ferramentas de consulta para conformidade com a diretiva.Por exemplo, você pode consultar se as configurações são protegidas com contratos de licença apropriado.

Aqui está um exemplo: o site de Web do Centro de download Microsoft fornece para downloads altamente escalonáveis para clientes.Para arquivos sejam hospedados nesse site, eles devem ser em um arquivo Microsoft Installer (MSI) e marcados com um contrato de licença ao usuário final (EULA).Depois de fazer isso sobre como metade de dúzias vezes usar a GUI no Visual Studio, deu procurando uma solução automatizada e encontrado um no Windows Installer XML (WiX), que permitem que eu usar XML para definir a configuração e compilá-lo em um MSI.

a Figura 1 mostra um exemplo do XML WiX.Para o olho destreinado, isso pode não parecer um aperfeiçoamento sobre executando uma INTERFACE gráfica, mas após você ter feito os gestos de mouse 27 mesmo algumas vezes, o programador no, você irá assumir.

A Figura 1 WiX XML para criar um arquivo MSI

<?xml version='1.0' encoding='Windows-1252'?>
<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
  <Product Name="SuperNotepad" Id="d65d2125-560b-4ba9-bdca-3b3bcd3f7b70"
           UpgradeCode="ac5c9dac-b3f0-469a-8f1a-02c2566eee33" 
           Language="1033" Codepage="1252"
           Version="1.0.0.0" Manufacturer="SuperNotepad Corp.">
    <Package Description="A really super pad for notes" 
             Manufacturer="SuperNotepad Corp."
             InstallerVersion="200" Languages="1033" Compressed="yes" />
    <Media Id="1" Cabinet="setup.cab" EmbedCab="yes" />
    <Directory Id="TARGETDIR" Name="SourceDir">
      <Directory Id="ProgramFilesFolder" Name="ProgramFilesFolder">
        <Directory Id="Directory3" Name="SuperNotepad Corp.">
          <Directory Id="INSTALLDIR" Name="Better NotePad">
            <Component Id="Component1" 
                       Guid="f7554ac8-32cd-44fb-bf85-0559c7d2e15c">
              <File Id="File1" Name="Manual.txt"
                    Source="C:\temp\SuperNotepad\Files\manual.txt" />
              <File Id="File2" Name="dependency.dll"
                    Source="C:\temp\SuperNotepad\Files\dependency.dll" />
              <File Id="File3" Name="BetterNotePad.exe"
                    Source="C:\temp\SuperNotepad\Files\notepad.exe" />
            </Component>
          </Directory>
        </Directory>
      </Directory>
    </Directory>
    <Feature Id="Feature1" Level="1">
      <ComponentRef Id="Component1" />
    </Feature>
  </Product>
</Wix>

MGraph e MSchema

Mesmo pode automatizar a criação do XML WiX até certo ponto, não realmente desejo escrever minhas configurações em um mar de colchetes angulares. " Oslo" permite que eu gravá-los em "M", uma família de idiomas, incluindo MSchema, MGrammar e MGraph. (As especificações MSchema e M­Grammar podem ser encontradas em" A especificação de linguagem de modelagem "Oslo""e" Especificação da linguagem MGrammar" respectivamente.)

Deixe-me confere a você uma rápida introdução a MGraph e MSchema (VOU explorar MGrammar em um artigo futuro). Se você quiser executar junto em casa, eu recomendo o SR.. Ferramenta epl que acompanha o "Oslo" SDK. ("SR.. Epl" é como nós Pronuncie MREPL.EXE, que significa para M Read-avaliar-impressão-loop.) Você pode usá-lo no editor de texto chamado Intellipad que vem em "Oslo" SDK pelo escolhendo Intellipad (exemplos habilitado) o menu Iniciar, pressionando CTRL + / para exibir o mini-buffer e digitando "SetMode('MScriptMode')" (sem aspas, mas assuntos de ocorrências), seguido de clicar em Inserir.

MGraph é uma linguagem para definição de instâncias de dados estruturados (melhor conhecido como valores). Neste exemplo, defini três partes de dados: um integer anônimo, uma coleção anônima de três números inteiros e um registro denominado "pt1" com dois campos, X e Y, dois inteiros:

42
{ 1, 2, 3 }
pt1 { X = 10, Y = 20 }

MSchema é uma linguagem para definir restrições sobre os dados. Em MSchema, um conjunto de restrições está vinculado juntos em um tipo. Aqui defini dois tipos de nomeados, um tipo de SmallInteger que restringe a interna no tipo de Integer32 para somente os valores menor que 256 e um tipo de entidade de ponto (o nome para tipos de registros em M) com dois campos, X e Y:

type SmallInteger : Integer32 where value < 256;
type Point { X : Integer32; Y : Integer32; };

X e Y são restritas para armazenar valores inteiros entre-2,147,483,648 e 2,147,483,647.

Qualquer pessoa ler este artigo já está familiarizada com o CLR. O CLR usa algo chamado "digitando nominal", que é, nomeando o único tipo ao qual pertence um valor. " "M, por outro lado, se baseia estruturais digitando, bem como XML. Em um mundo digitado Estruturalmente, um valor pode pertencer a qualquer número de tipos, contanto que os dados atendem as restrições definidas pelo tipo. Para verificar se um valor está no conjunto definido por um tipo, você use o operador de "de" (mostrado aqui de dentro o SR.. Ferramenta epl):

M>>> type SmallInteger : Integer32 where value < 256;
M>>> 4 in SmallInteger
true
M>>> 4 in Integer32
true
M>>> 256 in SmallInteger
false
M>>> 256 in Integer
true

Aqui você pode ver que 4 é um SmallInteger e um Integer32, mas 256 é apenas um Integer32. Valores de entidade podem ser verificados para membros de tipo bem:

M>>> type Point { X : Integer32; Y : Integer32; };
M>>> { X = 100, Y = 200 } in Point
true
M>>> pt1 { X = 10, Y = 20 }
M>>> pt1 in Point
true
M>>> pt1 in { X : SmallInteger; Y : SmallInteger; }
true
M>>> pt1 in { X; Y; }
true

Você pode ver que os pares de nomeado e sem nome X, Y são pontos e que os dois campos do nomeado X, Y par é SmallInteger valores, neste momento definindo um tipo anônimo para fazer a verificação para você. A última linha indica que o chamado X, Y par adapta o conjunto de valores que têm campos chamados X e Y, com nenhuma restrição em seus respectivos valores — podem ser seqüências de caracteres datas ou coleções ou qualquer.

Aqui está outro exemplo. Nesse caso, porque o chamado X, Y par também não tiver um campo de Z, ele não couber no tipo anônimo que requer campos X, Y e Z:

M>>> pt1 in { X; Y; Z; }
false
M>>> pt1 in { x; y; }
false

Além disso, a última linha mostra que M é diferencia maiúsculas de minúsculas.

Finalmente, você precisará compreender as notações de valor e a coleção padrão:

type Product {
    Name : Text;
    ...
};

type Package {
    Product : Product; // required value
    Keywords : Text*; // collection of 0 or more values
    Description : Text?; // optional value
    Comments : Text?; // optional value
    Manufacturer : Text; // required value
    InstallerVersion : Integer32 = 200; // default value
    Language : Integer32 = 1033; // default value
    Compressed : Logical = true; // defaults value
};

Aqui você ver o tipo de pacote do módulo WiX. Cada produto (o conceito de nível superior em uma instalação MSI) possui um pacote, que tem um conjunto opcional de palavras-chave de texto, uma descrição opcional e comentário, um fabricante necessário, uma versão do installer que adota como padrão o Windows Installer 2.0, uma linguagem os padrões para EUA Inglês e um sinalizador de compactação padrão é true.

Os valores necessários não têm nenhum sufixo, como produtos e fabricante. Os valores padrão têm um sinal de igual e um valor, como InstallerVersion e idioma. Os valores opcionais têm um sufixo de ponto de interrogação, como descrição e comentários. Os valores de coleção (aqueles com zero ou mais valores) terminar em estrela. A pergunta marcar e estrela Noções? e *) são destinados a lembrá-lo dos operadores Kleene do seu idioma favorito expressão regular.

Aqui está um exemplo valor de pacote:

Products { 
    SuperNotepad : Product* {
        Name = "SuperNotepad",
        ...
    }
}

Packages : Package* where item.Product in Products {
    Package1 {
        Product = Products.SuperNotepad,
        Description = "A really super pad for notes",
        Manufacturer = Products.SuperNotepad.Manufacturer,
        Keywords = { "Installer", "Super", "Notepad", "Sample" }
    }
}

Aqui eu tem parte de um produto e um pacote inteiro. Observe que eu tem dois tipos de restrições. O primeiro tipo é do formulário ": algo ", como em:

SuperNotepad : Product* {

Isso é chamado ascription de tipo e restrições em todos os valores dentro as chaves de acordo com as restrições do tipo.

A restrição a segunda é onde cláusula que informa o compilador "M" onde encontrar o armazenamento para os valores de entidade do produto:

Packages : Package* where item.Product in Products {

Observe também que dois os valores tenham nomes (SuperNotepad e Package1). A sintaxe MGraph permite para nomes a ser usado no meio de um gráfico de valores de inicialização para que uma parte do gráfico pode referenciar outra parte sem duplicar os dados. ESTOU fazendo isso para que eu possa referenciar meu produto na definição de pacote.

Tão útil quanto SR.. Epl é, será deseja usar um editor de texto para itens maiores. Visual Studio 2008 e Intellipad fornecem serviços de idioma para facilitar a edição "M" uma experiência agradável. Por exemplo, para verificar se você tem algo sintaticamente válido, você poderá verificar para obter dicas de dados os rabiscos vermelhos mostrando erros (por exemplo, um faltando fechamento duplas cotação).

Todos os códigos de "M" devem estar dentro de um módulo, muito parecido com todos os códigos baseados no .NET deverá estar dentro de um espaço para nome. Isso escopos os tipos e valores.

Se a falta de rabiscos não for suficiente para torná-lo feliz, você também pode executar o compilador "M" na linha de comando:

C:\>set path=%path%;"c:\Program Files\Microsoft Oslo SDK 1.0\Bin"
...
C:\>m.exe /t:none wixbits.m
Microsoft (R) "Codename M" Compiler version 1.0.0925.0
Copyright (C) Microsoft Corporation. All rights reserved.
C:\>

Se não houver nenhum erro relatado pelo compilador "M", seu código é limpo. Observe aqui que bem como passar um arquivo com uma extensão .m para m.exe, eu estou especificando um destino (por meio da opção /t) de nenhuma também. Isso significa que apenas fazer a verificação de sintaxe. Sem a opção de destino, o compilador "M" tentará usar o programa para gerar um script SQL para criar tabelas e inserir valores.

Geração de SQL

Se você tentar gerar SQL do bit de exemplo de dados de modelo do WiX (depois de adicionar as aspas duplas de fechamento), você receberá um relatório de erros como este:

C:\>m wixbits.m
Microsoft (R) "Codename M" Compiler version 1.0.0925.0
Copyright (C) Microsoft Corporation. All rights reserved.

C:\wixbits.m(16,9): error M2010: The referenced type 'Product' does not define an identity constraint.
...

Você também pode obter essa mensagem de erro se você escolher modo M | Reach SQL visualizar de dentro de Intellipad. O que está acontecendo é que o compilador "M" está tentando gerar um script SQL que corresponde a tipos e valores definidos no programa. Ele faz ao tentar mapear valores nomeados nível superior (chamados extensões) para criar instruções de tabela e para mapear os valores próprios em inserir instruções. No entanto, como "M" tem todos os tipos de dados de uso geral descrição usos, não tudo nele mapeia para SQL construções — por exemplo, tipos de entidade sem campos de identidade. É ainda válida "M", mas não é válido para geração de SQL.

Geração de SQL é a ação de padrão do compilador "M" porque um banco de dados relacional moderno é um ambiente riquezas para armazenar e manipular dados. Ele tem todos os tipos de recursos significativos, como segurança, replicação, versão, auditoria e em e em. Se você utilizam do SQL Server para hospedar seus dados, você obterá todos esses recursos, além de um host de otimizações de robustez e desempenho.

Para tornar seus tipos de "M" compatível com o SQL Server, o mapeamento requer uma coluna de identidade, que você pode adicionar usando o código a seguir:

type Package {
    Id : Integer32 = AutoNumber();
    ...
} where identity Id;

Como você pode ver, ESTOU criando um campo chamado identificação e usando a função de AutoNumeração para definir um valor padrão. Em seguida, adiciono uma restrição em tipo usando onde a palavra-chave que marca o campo ID como a coluna de identidade. Com isso no lugar, eu tenho dados suficientes para obter SQL válida para o tipo, conforme mostrado na Figura 2 .

A Figura 2 SQL gerado pelo "M"

...
create table [WixBits].[Packages](
  [Id] int not null identity,
  [Comments] nvarchar(max) null,
  [Compressed] bit not null default 1,
  [Description] nvarchar(max) null,
  [InstallerVersion] int not null default 200,
  [Language] int not null default 1033,
  [Manufacturer] nvarchar(max) not null,
  [Product] int not null,
  constraint [PK_Packages] primary key clustered ([Id]),
  constraint [FK_Packages_Product_WixBits_Products] foreign key ([Product]) references [WixBits].[Products] ([Id])
);
...

create table [WixBits].[Packages_Keywords](
  [_Id] bigint not null identity,
  [Packages_Id] int not null,
  [Item] nvarchar(max) not null,
  constraint [PK_Packages_Keywords] primary key clustered ([_Id]),
  constraint [FK_Packages_Keywords_Packages_Id_WixBits_Packages] foreign key 
  ([Packages_Id]) references [WixBits].[Packages] ([Id]) on delete cascade
);
...

Esperamos que o SQL gerado pelo compilador "M" corresponde ao que você poderia escrever sozinho. Os nomes de módulos de mapeiam para nomes de esquema SQL. Digite o mapa de nomes para nomes de tabela. Numeração automática mapeia a identidade no campo e a restrição de identidade mapeia para a restrição de chave primária no campo. Tipos de "M" intrínsecos, como mapa Integer32 e texto vá correspondentes tipos SQL, como int e nvarchar. Campos de coleção — o campo de palavras-chave do tipo texto * — é mapeado para outra tabela para armazenar os zero ou mais itens dessa coleção, com a restrição de chave externa correspondente. a Figura 3 ilustra como os valores mapeiam.

Figura 3 mapeamento "M" tipos para o SQL

insert into [WixBits].[Packages] ([Product], [Description], [Manufacturer])
 values (@WixBits_Products_Id0, N'A really super pad for notes', @WixBits_Products_Manufacturer0);
declare @WixBits_Packages_Id0 bigint = @@identity;

insert into [WixBits].[Packages_Keywords] ([Item], [Packages_Id])
 values (N'Installer', @WixBits_Packages_Id0);

insert into [WixBits].[Packages_Keywords] ([Item], [Packages_Id])
 values (N'Super', @WixBits_Packages_Id0);

insert into [WixBits].[Packages_Keywords] ([Item], [Packages_Id])
 values (N'Notepad', @WixBits_Packages_Id0);

insert into [WixBits].[Packages_Keywords] ([Item], [Packages_Id])
 values (N'Sample', @WixBits_Packages_Id0);

Empacotamento e implantação

A saída de padrão do compilador "M" é SQL, você provavelmente vai querer envio em uma instância do SQL Server 2008. Por padrão, esse SQL está em um único arquivo de script SQL:

C:\>m.exe wixbits.m
Microsoft (R) "Codename M" Compiler version 1.0.0925.0
Copyright (C) Microsoft Corporation. All rights reserved.

C:\>dir wixbits.sql
...
11/22/2008  04:43 PM             2,545 wixbits.sql
...

Você está livre para usar esse arquivo de script para preencher sua instância do banco de dados SQL mas desejar, tais como com sqlcmd.exe ou SQL Server Management Studio. No entanto, o script SQL tem muito menos de metadados que o código de origem original "M". Se você quiser manter esses metadados — e há valor ao fazer isso, conforme explicarei em instantes — você pode escolher o formato de compactação de imagem "M" com a opção de linha de comando /p:image para m.exe:

C:\>m.exe /p:image wixbits.m
Microsoft (R) "Codename M" Compiler version 1.0.0925.0
Copyright (C) Microsoft Corporation. All rights reserved.
C:\>dir wixbits.mx
...
11/22/2008  04:44 PM             9,073 wixbits.mx
...

O arquivo wixbits.mx é um arquivo de imagem "M", que contém o SQL gerado, bem como um manifesto e outros metadados. Como o arquivo está no formato OPCS (Open Packaging Conventions), você pode continuar uma extensão de arquivo .zip nele e abri-lo como qualquer outro arquivo ZIP. Mais importante, no entanto, você pode usar um arquivo .MX para referências e para a implantação.

Quando você cria um assembly .NET, você pode consultar esse assembly como parte do seu processo de compilação para receber tipos públicos e estáticas instâncias em seus programas baseados no .NET. Se você estiver usando os compiladores C# ou Visual Basic a partir da linha de comando, você pode referenciar existentes assemblies do .NET com a opção /r (referência). Da mesma forma, se você estiver compilando seus programas "M", você pode utilizar a opção /r no compilador do "M" de outros tipos de imagens "M". Para isso funcione, você deve primeiramente exportar seus tipos ou extensões partir o módulo que você está fazendo referência ao:

// WixbitsTypes.m 
module WixBits {
    export Product, Package; // export types
    export Products, Packages; // export extents

    type Product {...};
    type Package {...};
    Products : Product*;
    Packages : Package* where item.Product in Products;
}

Em seguida, você pode importar tipos e extensões que foram exportados:

// WixbitsValues.m
module WixBits {
    import WixBits; // bring in exported types and extents
    ...
}

Depois que você tenha criado um arquivo de imagem "M" com exportações, você pode referenciar que durante a compilação "M" programas com importações (para obter mais informações, consulte A Figura 4 ).

Figura 4 compilação com importado tipos e extensões

C:\>m.exe /p:image /t:Repository WixbitsTypes.m
Microsoft (R) "Codename M" Compiler version 1.0.0925.0
Copyright (C) Microsoft Corporation. All rights reserved.

C:\>dir WixbitsTypes.mx
...
11/22/2008  05:48 PM            28,332 WixbitsTypes.mx
...

C:\>m.exe /p:image /t:Repository /r:WixbitsTypes.mx WixbitsValues.m
Microsoft (R) "Codename M" Compiler version 1.0.0925.0
Copyright (C) Microsoft Corporation. All rights reserved.

C:\>dir WixbitsValues.mx
...
11/22/2008  05:50 PM             5,606 WixbitsValues.mx

Bem como embalagem dos tipos e extensões para referência em outros programas de "M", um arquivo de imagem "M" pode ser implantado a uma instância de banco de dados do SQL Server usando o utilitário de carregador "M", mx.exe, da seguinte maneira:

C:\>mx.exe /db:Repository /i:WixbitsTypes.mx /i:WixbitsValues.mx
Microsoft (R) "Codename M" Command-line Utility version 1.0.0925.0
Copyright (C) Microsoft Corporation. All rights reserved.

Aqui ESTOU usando a opção /db para especificar qual banco de dados para se conectar, supondo que o host local como servidor de banco de dados e instalar os arquivos de imagem dois. Eu carregar as tabelas em SQL e preenchê-los com Meus valores, que significa que pode usar a tecnologia de acesso de dados de minha preferência para puxá-los de volta novamente (ou atualizá-los ou excluí-los ou inserir novos registros). Nesse caso, ESTOU usando a ferramenta de linha de comando sqlcmd:

C:\>sqlcmd -d Repository
1> select Name from WixBitx.Products
2> go
Name
----------------
SuperNotepad
(1 rows affected)

Enquanto Intellipad oferece suporte a serviços de idioma "M" fora da caixa de, incluindo a geração de SQL, não há nenhum mecanismo com suporte para criar a imagem ou referência a outras imagens. No entanto, Visual Studio oferece suporte a esses recursos.

O Visual Studio Integration

O SDK do "Oslo" fornecido com suporte interno para Visual Studio 2008 SP1. Depois de instalar o SDK, você terá o modelo de projeto "M" instalado, como mostrado na Figura 5 .

Por padrão, você terá um arquivo Model1.m adicionado ao seu projeto. Isso fornece os mesmos recursos de IntelliSense que você tem em Intellipad. Quando você precisar de mais arquivos de modelo, você pode clique com o botão direito do mouse no seu projeto no Solution Explorer, adicione um novo item e, em seguida, escolher o modelo de modelo "M".

fig05.gif

A Figura 5 O modelo de projeto de “M” no Visual Studio 2008

Além disso, se você quiser fazer referência a imagens "M" existentes, você pode fazer isso clicando com o botão direito do mouse em seu projeto e escolha Add Reference, em seguida, escolhendo um arquivo .MX. Por exemplo, se você quiser criar um projeto que cria os valores que tenha sido brincar com e referencia os tipos que tenha sido demonstrando, ele aparência Figura 6 .

fig06.gif

A Figura 6 um projeto “M” com código-fonte e .MX referência de arquivo

Quando você cria, você verá os erros na Error List como esperado e a saída será ir em \bin\Debug ou \bin\Release (dependendo da configuração do que você está criando), incluindo tanto a. SQL .MX arquivos e para fazer com que você consulte ajustar (como execução mx.exe no arquivo de saída .MX). Todas essas coisas mesmas também funcionam no último CTP do Visual Studio 2010.

O processo de compilação dentro do Visual Studio é orientado por um arquivo MSBuild com a extensão .mproj (veja a Figura 7 ). Isso é útil se você quiser usar o arquivo de destinos do msbuild de "Oslo" em seus próprios arquivos de projeto.

A Figura 7 MSBuild arquivo para projetos de "M"

<?xml version="1.0" encoding="utf-8"?>
<Project ...>
  <PropertyGroup>
    <MTarget>Repository</MTarget>
    <MPackageScript>true</MPackageScript>
    <MPackageImage>true</MPackageImage>
    <MTargetsPath Condition="$(MTargetsPath) == ''">
      $(MSBuildExtensionsPath)\Microsoft\M\v1.0</MTargetsPath>
    ...
  </PropertyGroup>
  <ItemGroup>
    <Compile Include="MixbitsValues.m" />
  </ItemGroup>
  <ItemGroup>
    <MReference Include="C:\WixbitsTypes.mx" />
  </ItemGroup>
  <Import Project="$(MTargetsPath)\MProject.targets" />
</Project>

Código de exemplo

O código de exemplo incluído neste artigo é um recurso utilitário Installer repositório (repinst.exe) que entenda um modelo de um pouco mais completos para descrever os arquivos MSI que eu tenha sido discutir aqui. Quando os tipos e valores que descrevem os modelos do WiX tiverem sido compilado (usando m.exe) e carregado o repositório (usando mx.exe), executando o utilitário de repinst.exe nos dados de valor será ler os dados do repositório, criar um arquivo MSI dele e iniciar a instalação, permitindo que qualquer pessoa com acesso ao banco de dados para implantar aplicativos carregados dessa forma, conforme mostrado na Figura 8 .

fig08.gif

A Figura 8 O repinst exemplo em ação

Foi algum trabalho neste exemplo, reorganizando principalmente para exposição, mas a maior parte do trabalho (e o crédito!) vai para Delrue Thomas, Alejandro Trigo e Giovanni Della-Libera para o seu trabalho em modelagem WiX, convertendo "M" em WiX e produzir um MSI dos dados do SQL. Eu nunca pode ter escrito este artigo no tempo que fiz sem o seu trabalho de quebra de início. Além disso, graças a Josh Williams, Martin Gudgin e John Doty para uma amostra todo outra criada para explorar os recursos do repositório que você verá no "Oslo" Developer Center real logo agora.

Chris vende é gerente de programa para a divisão de sistemas conectados na Microsoft onde ele está trabalhando em gen próximo aplicativo técnicas de desenvolvimento. Obter mais informações sobre Carla e seus vários projetos podem ser encontrados no sellsbrothers.com.