Um dia desses na internet (parte 3 – O Retorno)…

17 de agosto de 2012 2 comentários

Continuando a série  “um dias desses na internet“, veja que lindo quando tentei verificar o extrato em um determinando banco..

Categorias:Diversos

NBT– Cursos & Palestras

28 de maio de 2012 Deixe um comentário

Nos próximos meses a NBT ( do qual sou um dos sócios Alegre) estará lançando vários treinamentos/palestras para a comunidade, alguns serão gratuitos limitado apenas a quantidade de pessoas (na maioria 100), por isso quem tiver interesse entre no site da NBT (seção Cursos) e faça a pré-inscrição para os cursos & palestras. Após a pré-inscrição você receberá um e-mail com o código (guarde esse codigo) do seu treinamento e/ou palestra e em seguida receberá um link para confirmar a inscrição.

 

Uma das palestras que já estão agendadas é o Cloud Computing, essa palestra tem com objetivo falar sobre o que é Cloud Computing, como surgiu e os modelos de serviço (SAAS, PAAS e IAAS), além de uma breve visão sobre as soluções IBM para Cloud (SmartCloud) e dentre outras.

 

Espero vocês nos treinamentos/palestras…

 

Nelson Borges

facebook3

Categorias:Azure, Cursos, Diversos

Um dia desses na internet (parte 2)…

1 de março de 2012 1 comentário

Sei que causei um pouco de desordem com o post “um dia desses na internet..”, agora navegando no site do governo brasileiro (NF Paulista), para consultar um resultado de sorteio, e eis que aparece uma nova pérola, um erro sem tratamento no momento em que seleciono os meus sorteios antigos (2009/2008). Pelo menos gostei de uma coisa no erro, eles estao usando o asp.net 4 :)..

Uma imagem vale mais que mil palavras, segue:

 

 

Senhores desenvolvedores, tenham mais cuidado 🙂

 

Até a proxima “pessoar”..

Categorias:Diversos

Um dia desses na internet..

23 de fevereiro de 2012 6 comentários

Bom, estava eu navegando em alguns sites de compras (não irei mencionar o nome por questão de ética) e me deparei com uma coisa no minima estranha :(, trata-se de um preço de computador NULL, enfim, vale mais uma imagem do que milhares de palavras. Não que eu goste de causar a desordem, mas é que não consegui comprar o produto, e infelizmente o comercio eletronico é o segmento da empresa 😦

Preço de computador NULL

Categorias:Diversos

Série EF : Utilizando POCO separação das entidades do Contexto (Parte 2)

22 de agosto de 2011 1 comentário

Continuando nossa série de artigos, confira aqui parte inicial

Introdução

O que é POCO?
POCO é o acrônimo de Plain Old CLR Object, e esta “técnica” se deriva do POJO, ambas permitem que você escreva sua própria classe de entidade de forma ignorante a persistência de dados, ou seja, você cria sua classe sem nenhuma herança ou implementação de contrato de dados (objetos chamados de estrutura simples), e esta classe é utilizada em ferramentas ORM para persistir os dados em um repositório.

Em resumo o que iremos fazer neste exemplo é criar um projeto chamado entidades, onde este irá conter todas nossas classes de entidades (PESSOA e PROFESSOR) e em outro projeto vamos criar a infra para persistência usando uma ferramenta ORM (Entity Framework), ela receberá as nossas entidades e persistir em um banco de dados SQL Server. A ideia do artigo é mostrar como é simples usar o POCO para separar fisicamente as funcionalidades da solução.

Criando a Solução

Para nosso exemplo utilizaremos uma solução do Visual Studio contendo três projetos, sendo eles:

Nome Tipo projeto Descrição
NBSampleEF Console Application Projeto Front-End.
NBSampleEF.DAL Class Library Projeto que irá conter o ObjectContext, responsável por persistir os objetos no banco de dados.
NBSampleEF.Entities Class Library Projeto que irá conter as entidades de nossa solução.

Criando as entidades

Abra o projeto NBSampleEF.Entities e crie duas classes para representar nossas entidades, importante que quando usamos o POCO temos algumas restrições, veja algumas delas:

  • O Nome da classe precisa ser o mesmo nome da entidade no EDM.
  • O Nome e os tipos das propriedades da classe precisam ser iguais aos da entidade no EDM.

Abaixo o código das classes de entidades:

Entidade ALUNO

namespace NBSampleEF.Entities
{
    publicclassAluno
    {
        publicint Id { get; set; }
        publicstring Nome { get; set; }
        publicint IdProfessor { get; set; }
        publicProfessor Professor { get; set; }
    }
}
Entidade PROFESSOR

using System.Collections.Generic;
namespace NBSampleEF.Entities
{
    publicclassProfessor
    {
        publicint Id { get; set; }
        publicstring Nome { get; set; }
        publicList<Aluno> Aluno { get; set; }
    }
}

 

Criando a estrutura de persistência de dados

No projeto NBSampleEF.DAL referencie o projeto de entidades através do Add-> References -> NBSample.Entities, posteriormente crie um arquivo do tipo Entity Data Model (.edmx) apontando para seu banco de dados, de o nome do .edmx como ArtigosEFSample. Seu projeto deverá ficar conforme a imagem abaixo:

2 overviewEFDALproject

 

Nota: Se você expandir o arquivo .edmx, irá ver que existe um arquivo abaixo dele chamado ArtigosEFSample.Designer.cs este arquivo contem as classes do ObjectContext e as classes de entidades mapeadas.

 

No solution explorer clique com o botão direito ArtigosEFSample.edmx e escolha a opção propriedades (F4). Na tela de propriedades limpe o conteúdo do Custom Tool (propriedade responsável por gerar os códigos automaticamente). Compile a aplicação e verá que nenhum arquivo de designer do ArtigosEFSample.edmx será gerado.

Com isso definimos a estrutura de acesso a dados sem gerar as entidades automaticamente, no entanto, agora se faz necessário criarmos uma classe de persistência de dados, para isso, crie uma nova classe chamada ArtigoObjectContext . Herde a ArtigoObjectContext da classe ObjectContext e modifique o construtor Default, conforme exemplo abaixo:

using System.Data.Objects;
namespace NBSampleEF.DAL
{
    classArtigoObjectContext : ObjectContext
    {
        public ArtigoObjectContext()
            : base(“name=ArtigoEFBlogEntities”, ArtigoEFBlogEntities”)  {        }

    }

}

 

Nota: Note que estamos herdando no construtor default o construtor da classe base, e neste passamos a connectionstring chamada artigoEFBlogEntities que se encontra no arquivo app.config. Este arquivo foi criado junto com a parametrização do Modelo.

 

Agora iremos criar nossos ObjectSet para efetuar as operações de CRUD nas entidades, para isso crie duas propriedades, sendo uma para cada entidade. E inicie ambas no construtor default da classe (criado anteriormente) através do método “base” CreateObjectSet.

using System.Data.Objects;
using NBSampleEF.Entities;

namespace NBSampleEF.DAL
{
    publicclassArtigoObjectContext : ObjectContext
    {
        public ArtigoObjectContext()

            : base(“name=ArtigoEFBlogEntities”, “ArtigoEFBlogEntities”)
        {
            alunos = CreateObjectSet<Aluno>();
            professores = CreateObjectSet<Professor();
        }
        publicObjectSet<Aluno> Alunos
        {
            get
            {
                return alunos;
            }
        }
privateObjectSet<Aluno> alunos;
publicObjectSet<Professor> Professores
        {
            get
            {
                return professores;
            }
        }
        privateObjectSet<Professor> professores;
    }
}
Nota: O ObjectSet<T> é uma especialização do ObjectQuery<T> que foi introduzido no EF 4.0

 

Persistindo as entidades no repositório

No projeto NBSampleEF referencie o projeto de entidades através do Add-> References -> NBSample.Entities faça o mesmo para o projeto de acesso a dados, use o Add ->References -> NBSample.DAL, posteriormente copie a connectionstring do arquivo app.config (NBSample.DAL ) para dentro do arquivo de configuração do projeto NBSampleEF, o arquivo app.config do NBSampleEF deverá ficar conforme abaixo:

<?xmlversion=“1.0“encoding=“utf-8“?>
<configuration>
  <connectionStrings>
    <addname=“ArtigoEFBlogEntities“connectionString=“metadata=res://*/ArtigosEFSample.csdl|res://*/ArtigosEFSample.ssdl|res://*/ArtigosEFSample.msl;provider=System.Data.SqlClient;provider connection string=&quot;Data Source=.\sqlexpress;Initial Catalog=ArtigoEFBlog;Integrated Security=True;Pooling=False;MultipleActiveResultSets=True&quot;“providerName=“System.Data.EntityClient“ />
</connectionStrings>
</configuration>

 

Agora para efetuar os nossos testes, dentro do método Main (método de entrada da aplicação) iremos inserir o código para criar um aluno e um professor e persistir na base de dados e posteriormente iremos pesquisar o mesmo, veja abaixo:

staticvoid Main(string[] args)
        {

            NBSampleEF.DAL.ArtigoObjectContext context = new DAL.ArtigoObjectContext();

            using (context)
            {
                //Criando um novo objeto do tipo professor.
NBSampleEF.Entities.Professor novoProfessor = new Entities.Professor();
                novoProfessor.Id = 1;
                novoProfessor.Nome = “Michel Habber”;
                //Inserindo o objeto professor no repositorio.
                context.Professores.AddObject(novoProfessor);
                context.SaveChanges();

//Criando um novo objeto do tipo aluno.
                NBSampleEF.Entities.Aluno novoAluno = new Entities.Aluno();
                novoAluno.Id = 1;
                novoAluno.Nome = “Joaozinho”;

                novoAluno.Professor = novoProfessor

//Inserindo o objeto aluno no repositorio.
                context.Alunos.AddObject(novoAluno);
                context.SaveChanges(); 

                //Pesquisando as entidades.
                var query = from entity in context.Alunos
                            where entity.Id >= 1
                            select entity;

                foreach (var entity in query)
                {
                    Console.WriteLine(“Id: {0}, Nome: {1}”, entity.Id, entity.Nome);
                }
                Console.Read();
            }
        }

 

Execute o programa, na tela de console deverá aparecer o seguinte resultado:

3 prompt

 

 

Com o poco é possível ter seu modelo de entidade e automatizar o CRUD usando o ObjectContext, é importante saber que também existem outras soluções quando falamos de separação física de entidades e repositórios.

Aguarde o proximo post.. tem mais.

 

[]´s

Nelson Borges
**Ao infinito e além **

Categorias:Ado.Net

Série EF : Utilizando POCO separação das entidades do Contexto (Parte 1)

21 de agosto de 2011 Deixe um comentário

Neste mês irei lançar aqui no Blog uma série de artigos falando sobre o Entity Framework, eu já havia falado sobre ele em alguns post´s anteriores. No entanto irei focar agora em soluções para o .net Framework 4.0, abaixo uma visão dos tópicos que irei abordar:

Utilizando POCO
CRUD Genérico
Como melhorar a performance do EF
WCF Data Services com EF

Para iniciar nossa série, segue o primeiro artigo onde irei falar sobre como utilizar POCO com EF, para elaboração dos artigos criei um banco de dados simples com duas tabelas, sendo Aluno e Professor.

Estrutura do banco de dados para exemplo

Conforme mencionado acima, para acompanhar este e os próximos exemplos é necessário possuir esta estrutura de banco de dados, pois será em cima desta que iremos fazer os códigos e mapeamentos. O banco de dados contem duas tabelas, sendo Professor e Aluno, veja abaixo:

1 bdoverview

Caso queira criar esta estrutura, segue o script que esta apontando para uma base de teste chamada “ArtigoEFBlog” (fique a vontade para mudar o nome).

— ————————————————–

— Entity Designer DDL Script for SQL Server 2005, 2008, and Azure
— ————————————————–— Date Created: 08/08/2011 11:41:21
— Generated from EDMX file–
————————————————– 

SETQUOTED_IDENTIFIEROFF;
GO
USE[ArtigoEFBlog];
GO
IFSCHEMA_ID(N’dbo’)ISNULLEXECUTE(N’CREATE SCHEMA [dbo]’);
GO
— ————————————————–
— Dropping existing FOREIGN KEY constraints
— ————————————————–

IFOBJECT_ID(N'[dbo].[FK_Aluno_Professor]’,‘F’)ISNOTNULL

    ALTERTABLE[dbo].[Aluno]DROPCONSTRAINT[FK_Aluno_Professor];
GO
— ————————————————–— Dropping existing tables
— ————————————————–

IFOBJECT_ID(N'[dbo].[Aluno]’,‘U’)ISNOTNULL
    DROPTABLE[dbo].[Aluno];
GO
IFOBJECT_ID(N'[dbo].[Professor]’,‘U’)ISNOTNUL
DROPTABLE[dbo].[Professor];
GO
— ————————————————–— Creating all tables
— ————————————————–
— Creating table ‘Aluno’

CREATETABLE[dbo].[Aluno](
    [Id]int  NOTNULL,
    [Nome]nchar(10)  NOTNULL,
    [IdProfessor]int  NOTNULL
);
GO 

— Creating table ‘Professor’
CREATETABLE[dbo].[Professor](
    [Id]int  NOTNULL,
    [Nome]varchar(100)  NOTNULL
);
GO
—————————————————-
— Creating all PRIMARY KEY constraints
— ————————————————–

— Creating primary key on [Id] in table ‘Aluno’
ALTERTABLE[dbo].[Aluno]
ADDCONSTRAINT[PK_Aluno]
    PRIMARYKEYCLUSTERED ([Id]ASC);
GO 

— Creating primary key on [Id] in table ‘Professor’
ALTERTABLE[dbo].[Professor]
ADDCONSTRAINT[PK_Professor]
    PRIMARYKEYCLUSTERED ([Id]ASC);
GO
— ————————————————–
— Creating all FOREIGN KEY constraints
— ————————————————–— Creating foreign key on [IdProfessor] in table ‘Aluno’

ALTERTABLE[dbo].[Aluno]
ADDCONSTRAINT[FK_Aluno_Professor]
    FOREIGNKEY ([IdProfessor])
    REFERENCES[dbo].[Professor]
        ([Id])
    ONDELETENOACTIONONUPDATENOACTION;

— Creating non-clustered index for FOREIGN KEY ‘FK_Aluno_Professor’

CREATEINDEX[IX_FK_Aluno_Professor]
ON[dbo].[Aluno]
    ([IdProfessor]);
GO

— ————————————————–
— Script has ended
— ————————————————–
Obs.: Eu gerei este script através da própria opção do EF, para fazer isso acesse seu modelo (.edmx) clique com o botão direito em alguma área em branco e escolha a opção Generate Database from Model, posteriormente siga o wizard, esta opção se deve ao modo de Model-First na versão 4.0.

Introdução

O que é POCO?
POCO é o acrônimo de Plain Old CLR Object, e esta “técnica” se deriva do POJO, 0ambas permitem que você escreva sua própria classe de entidade de forma ignorante a persistência de dados, ou seja, você cria sua classe sem nenhuma herança ou implementação de contrato de dados (objetos chamados de entidades simples), e esta classe é utilizada em ferramentas ORM para persistir os dados em um repositório.

Em resumo o que iremos fazer neste exemplo é criar um projeto chamado entidades, onde este irá conter todas nossas classes de entidades (PESSOA e PROFESSOR) e em outro projeto vamos criar a infra para persistência usando uma ferramenta ORM (Entity Framework), ela receberá as nossas entidades e deverá persistir as mesmas em um banco de dados SQL Server. A ideia do artigo é mostrar como é simples usar o POCO para separar fisicamente as funcionalidades da solução.

Existe duas formas de se trabalahar com POCO & Entity Framework, a forma com e sem Proxy, abaixo entenderemos ambas.

Criando a Solução

Para nosso exemplo utilizaremos uma solução do Visual Studio contendo três projetos, sendo eles:

Nome Tipo projeto Descrição
NBSampleEF Console Application Projeto Front-End.
NBSampleEF.DAL Class Library Projeto que irá conter o ObjectContext, responsável por persistir os objetos no banco de dados.
NBSampleEF.Entities Class Library Projeto que irá conter as entidades de nossa solução.


Criando as entidades

Abra o projeto NBSampleEF.Entities e crie duas classes para representar nossas entidades, importante que quando usamos o POCO temos algumas restrições, veja algumas delas:

  • O Nome da classe precisa ser o mesmo nome da entidade no EDM.
  • O Nome e os tipos das propriedades da classe precisam ser iguais aos da entidade no EDM.
    Abaixo o código das classes de entidades:
Entidade Aluno

namespace NBSampleEF.Entities
{
    publicclassAluno
    {
        publicint Id { get; set; }
        publicstring Nome { get; set; }
        publicint IdProfessor { get; set; }
        publicProfessor Professor { get; set; }
    }
}
Entidade Professor

using System.Collections.Generic;
namespace NBSampleEF.Entities
{
    publicclassProfessor
    {
        publicint Id { get; set; }
        publicstring Nome { get; set; }
        publicList<Aluno> Aluno { get; set; }
    }
}

Criando a estrutura de persistência de dados

No projeto NBSampleEF.DAL referencie o projeto de entidades através do Add-> References -> NBSample.Entities, posteriormente crie um arquivo do tipo Entity Data Model (.edmx) apontando para seu banco de dados, de o nome do .edmx como ArtigosEFSample. Seu projeto deverá ficar conforme a imagem abaixo:

2 overviewEFDALproject

Nota: Se você expandir o arquivo .edmx, irá ver que
existe um arquivo abaixo dele chamado ArtigosEFSample.Designer.cs este
arquivo contem as classes do ObjectContext e as classes de
entidades mapeadas.

No solution explorer clique com o botão direito ArtigosEFSample.edmx e escolha a opção propriedades (F4). Na tela de propriedades limpe o conteúdo do Custom Tool (propriedade responsável por gerar os códigos automaticamente). Compile a aplicação e verá que nenhum arquivo de designer do ArtigosEFSample.edmx será gerado.

Com isso definimos a estrutura de acesso a dados sem gerar as entidades automaticamente, no entanto, agora se faz necessário criarmos uma classe de persistência de dados, para isso, crie uma nova classe chamada ArtigoObjectContext . Herde a ArtigoObjectContext da classe ObjectContext e modifique o construtor Default, conforme exemplo abaixo:

using System.Data.Objects;
namespace NBSampleEF.DAL
{
    classArtigoObjectContext : ObjectContext
    {
        public ArtigoObjectContext()
            : base(“name=ArtigoEFBlogEntities”, “ArtigoEFBlogEntities”)
        {        }
    }
}
Nota: Note que estamos herdando no construtor default o construtor da classe base, e neste passamos a connectionstring chamada artigoEFBlogEntities que se encontra no arquivo app.config. Este arquivo foi criado junto com a parametrização do Modelo.

Na próxima parte criaremos os objectSet para cada uma das entidades, isso irá facilitar a navegação dos objetos e a persistencia do mesmo no repositório.

Até a próxima,

Nelson Borges

Categorias:Ado.Net

Melhorando a performance dos Serviços WCF

19 de agosto de 2011 Deixe um comentário

O WCF é a plataforma unificada de serviço da Microsoft .Net, e é a tecnologia adotada na criação e disponibilização de serviços. Eu já escrevi algumas coisas a respeito do mesmo, veja abaixo:

 E hoje nosso foco será entender um pouco de como melhorar a performance do WCF usando as configurações da própria tecnologia:

Concorrência e Instanciação:
O WCF disponibiliza algumas configurações que visam aumentar o rendimento dos serviços e o gerenciamento de memória, iremos ver aqui algumas delas:

InstanceMode: Após a requisição do cliente chegar no serviço, o mesmo poderá ter comportamentos diferentes na instanciação dos objetos dependentes na conversa (Request/Response) com o cliente. O WCF permite configurar a instanciação do serviço de 3 formas, sendo:

  • Modo de instanciação por chamada (Per-Call)
  • Modo de instanciação por Sessão (Per-Session)
  • Modo de instanciação Singleton (Per-Single).

Veja abaixo mais detalhes sobre cada um dos modos de instanciação:

Per-Session: Comportamento default dos serviços, ou seja, quando não há explicitamente um modo de instanciação definido. Uma instancia (criação de objetos) é criado na primeira requisição do cliente, e esses objetos são mantidos enquanto o cliente se comunica com as “N” operações do serviço.

Na imagem acima o Cliente B esta configurado com o  instanceMode Per-Session, enquanto os demais não, veja que ele possui uma instancia exclusiva para ele (instance 2) enquanto os demais compartilham a mesma instancia. A instance 2 irá durar enquanto a sessão do cliente estiver ativa, este comportamento é muito parecido com o objeto Session do Asp.Net.

Exemplo de implementação:

 [ServiceBehavior(InstanceContextMode=InstanceContextMode.PerSession)]
public class Service1 : IService

 Per-Call: Indica que cada cliente que solicita o serviço terá seu próprio contexto (operationContext), independente se for a primeira ou a segunda vez que o cliente executa a operação do serviço.

Na imagem acima para cada requisição efetuada ao serviço um novo contexto de objetos é criado e posteriormente liberado no final da requisição, deduz que teremos um aumento no processamento e uma variação nos objetos alocados em memória.

Exemplo de implementação:

 [ServiceBehavior(InstanceContextMode=InstanceContextMode.PerCall)]
public class Service1 : IService1

 Per-Single: Neste cenário, uma única instancia (criação dos objetos) será criado, e esta instancia atenderá todas as requisições lembrando muito o pattern Singleton.

Repare na imagem acima que uma única instancia foi criada e a mesma atende tanto a primeira requisição do cliente A, quanto as demais requisições (cliente B).

 Exemplo de implementação:

 [ServiceBehavior(InstanceContextMode=InstanceContextMode.Single)]
public class Service1 : IService1

ConcurrencyMode: Indica quais tipos de concorrência o serviço irá suportar,  ou seja, ao receber a requisição, o serviço deverá suportar o uso de paralelismo ou não para processar a requisição e devolver a resposta. O WCF suporta 3 configurações no comportamento do serviço (ServiceBehavior), são elas:

  • Modo de concorrência Single: Comportamento padrão do WCF quando um ConcurrencyMode não foi configurado, esta configuração indica que apenas uma thread por instancia do serviço, com esta configuração não é necessário efetuar nenhuma thread safety.
  • Modo de concorrência Reentrant: Indica que uma única thread pode chamar o serviço, no entanto, se esta thread estiver invocando outro serviço ou callback, o serviço poderá suportar outras threads.
  • Modo de concorrência Multiple: Indica que mais de uma thread pode chamar o serviço (paralelo).

 Configuração de Throttling no web.config: Por default o Service Host do WCF controla automaticamente as instancias possíveis para processar as solicitações do serviço. Em termos de perfomance é interessante deixar os valores default, uma vez que ele escala automaticamente a necessidade do servidor não forçando um estouro de memória ou de CPU no mesmo. Porém caso os valore default não te atendam você poderá altera-los de acordo com sua necessidade, apenas como uma recomendação é interessante considerar a capacidade do servidor em que a aplicação ficará hospedada antes de alterar o throttling do WCF.

 O WCF permite a alteração através de uma configuração chamada ServiceThrottling que contêm:

MaxConcurrentInstances – Controla as instancias que podem ser criadas pelo serviço, o valor default é o valor máximo do System.Int32 (int.MaxValue).

MaxConcurrentCall – Define o numero máximo de mensagens que podem ser encaminhadas ao serviço. A recomendação é o valor de 16 vezes o numero de processador da máquina.

MaxConcurrentSession: Usado para controlar o numero de sessões ativas no serviceHost, especialmente no uso de InstaceMode Per-Session.  A recomendação é 16 vezes o numero de processador da máquina que esta hospedando o serviço. Se qualquer uma destas definições de limite for atingido, não há nenhuma nova instancia/ thread/criação de sessão até que o anterior seja destruído.

 Exemplo de configuração no web.config:

            <serviceBehaviors>
                <behavior name=”MyService”>
                    <serviceMetadata
                      httpGetEnabled=”true”
                      httpGetUrl=”http://localhost:8000/MyService&#8221; />
                    <serviceDebug includeExceptionDetailInFaults=”true” />
                    <serviceThrottling
                      maxConcurrentCalls=”16″
                      maxConcurrentInstances=”26″
                      maxConcurrentSessions=”10″/>
                </behavior>
            </serviceBehaviors>

Mais referencias:

http://msdn.microsoft.com/en-us/library/ee377061(v=bts.10).aspx
http://blogs.msdn.com/b/wenlong/archive/2008/08/13/orcas-sp1-improvement-asynchronous-wcf-http-module-handler-for-iis7-for-better-server-scalability

 

Categorias:WCF

WCF – Interop

8 de agosto de 2011 Deixe um comentário

Como sabem o WCF é uma das tecnologias que mais me fascina no ponto de vista de desenvolvedor. E quando acho que já não tem mais o que fazer, a MS e/ou Comunidade sempre estão lançados mais features do mesmo. Eu já falei no blog sobre o Router Services, e os beneficios dele para ambientes enterprise (ainda mais se hospedado no IIS 7.0 com WAS e AppFabric), se falarmos da questão de centralização e gerenciamento dos serviços da empresa.

Sim, eu concordo o WCF não é um ESB nativo, mas por que não fazer um ESB com ele? Um ponto a se pensar, principalmente em empresas onde não temos ambientes homogêneos. Mas Nelson e se meu ambiente for heterogêneo? Como deixar essa interoperabilidade transparente com WCF?

Interoperabilidade (Oracle Weblogic, Oracle Metro, IBM WebSphere, Apache Axis2)

Quando pensamos em interoperabilidade, logo pensamos nos WS.*, pois foram feitos com o proposito de integrar soluções diferentes (wcf, jms e etc), mas esse tipo de interoperabilidade nem sempre é simples,  principalmente se falarmos de segurança, confiança, transação e encoding de diferentes tipos (text/mtom).

Por isso quero compartilhar com vocês, um projeto existente no codeplex que tem justamente o proposito de simplificar a criação de serviços WCF para integração com outras tecnologias visando segurança, confiança e etc, esse projeto chama-se WCF Express Interop Bindings

Quais tecnologias ele facilita a integração:

Oracle Metro (antigo projeto Tango)
Oracle WebLogic
IBM WebSphere (Application Server)
Apache Axis

O WCF Express Interop Bindings ao ser instalado habilita um template com Wizards que vai indicado as configurações necessárias para comunicação com plataformas diferentes, veja a imagem abaixo:

Veja aqui um passo a passo de como instalar e criar um projeto usando o WCF Express Interop.

Saiba mais: http://wcf.codeplex.com/releases/view/68276

Dica: Veja este artigo falando sobre interop .net x java, vale a pena: http://msdn.microsoft.com/en-us/netframework/gg413252

[]´s

Nelson Borges

Categorias:WCF

Tipos de dados .Net

4 de julho de 2011 Deixe um comentário

Havia prometido a alguns alunos, apesar de existir no MSDN e no ECMA, enfim, esta ai, pode ser util para alguém.

Nome Abreviado

 Classe .NET Type (Tipo) Width Range (BITS)
byte Byte Inteiro Não Assinado 8 0 to 255
sbyte SByte Inteiro Assinado 8 -128 to 127
int Int32 Inteiro Assinado 32 -2.147.483.648 to 2.147.483.647
uint UInt32 Inteiro Não Assinado 32 0 to 4294967295
short Int16 Inteiro Assinado 16 -32.768 to 32.767
ushort UInt16 Inteiro Não Assinado 16 0 to 65535
long Int64 Inteiro Assinado 64 -922337203685477508 to 922337203685477507
ulong UInt64 Inteiro Não Assinado 64 0 to 18446744073709551615
float Single Tipo ponto flutuante Simples-Precisão 32 -3.402823E38 para 3.402823E38
double Double Tipo ponto flutuante Dupla-Precisão 64 -1.79769313486232e308 para 1.79769313486232e308
char Char Caracter simples –  Unicode 16 Símbolos Unicode Used in Texto
bool Boolean Booleano 8 Verdadeiro or false
object Object Base de todos outros tipos    
string String Uma seqüência de caracteres    
decimal Decimal Preciso fracionário ou tipo integral que possa representar decimal números com 29 dígitos significativos

128

 10e-28 × ±1.0 para 10e28 × ±7.9

Abs,

Categorias:C#

Microsoft Security Development LifeCycle

25 de maio de 2011 1 comentário

Em um processo de desenvolvimento de software se faz necessário à verificação da qualidade do mesmo, ou seja, garantir que seu código seja flexível, reutilizável, seguro e etc. Abaixo eu irei listar algumas ferramentas que podem ser uteis na implementação de um modelo seguro de software:

Antes de mostrar as ferramentas, compartilho uma imagem que demonstra a visão do MSDL (Microsoft Security Development LifeCycle) sobre o ciclo de desenvolvimento de um software seguro:

Code Analysis: Ferramenta de análise estática de código gerenciado que é integrado com o Visual Studio, ideal para verificar se o código esta dentro dos padrões dado um ou mais regras.

Para utilizar o Code Analysis no seu projeto (VS 2010 Ultimate):
1-    Solution Explorer do seu projeto, clique com o botão direito em cima do projeto e escolha Properties.
2-    Na propriedade escolha a aba Code Analysis.
3-    Especifique o tipo de Build (Debug/Release/etc) na opção Configuration.

4-    Marque a opção Enable Code Analisys on Build.
5-    Escolha a regra que deseja utilizar no campo Run This Rule Set

Nota: Como sugestão, você pode escolher a regra Microsoft Minimum Recommended Rules.
Mais referencias:
http://blogs.msdn.com/b/codeanalysis/archive/tags/code+analysis/
http://archive.msdn.microsoft.com/codeanalysis


Code Analisys Tool (CAT.NET): Ferramenta de linha de comando e/ou plugin do Visual Studio para ajudar a análise de falhas de segurança em aplicativos web e/ou em aplicativos compilados (assemblies).  O CAT pode ser utilizado no processo de implementação do desenvolvimento de sua aplicação, ou seja junto com as ferramentas de Code Analysus, Anti-XSS, FX Corp e etc.

Itens que o CAT ajuda a identificar: XSS, Sql Injection, Process Command Injection, File Canonicalization, Exception Information, Ldap Injection, Xpath Injection, Redirection to User Controlled Site.

Utilizando o CAT em seu projeto:
1-    Abra o prompt de comando do Visual Studio e navegue até a pasta de instalação do CAT.
2-    Digite o seguinte comando “CATNetCmd64.exe /file:”sua.dll” onde o File é sua DLL.

3-    Posteriormente você poderá visualizar o relatório gerado pelo CAT.


Mais referencias:
http://msdn.microsoft.com/en-us/security/Video/gg6750097

Anti-XSS: Uma biblioteca e um modulo HTTP que podem ser adicionados a aplicação web  para evitar ataques de Cross-Site-Scripting, que é a pratica de explorar vulnerabilidades em aplicativos baseados na WEB que não validam corretamente as entradas de usuário, permitindo aos usuários mal intencionados injetarem scripts do lado do cliente em dados de resposta do servidor de sua aplicação.

Para maiores detalhes veja:
http://msdn.microsoft.com/en-us/library/aa973813.aspx


Application Verifier: Ferramenta dinâmica que verifica vazamentos de memória e recursos. Pode ser usada com código não gerenciado (escrito fora da plataforma .Net).

Para utilizar esta ferramenta siga os passos:
1-    Instale a ferramenta em seu computador.
2-    Abra a interface do Application Verifier.


3-    No file aponte para o caminho de sua aplicação.
4-    Clique em Save.
5-    Clique com o botão direito em cima de sua aplicação na área Applications.
6-    Escolha a opção Run Test.

Saiba mais:
http://msdn.microsoft.com/pt-br/library/ms220948(v=vs.90).aspx
http://technet.microsoft.com/en-us/library/bb457063.aspx

 PreFast:  Ferramenta de análise estática de código C++ que é utilizado através de linha de comando.
Mais: http://msdn.microsoft.com/en-us/library/aa449786.aspx


Safe CRT Libraries: Uma biblioteca de Runtime de C/C++ mais segura que foi incluída no Visual Studio 2005.
Veja mais: http://msdn.microsoft.com/pt-br/magazine/cc163794(en-us).aspx

Mais sobre segurança:
Microsoft Development Security LifeCycle:
http://www.microsoft.com/security/sdl/default.aspx
Developer Center (Segurança):
http://msdn.microsoft.com/pt-br/security/bb896640
Videos sobre Developer Center:
http://msdn.microsoft.com/pt-br/security/Video/gg558144

Categorias:Segurança
Crie um site como este com o WordPress.com
Comece agora