Arquivos da categoria: .NET

#if(DEBUG) – Executando Windows Service pelo Visual Studio

Faz um tempo que eu venho desenvolvendo, eventualmente, Windows Services para fazer processamentos esporádicos, para requisições assíncronas e tal.
Eu acho legal Windows Service, para caralho, é muito util. Mas tem uma coisa que realmente me deixa #chatiada: executá-lo no Visual Studio. Não dá.
Ontem precisei criar um Windows Service, com um timer que disparava um eventindo para chamar um serviço, simples como a vida. Queria executar para ver rolando, pesquisei um pouco e se liga nisso…

Essa é a classe do serviço, parecida com a que eu tenho, perceba que meu OnStart chama um método publico da classe, onde inicia o timer e seta o evento quando o intervalo for atingido.

public partial class ServiceOfDeath : ServiceBase
{
	System.Timers.Timer aTimer;
 
	public ServiceOfDeath()
	{
		InitializeComponent();
	}
 
	protected override void OnStart(string[] args)
	{
		IniciarTimer();
	}
 
	public void IniciarTimer()
	{
		aTimer = new System.Timers.Timer(Convert.ToInt32(ConfigurationManager.AppSettings["MilisegundosDeIntervalo"]));
		aTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent);
		aTimer.Start();
	}
 
	private void OnTimedEvent(object sender, ElapsedEventArgs e)
	{
		aTimer.Stop();
		new Liquidificador().Misturar();
		aTimer.Start();
	}
 
	protected override void OnStop()
	{
		aTimer.Stop();
	}
}

Daí na classe que é executada quando a aplicação é executada (Program.cs), fazemos o seguinte.

static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        static void Main()
        {
            #if (!DEBUG)
                ServiceBase[] ServicesToRun;
                ServicesToRun = new ServiceBase[] 
                { 
                    new ServiceOfDeath() 
                };
                ServiceBase.Run(ServicesToRun);
            #else
                ServiceOfDeath servicoDaMorte = new ServiceOfDeath();
                servicoDaMorte .IniciarTimer();
                //Thread eterna
                System.Threading.Thread.Sleep(System.Threading.Timeout.Infinite);
            #endif
        }
    }

Ou seja, o #if(DEBUG) serve para o Visual Studio interpretar aquele código somente quando estiver em modo debug (não acredito que ainda não conhecia isso), dá um mundinho de possibilidades aí para quem quer debugar alguma coisa que o VS não executa. Acho melhor que ficar attachando processo, que é chatissimo.

Anotem essa para quando estiverem com um código macarronico em mãos! rs

soapUI (ou xml string): como enviar valor nulo?

Acrescente no seu cabeçalho:

xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xmlns:xsd=”http://www.w3.org/2001/XMLSchema”

e na sua tag:

xsi:nil=”true”

E está prontim prontim.

<soapenv:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:tem="http://tempuri.org/" xmlns:privado="http://schemas.datacontract.org/2004/07/PRIVADA">
   <soapenv:Header xsi:nil="true"/>
   <soapenv:Body>
      <tem:Churros>
         <tem:Recheio>
            <privado:Cor xsi:nil="true"/>
         </tem:Recheio>
      </tem:Churros>
   </soapenv:Body>
</soapenv:Envelope>

WCF – Propriedade Specified e serialização

Eu não sou expert em WCF, mas já mexi até que bastante com ele.
Tem uns negocio de serialização dele que se você deixar default o capeta incorpora e você perde o controle.

Eu utilizo o DataContract nos contratos dos serviços para a serialização por simplesmente a lista de tipos suportados ser maior que a do XmlSerializerFormat.

Aí o problema (?) que eu sempre tenho consumindo o serviço de terceiros é: eu adiciono a service reference e vem aqueles mil campos specified para eu setar se eu alterei uma propriedade ou não. Desagradável demais.
Isso acontece porque tem alguns tipos de dados que tem o valor default e coisa e tal, daí para a serialização saber que não é um valor default e que foi setado, é baseado nessa propriedade specified. Corrijam-me se eu estiver falando caquinha.
Setando o DataMember como IsRequired obrigatoriamente o valor sempre tem que vir, então não tem mais a opção de não ter valor setado e o specified morre. Não vejo nenhum problema, inicialmente, em utiliza-lo já que você ainda pode usar o System.Nullable.

[DataContract]
public class Cachorro
{
	[DataMember]
	public string Nome { get; set; }
 
	[DataMember(IsRequired = true)]
	public int? QuantidadeDeFilhotes { get; set; }
}

Usem-o! E facilite a vida do carinha que tá integrando no seu bendito serviço!

Razor Helper – Menu dinâmico

O que falar do Razor que eu já considero tanto? rs
MVC é coisa linda demais, incrivelmente mais limpo, prático, rápido, etc etc. Não sei nem porque a Microsoft não já matou o WebForms.

Mas então.. estava montando um menuzinho dinâmico aqui de possíveis N gerações (?).
Mandei um helper para fazer o loop ad æternum, se liga só:

@helper MontarMenu(List<Menu> menus)
{
    foreach (Menu item in menus)
    {
        <li>
            <a href="item.Url">
                @item.Descricao
            </a>
 
            @if (item.Filhos != null && item.Filhos.Count > 0)
            {
                <ul>
                    @MontarMenu(item.Filhos)
                </ul>
            }
        </li>        
      }
}

Para chamar o lindão:

<div id="menucontainer">
	<ul id="menu">
		@if (ViewBag.Menu() != null && ViewBag.Menu().Count > 0)
		{
			@:@MontarMenu(ViewBag.Menu())
		}
	</ul>
</div>

Simples como a vida tem quer ser.
Amem.

E larguem o WebForms! :~

Could not load file or assembly ‘DotNetOpenAuth.Core’

Delicias a parte <3, estamos começando o ano com bug! Criei um projeto C# e depois transformei ele em MVC, fazer aquelas referencias na mão é hard. Fiquei com um erro chatão que não é nem um pouco auto explicável. O bendito era:
“Could not load file or assembly ‘DotNetOpenAuth.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=2780ccd10d57b246’ or one of its dependencies. The located assembly’s manifest definition does not match the assembly reference. (Exception from HRESULT: 0x80131040)”

Para resolve-lo basta checkar o Copy Local como true na referencia do MVC.

Problema resolvido e happy new year!

AutoMapper – mapeamento chato de objetos

Sabe quando voce tem aquelas quase replicas de classes? Aquele contratinho semi igual a uma classe sua de dominio? Nao deixe de cria-lo por preguica de mapea-los, expor seu objeto de negocio é coisa do capeta.

Ou quando temos um objeto de um legado que muda apenas uma propriedade. Olha esse codigo:

public class ClasseVelha
{
	public decimal Valor { get; set; }
}
 
public class ClasseJuvenil
{
	public int Id { get; set; }
	public decimal Valor { get; set; }
}
 
public ClasseJuvenil Mapear(ClasseVelha velhaco)
{
	AutoMapper.CreateMap<ClasseVelha, ClasseJuvenil>()
			.ForMember(dest => dest.Id, opt => opt.Ignore());
 
	return Mapper.Map<ClasseVelha, ClasseJuvenil>(velhaco);
}

Obs. O codigo acima foi criado no notepad++ e pode conter erros, rs.

O AutoMapper faz todo o trabalho sujo pra gente, e ainda com essa sintaxe lindona. Tem bastante exemplo no GitHub.

Sejam felizes! 🙂

Pingado – Monitoramento de webservices

SOA! Ando respirando isso, ai ai. Lembro a 2 anos atras quando eu queria pq queria viver isso day-by-day … Demorou, mas estou aqui, ein? Hehehehe. E ainda bem que demorou, hoje entendo a maturidade que um dev precisa ter para levar um projeto bacana nessa arquitetura .. seguimos aprendendo! But let’s go 🙂

A vida não é só flores e amor, preciso medir a disponibilidade de um projeto … preciso de alertas para manter essa disponibilidade caso ela esteja em risco. Como tudo é serviço, uma das maneiras que pensei em manter o espirito de escoteiro (SEMPRE ALERTA!) é pingando os benditos! Incrivelmente não achei nada free para fazer isso, estou cheia de coisas para testar (windows 8, visual studio 2012, github, frameworks, etc.) entao resolvi dar um start nisso. Vamos ver até onde vou!

FIRST STEP, instalar esse ambiente que quero testar.

Windows 8 tá muito rápido e a usabilidade dele tá maneira. É meio chato de inicio porque já estamos no modo automatico com a barra de inicialização e tal, mas uma semaninha usando como usuario n00b e já estou bem familiarizada. Ele é bonitão e não achei nada contra ainda além de ter que ter conta na live. Bug todo mundo tem então … pls, don’t tell me that gave a blue screen.

http://www.reddit.com/r/windows8/comments/1d3dok/why_dont_people_like_windows_8/
http://www.techradar.com/reviews/pc-mac/software/operating-systems/windows-8-1093002/review
http://www.reddit.com/r/windows8/comments/168ybd/windows_8_is_a_fantastic_os_why_do_so_many_people/

Visual Studio 2012: IDE mais sensacional não ha! Acho que é ela quem mantém meu relacionamento sério com o .NET. Dá um look http://msdn.microsoft.com/en-us/library/vstudio/bb386063.aspx.

Cadastrinho maroto no Github. Eu havia feito um teste já acompanhando o curso da Code School: Try Git. Recomendo, é free e objetivo.

Instalei também o plugin para o VS.

E claro, meu tema preferido do VS. Aqui tem mais: http://studiostyl.es/.

Ambiente semi pronto, proximo post tem codigo com farinha.

Deadlock usando TransactionScope

“Transaction (Process ID 666) was deadlocked on lock resources with another process and has been chosen as the deadlock victim. Rerun the transaction.”

Ainda no projeto utilizando SOA, fase de teste de performance, eu obtive um problema cabalistico onde, se um consumidor pedisse muita informação, o que ocorre, o tempo de resposta aumentaria exponencialmente. No fim de simulaçoes para carai, a solução foi paralelizar o processamento (beijo parallel.foreach).
Feito alguns stress, comecou a acontecer o erro que inicia o artigo: DREADLOCK!

Quando eu estava inserindo um registro em uma tabela, outro serviço nao conseguia dar um select na mesma, cheirava a lock de tabela.
Solução? (apos um tico de sofrimento)

SNAPSHOT ISOLATION LEVEL no TrasactionScope!

TransactionOptions options = new TransactionOptions();
options.IsolationLevel = IsolationLevel.Snapshot;
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, options))
{
}

Como o registro que eu estava inserindo NUNCA seria selecionado ao mesmo tempo, leriamos apenas registros antes dele. A isolacao da tabela enquanto estou executando esta transacao é feita deixando para leitura uma snapshot antes do insert. Magnifico nao?

E aproveitando o momento SQL supremo, agreguem esse blog ai no feed que é vida: http://www.brentozar.com/blog.

Enjoy!

Consumindo webservice com basic autenthication – WCF

Nunca tinha feito isso na minha vida, WCF tem mais configuração do que há dados no Google, potaqueparola.
Estou consumindo um webservice externo onde foi descrito que precisavamos enviar a cada chamada o header de autenticação básica com usuario e senha em Base 64, e esses dados deveriam ser concatenados separados por :.
Ou seja:

Usuario: teste
Senha: 123123

Concatenado: teste:123123
Criptografado: dGVzdGU6MTIzMTIz (by http://ostermiller.org/calc/encode.html)

E o header: Authorization: Basic dGVzdGU6MTIzMTIz

Acontece que isso é autenticação padrão em serviços, ou sejammmm, para usar isso no WCF precisamos apenas configurar o binding do client para o modo de segurança necessaria (varia de acordo com o serviço, claro), no meu caso , Transport e o tipo de credencial básica (Basic authentication, hãm hãm):

<basicHttpBinding>
	<binding name="meuBindingLindao">
	  <security mode="Transport">
		<transport clientCredentialType="Basic" />
	  </security>
	</binding>
</basicHttpBinding>

E setar o usuario e senha na chamada:

WebServiceClient cliente= new WebServiceClient();
cliente.ClientCredentials.UserName.UserName = "usuario";
cliente.ClientCredentials.UserName.Password = "senha";

Mais moleza que isso só .. sei la. Away!

WCF com .config comunitário – Configuração de hosteamento

Estou com um projeto orientado a infinitos serviços, claro que fizemos as configurações do WCF em granularidade, deixando os bindings e behaviors num .config partilhado entre todos (teoricamente como eles conversam entre si, as configurações são as mesmas).

Acontece que começou a estourar o buffer, sendo que todos estavam consumindo pelo mesma configuração de binding. Notei então que os expositores de serviço estavam hosteados com binding “padrões” aqueles sem nomes. Ou seja:

Não esqueça de configurar o binding default dos seus serviços expostos (caso esteja usando, claro). 🙂

<bindings>
			<basicHttpBinding>
				<binding closeTimeout="00:00:30" 
          openTimeout="00:00:30" receiveTimeout="00:00:30" sendTimeout="00:00:30" 
          allowCookies="false" bypassProxyOnLocal="false" hostNameComparisonMode="StrongWildcard" 
          maxBufferSize="2147483647" maxBufferPoolSize="524288" maxReceivedMessageSize="2147483647" 
          messageEncoding="Text" textEncoding="utf-8" transferMode="Buffered" 
          useDefaultWebProxy="true"> 
					<readerQuotas maxDepth="32" maxStringContentLength="2147483647" maxArrayLength="16384" 
            maxBytesPerRead="4096" maxNameTableCharCount="16384" /> 
					<security mode="None">
						<transport clientCredentialType="None" proxyCredentialType="None" realm="" />
						<message clientCredentialType="UserName" algorithmSuite="Default" />
					</security>
				</binding>
			</basicHttpBinding>
</bindings>