Arquivo

Archive for the ‘.NET’ Category

Chamando Métodos de uma Página ASPX usando JQuery e AJAX

Logo JQueryMuitas vezes no ASP.NET queremos evitar os Postbacks, chamadas para a mesma página, no intuido de melhorar a usabilidade de algum componente ou da própria página. Para isso utilizamos artifícios providos pelo Javascript, JQuery e AJAX.

No entanto, surge um problema quando queremos utilizar, no código que roda no lado cliente (client-side), dados que são produzidos no lado do servidor (server-side). A solução para esse problema é bem simples: fazer todo o trabalho no servidor e repassar para a página apenas o resultado das operações, através de JQuery. E para que não ocorram Postbacks, devemos usar AJAX para chamar os métodos da página aspx que produzem os dados a serem exibidos.

Como faço isso?! Desse jeito:
Crie um novo projeto Web, adicione o arquivo correspondente ao JQuery e uma classe chamada Client.
Arquivo JQuery adicionado ao Projeto

A classe Client só vai possuir duas propriedades, ficando assim:

public class Client
{
    public string Name { get; set; }
    public int Age { get; set; }
}

Adicione uma página com o nome de Clients.aspx e, em seu code-behind, crie o método GetClient para retornar um objeto do tipo Client. O método precisa ser static e assinado com o atributo [WebMethod].

public partial class Clients : System.Web.UI.Page
{
	protected void Page_Load(object sender, EventArgs e)
	{
	}

	[WebMethod]
	public static Client GetClient()
	{
		Client ada = new Client { Name = "Ada", Age = 40 };
		return ada;
	}
}

Agora, no modo Design, adicione à pagina o código JQuery que irá chamar o método GetClient. Para isso, na tag head acrescente o seguinte código:

<script type="text/javascript" src="Scripts/jquery-1.6.2.min.js"></script><script type="text/javascript">// <![CDATA[
        $(document).ready(function () {
            $("#runJasonFromPage").click(function () {
                $.ajax({
                    type: "POST",
                    url: "Clients.aspx/GetClient",
                    data: "{}",
                    contentType: "application/json; charset=utf-8",
                    dataType: "json",
                    success: function (jasonResult) {
                        alert(jasonResult.d.Name);
                    }
                });
            });
        });
// ]]></script>

O que o código acima faz é assinar o evento de click de um elemento da página chamando o método GetClient da página Clients.aspx. O resultado obtido na chamada desse método é repassado para uma função javascript, na forma de um objeto JSON, JavaScript Object Notation. Essa função simplesmente exibe a propriedade Name desse objeto, através de um alert.

Note que não é preciso serializar o objeto Client no código da página Clients.aspx. O ASP.NET já faz essa serialização por padrão.

Agora precisamos criar o elemento que irá executar o código JQuery que escrevemos acima. Adicione, então, um botão HTML com o id runJasonFromPage à página:

<input id="runJasonFromPage" type="button" value="Run JSON From Page" />

Pronto! Sua página está chamando um método de servidor sem ser necessário Postback e sem utilizar controles de servidor.

Categorias:.NET, ASP.NET

Mapeando Custom Fields com FluentPS

Enterprise custom fieldsNo post anterior aprendemos como utilizar a biblioteca FluentPS, que facilita o trabalho de manipular informações do Project Server.

Nesse post vamos ver como recuperar informações de campos personalizados do Project Server, os Enterprise Custom Fields.

O que são Enterprise Custom Fields?

Enterprise Custom Fields permitem extender os campos fornecidos por padrão pelo Project Server, podendo ser associados às entidades Projeto, Recurso e Tarefas. Eles são geralmente utilizados para atender a alguma necessidade específica da empresa/organização.

Os Enterprise Custom Fields são armazenados no Banco de Dados do próprio Project Server.

Onde estão os Enterprise Custom Fields?

Configurações do ServidorOs campos personalizados podem ser encontrados no PWA site, através do link Configurações do Servidor.

Agora navegue até a seção Dados da Empresa.

Selecione a opção Campos Personalizados da Empresa e Tabelas de Pesquisa para ver os campos cadastrados do servidor.

Seção Dados da Empresa

Nosso Exemplo

A nossa aplicação vai recuperar os dados do campo Departamento de um determinado projeto. Para isso, vamos criar a entrada Departamento de TI nesse campo.

Observação: lembre que você deve associar ao projeto o valor do campo Departamento que acabamos de criar, utilizando, por exemplo, o Microsoft Project Professional.

Usando o código do post anterior, vamos modificar a classe ProjectInfo. Criaremos a propriedade ProjectDepartment da seguinte forma:

[PSLookupField("9d77d62a-a92e-4d40-adc8-446c90eb7456", LookupTableUid="e7397277-1ab0-4096-b2dd-57029a055ba4",
FieldName = "Departamentos do Projeto", LookupTableName = "Departamento")]
public string ProjectDepartment { get; set; }

Para mapearmos o campo Departamento, utilizamos o atributo PSLookupField, recebendo em seu construtor os seguintes parâmetros: o ID do campo, o ID da tabela de lookup (tabela de pesquisa, em Português), o nome do campo e o nome da tabela de lookup.

Para recuperar o ID do campo, basta clicar no campo

Campo personalizado Departamento do Projeto

e copiar o GUID na parte inferior da página:

ID do campo DepartamentoDa mesma forma, para acessar o ID da tabela de lookup Departamento basta clicar nela,

Tabela de pesquisa Departamento

naveguar até a parte inferior da pagina e copiar o GUID:

GUID da tabela de lookup DepartamentoAgora altere a classe Program.cs para exibir o nome do Departamento associado ao projeto.

Console.WriteLine("Project Department: {0}", project.ProjectDepartment);

Pronto! Agora é só executar o código e o Departamento do projeto será exibido.

Novamente, se quiser mais informações sobre o FluentPS e o mapeamento de Custom Fields, acesse http://www.projectserver2010blog.com

Categorias:.NET, Project Server

Inovecast: Certificação SharePoint 2010

Inove InformáticaNesse mês de Abril, participei do Inovecast, Podcast da Inove Informática, falando um pouco sobre a nova série de certificações para a plataforma SharePoint 2010, juntamente com o Ronaldo Silva que trabalha comigo na Inove.

No podcast, apresentamos os temas mais abordados na certificação 70-573: Microsoft SharePoint 2010, Aplication Development

 

Caso não consiga ouvir o podcast, tente aqui.

Categorias:.NET, SharePoint

Usando FluentPS

fluentPS logo

FluentPS é uma biblioteca open source que tem o objetivo de simplificar o desenvolvimento de aplicações na plataforma Project Server 2010. Ela lembra bastante o FluentNHibernate, bem parecida com ORM (mapeamento objeto-relacional), provendo uma interface para o PSI (Project Server Interface).

No desenvolvimento de aplicações para Project Server sem usar o FluentPS, era preciso adicionar várias referências a WebServices que permitiam o acesso a informações dos arquivos de Projeto que estavam publicados no Portal PWA. Com o FluentPS, essa tarefa não é mais necessária. Toda a comunicação com o Project Server é feita através de objetos compilados na Plataforma .NET.

Agora que sabemos o que é o FluentPS vamos à prática!

Esse exemplo é bem simples e apenas recupera as informações referentes ao ID e Nome dos Projetos que estão publicados no Portal PWA.

Baixe as dlls do FluentPS do site http://fluentps.codeplex.com/. Para esse exemplo estou usando a versão 2.0.

Vamos criar um projeto Console com o nome de FluentPSTestApplication. Adicione as referências para as dlls do FluentPS que você acabou de baixar.

referências fluentps

Configure o a propriedade Target Framework do projeto para .NET Framework 3.5, clicando com o botão direito sobre o projeto e escolhendo a opção Properties.

Versão do .NET Framework

Agora, adicionamos a classe ProjectInfo que mapeará os campos referentes a um projeto do Project Server.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using FluentPS.Attributes;
using FluentPS.Consts;

namespace FluentPSTestApplication
{
public class ProjectInfo
{
[PSEntityUidField(ColumnName=ProjectCustomFieldsColumnNames.PROJ_UID)]
public Guid ProjectUid { get; set; }

[PSEntityUidField(ColumnName=ProjectCustomFieldsColumnNames.PROJ_NAME)]
public string ProjectName { get; set; }
}
}

O atributo PSEntityUidField realiza o mapeamento de um campo padrão de um projeto. Nesse exemplo, os campos padrões são o ID e o Nome do Projeto.

Na classe Program, adicione o seguinte trecho de código:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using FluentPS.Services.Impl;
using FluentSP.Services.Impl;
using FluentPS.WebSvcCustomFields;
using FluentPS.WebSvcLookupTable;

namespace FluentPSTestApplication
{
class Program
{
static void Main(string[] args)
{
var logService = new LogService();
var sessionService = new PSSessionService();
var psiContextService = new PsiContextService();
var psiSvcsFactory = new PSISvcsFactory(sessionService, psiContextService);

var lookupTableService = new PSLookupTableService(
logService,
psiSvcsFactory.CreateSvcClient());

var svcCustomFields = psiSvcsFactory.CreateSvcClient();
var svcLookupTable = psiSvcsFactory.CreateSvcClient();
var svcView = psiSvcsFactory.CreateSvcClient();

var environmentService = new EnvironmentService();
var customFieldService = new PSCustomFieldService(logService,
svcCustomFields,
svcView,
environmentService,
lookupTableService);

var projectsService = new PSProjectService(
logService,
lookupTableService,
customFieldService,
psiSvcsFactory.CreateSvcClient());
var projects = projectsService.GetAll();

foreach (var project in projects)
{
Console.WriteLine("Project Name: {0}", project.ProjectName);
Console.WriteLine("Project Uid: {0}", project.ProjectUid);
Console.WriteLine();
}

Console.ReadKey();
}
}
}

Basicamente, o que o código acima faz é instanciar os objetos do FluentPS que servem para mapear os WebServices do Project Server.

O comando abaixo, retorna todos os projetos publicados no Portal do PWA.

var projects = projectsService.GetAll();

Fácil, não? Se você quiser mais informações sobre o FluentPS, acesse o site http://www.projectserver2010blog.com. Exemplo concluído e até o próximo post.

Categorias:.NET, Project Server

SharePoint Disposable Pattern

DisposeMemory Alguns objetos do SharePoint implementam a interface IDisposable, para facilitar a liberação de memória. Mas por que, você deve estar se perguntando, precisamos nos preocupar com a memória se o Garbage Collector faz o “trabalho sujo” por nós?

Objetos como SPWeb e SPSite utilizam tanto código gerenciado como código não gerenciado. Dessa forma, o Garbage Collector cuida da memória utilizada pela parte gerenciada do código. O problema é que a porção não gerenciada do código utilizada por esses objetos é muito maior que a porção gerenciada. Assim é preciso que liberemos essa parte da memória para evitar problemas maiores, os memory leaks.

O método Dispose da IDisposable libera a memória (gerenciada e não gerenciada) associada àquele objeto. Após a chamada desse método o objeto fica inutilizado e qualquer referência feita a ele causa um erro.

Você agora deve estar pensando: “Ok, eu já sei por que utilizar o método Dispose. Mas em que situações eu vou precisar chamá-lo?”

De maneira geral, sempre que você instancia um objeto SPWeb ou SPSite usando a palavra chave new em seu código você precisará usar o método Dispose. Por exemplo:

SPSite site = new SPSite(“http://site”);

Por outro lado, objetos retornados por SPContext.Current.Web, SPContext.Current.Site, SPContext.Web, SPContext.Site não devem chamar o método Dispose no seu código.

A ferramenta SharePoint Dispose Check ajuda o desenvolvedor a saber quando é preciso usar esse método. Ela pode ser encontrada em http://code.msdn.microsoft.com/SPDisposeCheck.

Caso você queira saber mais sobre o assunto, leia o artigo “Best Practices: Using Disposable Windows SharePoint Services Objects” em http://msdn.microsoft.com/en-us/library/aa973248.aspx.

Categorias:.NET, SharePoint

Recursos avançados do C# – Parte I

As versões mais atuais do C# (3.0 e superiores) trouxeram recursos muito facilitam a vida do programador. Falaremos sobre dois deles:

Auto-Implemented Properties – Propriedades auto-implementadas

Veja o seguinte código:

public class Pessoa
{
	public string Nome { get; set; }
	public int Idade { get; set; }
}

Podemos notar que a Classe Pessoa possui duas Propriedades, embora não possua Atributos. Ao compilar esse código, o compilador cria atributos private escondidos, que só podem ser acessados através de sua respectiva Propriedade.

Object and Collection Initializers – Inicializadores de Objetos e Coleções

Os inicializadores de objetos permitem que sejam passados valores para os Membros (Atriutos ou Propriedades) de um objeto no momento de sua criação, sem a chamada explicita de um Construtor. O código abaixo mostra a inicialização de objetos da Classe Pessoa:

Pessoa p = new Pessoa { Idade = 21, Nome = "Denis Martins" };
Pessoa p2 = new Pessoa { Idade = 32, Nome = "Ada Lovelace" };

Assim como nos objetos, coleções podem ser inicializadas no momento de sua criação:

List<Pessoa> list = new List<Pessoa>
{
	new Pessoa(){ Idade = 21, Nome = "Denis Martins" },
	new Pessoa(){ Idade = 32, Nome = "Ada Lovelace" },
	new Pessoa(){ Idade = 40, Nome = "Charles Babage" }
};

É importante lembrar que esses recursos são bastante utilizados quando estamos trabalhando com LINQ.

Para quem quer mais informações sobre Recursos avançados do C#, é interessante consultar o Guia de Programação no site do MSDN: Guia de Programação C#

[/sourcecode] 

Categorias:.NET

Compilação, JIT e MSIL

Vamos entender um pouco mais sobre o mecanismo de geração de código no .NET Framework.

O fluxo de compilação de um programa escrito em C#, ou em outra linguagem suportada pelo .NET Framework, segue o seguinte esquema:

compilation

Na primeira parte do processo de compilação, o código escrito em Linguagem de Alto-nível é compilado para uma Linguagem Intermediária: a Microsoft Intermediate Language (MSIL), que é semelhante ao Assembly x86.

Na segunda parte da compilação (que ocorre na primeira execução do código-programa), a CLR chama o JIT (Compilador Just-in-time), que compila o código MSIL para código de máquina. E assim, para o código não precisa ser compilado para as demais execuções.

Dessa forma, apenas máquinas que possuem a CLR podem executar o código gerado pelo JIT. Esse código é chamado de gerenciado, porque a CLR cuida de atividades que seriam de obrigação do programador (alocação e liberação de memória, por exexmplo). Já o código não-gerenciado é compilado diretamente para a linguagem de máquina, não necessitando da CLR para executar.

O JIT também provê uma otimização no código gerado, compilando apenas o código que é realmente necessário para a execução do programa, reduzindo o tamanho do arquivo-final (.dll ou .exe).

Quando o compilador produz código MSIL, ele também produz Metadados, que descrevem as definições de tipo, declarações de membros, referências à bibliotecas e outros dados utilizados pelo programa. O conjunto MSIL + Metadados forma um arquivo Portable Executable (PE).

A ferramenta MSIL Assembler (Ilasm.exe) gera um arquivo PE. Já o MSIL Disassembler (Ildasm.exe) converte um arquivo PE em um arquivo texto que contém o código MSIL gerado.

Para mais informações sobre MSIL, JIT, Ilasm e Ildasm, veja:

http://msdn.microsoft.com/en-US/library/c5tkafs1%28v=VS.90%29.aspx

http://msdn.microsoft.com/en-US/library/496e4ekx%28v=VS.90%29.aspx

http://msdn.microsoft.com/en-US/library/f7dy01k1%28v=VS.90%29.aspx

Categorias:.NET