Este artigo foi traduzido por máquina.
Visual Studio
Entity Framework 4.0 e WCF Data Services 4.0 no Visual Studio 2010
Elisa Flasko
Entre seus vários aprimoramentos novos, Visual Studio 2010 apresenta os prevista muito Estrutura de Entidade 4.0 e WCF Data Services 4.0 (anteriormente conhecida como serviços de dados ADO.NET), que simplificam juntos como modelo, consumir e produzir dados.
Estrutura de Entidade 4.0 (EF 4.0) concentra-se na habilitação e simplificando a dois cenários principais: desenvolvimento de aplicativos centrados em domínio e os tradicionais centrados em dados “ formulários sobre dados. ” Ele apresenta recursos, como desenvolvimento primeiro modelo, o que permite que você criar um modelo e tiver personalizado o T-SQL gerado para você; suporte a persistence ignorance; chaves externas; carregamento lento e geração de código personalizado para entidades.
WCF Data Services 4.0 concentra-se em Ativar atualizações para o protocolo de dados aberto (odata.org) e em seus novos recursos, incluindo a vinculação de dados bidirecional para o Windows Presentation Foundation (WPF) e Silverlight, contagem de linhas, orientada por servidor paginação, aprimorado suporte objeto binário grande e suporte para projeções.
Usando um aplicativo weblog de amostra (MyBlog), I será explore os novos recursos no EF e serviços de dados do WCF e explique como as tecnologias funcionam em conjunto para simplificar a forma como dados são modelados e consumidos. Esse aplicativo de exemplo terá um aplicativo de ASP.NET que fornece uma exibição somente leitura de postagens de blog e um cliente de administrador do blog Silverlight permite que o proprietário do blog para editar postagens. Eu iniciar o aplicativo usando o modelo pela primeira vez para criar um EDM (modelo de dados de entidade) e, em seguida, gerar um banco de dados e o código para interagir com esse banco de dados. Este exemplo também fará com que usam da atualização de serviços de dados ADO.NET para Silverlight 3 CTP 3.
Introdução ao EF 4.0
Começarei com o projeto ASP.NET Web Application. (Meu aplicativo é chamado BlogModel; você pode baixar o código fornecido no Code.msdn.Microsoft.com/mag201004VSData.) Para começar com EF., posso usar o Assistente Adicionar novo item para adicionar um EDM do ADO.NET e selecione um modelo vazio que chamarei BlogModel também. Clicando com o botão direito do mouse na superfície vazia do Designer e escolhendo Propriedades, você pode ver o nome da entidade recipiente padrão, BlogModelContainer, nesse caso. Primeiro eu alterará o nome para BlogContext e, em seguida, criarei o modelo.
MyBlog requer três entidades que chamarei de Blog, postar e marca, como mostrado no Figura 1. Para criá-los, eu arrastar uma entidade da caixa de ferramentas para a superfície de design e, em seguida, clique com o botão direito do mouse e selecione Propriedades para editar as propriedades de entidade. Eu também precisará de algumas propriedades escalares em todas as entidades (clique com o botão direito do mouse na entidade e selecione Add | propriedade escalar).
Figura 1 Blog, postar e entidades de marca e configurações de propriedade associados
Suporte a chave externa no EF 4.0
Em seguida, adicionarei as relações entre essas entidades. Clique com o botão direito do mouse na superfície de design e selecione Add | Association, como mostra a Figura 2. EF agora oferece suporte a chaves externas, permitindo que a inclusão de propriedades de chave externas em uma entidade. Observe que adicionando a relação adicionado uma propriedade BlogBlogID (chave externa) para a entidade de POST.
Figura 2 Associações entre Blog, postar e entidades de marca
A inclusão de propriedades de chave estrangeiras em entidades simplifica um número de chave de codificação de padrões, incluindo dados de ligação, dinâmico de dados, o controle de simultaneidade e n-nível de desenvolvimento. Por exemplo, se tenho uma grade que mostra produtos e eu tiver o CategoryID (um valor de chave estrangeiro) em uma grade, mas Don tenho o respectivo objeto de categoria de ligação de dados, o suporte de chave estrangeiro no EF significa que Don são mais necessárias no custo de uma consulta para separadamente extrair novamente o objeto Category.
Modelar primeiro com EF. 4.0
Agora que o modelo foi criado (consulte Figura 3), o aplicativo precisa de um banco de dados. Nesse caso, MyBlog é um novo aplicativo e ainda não tem um banco de dados. Don desejo criar o banco de dados por conta própria; eu teria em vez disso, basta eficiente para mim — e possível. Com modelo pela primeira vez no EF 4.0, o Visual Studio pode agora gerar código personalizado não apenas para as entidades, mas também um banco de dados com base no modelo apenas criado.
Figura 3 Modelo de blog
Primeiro, preciso criar o banco de dados vazio para o qual aplicarei esquema gerado. Para fazer isso, eu Abra Server Explorer, clique com o botão direito do mouse no nó Data Connections e selecione Create New SQL Server Database (consulte Figura 4). Com o banco de dados vazio criado, eu clique com o botão direito do mouse na superfície de design do modelo e selecione Generate banco de dados do modelo. Percorrendo o Assistente para gerar o banco de dados cria um arquivo BlogModel.edmx.sql. Com esse novo arquivo aberto, é simples, clique com o botão direito do mouse no arquivo e executar o script SQL para criar o esquema para meu banco de dados.
Figura 4 Criar um novo banco de dados vazio e gerar o esquema de banco de dados do EDM
Geração de código personalizado com EF. 4.0
Neste ponto, há um número de próximas etapas possíveis, um deles é personalizar o código que gera EF, usando modelos T4. No Visual Studio 2008 SP1, embora EF fornecido alguns ganchos para personalizar a geração de código era relativamente inflexível e difícil de usar. EF 4.0 agora utiliza T4 modelos, fornecendo uma maneira muito mais simples, mais flexível e mais poderosa para personalizar o código gerado.
Para adicionar um novo modelo T4 para o projeto, clique com o botão direito do mouse na superfície do Designer de entidade e selecione Adicionar Item de geração de código. Aqui, escolha qualquer modelo atualmente instalado para usar como ponto de partida ou exibir os modelos disponíveis na galeria online. Para usar o modelo EF padrão como ponto de partida para este projeto, vou escolher o modelo do ADO.NET EntityObject gerador; por padrão, o modelo é chamado Model1.tt. Adicionando um modelo de geração de código dessa maneira, EF automaticamente desabilita geração de código padrão para o modelo. O código gerado é removido do BlogModel.Designer.cs e agora existe em Model1.cs. Neste ponto, o modelo pode ser editado para personalizar as entidades irá gerar e sempre que o arquivo .tt for salva, o código dependente será regenerado. Para obter mais informações sobre edição e usar modelos T4 com EF 4.0, confira o blog de equipe ADO.NET em blogs.msdn.com/adonet.
Usando entidades POCO com EF 4.0
O Visual Studio 2008 SP1 imposto uma série de restrições em classes de entidade dificultou, no mínimo, a criação de classes foram realmente independentes de preocupações de persistência. Um dos recursos mais solicitados em EF 4.0 é a capacidade de criar tipos POCO (Plain Old CLR Object) para as entidades que funcionam com EF. e Don impõem o tipo de restrições no Visual Studio 2008 SP1.
Let’s vá para a amostra MyBlog. Vou criar objetos POCO para três entidades — Blog, postar e a etiqueta. Primeiro, geração de código precisa ser desligado e preciso remover o arquivo .tt que adicionei na última seção. Para verificar as propriedades do modelo do, clique com o botão direito do mouse na superfície do Designer de entidades. Como mostra a Figura 5, há uma propriedade denominada estratégia de geração de código que precisa ser definido como Nenhum para desativar a geração de código.
Figura 5 Código de geração de estratégia de propriedade
Observe que essa propriedade é definida como nenhum automaticamente quando você adiciona um item de geração de código (modelo T4) a um projeto. Se o projeto tem um arquivo .tt incluído, você precisará removê-la antes de usar objetos POCO. Aqui, as classes para objetos POCO podem ser added—Blog.cs, Post.cs e Tag.cs, conforme mostrado no Figuras 6, 7 and 8.
Figura 6 POCO objeto para a entidade do Blog
public class Blog
{
public intBlogID
{
get;
set;
}
public string Name
{
get;
set;
}
public string Owner
{
get;
set;
}
public List<Post> Posts
{
get { return _posts; }
set { _posts = value; }
}
List<Post> _posts = new List<Post>();
}
Figura 7 POCO Object for Entity Tag
public class Tag
{
public int TagID
{
get;
set;
}
public string Name
{
get;
set;
}
public List<Post> Posts
{
get { return _posts; }
set { _posts = value; }
}
List<Post> _posts = new List<Post>();
}
Figura 8 POCO objeto para a entidade de POST
public class Post
{
public int PostID
{
get;
set;
}
public DateTime CreatedDate
{
get;
set;
}
public DateTime ModifiedDate
{
get;
set;
}
public string Title
{
get;
set;
}
public string PostContent
{
get;
set;
}
public Blog Blog
{
get;
set;
}
public int BlogBlogID
{
get;
set;
}
public Boolean Public
{
get;
set;
}
public List<Tag> Tags
{
get { return _tags; }
set { _tags = value; }
}
private List<Tag> _tags = new List<Tag>();
}
Por último, preciso criar a classe de contexto, que é muito semelhante a implementação de ObjectContext gerada com a geração de código padrão, mas chamarei ele BlogContext. Ele irá herdar da classe ObjectContext. O contexto é a classe que está ciente de persistência. Ele irá permitir a composição de consultas, Materializar entidades e salve as alterações do banco de dados (consulte Figura 9).
Figura 9 BlogContext
public class BlogContext : ObjectContext
{
public BlogContext()
: base("name=BlogContext", "BlogContext")
{
}
public ObjectSet<Blog> Blogs
{
get
{
if (_Blogs == null)
{
_Blogs =
base.CreateObjectSet<Blog>("Blogs");
}
return _Blogs;
}
}
private ObjectSet<Blog> _Blogs;
public ObjectSet<Post> Posts
{
get
{
if (_Posts == null)
{
_Posts =
base.CreateObjectSet<Post>("Posts");
}
return _Posts;
}
}
private ObjectSet<Post> _Posts;
public ObjectSet<Tag> Tags
{
get
{
if (_Tags == null)
{
_Tags = base.CreateObjectSet<Tag>("Tags");
}
return _Tags;
}
}
private ObjectSet<Tag> _Tags;
}
Carregamento lento
No Visual Studio 2008 SP1, EF suporte duas maneiras básicas de carregar entidades relacionadas, ambos os garantindo que o aplicativo acessa o banco de dados somente quando explicitamente instruído a fazê-lo, usando o método Load para carregar explicitamente entidades relacionadas ou o método Include avidamente carregar entidades relacionadas dentro de uma consulta. Outro dos recursos mais solicitados agora EF 4.0 é carregamento lento. Quando executar carregamentos explícitos não é necessária, você pode usar o carregamento lento (também conhecido como adiado carregamento) para carregar entidades relacionadas, quando uma propriedade de navegação é acessada pela primeira vez. No Visual Studio 2010, isso é feito, tornando a navegação propriedades virtuais.
No exemplo MyBlog, lista de pastas pública <Post>lança propriedade em ambos os Blog.cs e Tag.cs seria tornam-se lista pública virtuais <Post>postagens e a lista de pública <Tag>marcas de propriedade em Post.cs tornaria tags de lista virtual pública <Tag>. EF, criaria um tipo de proxy no tempo de execução que sabe como executar uma carga para que nenhuma alteração de código adicional é necessária. No entanto, como a amostra MyBlog usa serviços de dados do WCF para expor entidades em um serviço de protocolo de dados aberto (OData), o aplicativo não fazer uso de carregamento lento.
Criando um serviço de dados do WCF no Visual Studio 2010
MyBlog tira proveito da solução quase completo fornecido pelo WCF Data Services para fornecer um serviço OData por um EDM e inclui um cliente de administrador de blog do Silverlight que usa o serviço OData. O protocolo de dados aberto é um padrão de compartilhamento de dados que subdivide silos e promove um ecossistema eficaz, interoperative para consumidores de dados (clientes) e produtores (serviços), permitindo que mais aplicativos dar sentido a um conjunto mais amplo de dados.
Com um EDM e configurar o banco de dados, adicionar um novo serviço de dados do WCF para o aplicativo é simples; eu usando o Assistente Adicionar novo item, adicione um serviço de dados do WCF (chamarei ele BlogService). Isso gera um arquivo BlogService.svc que representa o esqueleto do serviço e está apontado para o EDM, fornecendo a ele o contexto criado anteriormente. Como o serviço é totalmente bloqueado por padrão, acesso os conjuntos de entidades que devem ser disponibilizados através do serviço deve ser explicitamente permitido usando config.SetEntitySetAccessRule. Para isso, uma regra é definir para cada EntitySet é disponibilizada, como visto no Figura 10.
Figura 10 BlogService.svc
public class BlogService : DataService<BlogContext>
{
// This method is called only once to initialize service-wide policies.
public static void InitializeService(DataServiceConfiguration config)
{
// TODO: set rules to indicate which entity sets and service
// operations are visible, updatable, etc.
// Examples:
config.SetEntitySetAccessRule("Blogs", EntitySetRights.All);
config.SetEntitySetAccessRule("Posts", EntitySetRights.All);
config.SetEntitySetAccessRule("Tags", EntitySetRights.All);
// config.SetServiceOperationAccessRule("MyServiceOperation",
// ServiceOperationRights.All);
config.DataServiceBehavior.MaxProtocolVersion =
DataServiceProtocolVersion.V2;
}
}
(Observação: Se você baixar o código de exemplo deste artigo, você perceberá ele usa um esquema de autenticação de formulários muito simples para proteger o site e os exemplos restantes também usará esse esquema para filtrar dados com base no usuário conectado no momento. Como implementar autenticação de formulários está além do escopo deste artigo, no entanto, vou para ignorar os detalhes aqui.)
Com o serviço de backup e em execução, a próxima etapa é filtrar os resultados com base no usuário conectado no momento para que sejam retornadas somente Blogs pertencentes a esse usuário. Você pode feita isso pela adição de consulta interceptores como visto no Figura 11 para restringir as entidades retornadas por uma consulta.
Figura 11 Interceptador de consulta
// returns only public posts and posts owned by the current user
[QueryInterceptor("Posts")]
public Expression<Func<Post, bool>>OnPostQuery()
{
return p =>p.Public == true ||
p.Blog.Owner.Equals(HttpContext.Current.User.Identity.Name);
}
// returns only the blogs the currently logged in user owns
[QueryInterceptor("Blogs")]
public Expression<Func<Blog, bool>>OnBlogQuery()
{
return b =>
b.Owner.Equals(HttpContext.Current.User.Identity.Name);
}
Consumir um serviço WCF de dados no Silverlight
Os detalhes da criação de uma interface de usuário do Silverlight estão além do escopo deste artigo, para que eu vai gloss sobre alguns deles. Mas antes de indo como ligar o serviço de dados para um aplicativo do Silverlight, adicionarei um novo aplicativo do Silverlight para o projeto que contém a página do Silverlight padrão MainPage.xaml. Para que eu adicionar um DataGrid básico, ComboBox, Button e algumas das etiquetas. Com um aplicativo do Silverlight esqueleto pronto (consulte Figura 12), pode conectar o serviço de dados.
Figura 12 Layout básico de MyBlog SilverlightAdministrator de aplicativos
Para iniciar, o aplicativo Silverlight dos objetos que representam cada uma das entidades definidas pelo serviço de dados. Para fazer isso, você deve usar o assistente Add Service Reference no Visual Studio para gerar classes de cliente para o serviço de dados automaticamente. (Observe que para usar o Add Service Reference, preciso desabilitar temporariamente as verificações de autorização implementadas no serviço, de modo que adicionar referência de serviço tem acesso completo ao serviço. O assistente Add Service Reference, aponte para o URI de base para o serviço, que MyBlog é localhost:48009/BlogService.svc).
Ligação de dados no WCF Data Services 4.0
Suporte aprimorado para ligação de dados no WCF Data Services 4.0 adiciona um novo tipo de coleção DataServiceCollection, à biblioteca de cliente, estende ObservableCollection. No entanto, no Silverlight 3, vinculação de dados está desativada por padrão quando uma referência de serviço é adicionada ao projeto. Assim, para aproveitar os novos dados ligação funcionalidade na Data Services do WCF, ligação de dados precisa estar ligado e a referência de serviço precisa ser atualizado. A partir do Solution Explorer, clique no botão Show All Files e expanda o item BlogService sob o nó referências de serviços. Clique duas vezes no arquivo de mapa Reference.datasvc e substituir o elemento de parâmetros com o trecho de XML mostrado aqui:
<Parameters>
<Parameter Name="UseDataServiceCollection" Value="true" />
<Parameter Name="Version" Value="2.0" />
</Parameters>
Definindo o parâmetro UseDataServiceCollection como true auto-gera tipos de cliente que implementam as interfaces INotifyCollectionChanged e de INotifyPropertyChanged. Isso significa que todas as alterações feitas no conteúdo de um DataServiceCollection ou as entidades na coleção são refletidas no contexto do cliente. Isso também significa que, se uma entidade na coleção é novamente consultada, quaisquer alterações desta entidade serão refletidas nas entidades no DataServiceCollection. E significa que, como o DataServiceCollection implementa o padrão de interfaces de vinculação, pode ser vinculado como a fonte de dados ao WPF a maioria dos e controles do Silverlight.
Voltando ao exemplo MyBlog, a próxima etapa é criar uma conexão com o serviço, criando um novo DataServiceContext e usá-lo para consultar o serviço. Figura 13 inclui MainPage.xaml e MainPage.xaml.cs e mostra a criação de um novo DataServiceContext, consultar o serviço para todos os blogs — nesse caso, o serviço retorna todos os blogs de propriedade por conectado - in usuário — e ligando os blogs para uma caixa de combinação no aplicativo do Silverlight.
Figura 13 MainPage.xaml e MainPage.xaml.cs
MainPage.xaml
<Grid x:Name="LayoutRoot" Background="White" Width="618">
<data:DataGrid Name="grdPosts" AutoGenerateColumns="False"
Height="206" HorizontalAlignment="Left"Margin="17,48,0,0"
VerticalAlignment="Top" Width="363" ItemsSource="{Binding Posts}">
<data:DataGrid.Columns>
<data:DataGridTextColumn Header="Title" Binding="{Binding Title}"/>
<data:DataGridCheckBoxColumn Header="Public"
Binding="{Binding Public}"/>
<data:DataGridTextColumn Header="Text"
Binding="{Binding PostContent}"/>
</data:DataGrid.Columns>
</data:DataGrid>
<Button Content="Save" Height="23" HorizontalAlignment="Left"
Margin="275,263,0,0" Name="btnSave" VerticalAlignment="Top"
Width="75" Click="btnSave_Click_1" />
<ComboBox Height="23" HorizontalAlignment="Left"
Margin="86,11,0,0" Name="cboBlogs" VerticalAlignment="Top"
Width="199" ItemsSource="{Binding}" DisplayMemberPath="Name"
SelectionChanged="cboBlogs_SelectionChanged" />
<dataInput:Label Height="50" HorizontalAlignment="Left"
Margin="36,15,0,0" Name="label1"
VerticalAlignment="Top"Width="100" Content="Blogs:" />
<dataInput:Label Height="17" HorizontalAlignment="Left"
Margin="17,263,0,0" Name="lblCount" VerticalAlignment="Top"
Width="200" Content="Showing 0 of 0 posts"/>
<Button Content="Load More Posts" Height="23" HorizontalAlignment="Left" Margin="165,263,0,0" Name="btnMorePosts"
VerticalAlignment="Top" Width="100" Click="btnMorePosts_Click" />
</Grid>
MainPage.xaml.cs
public MainPage()
{
InitializeComponent();
svc = new BlogContext(new Uri("/BlogService.svc", UriKind.Relative));
blogs = new DataServiceCollection<Blog>(svc);
this.LayoutRoot.DataContext = blogs;
blogs.LoadCompleted +=
new EventHandler<LoadCompletedEventArgs>(blogs_LoadCompleted);
var q = svc.Blogs.Expand("Posts");
blogs.LoadAsync(q);
}
void blogs_LoadCompleted(object sender, LoadCompletedEventArgs e)
{
if (e.Error == null)
{
if (blogs.Count> 0)
{
cboBlogs.SelectedIndex = 0;
}
}
}
Para vincular a DataGrid, um método cboBlogs_SelectionChanged() é adicionado:
private void cboBlogs_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
this.grdPosts.DataContext = ((Blog)cboBlogs.SelectedItem);
}
Esse método será chamado toda vez que o item atualmente selecionado na ComboBox é alterado.
O último item a ser conectado no aplicativo do Silverlight é o botão Salvar, que é habilitado adicionando um método btnSave_Click que chama SaveChanges DataServiceContext, como visto no Figura 14.
Figura 14 Salvando alterações voltar para o banco de dados
private void btnSave_Click_1(object sender, RoutedEventArgs e)
{
svc.BeginSaveChanges(SaveChangesOptions.Batch, OnChangesSaved, svc);
}
private void OnChangesSaved(IAsyncResult result)
{
var q = result.AsyncState as BlogContext;
try
{
// Complete the save changes operation
q.EndSaveChanges(result);
}
catch (Exception ex)
{
// Display the error from the response.
MessageBox.Show(ex.Message);
}
}
Paginação baseados em servidor
Geralmente, é necessário para limitar o número total de resultados de que um servidor irá retornar para uma determinada consulta, para evitar a necessidade de um aplicativo acidentalmente puxe para trás uma quantidade extremamente grande de dados. Paginação orientados por servidor no WCF Data Services 4.0 permite que o autor de um serviço para definir os limites por coleção o número total de entidades de que um serviço retorna para cada solicitação, definindo a propriedade SetEntitySetPageSize no método InitializeService para cada conjunto de entidades para. Com a limitação do número de entidades retornadas para cada solicitação, o serviço de dados fornece ao cliente “ próximo link ” — um URI, especificando como o cliente é recuperar o próximo conjunto de entidades na coleção, na forma do AtomPub < link rel = ” seguida ” > elemento.
Voltando ao exemplo MyBlog, I será definir a propriedade SetEntitySetPageSize em meu serviço para o EntitySet postagens cinco dos resultados:
config.SetEntitySetPageSize ("postagens", 5);
Isso limitará o número de entidades retornadas quando o serviço é consultado para postagens. Eu estou definindo a propriedade SetEntitySetPageSize como um número pequeno para ilustrar como funciona o recurso; geralmente, um aplicativo deve definir um limite que a maioria dos clientes não será executado em (em vez disso, o cliente deve usar $ superior e $ pule para controlar a quantidade de dados solicitados a qualquer momento).
Além disso, adicionarei um novo botão para o aplicativo para permitir que o usuário solicitar a próxima página de postagens do serviço. Este snippet mostra o método btnMorePosts_Click acessando o próximo conjunto de postagens:
private void btnMorePosts_Click(object sender, RoutedEventArgs e)
{
Blog curBlog = cboBlogs.SelectedItem as Blog;
curBlog.Posts.LoadCompleted += new
EventHandler<LoadCompletedEventArgs>(Posts_LoadCompleted);
curBlog.Posts.LoadNextPartialSetAsync();
}
Contagem de linha
Um dos recursos mais solicitados depois que a versão dos serviços de dados ADO.NET no Visual Studio 2008 SP1 era a capacidade de determinar o número de entidades em um conjunto sem a necessidade de extrair todos eles total fazer do banco de dados. No WCF Data Services 4.0, adicionamos o recurso Row Count para fazer isso.
Ao criar uma consulta no cliente, o método IncludeTotalCount pode ser chamado para incluir a marca de contagem na resposta. O valor, em seguida, pode ser acessado como mostrado no Figura 15, usando a propriedade TotalCount no objeto QueryOperationResponse.
Figura 15 Usando Row Count
private void cboBlogs_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
Blog curBlog = this.cboBlogs.SelectedItem as Blog;
this.grdPosts.DataContext = curBlog;
var q = (from p in svc.Posts.IncludeTotalCount()
where p.BlogBlogID == curBlog.ID
select p) as DataServiceQuery<Post>;
curBlog.Posts.LoadCompleted += new
EventHandler<LoadCompletedEventArgs>(Posts_LoadCompleted);
curBlog.Posts.LoadAsync(q);
}
void Posts_LoadCompleted(object sender, LoadCompletedEventArgs e)
{
if (e.Error == null)
{
Blog curBlog = cboBlogs.SelectedItem as Blog;
totalPostCount = e.QueryOperationResponse.TotalCount;
string postsCount = string.Format("Displaying {0} of {1} posts",
curBlog.Posts.Count, totalPostCount);
this.lblCount.Content = postsCount;
curBlog.Posts.LoadCompleted -= Posts_LoadCompleted;
}
}
Projeções
Outro dos recursos mais solicitados no WCF Data Services 4.0 é projeção, a capacidade de especificar um subconjunto das propriedades da entidade a ser retornado de uma consulta, permitindo que os aplicativos de otimizar o espaço de largura de banda consumo e a memória. No Visual Studio 2010, o formato de URI de serviços de dados foi estendido para incluir a opção de consulta seleção $, permitindo que os clientes especificar o subconjunto de propriedades a serem retornados pela consulta. Por exemplo, com MyBlog, eu poderia consultar para todas as postagens e projeto somente título e PostContent usando o seguinte URI: BlogService.svc/Posts?$select=Title,PostContent. No lado do cliente, você pode usar o LINQ agora também a consulta com projeções.
Aprenda mais
Este artigo aborda apenas o suficiente para começar com Estrutura de Entidade 4.0 e o WCF Data Services 4.0 no Visual Studio 2010. Há uma série de outros tópicos e novos recursos que você esteja interessado. Para obter mais informações, confira o centro MSDN Data Development em MSDN.Microsoft.com/data.
Elisa Flasko é gerente de programa no atMicrosoft de equipe de programação de dados, trabalhando em tecnologias ADO.NET Estrutura de Entidade, serviços de dados do WCF, M, Quadrant e serviços de modelagem do SQL Server. Ela pode ser contatada pelo blogs.msdn.com/elisaj.
Graças aos seguintes especialistas técnicos para revisar este artigo: Jeff Derstadt e Mike Flasko