Search results for 'app:weblogs' matching tag 'LINQ'

Populating a DataGridView from Xml Data

DeborahK — Tue, 20 Oct 2009 05:00:00 GMT

If you are using XML in a WinForms application you may find the need to display the XML data in a DataGridView.

Let's take this XML:

<states>
    <state name="California">
        <abbreviation>CA</abbreviation>
        <year>1850</year>
        <governor>Schwarzenegger</governor>
    </state>
    <state name="Wisconsin">
        <abbreviation>WI</abbreviation>
        <year>1848</year>
        <governor>Doyle</governor>
    </state>
</states>

Displaying XML in a DataGridView sounds easy, but if you just set the DataGridView DataSource to the XML data, you will get something like this:

Notice how it has lots of yuck in it: attribute details, node properties, and so on for every node in the XML. So how do you get something more like this:

The trick is to use anonymous types.

The code is provided here in VB and C# and then described in detail below.

NOTE: Be sure to set a reference to System.Core and System.Xml.Linq

In C#:

XElement statesXml = XElement.Parse("<states>" +
    "<state name='California'>" +
        "<abbreviation>CA</abbreviation>" +
        "<year>1850</year>" +
        "<governor>Schwarzenegger</governor>" +
    "</state>" +
    "<state name='Wisconsin'>" +
        "<abbreviation>WI</abbreviation>" +
        "<year>1848</year>" +
        "<governor>Doyle</governor>" +
    "</state>" +
   "</states>");

var query = from st in statesXml.Descendants("state")
            select new
            {
                Name = st.Attribute("name").Value,
                Abbrev = st.Element("abbreviation").Value,
                Year = st.Element("year").Value,
                Governor = st.Element("governor").Value
            };
DataGridView1.DataSource = query.ToList();

In VB:

Dim statesXml As XElement = _
    <states>
        <state name="California">
            <abbreviation>CA</abbreviation>
            <year>1850</year>
            <governor>Schwarzenegger</governor>
        </state>
        <state name="Wisconsin">
            <abbreviation>WI</abbreviation>
            <year>1848</year>
            <governor>Doyle</governor>
        </state>
    </states>

Dim query = From st In statesXml...<state> _
            Select New With { _
                  .Name = st.@name, _
                  .Abbrev = st.<abbreviation>.Value, _
                  .Year = st.<year>.Value, _
                  .Governor = st.<governor>.Value}
DataGridView1.DataSource = query.ToList

The first part of this code builds the XML. The C# code uses the XElement.Parse function to build the XML; VB uses XML literals. This part of the code is not necessary if you are reading the XML from another source, such as a file.

The second part of the code leverages Linq to XML to process the set of state XML elements. For each element, it uses the Select New syntax to create an anonymous type. The syntax defines an unnamed (anonymous) type with properties Name, Abbrev, Year, and Governor.

[To view an overview of anonymous types, start here.]

The last line converts the results of the query to a generic list and assigns it to the DataSource property of the DataGridView. Visual Studio uses the anonymous type property names as the text for the column titles and populates the rows with each state element.

Use this technique any time you have XML that you want to display in a DataGridView.

Enjoy!

Nederlandse CodeCamp 2009

Maurice — Mon, 19 Oct 2009 05:00:00 GMT

Op 21 november 2009 organiseren de SDN, Stichting dotNed en VBcentral samen het derde Nederlandse Code Camp. Dit is een dag lang met code, code sharing, freaking en gezellig samenzijn. Een evenement door ontwikkelaars, voor ontwikkelaars. De regie ligt voor een belangrijk deel bij de deelnemers! Het aantal plaatsen voor deelnemers is wel beperkt tot maximaal 150. Wacht dus niet te lang met beslissen want voor je het weet is er geen plaats meer. Vergeet bij je aanmelding niet op te geven welke onderwerpen je interesse hebben. Bovendien nodigen we iedereen graag uit om zelf een sessie in te vullen.

Op de website, www.codecamp.nl, vind je meer informatie en kan je je aanmelden.

LINQ To SQL Tips & Tricks: String Operations

paulo — Tue, 13 Oct 2009 05:00:00 GMT

LINQ brought developers a very user friendly and domain independent style of writing queries.

The fact that the way queries are written is domain independent doesn’t mean that any query will compile the same way or even run the same way. You’ll always need to know how the provider will behave.

LINQ To Objects, for example, will compile queries as a Func<> delegate and the query methods will return IEnumerable(T) implementations.

On the other hand, LINQ To SQL will compile queries as an Expression<Func<>> (which is, in fact, an expression tree) instance and the query methods will return IQueryable(T) implementations.

Because LINQ To SQL queries are compiled to an expression tree, that allows the provider to treat the query elements as it sees fit.

In this case, this means that all operations that can be done on the database will be done on the database and the developer must be aware of this when she/he is writing the queries.

Lets take an example using the AdventureWorks database (if you don’t have it, you can download it from here).

I want to build a list of salutation for every employee that has the SalariedFlag set, in the form of:

[Mr.|Mrs.|Miss] <first name> <middle name> <last name>

But there’s also one detail about the data in the database: FirstName, MiddleName and LastName may have trailing spaces and I don’t want them.

This is a simple query like this:

var q1 = from e in context.Employees
         where e.SalariedFlag
         select
            ((e.Gender == 'F') ? ((e.MaritalStatus == 'S') ? "Miss" : "Mrs.") : "Mr.") + " " +
            e.Person.FirstName.Trim() +
            (e.Person.MiddleName == null || e.Person.MiddleName.Trim().Length == 0 ? " " : " " + e.Person.MiddleName.Trim() + " ") +
            e.Person.LastName.Trim();

and it will be executed as:

SELECT ((((
    (CASE
        WHEN UNICODE([t0].[Gender]) = @p0 THEN
            (CASE
                WHEN UNICODE([t0].[MaritalStatus]) = @p1 THEN @p2
                ELSE @p3
             END)
        ELSE CONVERT(NVarChar(4),@p4)
     END)) + @p5) + LTRIM(RTRIM([t1].[FirstName]))) + (
    (CASE
        WHEN ([t1].[MiddleName] IS NULL) OR (LEN(LTRIM(RTRIM([t1].[MiddleName]))) = @p6) THEN CONVERT(NVarChar(MAX),@p7)
        ELSE (@p8 + LTRIM(RTRIM([t1].[MiddleName]))) + @p9
     END))) + LTRIM(RTRIM([t1].[LastName])) AS [value]
FROM [HumanResources].[Employee] AS [t0]
INNER JOIN [Person].[Person] AS [t1] ON [t1].[BusinessEntityID] = [t0].[BusinessEntityID]
WHERE [t0].[SalariedFlag] = 1
-- @p0: Input Int (Size = 0; Prec = 0; Scale = 0) [70]
-- @p1: Input Int (Size = 0; Prec = 0; Scale = 0) [83]
-- @p2: Input NVarChar (Size = 4; Prec = 0; Scale = 0) [Miss]
-- @p3: Input NVarChar (Size = 4; Prec = 0; Scale = 0) [Mrs.]
-- @p4: Input NVarChar (Size = 3; Prec = 0; Scale = 0) [Mr.]
-- @p5: Input NVarChar (Size = 1; Prec = 0; Scale = 0) [ ]
-- @p6: Input Int (Size = 0; Prec = 0; Scale = 0) [0]
-- @p7: Input NVarChar (Size = 1; Prec = 0; Scale = 0) [ ]
-- @p8: Input NVarChar (Size = 1; Prec = 0; Scale = 0) [ ]
-- @p9: Input NVarChar (Size = 1; Prec = 0; Scale = 0) [ ]
-- Context: SqlProvider(Sql2008) Model: AttributedMetaModel Build: 3.5.30729.4926

If you notice the query, there are a lot of text operations going on for each row.

Depending on the number of rows or database load this can prove to be very bad. The result might even be just a timeout.

So, how do we force the string operations to occur on the client instead of the database?

Only IQueryable<T> will be translated to T-SQL. So, all we need to do is change the type of the enumerator being iterated.

One way to do this is using the the AsEnumerable method of the Enumerable class.

The query would now be written as:

var q2 = from e in context.Employees.Where(e => e.SalariedFlag).AsEnumerable()
         select
            ((e.Gender == 'F') ? ((e.MaritalStatus == 'S') ? "Miss" : "Mrs.") : "Mr.") + " " + e.Person.FirstName.Trim() +
            (e.Person.MiddleName == null || e.Person.MiddleName.Trim().Length == 0 ? " " : " " + e.Person.MiddleName.Trim() + " ") +
            e.Person.LastName.Trim();

and it will be executed as:

SELECT
    [t0].[BusinessEntityID],
    [t0].[LoginID],
    [t0].[NationalIDNumber],
    [t0].[JobTitle],
    [t0].[MaritalStatus],
    [t0].[BirthDate],
    [t0].[Gender],
    [t0].[HireDate],
    [t0].[SalariedFlag],
    [t0].[VacationHours],
    [t0].[SickLeaveHours],
    [t0].[CurrentFlag],
    [t0].[rowguid],
    [t0].[ModifiedDate],
    [t1].[BusinessEntityID] AS [BusinessEntityID2],
    [t1].[PersonType],
    [t1].[NameStyle],
    [t1].[Title],
    [t1].[FirstName],
    [t1].[MiddleName],
    [t1].[LastName],
    [t1].[Suffix],
    [t1].[EmailPromotion],
    [t1].[AdditionalContactInfo],
    [t1].[Demographics],
    [t1].[rowguid] AS [rowguid2],
    [t1].[ModifiedDate] AS [ModifiedDate2]
FROM [HumanResources].[Employee] AS [t0]
INNER JOIN [Person].[Person] AS [t1] ON [t1].[BusinessEntityID] = [t0].[BusinessEntityID]
WHERE [t0].[SalariedFlag] = 1
-- Context: SqlProvider(Sql2008) Model: AttributedMetaModel Build: 3.5.30729.4926

As you can notice, text operations are no longer done on the database, but all the columns of both tables are being returned. And this is still a bad thing because we are using network bandwidth with data that won’t be used.

The way to choose the columns that will be retrieved from the database is by selecting only the ones wanted in the select statement. But because we still want string operations the be done on the client, we’ll need to project the desired columns into an intermediary object. Since we won’t need this object outside the query, we’ll use an anonymous type.

The query would now be written as:

var q3 = from n in
             (
                 from e in context.Employees
                 where e.SalariedFlag
                 select new
                 {
                     Gender = e.Gender,
                     MaritalStatus = e.MaritalStatus,
                     FirstName = e.Person.FirstName,
                     MiddleName = e.Person.MiddleName,
                     LastName = e.Person.LastName
                 }
             ).AsEnumerable()
         select ((n.Gender == 'F') ? ((n.MaritalStatus == 'S') ? "Miss" : "Mrs.") : "Mr.") + " " + n.FirstName.Trim()
         + (n.MiddleName == null || n.MiddleName.Trim().Length == 0 ? " " : " " + n.MiddleName.Trim() + " ")
         + n.LastName.Trim();

and it will be executed as:

SELECT
    [t0].[Gender],
    [t0].[MaritalStatus],
    [t1].[FirstName],
    [t1].[MiddleName],
    [t1].[LastName]
FROM [HumanResources].[Employee] AS [t0]
INNER JOIN [Person].[Person] AS [t1] ON [t1].[BusinessEntityID] = [t0].[BusinessEntityID]
WHERE [t0].[SalariedFlag] = 1
-- Context: SqlProvider(Sql2008) Model: AttributedMetaModel Build: 3.5.30729.4926

Notice the call to Enumerable.As Enumerable to translate the LINQ To SQL query into a LINQ To Objects query.

And, to end this long blog post, if you don’t use any string operations on the query, they, obviously, won’t be translated to T-SQL:

var q4 = from e in context.Employees
         where e.SalariedFlag
         select BuildSalutation(e.Gender, e.MaritalStatus, e.Person.FirstName, e.Person.MiddleName, e.Person.LastName);

where BuildSalutation is implemented as:

private static object BuildSalutation(char gender, char maritalStatus, string firstName, string middleName, string lastName)
{
    return ((gender == 'F') ? ((maritalStatus == 'S') ? "Miss" : "Mrs.") : "Mr.") + " "
        + firstName.Trim()
        + (middleName == null || middleName.Trim().Length == 0 ? " " : " " + middleName.Trim() + " ")
        + lastName.Trim();
}

and it will be executed as:

SELECT
    [t0].[Gender] AS [gender],
    [t0].[MaritalStatus] AS [maritalStatus],
    [t1].[FirstName] AS [firstName],
    [t1].[MiddleName] AS [middleName],
    [t1].[LastName] AS [lastName]
FROM [HumanResources].[Employee] AS [t0]
INNER JOIN [Person].[Person] AS [t1] ON [t1].[BusinessEntityID] = [t0].[BusinessEntityID]
WHERE [t0].[SalariedFlag] = 1
-- Context: SqlProvider(Sql2008) Model: AttributedMetaModel Build: 3.5.30729.4926

Have you noticed that this T-SQL query is pretty much the same in the previous example?

If you are still reading this, I hope you now aware of how you write your LINQ To SQL queries affect the generated T-SQL.

Lambda Expressions: Finding an Item in a Generic List

DeborahK — Sun, 11 Oct 2009 05:00:00 GMT

In this prior post, I detailed how to build lists of things using a generic List<T>. Once you have a list, you may need to find items in the list. There are several ways to accomplish this, but using lambda expressions is the most concise.

[To begin with an overview of lambda expressions, start here.]

For example, here is how you find an item in a generic list using a for/each statement.

In C#:

Customer foundCustomer = null;
foreach (var c in custList)
{
    if (c.CustomerId == 4)
    {
        foundCustomer = c;
        break;
    }
}
Debug.WriteLine(foundCustomer);

In VB:

Dim foundCustomer As Customer = Nothing
For Each c As Customer In custList
    If c.CustomerId = 4 Then
        foundCustomer = c
        Exit For
    End If
Next
Debug.WriteLine(foundCustomer)

Notice the amount of code required to loop through each item in the list and find the one with a particular customer Id.

You may have heard about language integrated query (LINQ) and how you can use it to search a list.

In C#:

Customer foundCustomer = null;
var query = from c in custList
where c.CustomerId == 4
select c;
foundCustomer = query.FirstOrDefault();
Debug.WriteLine(foundCustomer);

In VB:

Dim foundCustomer As Customer = Nothing
Dim query = From c As Customer In custList _
Where c.CustomerId = 4 _
Select c
foundCustomer = query.FirstOrDefault()
Debug.WriteLine(foundCustomer)

So LINQ is cool, but the code does not seem much shorter.

Now let’s look at using lambda expressions to find the item in the list.

In C#:

Customer foundCustomer = null;
foundCustomer = custList.FirstOrDefault(c =>
c.CustomerId == 4);
Debug.WriteLine(foundCustomer);

The lambda expression syntax in C# looks like this:

c => c.CustomerId == 4

The code begins with the set of parameters to the lambda expression. The => is the “goes to” or lambda operator. The remainder of the code is the expression itself. In this case, checking for the item in the list where CustomerId is 4.

In VB:

Dim foundCustomer As Customer = Nothing
foundCustomer = custList.FirstOrDefault(Function(c)
c.CustomerId = 4)
Debug.WriteLine(foundCustomer)

The lambda expression syntax in VB looks like this:

Function(c) c.CustomerId = 4

The code begins with the word “Function” along with the set of parameters to the lambda expression. The remainder of the code is the expression itself. In this case, checking the item in the list where CustomerId is 4.

.NET 3.5 added a large list of extension methods on the Enumerable class. Any object that implements IEnumerable or IEnumerable<T> (basically any object you can do a for/each over) can use these methods. Many of these extension methods (such as the FirstOrDefault method shown in the above example) support lambda expressions.

The FirstOrDefault extension method of the Enumerable class returns the first item in the list or the default value for the object. If you pass it a lambda expression, it returns the first item in the list that matches the Boolean expression.

Enjoy!

Série LINQ to SQL Parte 6 - Atualizando registros com LINQ to SQL

andrey — Tue, 06 Oct 2009 05:00:00 GMT

Nesse post, para finalizar a série de LINQ to SQL, vou demonstrar como atualizar registros de uma tabela utilizando a query do LINQ.

O Códgo abaixo atualiza os dados de um Produto que é recuperado através do seu ID. Veja como é simples a atualização do objeto em banco de dados.

public void AtualizarProduto(int idProduto)
    {
        BlogLinqDemoDataContext bd = new BlogLinqDemoDataContext();
        Produto QueryProduto = bd.Produtos.Single(p => p.ProdutoID == idProduto);

QueryProduto.Descricao = "Ferro";

QueryProduto.CategProdID = 1;

bd.SubmitChanges();

}

O método AtualizarProduto recebe por parâmetro o ID do produto à ser atualizado. Veja é feito uma query LINQ para recuperar do banco de dados o Produto correspondente. Após a recuperação, basta atribuir os novos valores para o objeto e chamar o método SubmitChanges() para que a atualização seja efetuada no banco de dados destino.

Com esse último post, vimos como é simples utilizar da LINQ to SQL para manipular objetos de banco de dados e também como construir a sua camada de persistência com as principais operações de banco de dados.

Espero que tenha sido útil e deixo abaixo alguns "links" para consulta e estudos mais aprofundados

101 linq samples - http://msdn.microsoft.com/en-us/vcsharp/aa336746.aspx
Videos de LINQ - http://www.asp.net/learn/linq-videos/

Série LINQ to SQL Parte 5 - Criando querys com JOIN entre tabelas

andrey — Thu, 24 Sep 2009 05:00:00 GMT

Como vocês já devem ter percebido, a linguagem LINQ é muito semelhante a uma query SQL e essa tem sido uma das grandes vantagens do LINQ.

Nesse post vamos explorar mais um desses recursos, a utilização de JOIN entre duas tabelas em uma consulta e faremos o bind do resultado em um gridView do ASP.NET

Crie uma nova página ListarTodosProdutos.aspx e desenhe o leiaute como da seguinte forma:

Em seguida, clique duas vezes sobre o form e codifique o evento Page_Load() conforme o código abaixo:

protected void Page_Load(object sender, EventArgs e)
{
BlogLinqDemoDataContext db = new BlogLinqDemoDataContext();

        var query = from p in db.Produtos
                    join c in db.CategoriaProdutos on p.CategProdID equals c.CategProdID
                    select new {
                        ID = p.ProdutoID,
                        Produto = p.Descricao,
                        Categoria = c.Descricao };

        GridView1.DataSource = query;
        GridView1.DataBind();
   }

Veja que a query do LINQ é muito parecida com uma query T-SQL. É feito uma query na tabela de Produtos com um JOIN com a tabela de CategoriaProdutos a fim de recuperar a descrição da Categoria. Em seguida o select new determina quais campos serão selecionados e inclusive escolhendo alias para cada campo. Ao efetuar o bind no GridView, é possível ver a execução conforme tela abaixo:

Outros tipos de JOINS

No exemplo acima executamos o conhecido INNER JOIN, mas é claro que poderíamos executar outros tipos de join como LEFT JOIN, RIGHT JOIN, etc. Veja os próximos exemplos:

LEFT JOIN

var query = from produtos in db.Produtos
                    join categorias in db.CategoriaProdutos on produtos.CategProdID equals categorias.CategProdID into x
                    from categorias in x.DefaultIfEmpty()
                    select new {
                        ID = produtos.ProdutoID,
                        Produto = produtos.Descricao,
                        Categoria = categorias.Descricao };

No exemplo acima são exibidos todos os produtos que possuam ou não categorias relacionadas. No caso dos produtos sem categoria, retorna NULL. Coloquei sublinhando o que difere de um INNER JOIN que é o fato de atribuir o relacionamento à um objeto que dei o nome de "x" e depois informar que a tabela de CategoriaProdutos é DefaultIfEmpty() informando que se não houver categoria o Produto sera exibido da mesma forma.

RIGHT JOIN

var query = from produtos in db.Produtos.DefaultIfEmpty()
                    join categorias in db.CategoriaProdutos on produtos.CategProdID equals categorias.CategProdID into x
                    from prod in x
                    select new {
                        ID = prod.CategProdID,
                        Categoria = prod.Descricao};

No exemplo acima são exibidos todos as categorias que possuam produtos relacionadas. O resultado dessa query será esse:

No próximo post dessa série, vou mostrar como executar querys utilizando recursos de GROUP, SELECT IN e outros.

Até lá

Série LINQ to SQL Parte 4 - Recuperando um registro específico com LINQ

andrey — Mon, 21 Sep 2009 05:00:00 GMT

Em continuação à série LINQ to SQL, nesse post veremos como fazer query dos dados em banco e o bind diretamente em controles ASP.NET. Nesse exemplo iremos:

Codificar o método que retornará um objeto produto;
Codificar o preenchimento do objeto na UI

Query em registros únicos

Na classe beProduto.cs crie o método para recuperar um produto específico. Segue abaixo o código:

public Produto RecuperarProduto(int idProduto)
   {
       BlogLinqDemoDataContext bd = new BlogLinqDemoDataContext();
       try
        {
            Produto oProduto = bd.Produtos.Single(p => p.ProdutoID == idProduto);
            return oProduto;
        }
        catch (InvalidOperationException)
        {
            throw new ApplicationException("Produto não encontrado !");
        }
    }

Com apenas 3 linhas de código é possível fazer a recuperação do objeto. Veja que se o objeto não foi localizado, o .net dispara uma exceção do tipo InvalidOperationException que poderá ser tratada e exibida a mensagem de produto inexistente.

Antes mesmo de eu explicar todos vocês já deviam ter adivinhado, inclusive no post anterior, que estamos fazendo uma query na tabela de Produtos pois o código é muito intuitivo. Essa é a idéia do LINQ, fazer ser simples algo que antes costumava dar um trabalho que sempre era repetitivo.

Em seguida, codifique a UI para recuperar e exibir o objeto:

     protected void btBuscar_Click(object sender, EventArgs e)
    {
        beProduto beoProduto = new beProduto();
        try
        {
            Produto oProduto = beoProduto.RecuperarProduto(Convert.ToInt32(txtCodigoProduto.Text));
            txtDescricao.Text = oProduto.Descricao;
            txtValor.Text = oProduto.Valor.ToString("N");
            ddlCategoria.SelectedValue = oProduto.CategProdID.ToString();
        }
        catch (Exception ex)
        {
            lblerro.Text = ex.Message;
        }
    }

Dessa forma é possível fazer a recuperação do objeto e exibição dele nos controles. Veja que para acessar a categoria do produto eu fiz acesso à propriedade CategProdID do objeto Produto.

Fiquem atentos com a continuidade dessa série e execute os exemplos passo-a-passo pois é a melhor forma de aprender, fazendo na prática :)

Até o próximo post e aguardo comentários

An object lesson in blogging and accuracy; was: Efficient "vote counting" with LINQ to Objects - and the value of nothing

skeet — Sun, 20 Sep 2009 05:00:00 GMT

Well, this is embarrassing.

Yesterday evening, I excitedly wrote a blog post about an interesting little idea for making a particular type of LINQ query (basically vote counting) efficient. It was an idea that had occurred to me a few months back, but I hadn't got round to blogging about it.

The basic idea was to take a completely empty struct, and use that as the element type in the results of a grouping query - as the struct was empty, it would take no space, therefore "huge" arrays could be created for no cost beyond the fixed array overhead, etc. I carefully checked that the type used for grouping did in fact implement ICollection<T> so that the Count method would be efficient; I wrote sample code which made sure my queries were valid... but I failed to check that the empty struct really took up no memory.

Fortunately, I have smart readers, a number of whom pointed out my mistake in very kind terms.

Ben Voigt gave the reason for the size being 1 in a comment:

The object identity rules require a unique address for each instance... identity can be shared with super- or sub- class objects (Empty Base Optimization) but the total size of the instance has to be at least 1.

This makes perfect sense - it's just a shame I didn't realise it before.

Live and learn, I guess - but apologies for the poorly researched post. I'll attempt to be more careful next time.

Série LINQ to SQL Parte 3 - Inserindo registros no Banco de Dados SQL Server

andrey — Thu, 17 Sep 2009 05:00:00 GMT

Continuando a série LINQ to SQL , nesse post iremos incluir um registro de Produto na Base de Dados SQL Server utilizando LINQ.

Crie uma nova página por nome /LINQ/Cadastro.aspx e desenho seu layout conforme mostra figura abaixo:

Após a criação da Página, crie duas classes na pasta App_Code do seu WebSite por nomes beProduto.cs e beCategoriaProduto.cs

Codifique a classe beProduto.cs conforme mostra o código abaixo:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

/// <summary>
/// Summary description for beProduto
/// </summary>

public class beProduto
{
      public beProduto()
      {
            //
            // TODO: Add constructor logic here
            //
      }
    public void GravarProduto(Produto oProduto)
    {
        BloqLinqDemoDataContext bd = new BloqLinqDemoDataContext();
        bd.Produtos.InsertOnSubmit(oProduto);
        bd.SubmitChanges();
    }
}

Veja que é criado um método que recebe um objeto do tipo Produto por parâmetro. Essa classe Produto é a própria classe criada pelo LINQ no momento da modelagem.
O objeto bd representa a conexão com o banco de dados e é representado também pela classe BlogLinqDemoDataContext. Se você abrir a classe BlogLinqDemoDataContext vai ver que o construtor padrão acessa a chave de conexão no web.config. O método InsertOnSubmit() configura uma operação de INSERT na query que será montada pelo LINQ, Já o método SubmitChanges() executa no banco de dados todas as operações processadas pelo LINQ que você tenha programado. Isso quer dizer que você pode executar diversas operações (INSERT, UPDATE, DELETE) e enviar as alterações de uma só vez para o banco de dados através do método SubmitChanges().

Em seguida codifique a classe beCategoriaProduto.cs conforme mostra o código abaixo:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

/// <summary>
/// Summary description for beCategoriaProduto
/// </summary>
public class beCategoriaProduto
{
      public beCategoriaProduto()
      {
            //
            // TODO: Add constructor logic here
            //
      }
    public List<CategoriaProduto> ListarTodasCategorias()
    {
        BloqLinqDemoDataContext bd = new BloqLinqDemoDataContext();
        var query = from c in bd.CategoriaProdutos
                    select c;

return query.ToList();

}
}

Como você pode ver estamos fazendo uma query na tabela CategoriaProdutos e retornando TODOS os registros. O resultado da query é transformada numa lista Generics List<CategoriaProduto>.
Agora na camada de apresentação, ou UI (User Interface), faremos a chamada para os métodos da camada de negócio, ou BE (Business Layer) para o preenchimento da lista de categorias e gravação do Produto. Sendo assim, faremos:

Preenchimento da DropDownList de Categorias de Produtos;
Código do botão Inserir que vai preparar o objeto para ser persistido;

Segue abaixo o código para preenchimento da DropDownList de Categorias:

protected void Page_Load(object sender, EventArgs e)
    {
        if (!Page.IsPostBack)
        {
            beCategoriaProduto oCategProduto = new beCategoriaProduto();
            ddlCategoria.DataSource = oCategProduto.ListarTodasCategorias();
            ddlCategoria.DataTextField = "Descricao";
            ddlCategoria.DataValueField = "CategProdID";
            ddlCategoria.DataBind();

            ddlCategoria.Items.Insert(0, new ListItem("Selecione ...", ""));
        }
    }

Em seguida, codifique o método do botão Inserir:

protected void btIncluir_Click(object sender, EventArgs e)
    {
        try
        {
            //preenche o objeto Produto
            Produto oProduto = new Produto();
            oProduto.Descricao = txtDescricao.Text;
            oProduto.Valor = Convert.ToDecimal(txtValor.Text);
            oProduto.CategProdID = Convert.ToInt32(ddlCategoria.SelectedValue);

            beProduto produto = new beProduto();
            produto.GravarProduto(oProduto);

            lblerro.Text = "Registro incluído com sucesso";
        }
        catch (Exception ex)
        {
            lblerro.Text = ex.Message;
        }
    }

Execute a aplicação exemplo e debugue o código. Veja que tudo está mais claro e simples de entender. Não precisamos nos preocupar com síntaxe SQL, nem mesmo manipular os nativos objetos SqlCommand, SqlConnection, DataTable, etc.

Com certeza, o uso do LINQ tratá muita produtividade para as equipes de desenvolvimento de software.

Na próxima parte dessa série, veremos como criar querys com parâmetros, joins, group by exibindo as informações em controles ASP.NET, é claro

Até lá !!!

Série LINQ to SQL Parte 2 - Modelando objetos com LINQ

andrey — Wed, 16 Sep 2009 05:00:00 GMT

Mão na massa

Continuando a série sobre LINQ to SQL , nesse post vou publicar como modelar os objetos no VS 2008 e preparar as classes para persistência dos objetos em Banco de Dados.

Crie um banco de dados no SQLEXPRESS por nome BlodDemo e duas tabelas Produtos e CategoriaProdutos. As duas tabelas se relacionam conforme figura abaixo.

Agora que já modelamos o banco, iremos modelar os objetos para que o LINQ crie as classes e faça o mapeamento com as tabelas.

No VS 2008:

Crie um projeto do tipo WebSite e na linguagem C#
Clique com o botão direito no projeto web, aponte para Add New Item, selecione o template LINQ to SQL Classes e dê nome de BlogLinqDemo.dbml. Veja que o VS cria o diagrama de mapeamento automaticamente.
Aponte para o Server Explorer e adicione ou localize a conexão para o banco de dados que você criou
Localize as duas tabelas e arraste as duas tabelas para o diagrama criado. O VS já cria as classes gerando os relacionamentos necessários. Você também pode editar os relacionamentos clicando com o botão direito no relacionamento

Veja na figura abaixo o diagrama que o VS 2008 cria no momento que você arrasta as tabelas para o diagrama.

Por trás das câmeras

É claro que não existe mágica nisso tudo. O VS é somente um modelador que gera as classes que serão executadas no seu código C#.
Se você abrir o arquivo BloqLinqDemo.designer.cs criado abaixo do BloqLinqDemo.dbml na Solution Explorer verá o código gerado para as classes. Parte do código, segue abaixo:

[Table(Name="dbo.Produtos")]

public partial class Produto : INotifyPropertyChanging, INotifyPropertyChanged

{
      public Produto()
      {
            this._CategoriaProduto = default(EntityRef<CategoriaProduto>);
            OnCreated();
      }

      [Column(Storage="_Descricao", DbType="NChar(10) NOT NULL", CanBeNull=false)]
      public string Descricao
      {
            get
            {
                 return this._Descricao
            }

            set
            {
                  if ((this._Descricao != value))
                  {

                        this.OnDescricaoChanging(value);
                        this.SendPropertyChanging();
                        this._Descricao = value;
                        this.SendPropertyChanged("Descricao");
                        this.OnDescricaoChanged();

}
}

}

[Column(Storage="_Valor", DbType="Decimal(18,2) NOT NULL")]
public decimal Valor

      {
            get
            {
                  return this._Valor;
            }

            set
            {
                  if ((this._Valor != value))
                  {

                        this.OnValorChanging(value);
                        this.SendPropertyChanging();
                        this._Valor = value;
                        this.SendPropertyChanged("Valor");
                        this.OnValorChanged();
                  }

}

Na próxima parte dessa série, vamos criar um formulário web recebendo os valores do Cadastro de Produtos e faremos a inclusão do registro utilizando a síntaxe do LINQ

Até