}

}

}

> Oi!

> Temos falado muito em testes e DI/IoC ultimamente, mas acabamos não
> vendo código. Pra resolver isso tenho um problema que estou
> enfrentando e queria os palpites de vocês.

> Tenho duas classes: GeradorPedidos e Precificador. Para gerar um
> pedido, minha classe precisa de uma instância de Precificador que é a
> responsável por fornecer os preços dos produtos. Algo assim:

> public class GeradorPedido
> {
>        private IPrecificador _precificador;
>        public GeradorPedido(IPrecificador _precificador)
>        {
>                _precificador = precificador;
>        }

>        public void GerarPedido(Pedido novoPedido)
>        {
>                var total = 0;
>                foreach(var item in novoPedido.Itens)
>                {
>                        total += _precificador.QuantoCusta(item);
>                }
>                //faz mais um monte de coisas
>        }
> }

> Esquema bem simples pra qualquer container de DI/IoC resolver. Peço
> pro meu container uma instância da classe GeradorPedido e
> automaticamente ele injeta uma nova instância da classe Precificador
> do jeitinho que eu esperava.

> Agora vem o problema...

> Aparece um novo requisito que diz que o preço deve variar de acordo
> com a loja, portanto Precificador depende agora também de loja:

> public class Precificador : IPrecificador
> {
>        private Loja _lojaFiltro;
>        public Precificador(Loja lojaFiltro)
>        {
>                _lojaFiltro = lojaFiltro;
>        }

>        public int QuantoCusta(Item itemAPrecificar)
>        {
>                //retorna o preço de acordo com a loja
>                if(_lojaFiltro.Codigo == 1)
>                        return 10;
>                else if(_lojaFiltro.Codigo == 2)
>                        return 20
>                else
>                        return 30;
>        }
> }

> No entanto, eu só vou descobrir este valor em runtime, logo não posso
> mais resolver essa dependência com container tão facilmente.

> Uma opção seria criar uma AbstractFactory e injeta-la no GeradorPedido
> que utilizaria a factory pra criar o Precificador passando o parametro
> recebido em runtime. O único problema disso é que dessa forma o
> GeradorPedido que não tem nada a ver com a história também vira
> dependente da Loja, pois ele deve recebe-la pra poder passar para
> factory.

> Alguma outra sugestão?

> --
> Você recebeu esta mensagem porque faz parte do grupo .Net Architects
> hospedado no Google Groups.
> Para postar envie uma mensagem para dotnetarchitects@googlegroups.com
> Para sair do grupo envie uma mensagem para
> dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com>
> Para mais opções visite o grupo em
> http://groups.google.com/group/dotnetarchitects?hl=pt-br

> Tuca,

> Se você trabalhasse com isso não no nível do GeradorDePedido, mas no nível
> da aplicação. A aplicação sabe qual a loja, cria então(ou obtém) um
> Precificador para esta loja, e passa o precificador para o Gerador.

> Na verdade acho que o Precificador nem deve conhecer a loja, mas talvez uma
> estratégia de preços por loja, algo assim.

> por exmeplo:

> //classe que coordena esse processo
> public void ExecutarTodoEsseProcesso(Loja lojaSelecionada)
> {
>    //interface que o precificador conhece
>    var estrategiaDePrecosPorLoja =
> FabricaDeEstrategiasDePreco(lojaSelecionada);

>    var precificador = new Precificador(estrategiaDePrecosPorLoja);

>    var geradorDePedido = new GeradorDePedido(precificador);

> }

> Assim você pode continuar usando o container para resolver o Gerador.

> abraços,

> *Vinicius Quaiato*http://viniciusquaiato.com

> Twitter <vquaiato>
> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> vinicius.quai...@gmail.com

> 2010/7/28 tucaz <tuca...@gmail.com>

> > Oi!

> > Temos falado muito em testes e DI/IoC ultimamente, mas acabamos não
> > vendo código. Pra resolver isso tenho um problema que estou
> > enfrentando e queria os palpites de vocês.

> > Tenho duas classes: GeradorPedidos e Precificador. Para gerar um
> > pedido, minha classe precisa de uma instância de Precificador que é a
> > responsável por fornecer os preços dos produtos. Algo assim:

> > public class GeradorPedido
> > {
> >        private IPrecificador _precificador;
> >        public GeradorPedido(IPrecificador _precificador)
> >        {
> >                _precificador = precificador;
> >        }

> >        public void GerarPedido(Pedido novoPedido)
> >        {
> >                var total = 0;
> >                foreach(var item in novoPedido.Itens)
> >                {
> >                        total += _precificador.QuantoCusta(item);
> >                }
> >                //faz mais um monte de coisas
> >        }
> > }

> > Esquema bem simples pra qualquer container de DI/IoC resolver. Peço
> > pro meu container uma instância da classe GeradorPedido e
> > automaticamente ele injeta uma nova instância da classe Precificador
> > do jeitinho que eu esperava.

> > Agora vem o problema...

> > Aparece um novo requisito que diz que o preço deve variar de acordo
> > com a loja, portanto Precificador depende agora também de loja:

> > public class Precificador : IPrecificador
> > {
> >        private Loja _lojaFiltro;
> >        public Precificador(Loja lojaFiltro)
> >        {
> >                _lojaFiltro = lojaFiltro;
> >        }

> >        public int QuantoCusta(Item itemAPrecificar)
> >        {
> >                //retorna o preço de acordo com a loja
> >                if(_lojaFiltro.Codigo == 1)
> >                        return 10;
> >                else if(_lojaFiltro.Codigo == 2)
> >                        return 20
> >                else
> >                        return 30;
> >        }
> > }

> > No entanto, eu só vou descobrir este valor em runtime, logo não posso
> > mais resolver essa dependência com container tão facilmente.

> > Uma opção seria criar uma AbstractFactory e injeta-la no GeradorPedido
> > que utilizaria a factory pra criar o Precificador passando o parametro
> > recebido em runtime. O único problema disso é que dessa forma o
> > GeradorPedido que não tem nada a ver com a história também vira
> > dependente da Loja, pois ele deve recebe-la pra poder passar para
> > factory.

> > Alguma outra sugestão?

> > --
> > Você recebeu esta mensagem porque faz parte do grupo .Net Architects
> > hospedado no Google Groups.
> > Para postar envie uma mensagem para dotnetarchitects@googlegroups.com
> > Para sair do grupo envie uma mensagem para
> > dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com>
> > Para mais opções visite o grupo em
> >http://groups.google.com/group/dotnetarchitects?hl=pt-br

> É esse o cenário mesmo Vinicius, mas não consigo ver uma forma de
> passar isso pro container. Seu exemplo não está cobrindo o uso do
> container.

> On Jul 28, 11:57 am, Vinicius Quaiato <vinicius.quai...@gmail.com>
> wrote:
> > Tuca,

> > Se você trabalhasse com isso não no nível do GeradorDePedido, mas no
> nível
> > da aplicação. A aplicação sabe qual a loja, cria então(ou obtém) um
> > Precificador para esta loja, e passa o precificador para o Gerador.

> > Na verdade acho que o Precificador nem deve conhecer a loja, mas talvez
> uma
> > estratégia de preços por loja, algo assim.

> > por exmeplo:

> > //classe que coordena esse processo
> > public void ExecutarTodoEsseProcesso(Loja lojaSelecionada)
> > {
> >    //interface que o precificador conhece
> >    var estrategiaDePrecosPorLoja =
> > FabricaDeEstrategiasDePreco(lojaSelecionada);

> >    var precificador = new Precificador(estrategiaDePrecosPorLoja);

> >    var geradorDePedido = new GeradorDePedido(precificador);

> > }

> > Assim você pode continuar usando o container para resolver o Gerador.

> > abraços,

> > *Vinicius Quaiato*http://viniciusquaiato.com

> > Twitter <vquaiato>
> > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > vinicius.quai...@gmail.com

> > 2010/7/28 tucaz <tuca...@gmail.com>

> > > Oi!

> > > Temos falado muito em testes e DI/IoC ultimamente, mas acabamos não
> > > vendo código. Pra resolver isso tenho um problema que estou
> > > enfrentando e queria os palpites de vocês.

> > > Tenho duas classes: GeradorPedidos e Precificador. Para gerar um
> > > pedido, minha classe precisa de uma instância de Precificador que é a
> > > responsável por fornecer os preços dos produtos. Algo assim:

> > > public class GeradorPedido
> > > {
> > >        private IPrecificador _precificador;
> > >        public GeradorPedido(IPrecificador _precificador)
> > >        {
> > >                _precificador = precificador;
> > >        }

> > >        public void GerarPedido(Pedido novoPedido)
> > >        {
> > >                var total = 0;
> > >                foreach(var item in novoPedido.Itens)
> > >                {
> > >                        total += _precificador.QuantoCusta(item);
> > >                }
> > >                //faz mais um monte de coisas
> > >        }
> > > }

> > > Esquema bem simples pra qualquer container de DI/IoC resolver. Peço
> > > pro meu container uma instância da classe GeradorPedido e
> > > automaticamente ele injeta uma nova instância da classe Precificador
> > > do jeitinho que eu esperava.

> > > Agora vem o problema...

> > > Aparece um novo requisito que diz que o preço deve variar de acordo
> > > com a loja, portanto Precificador depende agora também de loja:

> > > public class Precificador : IPrecificador
> > > {
> > >        private Loja _lojaFiltro;
> > >        public Precificador(Loja lojaFiltro)
> > >        {
> > >                _lojaFiltro = lojaFiltro;
> > >        }

> > >        public int QuantoCusta(Item itemAPrecificar)
> > >        {
> > >                //retorna o preço de acordo com a loja
> > >                if(_lojaFiltro.Codigo == 1)
> > >                        return 10;
> > >                else if(_lojaFiltro.Codigo == 2)
> > >                        return 20
> > >                else
> > >                        return 30;
> > >        }
> > > }

> > > No entanto, eu só vou descobrir este valor em runtime, logo não posso
> > > mais resolver essa dependência com container tão facilmente.

> > > Uma opção seria criar uma AbstractFactory e injeta-la no GeradorPedido
> > > que utilizaria a factory pra criar o Precificador passando o parametro
> > > recebido em runtime. O único problema disso é que dessa forma o
> > > GeradorPedido que não tem nada a ver com a história também vira
> > > dependente da Loja, pois ele deve recebe-la pra poder passar para
> > > factory.

> > > Alguma outra sugestão?

> > > --
> > > Você recebeu esta mensagem porque faz parte do grupo .Net Architects
> > > hospedado no Google Groups.
> > > Para postar envie uma mensagem para dotnetarchitects@googlegroups.com
> > > Para sair do grupo envie uma mensagem para
> > > dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com><dotnetarchitects%2Bunsubscrib
> e@googlegroups.com>
> > > Para mais opções visite o grupo em
> > >http://groups.google.com/group/dotnetarchitects?hl=pt-br

> --
> Você recebeu esta mensagem porque faz parte do grupo .Net Architects
> hospedado no Google Groups.
> Para postar envie uma mensagem para dotnetarchitects@googlegroups.com
> Para sair do grupo envie uma mensagem para
> dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com>
> Para mais opções visite o grupo em
> http://groups.google.com/group/dotnetarchitects?hl=pt-br

> É vdd...

> Mas, você precisa mesmo de um container nesse ponto específico? Pelo que
> vejo, o código está uando IoC e DI, só não está usando um container.

> Qual sua intenção em usar um container nesse caso?

> *Vinicius Quaiato*http://viniciusquaiato.com

> Twitter <vquaiato>
> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> vinicius.quai...@gmail.com

> 2010/7/28 tucaz <tuca...@gmail.com>

> > É esse o cenário mesmo Vinicius, mas não consigo ver uma forma de
> > passar isso pro container. Seu exemplo não está cobrindo o uso do
> > container.

> > On Jul 28, 11:57 am, Vinicius Quaiato <vinicius.quai...@gmail.com>
> > wrote:
> > > Tuca,

> > > Se você trabalhasse com isso não no nível do GeradorDePedido, mas no
> > nível
> > > da aplicação. A aplicação sabe qual a loja, cria então(ou obtém) um
> > > Precificador para esta loja, e passa o precificador para o Gerador.

> > > Na verdade acho que o Precificador nem deve conhecer a loja, mas talvez
> > uma
> > > estratégia de preços por loja, algo assim.

> > > por exmeplo:

> > > //classe que coordena esse processo
> > > public void ExecutarTodoEsseProcesso(Loja lojaSelecionada)
> > > {
> > >    //interface que o precificador conhece
> > >    var estrategiaDePrecosPorLoja =
> > > FabricaDeEstrategiasDePreco(lojaSelecionada);

> > >    var precificador = new Precificador(estrategiaDePrecosPorLoja);

> > >    var geradorDePedido = new GeradorDePedido(precificador);

> > > }

> > > Assim você pode continuar usando o container para resolver o Gerador.

> > > abraços,

> > > *Vinicius Quaiato*http://viniciusquaiato.com

> > > Twitter <vquaiato>
> > > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > > vinicius.quai...@gmail.com

> > > 2010/7/28 tucaz <tuca...@gmail.com>

> > > > Oi!

> > > > Temos falado muito em testes e DI/IoC ultimamente, mas acabamos não
> > > > vendo código. Pra resolver isso tenho um problema que estou
> > > > enfrentando e queria os palpites de vocês.

> > > > Tenho duas classes: GeradorPedidos e Precificador. Para gerar um
> > > > pedido, minha classe precisa de uma instância de Precificador que é a
> > > > responsável por fornecer os preços dos produtos. Algo assim:

> > > > public class GeradorPedido
> > > > {
> > > >        private IPrecificador _precificador;
> > > >        public GeradorPedido(IPrecificador _precificador)
> > > >        {
> > > >                _precificador = precificador;
> > > >        }

> > > >        public void GerarPedido(Pedido novoPedido)
> > > >        {
> > > >                var total = 0;
> > > >                foreach(var item in novoPedido.Itens)
> > > >                {
> > > >                        total += _precificador.QuantoCusta(item);
> > > >                }
> > > >                //faz mais um monte de coisas
> > > >        }
> > > > }

> > > > Esquema bem simples pra qualquer container de DI/IoC resolver. Peço
> > > > pro meu container uma instância da classe GeradorPedido e
> > > > automaticamente ele injeta uma nova instância da classe Precificador
> > > > do jeitinho que eu esperava.

> > > > Agora vem o problema...

> > > > Aparece um novo requisito que diz que o preço deve variar de acordo
> > > > com a loja, portanto Precificador depende agora também de loja:

> > > > public class Precificador : IPrecificador
> > > > {
> > > >        private Loja _lojaFiltro;
> > > >        public Precificador(Loja lojaFiltro)
> > > >        {
> > > >                _lojaFiltro = lojaFiltro;
> > > >        }

> > > >        public int QuantoCusta(Item itemAPrecificar)
> > > >        {
> > > >                //retorna o preço de acordo com a loja
> > > >                if(_lojaFiltro.Codigo == 1)
> > > >                        return 10;
> > > >                else if(_lojaFiltro.Codigo == 2)
> > > >                        return 20
> > > >                else
> > > >                        return 30;
> > > >        }
> > > > }

> > > > No entanto, eu só vou descobrir este valor em runtime, logo não posso
> > > > mais resolver essa dependência com container tão facilmente.

> > > > Uma opção seria criar uma AbstractFactory e injeta-la no GeradorPedido
> > > > que utilizaria a factory pra criar o Precificador passando o parametro
> > > > recebido em runtime. O único problema disso é que dessa forma o
> > > > GeradorPedido que não tem nada a ver com a história também vira
> > > > dependente da Loja, pois ele deve recebe-la pra poder passar para
> > > > factory.

> > > > Alguma outra sugestão?

> > > > --
> > > > Você recebeu esta mensagem porque faz parte do grupo .Net Architects
> > > > hospedado no Google Groups.
> > > > Para postar envie uma mensagem para dotnetarchitects@googlegroups.com
> > > > Para sair do grupo envie uma mensagem para
> > > > dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com><dotnetarchitects%2Bunsubscrib
> > e@googlegroups.com>
> > > > Para mais opções visite o grupo em
> > > >http://groups.google.com/group/dotnetarchitects?hl=pt-br

> > --
> > Você recebeu esta mensagem porque faz parte do grupo .Net Architects
> > hospedado no Google Groups.
> > Para postar envie uma mensagem para dotnetarchitects@googlegroups.com
> > Para sair do grupo envie uma mensagem para
> > dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com>
> > Para mais opções visite o grupo em
> >http://groups.google.com/group/dotnetarchitects?hl=pt-br

> O container já existe. Estou mexendo em um código que criei
> anteriormente e inclusive já existem alguns objetos que dependem de
> GeradorPedido e outros que também dependem de IPrecificador.

> A idéia de abstract factory é boa, mas traz a dependência pra todo
> mundo que consome IPrecificador. Outra alternativa seria fazer injeção
> por Property ou usar um método pra Inicializar a classe, mas não gosto
> muito dessa idéia.

> On Jul 28, 12:12 pm, Vinicius Quaiato <vinicius.quai...@gmail.com>
> wrote:
> > É vdd...

> > Mas, você precisa mesmo de um container nesse ponto específico? Pelo que
> > vejo, o código está uando IoC e DI, só não está usando um container.

> > Qual sua intenção em usar um container nesse caso?

> > *Vinicius Quaiato*http://viniciusquaiato.com

> > Twitter <vquaiato>
> > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > vinicius.quai...@gmail.com

> > 2010/7/28 tucaz <tuca...@gmail.com>

> > > É esse o cenário mesmo Vinicius, mas não consigo ver uma forma de
> > > passar isso pro container. Seu exemplo não está cobrindo o uso do
> > > container.

> > > On Jul 28, 11:57 am, Vinicius Quaiato <vinicius.quai...@gmail.com>
> > > wrote:
> > > > Tuca,

> > > > Se você trabalhasse com isso não no nível do GeradorDePedido, mas no
> > > nível
> > > > da aplicação. A aplicação sabe qual a loja, cria então(ou obtém) um
> > > > Precificador para esta loja, e passa o precificador para o Gerador.

> > > > Na verdade acho que o Precificador nem deve conhecer a loja, mas
> talvez
> > > uma
> > > > estratégia de preços por loja, algo assim.

> > > > por exmeplo:

> > > > //classe que coordena esse processo
> > > > public void ExecutarTodoEsseProcesso(Loja lojaSelecionada)
> > > > {
> > > >    //interface que o precificador conhece
> > > >    var estrategiaDePrecosPorLoja =
> > > > FabricaDeEstrategiasDePreco(lojaSelecionada);

> > > >    var precificador = new Precificador(estrategiaDePrecosPorLoja);

> > > >    var geradorDePedido = new GeradorDePedido(precificador);

> > > > }

> > > > Assim você pode continuar usando o container para resolver o Gerador.

> > > > abraços,

> > > > *Vinicius Quaiato*http://viniciusquaiato.com

> > > > Twitter <vquaiato>
> > > > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > > > vinicius.quai...@gmail.com

> > > > 2010/7/28 tucaz <tuca...@gmail.com>

> > > > > Oi!

> > > > > Temos falado muito em testes e DI/IoC ultimamente, mas acabamos não
> > > > > vendo código. Pra resolver isso tenho um problema que estou
> > > > > enfrentando e queria os palpites de vocês.

> > > > > Tenho duas classes: GeradorPedidos e Precificador. Para gerar um
> > > > > pedido, minha classe precisa de uma instância de Precificador que é
> a
> > > > > responsável por fornecer os preços dos produtos. Algo assim:

> > > > > public class GeradorPedido
> > > > > {
> > > > >        private IPrecificador _precificador;
> > > > >        public GeradorPedido(IPrecificador _precificador)
> > > > >        {
> > > > >                _precificador = precificador;
> > > > >        }

> > > > >        public void GerarPedido(Pedido novoPedido)
> > > > >        {
> > > > >                var total = 0;
> > > > >                foreach(var item in novoPedido.Itens)
> > > > >                {
> > > > >                        total += _precificador.QuantoCusta(item);
> > > > >                }
> > > > >                //faz mais um monte de coisas
> > > > >        }
> > > > > }

> > > > > Esquema bem simples pra qualquer container de DI/IoC resolver. Peço
> > > > > pro meu container uma instância da classe GeradorPedido e
> > > > > automaticamente ele injeta uma nova instância da classe
> Precificador
> > > > > do jeitinho que eu esperava.

> > > > > Agora vem o problema...

> > > > > Aparece um novo requisito que diz que o preço deve variar de acordo
> > > > > com a loja, portanto Precificador depende agora também de loja:

> > > > > public class Precificador : IPrecificador
> > > > > {
> > > > >        private Loja _lojaFiltro;
> > > > >        public Precificador(Loja lojaFiltro)
> > > > >        {
> > > > >                _lojaFiltro = lojaFiltro;
> > > > >        }

> > > > >        public int QuantoCusta(Item itemAPrecificar)
> > > > >        {
> > > > >                //retorna o preço de acordo com a loja
> > > > >                if(_lojaFiltro.Codigo == 1)
> > > > >                        return 10;
> > > > >                else if(_lojaFiltro.Codigo == 2)
> > > > >                        return 20
> > > > >                else
> > > > >                        return 30;
> > > > >        }
> > > > > }

> > > > > No entanto, eu só vou descobrir este valor em runtime, logo não
> posso
> > > > > mais resolver essa dependência com container tão facilmente.

> > > > > Uma opção seria criar uma AbstractFactory e injeta-la no
> GeradorPedido
> > > > > que utilizaria a factory pra criar o Precificador passando o
> parametro
> > > > > recebido em runtime. O único problema disso é que dessa forma o
> > > > > GeradorPedido que não tem nada a ver com a história também vira
> > > > > dependente da Loja, pois ele deve recebe-la pra poder passar para
> > > > > factory.

> > > > > Alguma outra sugestão?

> > > > > --
> > > > > Você recebeu esta mensagem porque faz parte do grupo .Net
> Architects
> > > > > hospedado no Google Groups.
> > > > > Para postar envie uma mensagem para
> dotnetarchitects@googlegroups.com
> > > > > Para sair do grupo envie uma mensagem para
> > > > > dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com><dotnetarchitects%2Bunsubscrib
> e@googlegroups.com><dotnetarchitects%2Bunsubscrib
> > > e@googlegroups.com>
> > > > > Para mais opções visite o grupo em
> > > > >http://groups.google.com/group/dotnetarchitects?hl=pt-br

> > > --
> > > Você recebeu esta mensagem porque faz parte do grupo .Net Architects
> > > hospedado no Google Groups.
> > > Para postar envie uma mensagem para dotnetarchitects@googlegroups.com
> > > Para sair do grupo envie uma mensagem para
> > > dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com><dotnetarchitects%2Bunsubscrib
> e@googlegroups.com>
> > > Para mais opções visite o grupo em
> > >http://groups.google.com/group/dotnetarchitects?hl=pt-br

> --
> Você recebeu esta mensagem porque faz parte do grupo .Net Architects
> hospedado no Google Groups.
> Para postar envie uma mensagem para dotnetarchitects@googlegroups.com
> Para sair do grupo envie uma mensagem para
> dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com>
> Para mais opções visite o grupo em
> http://groups.google.com/group/dotnetarchitects?hl=pt-br

> O container já existe. Estou mexendo em um código que criei
> anteriormente e inclusive já existem alguns objetos que dependem de
> GeradorPedido e outros que também dependem de IPrecificador.

> A idéia de abstract factory é boa, mas traz a dependência pra todo
> mundo que consome IPrecificador. Outra alternativa seria fazer injeção
> por Property ou usar um método pra Inicializar a classe, mas não gosto
> muito dessa idéia.

> On Jul 28, 12:12 pm, Vinicius Quaiato <vinicius.quai...@gmail.com>
> wrote:
> > É vdd...

> > Mas, você precisa mesmo de um container nesse ponto específico? Pelo que
> > vejo, o código está uando IoC e DI, só não está usando um container.

> > Qual sua intenção em usar um container nesse caso?

> > *Vinicius Quaiato*http://viniciusquaiato.com

> > Twitter <vquaiato>
> > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > vinicius.quai...@gmail.com

> > 2010/7/28 tucaz <tuca...@gmail.com>

> > > É esse o cenário mesmo Vinicius, mas não consigo ver uma forma de
> > > passar isso pro container. Seu exemplo não está cobrindo o uso do
> > > container.

> > > On Jul 28, 11:57 am, Vinicius Quaiato <vinicius.quai...@gmail.com>
> > > wrote:
> > > > Tuca,

> > > > Se você trabalhasse com isso não no nível do GeradorDePedido, mas no
> > > nível
> > > > da aplicação. A aplicação sabe qual a loja, cria então(ou obtém) um
> > > > Precificador para esta loja, e passa o precificador para o Gerador.

> > > > Na verdade acho que o Precificador nem deve conhecer a loja, mas
> talvez
> > > uma
> > > > estratégia de preços por loja, algo assim.

> > > > por exmeplo:

> > > > //classe que coordena esse processo
> > > > public void ExecutarTodoEsseProcesso(Loja lojaSelecionada)
> > > > {
> > > >    //interface que o precificador conhece
> > > >    var estrategiaDePrecosPorLoja =
> > > > FabricaDeEstrategiasDePreco(lojaSelecionada);

> > > >    var precificador = new Precificador(estrategiaDePrecosPorLoja);

> > > >    var geradorDePedido = new GeradorDePedido(precificador);

> > > > }

> > > > Assim você pode continuar usando o container para resolver o Gerador.

> > > > abraços,

> > > > *Vinicius Quaiato*http://viniciusquaiato.com

> > > > Twitter <vquaiato>
> > > > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > > > vinicius.quai...@gmail.com

> > > > 2010/7/28 tucaz <tuca...@gmail.com>

> > > > > Oi!

> > > > > Temos falado muito em testes e DI/IoC ultimamente, mas acabamos não
> > > > > vendo código. Pra resolver isso tenho um problema que estou
> > > > > enfrentando e queria os palpites de vocês.

> > > > > Tenho duas classes: GeradorPedidos e Precificador. Para gerar um
> > > > > pedido, minha classe precisa de uma instância de Precificador que é
> a
> > > > > responsável por fornecer os preços dos produtos. Algo assim:

> > > > > public class GeradorPedido
> > > > > {
> > > > >        private IPrecificador _precificador;
> > > > >        public GeradorPedido(IPrecificador _precificador)
> > > > >        {
> > > > >                _precificador = precificador;
> > > > >        }

> > > > >        public void GerarPedido(Pedido novoPedido)
> > > > >        {
> > > > >                var total = 0;
> > > > >                foreach(var item in novoPedido.Itens)
> > > > >                {
> > > > >                        total += _precificador.QuantoCusta(item);
> > > > >                }
> > > > >                //faz mais um monte de coisas
> > > > >        }
> > > > > }

> > > > > Esquema bem simples pra qualquer container de DI/IoC resolver. Peço
> > > > > pro meu container uma instância da classe GeradorPedido e
> > > > > automaticamente ele injeta uma nova instância da classe
> Precificador
> > > > > do jeitinho que eu esperava.

> > > > > Agora vem o problema...

> > > > > Aparece um novo requisito que diz que o preço deve variar de acordo
> > > > > com a loja, portanto Precificador depende agora também de loja:

> > > > > public class Precificador : IPrecificador
> > > > > {
> > > > >        private Loja _lojaFiltro;
> > > > >        public Precificador(Loja lojaFiltro)
> > > > >        {
> > > > >                _lojaFiltro = lojaFiltro;
> > > > >        }

> > > > >        public int QuantoCusta(Item itemAPrecificar)
> > > > >        {
> > > > >                //retorna o preço de acordo com a loja
> > > > >                if(_lojaFiltro.Codigo == 1)
> > > > >                        return 10;
> > > > >                else if(_lojaFiltro.Codigo == 2)
> > > > >                        return 20
> > > > >                else
> > > > >                        return 30;
> > > > >        }
> > > > > }

> > > > > No entanto, eu só vou descobrir este valor em runtime, logo não
> posso
> > > > > mais resolver essa dependência com container tão facilmente.

> > > > > Uma opção seria criar uma AbstractFactory e injeta-la no
> GeradorPedido
> > > > > que utilizaria a factory pra criar o Precificador passando o
> parametro
> > > > > recebido em runtime. O único problema disso é que dessa forma o
> > > > > GeradorPedido que não tem nada a ver com a história também vira
> > > > > dependente da Loja, pois ele deve recebe-la pra poder passar para
> > > > > factory.

> > > > > Alguma outra sugestão?

> > > > > --
> > > > > Você recebeu esta mensagem porque faz parte do grupo .Net
> Architects
> > > > > hospedado no Google Groups.
> > > > > Para postar envie uma mensagem para
> dotnetarchitects@googlegroups.com
> > > > > Para sair do grupo envie uma mensagem para
> > > > > dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com><dotnetarchitects%2Bunsubscrib
> e@googlegroups.com><dotnetarchitects%2Bunsubscrib
> > > e@googlegroups.com>
> > > > > Para mais opções visite o grupo em
> > > > >http://groups.google.com/group/dotnetarchitects?hl=pt-br

> > > --
> > > Você recebeu esta mensagem porque faz parte do grupo .Net Architects
> > > hospedado no Google Groups.
> > > Para postar envie uma mensagem para dotnetarchitects@googlegroups.com
> > > Para sair do grupo envie uma mensagem para
> > > dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com><dotnetarchitects%2Bunsubscrib
> e@googlegroups.com>
> > > Para mais opções visite o grupo em
> > >http://groups.google.com/group/dotnetarchitects?hl=pt-br

> --
> Você recebeu esta mensagem porque faz parte do grupo .Net Architects
> hospedado no Google Groups.
> Para postar envie uma mensagem para dotnetarchitects@googlegroups.com
> Para sair do grupo envie uma mensagem para
> dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com>
> Para mais opções visite o grupo em
> http://groups.google.com/group/dotnetarchitects?hl=pt-br

> Não sei se precisa de uma AbstractFactory Tuca.

> Seu ponto é conseguir criar o GeradorDePedido, que agora depende de uma
> Loja que só é conhecida em runtime.

> Isso está mais para um Builder. E eu abriria mão do container nessa
> situação. O builder recebendo uma Loja cria o seu Gerador.

> Afinal o Gerado não muda por causa da loja, o que muda é o Precificador,
> por isso acho que não cabe uma abstract factory.

> E sobre a dependência de outro sobre IPrecificador, utilizaria uma fábrica
> para eles, baseado na loja. E essa fábrica será também consumida pelo
> Builder.

> Acho que o container vai dançar. Ou se alguém souber umas mágicas mais
> avançadas, manda aê.

> *Vinicius Quaiato*
> http://viniciusquaiato.com

> Twitter <http://vquaiato>
> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> vinicius.quai...@gmail.com

> 2010/7/28 tucaz <tuca...@gmail.com>

> O container já existe. Estou mexendo em um código que criei
>> anteriormente e inclusive já existem alguns objetos que dependem de
>> GeradorPedido e outros que também dependem de IPrecificador.

>> A idéia de abstract factory é boa, mas traz a dependência pra todo
>> mundo que consome IPrecificador. Outra alternativa seria fazer injeção
>> por Property ou usar um método pra Inicializar a classe, mas não gosto
>> muito dessa idéia.

>> On Jul 28, 12:12 pm, Vinicius Quaiato <vinicius.quai...@gmail.com>
>> wrote:
>> > É vdd...

>> > Mas, você precisa mesmo de um container nesse ponto específico? Pelo que
>> > vejo, o código está uando IoC e DI, só não está usando um container.

>> > Qual sua intenção em usar um container nesse caso?

>> > *Vinicius Quaiato*http://viniciusquaiato.com

>> > Twitter <vquaiato>
>> > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
>> > vinicius.quai...@gmail.com

>> > 2010/7/28 tucaz <tuca...@gmail.com>

>> > > É esse o cenário mesmo Vinicius, mas não consigo ver uma forma de
>> > > passar isso pro container. Seu exemplo não está cobrindo o uso do
>> > > container.

>> > > On Jul 28, 11:57 am, Vinicius Quaiato <vinicius.quai...@gmail.com>
>> > > wrote:
>> > > > Tuca,

>> > > > Se você trabalhasse com isso não no nível do GeradorDePedido, mas no
>> > > nível
>> > > > da aplicação. A aplicação sabe qual a loja, cria então(ou obtém) um
>> > > > Precificador para esta loja, e passa o precificador para o Gerador.

>> > > > Na verdade acho que o Precificador nem deve conhecer a loja, mas
>> talvez
>> > > uma
>> > > > estratégia de preços por loja, algo assim.

>> > > > por exmeplo:

>> > > > //classe que coordena esse processo
>> > > > public void ExecutarTodoEsseProcesso(Loja lojaSelecionada)
>> > > > {
>> > > >    //interface que o precificador conhece
>> > > >    var estrategiaDePrecosPorLoja =
>> > > > FabricaDeEstrategiasDePreco(lojaSelecionada);

>> > > >    var precificador = new Precificador(estrategiaDePrecosPorLoja);

>> > > >    var geradorDePedido = new GeradorDePedido(precificador);

>> > > > }

>> > > > Assim você pode continuar usando o container para resolver o
>> Gerador.

>> > > > abraços,

>> > > > *Vinicius Quaiato*http://viniciusquaiato.com

>> > > > Twitter <vquaiato>
>> > > > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
>> > > > vinicius.quai...@gmail.com

>> > > > 2010/7/28 tucaz <tuca...@gmail.com>

>> > > > > Oi!

>> > > > > Temos falado muito em testes e DI/IoC ultimamente, mas acabamos
>> não
>> > > > > vendo código. Pra resolver isso tenho um problema que estou
>> > > > > enfrentando e queria os palpites de vocês.

>> > > > > Tenho duas classes: GeradorPedidos e Precificador. Para gerar um
>> > > > > pedido, minha classe precisa de uma instância de Precificador que
>> é a
>> > > > > responsável por fornecer os preços dos produtos. Algo assim:

>> > > > > public class GeradorPedido
>> > > > > {
>> > > > >        private IPrecificador _precificador;
>> > > > >        public GeradorPedido(IPrecificador _precificador)
>> > > > >        {
>> > > > >                _precificador = precificador;
>> > > > >        }

>> > > > >        public void GerarPedido(Pedido novoPedido)
>> > > > >        {
>> > > > >                var total = 0;
>> > > > >                foreach(var item in novoPedido.Itens)
>> > > > >                {
>> > > > >                        total += _precificador.QuantoCusta(item);
>> > > > >                }
>> > > > >                //faz mais um monte de coisas
>> > > > >        }
>> > > > > }

>> > > > > Esquema bem simples pra qualquer container de DI/IoC resolver.
>> Peço
>> > > > > pro meu container uma instância da classe GeradorPedido e
>> > > > > automaticamente ele injeta uma nova instância da classe
>> Precificador
>> > > > > do jeitinho que eu esperava.

>> > > > > Agora vem o problema...

>> > > > > Aparece um novo requisito que diz que o preço deve variar de
>> acordo
>> > > > > com a loja, portanto Precificador depende agora também de loja:

>> > > > > public class Precificador : IPrecificador
>> > > > > {
>> > > > >        private Loja _lojaFiltro;
>> > > > >        public Precificador(Loja lojaFiltro)
>> > > > >        {
>> > > > >                _lojaFiltro = lojaFiltro;
>> > > > >        }

>> > > > >        public int QuantoCusta(Item itemAPrecificar)
>> > > > >        {
>> > > > >                //retorna o preço de acordo com a loja
>> > > > >                if(_lojaFiltro.Codigo == 1)
>> > > > >                        return 10;
>> > > > >                else if(_lojaFiltro.Codigo == 2)
>> > > > >                        return 20
>> > > > >                else
>> > > > >                        return 30;
>> > > > >        }
>> > > > > }

>> > > > > No entanto, eu só vou descobrir este valor em runtime, logo não
>> posso
>> > > > > mais resolver essa dependência com container tão facilmente.

>> > > > > Uma opção seria criar uma AbstractFactory e injeta-la no
>> GeradorPedido
>> > > > > que utilizaria a factory pra criar o Precificador passando o
>> parametro
>> > > > > recebido em runtime. O único problema disso é que dessa forma o
>> > > > > GeradorPedido que não tem nada a ver com a história também vira
>> > > > > dependente da Loja, pois ele deve recebe-la pra poder passar para
>> > > > > factory.

>> > > > > Alguma outra sugestão?

>> > > > > --
>> > > > > Você recebeu esta mensagem porque faz parte do grupo .Net
>> Architects
>> > > > > hospedado no Google Groups.
>> > > > > Para postar envie uma mensagem para
>> dotnetarchitects@googlegroups.com
>> > > > > Para sair do grupo envie uma mensagem para
>> > > > > dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com><dotnetarchitects%2Bunsubscrib
>> e@googlegroups.com><dotnetarchitects%2Bunsubscrib
>> > > e@googlegroups.com>
>> > > > > Para mais opções visite o grupo em
>> > > > >http://groups.google.com/group/dotnetarchitects?hl=pt-br

>> > > --
>> > > Você recebeu esta mensagem porque faz parte do grupo .Net Architects
>> > > hospedado no Google Groups.
>> > > Para postar envie uma mensagem para dotnetarchitects@googlegroups.com
>> > > Para sair do grupo envie uma mensagem para
>> > > dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com><dotnetarchitects%2Bunsubscrib
>> e@googlegroups.com>
>> > > Para mais opções visite o grupo em
>> > >http://groups.google.com/group/dotnetarchitects?hl=pt-br

>> --
>> Você recebeu esta mensagem porque faz parte do grupo .Net Architects
>> hospedado no Google Groups.
>> Para postar envie uma mensagem para dotnetarchitects@googlegroups.com
>> Para sair do grupo envie uma mensagem para
>> dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com>
>> Para mais opções visite o grupo em
>> http://groups.google.com/group/dotnetarchitects?hl=pt-br

>  --
> Você recebeu esta mensagem porque faz parte do grupo .Net Architects
> hospedado no Google Groups.
> Para postar envie uma mensagem para dotnetarchitects@googlegroups.com
> Para sair do grupo envie uma mensagem para
> dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com>
> Para mais opções visite o grupo em
> http://groups.google.com/group/dotnetarchitects?hl=pt-br

> Oi,

> Só não concordo com o Vinicius em ter que criar um Builder para isso, uma
> fabrica de estratégias já seria suficiente para criar seu especialista na
> precificação.

> Além do mais não estou entendendo porque o GeradorDePedido precisa de um
> container DI para ser criado.

> Ele me parece ser um serviço especialista na função, e normalmente teremos
> um único especialista na função por domínio.

> Digo isso, porque imagino que no seu domínio você não precise de um
> GeradorDePedidoDeCarros, GeradorDePedidosDeImoveis...

> Ao que parece o container vai morrer mesmo...

> []'s

> Ricardo Simões

> 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

>> Não sei se precisa de uma AbstractFactory Tuca.

>> Seu ponto é conseguir criar o GeradorDePedido, que agora depende de uma
>> Loja que só é conhecida em runtime.

>> Isso está mais para um Builder. E eu abriria mão do container nessa
>> situação. O builder recebendo uma Loja cria o seu Gerador.

>> Afinal o Gerado não muda por causa da loja, o que muda é o Precificador,
>> por isso acho que não cabe uma abstract factory.

>> E sobre a dependência de outro sobre IPrecificador, utilizaria uma fábrica
>> para eles, baseado na loja. E essa fábrica será também consumida pelo
>> Builder.

>> Acho que o container vai dançar. Ou se alguém souber umas mágicas mais
>> avançadas, manda aê.

>>  *Vinicius Quaiato*
>> http://viniciusquaiato.com

>> Twitter <http://vquaiato>
>> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
>> vinicius.quai...@gmail.com

>> 2010/7/28 tucaz <tuca...@gmail.com>

>> O container já existe. Estou mexendo em um código que criei
>>> anteriormente e inclusive já existem alguns objetos que dependem de
>>> GeradorPedido e outros que também dependem de IPrecificador.

>>> A idéia de abstract factory é boa, mas traz a dependência pra todo
>>> mundo que consome IPrecificador. Outra alternativa seria fazer injeção
>>> por Property ou usar um método pra Inicializar a classe, mas não gosto
>>> muito dessa idéia.

>>> On Jul 28, 12:12 pm, Vinicius Quaiato <vinicius.quai...@gmail.com>
>>> wrote:
>>> > É vdd...

>>> > Mas, você precisa mesmo de um container nesse ponto específico? Pelo
>>> que
>>> > vejo, o código está uando IoC e DI, só não está usando um container.

>>> > Qual sua intenção em usar um container nesse caso?

>>> > *Vinicius Quaiato*http://viniciusquaiato.com

>>> > Twitter <vquaiato>
>>> > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
>>> > vinicius.quai...@gmail.com

>>> > 2010/7/28 tucaz <tuca...@gmail.com>

>>> > > É esse o cenário mesmo Vinicius, mas não consigo ver uma forma de
>>> > > passar isso pro container. Seu exemplo não está cobrindo o uso do
>>> > > container.

>>> > > On Jul 28, 11:57 am, Vinicius Quaiato <vinicius.quai...@gmail.com>
>>> > > wrote:
>>> > > > Tuca,

>>> > > > Se você trabalhasse com isso não no nível do GeradorDePedido, mas
>>> no
>>> > > nível
>>> > > > da aplicação. A aplicação sabe qual a loja, cria então(ou obtém) um
>>> > > > Precificador para esta loja, e passa o precificador para o Gerador.

>>> > > > Na verdade acho que o Precificador nem deve conhecer a loja, mas
>>> talvez
>>> > > uma
>>> > > > estratégia de preços por loja, algo assim.

>>> > > > por exmeplo:

>>> > > > //classe que coordena esse processo
>>> > > > public void ExecutarTodoEsseProcesso(Loja lojaSelecionada)
>>> > > > {
>>> > > >    //interface que o precificador conhece
>>> > > >    var estrategiaDePrecosPorLoja =
>>> > > > FabricaDeEstrategiasDePreco(lojaSelecionada);

>>> > > >    var precificador = new Precificador(estrategiaDePrecosPorLoja);

>>> > > >    var geradorDePedido = new GeradorDePedido(precificador);

>>> > > > }

>>> > > > Assim você pode continuar usando o container para resolver o
>>> Gerador.

>>> > > > abraços,

>>> > > > *Vinicius Quaiato*http://viniciusquaiato.com

>>> > > > Twitter <vquaiato>
>>> > > > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
>>> > > > vinicius.quai...@gmail.com

>>> > > > 2010/7/28 tucaz <tuca...@gmail.com>

>>> > > > > Oi!

>>> > > > > Temos falado muito em testes e DI/IoC ultimamente, mas acabamos
>>> não
>>> > > > > vendo código. Pra resolver isso tenho um problema que estou
>>> > > > > enfrentando e queria os palpites de vocês.

>>> > > > > Tenho duas classes: GeradorPedidos e Precificador. Para gerar um
>>> > > > > pedido, minha classe precisa de uma instância de Precificador que
>>> é a
>>> > > > > responsável por fornecer os preços dos produtos. Algo assim:

>>> > > > > public class GeradorPedido
>>> > > > > {
>>> > > > >        private IPrecificador _precificador;
>>> > > > >        public GeradorPedido(IPrecificador _precificador)
>>> > > > >        {
>>> > > > >                _precificador = precificador;
>>> > > > >        }

>>> > > > >        public void GerarPedido(Pedido novoPedido)
>>> > > > >        {
>>> > > > >                var total = 0;
>>> > > > >                foreach(var item in novoPedido.Itens)
>>> > > > >                {
>>> > > > >                        total += _precificador.QuantoCusta(item);
>>> > > > >                }
>>> > > > >                //faz mais um monte de coisas
>>> > > > >        }
>>> > > > > }

>>> > > > > Esquema bem simples pra qualquer container de DI/IoC resolver.
>>> Peço
>>> > > > > pro meu container uma instância da classe GeradorPedido e
>>> > > > > automaticamente ele injeta uma nova instância da classe
>>> Precificador
>>> > > > > do jeitinho que eu esperava.

>>> > > > > Agora vem o problema...

>>> > > > > Aparece um novo requisito que diz que o preço deve variar de
>>> acordo
>>> > > > > com a loja, portanto Precificador depende agora também de loja:

>>> > > > > public class Precificador : IPrecificador
>>> > > > > {
>>> > > > >        private Loja _lojaFiltro;
>>> > > > >        public Precificador(Loja lojaFiltro)
>>> > > > >        {
>>> > > > >                _lojaFiltro = lojaFiltro;
>>> > > > >        }

>>> > > > >        public int QuantoCusta(Item itemAPrecificar)
>>> > > > >        {
>>> > > > >                //retorna o preço de acordo com a loja
>>> > > > >                if(_lojaFiltro.Codigo == 1)
>>> > > > >                        return 10;
>>> > > > >                else if(_lojaFiltro.Codigo == 2)
>>> > > > >                        return 20
>>> > > > >                else
>>> > > > >                        return 30;
>>> > > > >        }
>>> > > > > }

>>> > > > > No entanto, eu só vou descobrir este valor em runtime, logo não
>>> posso
>>> > > > > mais resolver essa dependência com container tão facilmente.

>>> > > > > Uma opção seria criar uma AbstractFactory e injeta-la no
>>> GeradorPedido
>>> > > > > que utilizaria a factory pra criar o Precificador passando o
>>> parametro
>>> > > > > recebido em runtime. O único problema disso é que dessa forma o
>>> > > > > GeradorPedido que não tem nada a ver com a história também vira
>>> > > > > dependente da Loja, pois ele deve recebe-la pra poder passar para
>>> > > > > factory.

>>> > > > > Alguma outra sugestão?

>>> > > > > --
>>> > > > > Você recebeu esta mensagem porque faz parte do grupo .Net
>>> Architects
>>> > > > > hospedado no Google Groups.
>>> > > > > Para postar envie uma mensagem para
>>> dotnetarchitects@googlegroups.com
>>> > > > > Para sair do grupo envie uma mensagem para
>>> > > > > dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com><dotnetarchitects%2Bunsubscrib
>>> e@googlegroups.com><dotnetarchitects%2Bunsubscrib
>>> > > e@googlegroups.com>
>>> > > > > Para mais opções visite o grupo em
>>> > > > >http://groups.google.com/group/dotnetarchitects?hl=pt-br

>>> > > --
>>> > > Você recebeu esta mensagem porque faz parte do grupo .Net Architects
>>> > > hospedado no Google Groups.
>>> > > Para postar envie uma mensagem para
>>> dotnetarchitects@googlegroups.com
>>> > > Para sair do grupo envie uma mensagem para
>>> > > dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com><dotnetarchitects%2Bunsubscrib
>>> e@googlegroups.com>
>>> > > Para mais opções visite o grupo em
>>> > >http://groups.google.com/group/dotnetarchitects?hl=pt-br

>>> --
>>> Você recebeu esta mensagem porque faz parte do grupo .Net Architects
>>> hospedado no Google Groups.
>>> Para postar envie uma mensagem para dotnetarchitects@googlegroups.com
>>> Para sair do grupo envie uma mensagem para
>>> dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com>
>>> Para mais opções visite o grupo em
>>> http://groups.google.com/group/dotnetarchitects?hl=pt-br

>>  --
>> Você recebeu esta mensagem porque faz parte do grupo .Net Architects
>> hospedado no Google Groups.
>> Para postar envie uma mensagem para dotnetarchitects@googlegroups.com
>> Para sair do grupo envie uma mensagem para
>> dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com>
>> Para mais opções visite o grupo em

> Então ricardo, eu disse um Builder por que pelo que entendi mais de um
> lugar usa o Gerador, e o gerador depende de um IPrecificador, que por sua
> vez depende de uma loja.

> Para matar essa dependência com a loja, crio uma fábrica de
> EstratégiasDePrecificacao, e depois de obter passo a estratégia para o
> Gerador.

> Na verdade o Builder seria para ocultar os passos da criação do Gerador
> apenas.

> *Vinicius Quaiato*
> http://viniciusquaiato.com

> Twitter <http://vquaiato>
> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> vinicius.quai...@gmail.com

> 2010/7/28 Ricardo Simões <rsc....@gmail.com>

>> Oi,

>> Só não concordo com o Vinicius em ter que criar um Builder para isso, uma
>> fabrica de estratégias já seria suficiente para criar seu especialista na
>> precificação.

>> Além do mais não estou entendendo porque o GeradorDePedido precisa de um
>> container DI para ser criado.

>> Ele me parece ser um serviço especialista na função, e normalmente teremos
>> um único especialista na função por domínio.

>> Digo isso, porque imagino que no seu domínio você não precise de um
>> GeradorDePedidoDeCarros, GeradorDePedidosDeImoveis...

>> Ao que parece o container vai morrer mesmo...

>> []'s

>> Ricardo Simões

>> 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

>>> Não sei se precisa de uma AbstractFactory Tuca.

>>> Seu ponto é conseguir criar o GeradorDePedido, que agora depende de uma
>>> Loja que só é conhecida em runtime.

>>> Isso está mais para um Builder. E eu abriria mão do container nessa
>>> situação. O builder recebendo uma Loja cria o seu Gerador.

>>> Afinal o Gerado não muda por causa da loja, o que muda é o Precificador,
>>> por isso acho que não cabe uma abstract factory.

>>> E sobre a dependência de outro sobre IPrecificador, utilizaria uma
>>> fábrica para eles, baseado na loja. E essa fábrica será também consumida
>>> pelo Builder.

>>> Acho que o container vai dançar. Ou se alguém souber umas mágicas mais
>>> avançadas, manda aê.

>>>  *Vinicius Quaiato*
>>> http://viniciusquaiato.com

>>> Twitter <http://vquaiato>
>>> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
>>> vinicius.quai...@gmail.com

>>> 2010/7/28 tucaz <tuca...@gmail.com>

>>> O container já existe. Estou mexendo em um código que criei
>>>> anteriormente e inclusive já existem alguns objetos que dependem de
>>>> GeradorPedido e outros que também dependem de IPrecificador.

>>>> A idéia de abstract factory é boa, mas traz a dependência pra todo
>>>> mundo que consome IPrecificador. Outra alternativa seria fazer injeção
>>>> por Property ou usar um método pra Inicializar a classe, mas não gosto
>>>> muito dessa idéia.

>>>> On Jul 28, 12:12 pm, Vinicius Quaiato <vinicius.quai...@gmail.com>
>>>> wrote:
>>>> > É vdd...

>>>> > Mas, você precisa mesmo de um container nesse ponto específico? Pelo
>>>> que
>>>> > vejo, o código está uando IoC e DI, só não está usando um container.

>>>> > Qual sua intenção em usar um container nesse caso?

>>>> > *Vinicius Quaiato*http://viniciusquaiato.com

>>>> > Twitter <vquaiato>
>>>> > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
>>>> > vinicius.quai...@gmail.com

>>>> > 2010/7/28 tucaz <tuca...@gmail.com>

>>>> > > É esse o cenário mesmo Vinicius, mas não consigo ver uma forma de
>>>> > > passar isso pro container. Seu exemplo não está cobrindo o uso do
>>>> > > container.

>>>> > > On Jul 28, 11:57 am, Vinicius Quaiato <vinicius.quai...@gmail.com>
>>>> > > wrote:
>>>> > > > Tuca,

>>>> > > > Se você trabalhasse com isso não no nível do GeradorDePedido, mas
>>>> no
>>>> > > nível
>>>> > > > da aplicação. A aplicação sabe qual a loja, cria então(ou obtém)
>>>> um
>>>> > > > Precificador para esta loja, e passa o precificador para o
>>>> Gerador.

>>>> > > > Na verdade acho que o Precificador nem deve conhecer a loja, mas
>>>> talvez
>>>> > > uma
>>>> > > > estratégia de preços por loja, algo assim.

>>>> > > > por exmeplo:

>>>> > > > //classe que coordena esse processo
>>>> > > > public void ExecutarTodoEsseProcesso(Loja lojaSelecionada)
>>>> > > > {
>>>> > > >    //interface que o precificador conhece
>>>> > > >    var estrategiaDePrecosPorLoja =
>>>> > > > FabricaDeEstrategiasDePreco(lojaSelecionada);

>>>> > > >    var precificador = new Precificador(estrategiaDePrecosPorLoja);

>>>> > > >    var geradorDePedido = new GeradorDePedido(precificador);

>>>> > > > }

>>>> > > > Assim você pode continuar usando o container para resolver o
>>>> Gerador.

>>>> > > > abraços,

>>>> > > > *Vinicius Quaiato*http://viniciusquaiato.com

>>>> > > > Twitter <vquaiato>
>>>> > > > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
>>>> > > > vinicius.quai...@gmail.com

>>>> > > > 2010/7/28 tucaz <tuca...@gmail.com>

>>>> > > > > Oi!

>>>> > > > > Temos falado muito em testes e DI/IoC ultimamente, mas acabamos
>>>> não
>>>> > > > > vendo código. Pra resolver isso tenho um problema que estou
>>>> > > > > enfrentando e queria os palpites de vocês.

>>>> > > > > Tenho duas classes: GeradorPedidos e Precificador. Para gerar um
>>>> > > > > pedido, minha classe precisa de uma instância de Precificador
>>>> que é a
>>>> > > > > responsável por fornecer os preços dos produtos. Algo assim:

>>>> > > > > public class GeradorPedido
>>>> > > > > {
>>>> > > > >        private IPrecificador _precificador;
>>>> > > > >        public GeradorPedido(IPrecificador _precificador)
>>>> > > > >        {
>>>> > > > >                _precificador = precificador;
>>>> > > > >        }

>>>> > > > >        public void GerarPedido(Pedido novoPedido)
>>>> > > > >        {
>>>> > > > >                var total = 0;
>>>> > > > >                foreach(var item in novoPedido.Itens)
>>>> > > > >                {
>>>> > > > >                        total += _precificador.QuantoCusta(item);
>>>> > > > >                }
>>>> > > > >                //faz mais um monte de coisas
>>>> > > > >        }
>>>> > > > > }

>>>> > > > > Esquema bem simples pra qualquer container de DI/IoC resolver.
>>>> Peço
>>>> > > > > pro meu container uma instância da classe GeradorPedido e
>>>> > > > > automaticamente ele injeta uma nova instância da classe
>>>> Precificador
>>>> > > > > do jeitinho que eu esperava.

>>>> > > > > Agora vem o problema...

>>>> > > > > Aparece um novo requisito que diz que o preço deve variar de
>>>> acordo
>>>> > > > > com a loja, portanto Precificador depende agora também de loja:

>>>> > > > > public class Precificador : IPrecificador
>>>> > > > > {
>>>> > > > >        private Loja _lojaFiltro;
>>>> > > > >        public Precificador(Loja lojaFiltro)
>>>> > > > >        {
>>>> > > > >                _lojaFiltro = lojaFiltro;
>>>> > > > >        }

>>>> > > > >        public int QuantoCusta(Item itemAPrecificar)
>>>> > > > >        {
>>>> > > > >                //retorna o preço de acordo com a loja
>>>> > > > >                if(_lojaFiltro.Codigo == 1)
>>>> > > > >                        return 10;
>>>> > > > >                else if(_lojaFiltro.Codigo == 2)
>>>> > > > >                        return 20
>>>> > > > >                else
>>>> > > > >                        return 30;
>>>> > > > >        }
>>>> > > > > }

>>>> > > > > No entanto, eu só vou descobrir este valor em runtime, logo não
>>>> posso
>>>> > > > > mais resolver essa dependência com container tão facilmente.

>>>> > > > > Uma opção seria criar uma AbstractFactory e injeta-la no
>>>> GeradorPedido
>>>> > > > > que utilizaria a factory pra criar o Precificador passando o
>>>> parametro
>>>> > > > > recebido em runtime. O único problema disso é que dessa forma o
>>>> > > > > GeradorPedido que não tem nada a ver com a história também vira
>>>> > > > > dependente da Loja, pois ele deve recebe-la pra poder passar
>>>> para
>>>> > > > > factory.

>>>> > > > > Alguma outra sugestão?

>>>> > > > > --
>>>> > > > > Você recebeu esta mensagem porque faz parte do grupo .Net
>>>> Architects
>>>> > > > > hospedado no Google Groups.
>>>> > > > > Para postar envie uma mensagem para
>>>> dotnetarchitects@googlegroups.com
>>>> > > > > Para sair do grupo envie uma mensagem para
>>>> > > > > dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com><dotnetarchitects%2Bunsubscrib
>>>> e@googlegroups.com><dotnetarchitects%2Bunsubscrib
>>>> > > e@googlegroups.com>
>>>> > > > > Para mais opções visite o grupo em
>>>> > > > >http://groups.google.com/group/dotnetarchitects?hl=pt-br

>>>> > > --
>>>> > > Você recebeu esta mensagem porque faz parte do grupo .Net Architects
>>>> > > hospedado no Google Groups.
>>>> > > Para postar envie uma mensagem para
>>>> dotnetarchitects@googlegroups.com
>>>> > > Para sair do

> Oi!

> Temos falado muito em testes e DI/IoC ultimamente, mas acabamos não
> vendo código. Pra resolver isso tenho um problema que estou
> enfrentando e queria os palpites de vocês.

> Tenho duas classes: GeradorPedidos e Precificador. Para gerar um
> pedido, minha classe precisa de uma instância de Precificador que é a
> responsável por fornecer os preços dos produtos. Algo assim:

> public class GeradorPedido
> {
>         private IPrecificador _precificador;
>         public GeradorPedido(IPrecificador _precificador)
>         {
>                 _precificador = precificador;
>         }

>         public void GerarPedido(Pedido novoPedido)
>         {
>                 var total = 0;
>                 foreach(var item in novoPedido.Itens)
>                 {
>                         total += _precificador.QuantoCusta(item);
>                 }
>                 //faz mais um monte de coisas
>         }

> }

> Esquema bem simples pra qualquer container de DI/IoC resolver. Peço
> pro meu container uma instância da classe GeradorPedido e
> automaticamente ele injeta uma nova instância da classe Precificador
> do jeitinho que eu esperava.

> Agora vem o problema...

> Aparece um novo requisito que diz que o preço deve variar de acordo
> com a loja, portanto Precificador depende agora também de loja:

> public class Precificador : IPrecificador
> {
>         private Loja _lojaFiltro;
>         public Precificador(Loja lojaFiltro)
>         {
>                 _lojaFiltro = lojaFiltro;
>         }

>         public int QuantoCusta(Item itemAPrecificar)
>         {
>                 //retorna o preço de acordo com a loja
>                 if(_lojaFiltro.Codigo == 1)
>                         return 10;
>                 else if(_lojaFiltro.Codigo == 2)
>                         return 20
>                 else
>                         return 30;
>         }

> }

> No entanto, eu só vou descobrir este valor em runtime, logo não posso
> mais resolver essa dependência com container tão facilmente.

> Uma opção seria criar uma AbstractFactory e injeta-la no GeradorPedido
> que utilizaria a factory pra criar o Precificador passando o parametro
> recebido em runtime. O único problema disso é que dessa forma o
> GeradorPedido que não tem nada a ver com a história também vira
> dependente da Loja, pois ele deve recebe-la pra poder passar para
> factory.

> Alguma outra sugestão?

> Fala moçada.

> Meu primeiro post aqui na comunidade. Tenho muita experiência em
> outras plataformas. Mas bora ver se consigo ajudar em forma de
> analogia com Java. :P

> No Java o Spring, container de DI/IoC mais utilizado tem a
> possibilidade de receber uma indicação de qual factory ele usa pra
> instanciar uma dependência.
> Dessa forma, você poderia usar uma factory, como vc mesmo sugeriu, mas
> ao invés de invocar a factory a partir do GeradordPedido, o container
> de IoC invoca a Factory pra você. Logo, você não precisa de uma
> instância de Loja no GeradorPedido.

> Isso resolveria o seu problema, a minha pergunta agora é: Tem isso
> em .NET? (Qual é o container de DI/IoC utilizado nesse caso?)

> PS: Reforço que não manjo muito de .NET.

> []'s

> Felipe

> On Jul 28, 11:16 am, tucaz <tuca...@gmail.com> wrote:
> > Oi!

> > Temos falado muito em testes e DI/IoC ultimamente, mas acabamos não
> > vendo código. Pra resolver isso tenho um problema que estou
> > enfrentando e queria os palpites de vocês.

> > Tenho duas classes: GeradorPedidos e Precificador. Para gerar um
> > pedido, minha classe precisa de uma instância de Precificador que é a
> > responsável por fornecer os preços dos produtos. Algo assim:

> > public class GeradorPedido
> > {
> >         private IPrecificador _precificador;
> >         public GeradorPedido(IPrecificador _precificador)
> >         {
> >                 _precificador = precificador;
> >         }

> >         public void GerarPedido(Pedido novoPedido)
> >         {
> >                 var total = 0;
> >                 foreach(var item in novoPedido.Itens)
> >                 {
> >                         total += _precificador.QuantoCusta(item);
> >                 }
> >                 //faz mais um monte de coisas
> >         }

> > }

> > Esquema bem simples pra qualquer container de DI/IoC resolver. Peço
> > pro meu container uma instância da classe GeradorPedido e
> > automaticamente ele injeta uma nova instância da classe Precificador
> > do jeitinho que eu esperava.

> > Agora vem o problema...

> > Aparece um novo requisito que diz que o preço deve variar de acordo
> > com a loja, portanto Precificador depende agora também de loja:

> > public class Precificador : IPrecificador
> > {
> >         private Loja _lojaFiltro;
> >         public Precificador(Loja lojaFiltro)
> >         {
> >                 _lojaFiltro = lojaFiltro;
> >         }

> >         public int QuantoCusta(Item itemAPrecificar)
> >         {
> >                 //retorna o preço de acordo com a loja
> >                 if(_lojaFiltro.Codigo == 1)
> >                         return 10;
> >                 else if(_lojaFiltro.Codigo == 2)
> >                         return 20
> >                 else
> >                         return 30;
> >         }

> > }

> > No entanto, eu só vou descobrir este valor em runtime, logo não posso
> > mais resolver essa dependência com container tão facilmente.

> > Uma opção seria criar uma AbstractFactory e injeta-la no GeradorPedido
> > que utilizaria a factory pra criar o Precificador passando o parametro
> > recebido em runtime. O único problema disso é que dessa forma o
> > GeradorPedido que não tem nada a ver com a história também vira
> > dependente da Loja, pois ele deve recebe-la pra poder passar para
> > factory.

> > Alguma outra sugestão?

> --
> Você recebeu esta mensagem porque faz parte do grupo .Net Architects
> hospedado no Google Groups.
> Para postar envie uma mensagem para dotnetarchitects@googlegroups.com
> Para sair do grupo envie uma mensagem para
> dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com>
> Para mais opções visite o grupo em
> http://groups.google.com/group/dotnetarchitects?hl=pt-br

> Oi, Vinicius,

> Achei mesmo que tinha entendido seu conceito.

> Contudo minha afirmação é realmente sobre o conceito da especialidade por
> domínio. Não consigo imaginar um domínio que precise de mais de um
> especialista na função de gerar pedidos.

> Claro que o algoritmo de geração de pedido pode variar, como é o caso do
> nosso amigo tuca, entretanto não é necessário solicitar isto para um outro
> especialista na função, basta que ele saiba qual é o algoritmo de geração
> que precisa utilizar e dar o resultado desejado.

> Por este motivo acredito que um Strategy mesclado com FactoryMethod e
> talvez um TemplateMethod resolva o problema.

> Eu só iria considerar utilizar um container para os Precificadores, que aí
> sim pode haver a necessidade de consultar mais que um neste domínio.

> []'s

> Ricardo Simões

> 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

>> Então ricardo, eu disse um Builder por que pelo que entendi mais de um
>> lugar usa o Gerador, e o gerador depende de um IPrecificador, que por sua
>> vez depende de uma loja.

>> Para matar essa dependência com a loja, crio uma fábrica de
>> EstratégiasDePrecificacao, e depois de obter passo a estratégia para o
>> Gerador.

>> Na verdade o Builder seria para ocultar os passos da criação do Gerador
>> apenas.

>> *Vinicius Quaiato*
>> http://viniciusquaiato.com

>> Twitter <http://vquaiato>
>> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
>> vinicius.quai...@gmail.com

>> 2010/7/28 Ricardo Simões <rsc....@gmail.com>

>>> Oi,

>>> Só não concordo com o Vinicius em ter que criar um Builder para isso, uma
>>> fabrica de estratégias já seria suficiente para criar seu especialista na
>>> precificação.

>>> Além do mais não estou entendendo porque o GeradorDePedido precisa de um
>>> container DI para ser criado.

>>> Ele me parece ser um serviço especialista na função, e normalmente
>>> teremos um único especialista na função por domínio.

>>> Digo isso, porque imagino que no seu domínio você não precise de um
>>> GeradorDePedidoDeCarros, GeradorDePedidosDeImoveis...

>>> Ao que parece o container vai morrer mesmo...

>>> []'s

>>> Ricardo Simões

>>> 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

>>>> Não sei se precisa de uma AbstractFactory Tuca.

>>>> Seu ponto é conseguir criar o GeradorDePedido, que agora depende de uma
>>>> Loja que só é conhecida em runtime.

>>>> Isso está mais para um Builder. E eu abriria mão do container nessa
>>>> situação. O builder recebendo uma Loja cria o seu Gerador.

>>>> Afinal o Gerado não muda por causa da loja, o que muda é o Precificador,
>>>> por isso acho que não cabe uma abstract factory.

>>>> E sobre a dependência de outro sobre IPrecificador, utilizaria uma
>>>> fábrica para eles, baseado na loja. E essa fábrica será também consumida
>>>> pelo Builder.

>>>> Acho que o container vai dançar. Ou se alguém souber umas mágicas mais
>>>> avançadas, manda aê.

>>>>  *Vinicius Quaiato*
>>>> http://viniciusquaiato.com

>>>> Twitter <http://vquaiato>
>>>> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
>>>> vinicius.quai...@gmail.com

>>>> 2010/7/28 tucaz <tuca...@gmail.com>

>>>> O container já existe. Estou mexendo em um código que criei
>>>>> anteriormente e inclusive já existem alguns objetos que dependem de
>>>>> GeradorPedido e outros que também dependem de IPrecificador.

>>>>> A idéia de abstract factory é boa, mas traz a dependência pra todo
>>>>> mundo que consome IPrecificador. Outra alternativa seria fazer injeção
>>>>> por Property ou usar um método pra Inicializar a classe, mas não gosto
>>>>> muito dessa idéia.

>>>>> On Jul 28, 12:12 pm, Vinicius Quaiato <vinicius.quai...@gmail.com>
>>>>> wrote:
>>>>> > É vdd...

>>>>> > Mas, você precisa mesmo de um container nesse ponto específico? Pelo
>>>>> que
>>>>> > vejo, o código está uando IoC e DI, só não está usando um container.

>>>>> > Qual sua intenção em usar um container nesse caso?

>>>>> > *Vinicius Quaiato*http://viniciusquaiato.com

>>>>> > Twitter <vquaiato>
>>>>> > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
>>>>> > vinicius.quai...@gmail.com

>>>>> > 2010/7/28 tucaz <tuca...@gmail.com>

>>>>> > > É esse o cenário mesmo Vinicius, mas não consigo ver uma forma de
>>>>> > > passar isso pro container. Seu exemplo não está cobrindo o uso do
>>>>> > > container.

>>>>> > > On Jul 28, 11:57 am, Vinicius Quaiato <vinicius.quai...@gmail.com>
>>>>> > > wrote:
>>>>> > > > Tuca,

>>>>> > > > Se você trabalhasse com isso não no nível do GeradorDePedido, mas
>>>>> no
>>>>> > > nível
>>>>> > > > da aplicação. A aplicação sabe qual a loja, cria então(ou obtém)
>>>>> um
>>>>> > > > Precificador para esta loja, e passa o precificador para o
>>>>> Gerador.

>>>>> > > > Na verdade acho que o Precificador nem deve conhecer a loja, mas
>>>>> talvez
>>>>> > > uma
>>>>> > > > estratégia de preços por loja, algo assim.

>>>>> > > > por exmeplo:

>>>>> > > > //classe que coordena esse processo
>>>>> > > > public void ExecutarTodoEsseProcesso(Loja lojaSelecionada)
>>>>> > > > {
>>>>> > > >    //interface que o precificador conhece
>>>>> > > >    var estrategiaDePrecosPorLoja =
>>>>> > > > FabricaDeEstrategiasDePreco(lojaSelecionada);

>>>>> > > >    var precificador = new
>>>>> Precificador(estrategiaDePrecosPorLoja);

>>>>> > > >    var geradorDePedido = new GeradorDePedido(precificador);

>>>>> > > > }

>>>>> > > > Assim você pode continuar usando o container para resolver o
>>>>> Gerador.

>>>>> > > > abraços,

>>>>> > > > *Vinicius Quaiato*http://viniciusquaiato.com

>>>>> > > > Twitter <vquaiato>
>>>>> > > > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
>>>>> > > > vinicius.quai...@gmail.com

>>>>> > > > 2010/7/28 tucaz <tuca...@gmail.com>

>>>>> > > > > Oi!

>>>>> > > > > Temos falado muito em testes e DI/IoC ultimamente, mas acabamos
>>>>> não
>>>>> > > > > vendo código. Pra resolver isso tenho um problema que estou
>>>>> > > > > enfrentando e queria os palpites de vocês.

>>>>> > > > > Tenho duas classes: GeradorPedidos e Precificador. Para gerar
>>>>> um
>>>>> > > > > pedido, minha classe precisa de uma instância de Precificador
>>>>> que é a
>>>>> > > > > responsável por fornecer os preços dos produtos. Algo assim:

>>>>> > > > > public class GeradorPedido
>>>>> > > > > {
>>>>> > > > >        private IPrecificador _precificador;
>>>>> > > > >        public GeradorPedido(IPrecificador _precificador)
>>>>> > > > >        {
>>>>> > > > >                _precificador = precificador;
>>>>> > > > >        }

>>>>> > > > >        public void GerarPedido(Pedido novoPedido)
>>>>> > > > >        {
>>>>> > > > >                var total = 0;
>>>>> > > > >                foreach(var item in novoPedido.Itens)
>>>>> > > > >                {
>>>>> > > > >                        total +=
>>>>> _precificador.QuantoCusta(item);
>>>>> > > > >                }
>>>>> > > > >                //faz mais um monte de coisas
>>>>> > > > >        }
>>>>> > > > > }

>>>>> > > > > Esquema bem simples pra qualquer container de DI/IoC resolver.
>>>>> Peço
>>>>> > > > > pro meu container uma instância da classe GeradorPedido e
>>>>> > > > > automaticamente ele injeta uma nova instância da classe
>>>>> Precificador
>>>>> > > > > do jeitinho que eu esperava.

>>>>> > > > > Agora vem o problema...

>>>>> > > > > Aparece um novo requisito que diz que o preço deve variar de
>>>>> acordo
>>>>> > > > > com a loja, portanto Precificador depende agora também de loja:

>>>>> > > > > public class Precificador : IPrecificador
>>>>> > > > > {
>>>>> > > > >        private Loja _lojaFiltro;
>>>>> > > > >        public Precificador(Loja lojaFiltro)
>>>>> > > > >        {
>>>>> > > > >                _lojaFiltro = lojaFiltro;
>>>>> > > > >        }

>>>>> > > > >        public int QuantoCusta(Item itemAPrecificar)
>>>>> > > > >        {
>>>>> > > > >                //retorna o preço de acordo com a loja
>>>>> > > > >                if(_lojaFiltro.Codigo == 1)
>>>>> > > > >                        return 10;
>>>>> > > > >                else if(_lojaFiltro.Codigo == 2)
>>>>> > > > >                        return 20
>>>>> > > > >                else
>>>>> > > > >                        return 30;
>>>>> > > > >        }
>>>>> > > > > }

>>>>> > > > > No entanto, eu só vou descobrir este valor em runtime, logo não
>>>>> posso
>>>>> > > > > mais resolver essa dependência com container tão facilmente.

>>>>> > > > > Uma opção seria criar uma AbstractFactory e injeta-la no
>>>>> GeradorPedido
>>>>> > > > > que utilizaria a factory pra criar o Precificador passando o
>>>>> parametro
>>>>> > > > > recebido em runtime. O único problema disso é que dessa forma o
>>>>> > > > > GeradorPedido que não tem nada a ver com a história

> Olhá quem está por aqui!!!

> Sejá bem vindo, tenho certeza que as suas ideias irão contribuir muito para
> a comunidade .Net!

> Abraços,

> Victor Cavalcante

> 2010/7/28 felipe <felip...@gmail.com>

> > Fala moçada.

> > Meu primeiro post aqui na comunidade. Tenho muita experiência em
> > outras plataformas. Mas bora ver se consigo ajudar em forma de
> > analogia com Java. :P

> > No Java o Spring, container de DI/IoC mais utilizado tem a
> > possibilidade de receber uma indicação de qual factory ele usa pra
> > instanciar uma dependência.
> > Dessa forma, você poderia usar uma factory, como vc mesmo sugeriu, mas
> > ao invés de invocar a factory a partir do GeradordPedido, o container
> > de IoC invoca a Factory pra você. Logo, você não precisa de uma
> > instância de Loja no GeradorPedido.

> > Isso resolveria o seu problema, a minha pergunta agora é: Tem isso
> > em .NET? (Qual é o container de DI/IoC utilizado nesse caso?)

> > PS: Reforço que não manjo muito de .NET.

> > []'s

> > Felipe

> > On Jul 28, 11:16 am, tucaz <tuca...@gmail.com> wrote:
> > > Oi!

> > > Temos falado muito em testes e DI/IoC ultimamente, mas acabamos não
> > > vendo código. Pra resolver isso tenho um problema que estou
> > > enfrentando e queria os palpites de vocês.

> > > Tenho duas classes: GeradorPedidos e Precificador. Para gerar um
> > > pedido, minha classe precisa de uma instância de Precificador que é a
> > > responsável por fornecer os preços dos produtos. Algo assim:

> > > public class GeradorPedido
> > > {
> > >         private IPrecificador _precificador;
> > >         public GeradorPedido(IPrecificador _precificador)
> > >         {
> > >                 _precificador = precificador;
> > >         }

> > >         public void GerarPedido(Pedido novoPedido)
> > >         {
> > >                 var total = 0;
> > >                 foreach(var item in novoPedido.Itens)
> > >                 {
> > >                         total += _precificador.QuantoCusta(item);
> > >                 }
> > >                 //faz mais um monte de coisas
> > >         }

> > > }

> > > Esquema bem simples pra qualquer container de DI/IoC resolver. Peço
> > > pro meu container uma instância da classe GeradorPedido e
> > > automaticamente ele injeta uma nova instância da classe Precificador
> > > do jeitinho que eu esperava.

> > > Agora vem o problema...

> > > Aparece um novo requisito que diz que o preço deve variar de acordo
> > > com a loja, portanto Precificador depende agora também de loja:

> > > public class Precificador : IPrecificador
> > > {
> > >         private Loja _lojaFiltro;
> > >         public Precificador(Loja lojaFiltro)
> > >         {
> > >                 _lojaFiltro = lojaFiltro;
> > >         }

> > >         public int QuantoCusta(Item itemAPrecificar)
> > >         {
> > >                 //retorna o preço de acordo com a loja
> > >                 if(_lojaFiltro.Codigo == 1)
> > >                         return 10;
> > >                 else if(_lojaFiltro.Codigo == 2)
> > >                         return 20
> > >                 else
> > >                         return 30;
> > >         }

> > > }

> > > No entanto, eu só vou descobrir este valor em runtime, logo não posso
> > > mais resolver essa dependência com container tão facilmente.

> > > Uma opção seria criar uma AbstractFactory e injeta-la no GeradorPedido
> > > que utilizaria a factory pra criar o Precificador passando o parametro
> > > recebido em runtime. O único problema disso é que dessa forma o
> > > GeradorPedido que não tem nada a ver com a história também vira
> > > dependente da Loja, pois ele deve recebe-la pra poder passar para
> > > factory.

> > > Alguma outra sugestão?

> > --
> > Você recebeu esta mensagem porque faz parte do grupo .Net Architects
> > hospedado no Google Groups.
> > Para postar envie uma mensagem para dotnetarchitects@googlegroups.com
> > Para sair do grupo envie uma mensagem para
> > dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com>
> > Para mais opções visite o grupo em
> >http://groups.google.com/group/dotnetarchitects?hl=pt-br

> Fala moçada.

> Meu primeiro post aqui na comunidade. Tenho muita experiência em
> outras plataformas. Mas bora ver se consigo ajudar em forma de
> analogia com Java. :P

> No Java o Spring, container de DI/IoC mais utilizado tem a
> possibilidade de receber uma indicação de qual factory ele usa pra
> instanciar uma dependência.
> Dessa forma, você poderia usar uma factory, como vc mesmo sugeriu, mas
> ao invés de invocar a factory a partir do GeradordPedido, o container
> de IoC invoca a Factory pra você. Logo, você não precisa de uma
> instância de Loja no GeradorPedido.

> Isso resolveria o seu problema, a minha pergunta agora é: Tem isso
> em .NET? (Qual é o container de DI/IoC utilizado nesse caso?)

> PS: Reforço que não manjo muito de .NET.

> []'s

> Felipe

> On Jul 28, 11:16 am, tucaz <tuca...@gmail.com> wrote:
> > Oi!

> > Temos falado muito em testes e DI/IoC ultimamente, mas acabamos não
> > vendo código. Pra resolver isso tenho um problema que estou
> > enfrentando e queria os palpites de vocês.

> > Tenho duas classes: GeradorPedidos e Precificador. Para gerar um
> > pedido, minha classe precisa de uma instância de Precificador que é a
> > responsável por fornecer os preços dos produtos. Algo assim:

> > public class GeradorPedido
> > {
> >         private IPrecificador _precificador;
> >         public GeradorPedido(IPrecificador _precificador)
> >         {
> >                 _precificador = precificador;
> >         }

> >         public void GerarPedido(Pedido novoPedido)
> >         {
> >                 var total = 0;
> >                 foreach(var item in novoPedido.Itens)
> >                 {
> >                         total += _precificador.QuantoCusta(item);
> >                 }
> >                 //faz mais um monte de coisas
> >         }

> > }

> > Esquema bem simples pra qualquer container de DI/IoC resolver. Peço
> > pro meu container uma instância da classe GeradorPedido e
> > automaticamente ele injeta uma nova instância da classe Precificador
> > do jeitinho que eu esperava.

> > Agora vem o problema...

> > Aparece um novo requisito que diz que o preço deve variar de acordo
> > com a loja, portanto Precificador depende agora também de loja:

> > public class Precificador : IPrecificador
> > {
> >         private Loja _lojaFiltro;
> >         public Precificador(Loja lojaFiltro)
> >         {
> >                 _lojaFiltro = lojaFiltro;
> >         }

> >         public int QuantoCusta(Item itemAPrecificar)
> >         {
> >                 //retorna o preço de acordo com a loja
> >                 if(_lojaFiltro.Codigo == 1)
> >                         return 10;
> >                 else if(_lojaFiltro.Codigo == 2)
> >                         return 20
> >                 else
> >                         return 30;
> >         }

> > }

> > No entanto, eu só vou descobrir este valor em runtime, logo não posso
> > mais resolver essa dependência com container tão facilmente.

> > Uma opção seria criar uma AbstractFactory e injeta-la no GeradorPedido
> > que utilizaria a factory pra criar o Precificador passando o parametro
> > recebido em runtime. O único problema disso é que dessa forma o
> > GeradorPedido que não tem nada a ver com a história também vira
> > dependente da Loja, pois ele deve recebe-la pra poder passar para
> > factory.

> > Alguma outra sugestão?

> --
> Você recebeu esta mensagem porque faz parte do grupo .Net Architects
> hospedado no Google Groups.
> Para postar envie uma mensagem para dotnetarchitects@googlegroups.com
> Para sair do grupo envie uma mensagem para
> dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com>
> Para mais opções visite o grupo em
> http://groups.google.com/group/dotnetarchitects?hl=pt-br

> Fala moçada.

> Meu primeiro post aqui na comunidade. Tenho muita experiência em
> outras plataformas. Mas bora ver se consigo ajudar em forma de
> analogia com Java. :P

> No Java o Spring, container de DI/IoC mais utilizado tem a
> possibilidade de receber uma indicação de qual factory ele usa pra
> instanciar uma dependência.
> Dessa forma, você poderia usar uma factory, como vc mesmo sugeriu, mas
> ao invés de invocar a factory a partir do GeradordPedido, o container
> de IoC invoca a Factory pra você. Logo, você não precisa de uma
> instância de Loja no GeradorPedido.

> Isso resolveria o seu problema, a minha pergunta agora é: Tem isso
> em .NET? (Qual é o container de DI/IoC utilizado nesse caso?)

> PS: Reforço que não manjo muito de .NET.

> []'s

> Felipe

> On Jul 28, 11:16 am, tucaz <tuca...@gmail.com> wrote:
> > Oi!

> > Temos falado muito em testes e DI/IoC ultimamente, mas acabamos não
> > vendo código. Pra resolver isso tenho um problema que estou
> > enfrentando e queria os palpites de vocês.

> > Tenho duas classes: GeradorPedidos e Precificador. Para gerar um
> > pedido, minha classe precisa de uma instância de Precificador que é a
> > responsável por fornecer os preços dos produtos. Algo assim:

> > public class GeradorPedido
> > {
> >         private IPrecificador _precificador;
> >         public GeradorPedido(IPrecificador _precificador)
> >         {
> >                 _precificador = precificador;
> >         }

> >         public void GerarPedido(Pedido novoPedido)
> >         {
> >                 var total = 0;
> >                 foreach(var item in novoPedido.Itens)
> >                 {
> >                         total += _precificador.QuantoCusta(item);
> >                 }
> >                 //faz mais um monte de coisas
> >         }

> > }

> > Esquema bem simples pra qualquer container de DI/IoC resolver. Peço
> > pro meu container uma instância da classe GeradorPedido e
> > automaticamente ele injeta uma nova instância da classe Precificador
> > do jeitinho que eu esperava.

> > Agora vem o problema...

> > Aparece um novo requisito que diz que o preço deve variar de acordo
> > com a loja, portanto Precificador depende agora também de loja:

> > public class Precificador : IPrecificador
> > {
> >         private Loja _lojaFiltro;
> >         public Precificador(Loja lojaFiltro)
> >         {
> >                 _lojaFiltro = lojaFiltro;
> >         }

> >         public int QuantoCusta(Item itemAPrecificar)
> >         {
> >                 //retorna o preço de acordo com a loja
> >                 if(_lojaFiltro.Codigo == 1)
> >                         return 10;
> >                 else if(_lojaFiltro.Codigo == 2)
> >                         return 20
> >                 else
> >                         return 30;
> >         }

> > }

> > No entanto, eu só vou descobrir este valor em runtime, logo não posso
> > mais resolver essa dependência com container tão facilmente.

> > Uma opção seria criar uma AbstractFactory e injeta-la no GeradorPedido
> > que utilizaria a factory pra criar o Precificador passando o parametro
> > recebido em runtime. O único problema disso é que dessa forma o
> > GeradorPedido que não tem nada a ver com a história também vira
> > dependente da Loja, pois ele deve recebe-la pra poder passar para
> > factory.

> > Alguma outra sugestão?

> --
> Você recebeu esta mensagem porque faz parte do grupo .Net Architects
> hospedado no Google Groups.
> Para postar envie uma mensagem para dotnetarchitects@googlegroups.com
> Para sair do grupo envie uma mensagem para
> dotnetarchitects+unsubscribe@googlegroups.com<dotnetarchitects%2Bunsubscrib e@googlegroups.com>
> Para mais opções visite o grupo em
> http://groups.google.com/group/dotnetarchitects?hl=pt-br

}

> Puts Ricardo,
> Ou eu não entendi nada do que vc falou, ou vc criou um monstro :P

> Concordo com o que vc disse sobre a especialidade. Mas o que isso tem com o
> Builder? Um Buider cria objetos em partes, só isso.

> Pelo que entendi do Tuca, não existem vários Geradores diferentes, o que
> muda é o Precificador que vai dentro do Gerador, este por sua vez que
> depende da Loja conhecida em runtime.

> Sendo assim, não dá mesmo para usar um container para o precificador, e por
> isso sugeri uma estratégia baseada na Loja para conter o precificador.

> *Vinicius Quaiato*
> http://viniciusquaiato.com

> Twitter <http://vquaiato>
> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> vinicius.quai...@gmail.com

> 2010/7/28 Ricardo Simões <rsc....@gmail.com>

>> Oi, Vinicius,

>> Achei mesmo que tinha entendido seu conceito.

>> Contudo minha afirmação é realmente sobre o conceito da especialidade por
>> domínio. Não consigo imaginar um domínio que precise de mais de um
>> especialista na função de gerar pedidos.

>> Claro que o algoritmo de geração de pedido pode variar, como é o caso do
>> nosso amigo tuca, entretanto não é necessário solicitar isto para um outro
>> especialista na função, basta que ele saiba qual é o algoritmo de geração
>> que precisa utilizar e dar o resultado desejado.

>> Por este motivo acredito que um Strategy mesclado com FactoryMethod e
>> talvez um TemplateMethod resolva o problema.

>> Eu só iria considerar utilizar um container para os Precificadores, que aí
>> sim pode haver a necessidade de consultar mais que um neste domínio.

>> []'s

>> Ricardo Simões

>> 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

>>> Então ricardo, eu disse um Builder por que pelo que entendi mais de um
>>> lugar usa o Gerador, e o gerador depende de um IPrecificador, que por sua
>>> vez depende de uma loja.

>>> Para matar essa dependência com a loja, crio uma fábrica de
>>> EstratégiasDePrecificacao, e depois de obter passo a estratégia para o
>>> Gerador.

>>> Na verdade o Builder seria para ocultar os passos da criação do Gerador
>>> apenas.

>>> *Vinicius Quaiato*
>>> http://viniciusquaiato.com

>>> Twitter <http://vquaiato>
>>> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
>>> vinicius.quai...@gmail.com

>>> 2010/7/28 Ricardo Simões <rsc....@gmail.com>

>>>> Oi,

>>>> Só não concordo com o Vinicius em ter que criar um Builder para isso,
>>>> uma fabrica de estratégias já seria suficiente para criar seu especialista
>>>> na precificação.

>>>> Além do mais não estou entendendo porque o GeradorDePedido precisa de um
>>>> container DI para ser criado.

>>>> Ele me parece ser um serviço especialista na função, e normalmente
>>>> teremos um único especialista na função por domínio.

>>>> Digo isso, porque imagino que no seu domínio você não precise de um
>>>> GeradorDePedidoDeCarros, GeradorDePedidosDeImoveis...

>>>> Ao que parece o container vai morrer mesmo...

>>>> []'s

>>>> Ricardo Simões

>>>> 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

>>>>> Não sei se precisa de uma AbstractFactory Tuca.

>>>>> Seu ponto é conseguir criar o GeradorDePedido, que agora depende de uma
>>>>> Loja que só é conhecida em runtime.

>>>>> Isso está mais para um Builder. E eu abriria mão do container nessa
>>>>> situação. O builder recebendo uma Loja cria o seu Gerador.

>>>>> Afinal o Gerado não muda por causa da loja, o que muda é o
>>>>> Precificador, por isso acho que não cabe uma abstract factory.

>>>>> E sobre a dependência de outro sobre IPrecificador, utilizaria uma
>>>>> fábrica para eles, baseado na loja. E essa fábrica será também consumida
>>>>> pelo Builder.

>>>>> Acho que o container vai dançar. Ou se alguém souber umas mágicas mais
>>>>> avançadas, manda aê.

>>>>>  *Vinicius Quaiato*
>>>>> http://viniciusquaiato.com

>>>>> Twitter <http://vquaiato>
>>>>> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
>>>>> vinicius.quai...@gmail.com

>>>>> 2010/7/28 tucaz <tuca...@gmail.com>

>>>>> O container já existe. Estou mexendo em um código que criei
>>>>>> anteriormente e inclusive já existem alguns objetos que dependem de
>>>>>> GeradorPedido e outros que também dependem de IPrecificador.

>>>>>> A idéia de abstract factory é boa, mas traz a dependência pra todo
>>>>>> mundo que consome IPrecificador. Outra alternativa seria fazer injeção
>>>>>> por Property ou usar um método pra Inicializar a classe, mas não gosto
>>>>>> muito dessa idéia.

>>>>>> On Jul 28, 12:12 pm, Vinicius Quaiato <vinicius.quai...@gmail.com>
>>>>>> wrote:
>>>>>> > É vdd...

>>>>>> > Mas, você precisa mesmo de um container nesse ponto específico? Pelo
>>>>>> que
>>>>>> > vejo, o código está uando IoC e DI, só não está usando um container.

>>>>>> > Qual sua intenção em usar um container nesse caso?

>>>>>> > *Vinicius Quaiato*http://viniciusquaiato.com

>>>>>> > Twitter <vquaiato>
>>>>>> > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
>>>>>> > vinicius.quai...@gmail.com

>>>>>> > 2010/7/28 tucaz <tuca...@gmail.com>

>>>>>> > > É esse o cenário mesmo Vinicius, mas não consigo ver uma forma de
>>>>>> > > passar isso pro container. Seu exemplo não está cobrindo o uso do
>>>>>> > > container.

>>>>>> > > On Jul 28, 11:57 am, Vinicius Quaiato <vinicius.quai...@gmail.com

>>>>>> > > wrote:
>>>>>> > > > Tuca,

>>>>>> > > > Se você trabalhasse com isso não no nível do GeradorDePedido,
>>>>>> mas no
>>>>>> > > nível
>>>>>> > > > da aplicação. A aplicação sabe qual a loja, cria então(ou obtém)
>>>>>> um
>>>>>> > > > Precificador para esta loja, e passa o precificador para o
>>>>>> Gerador.

>>>>>> > > > Na verdade acho que o Precificador nem deve conhecer a loja, mas
>>>>>> talvez
>>>>>> > > uma
>>>>>> > > > estratégia de preços por loja, algo assim.

>>>>>> > > > por exmeplo:

>>>>>> > > > //classe que coordena esse processo
>>>>>> > > > public void ExecutarTodoEsseProcesso(Loja lojaSelecionada)
>>>>>> > > > {
>>>>>> > > >    //interface que o precificador conhece
>>>>>> > > >    var estrategiaDePrecosPorLoja =
>>>>>> > > > FabricaDeEstrategiasDePreco(lojaSelecionada);

>>>>>> > > >    var precificador = new
>>>>>> Precificador(estrategiaDePrecosPorLoja);

>>>>>> > > >    var geradorDePedido = new GeradorDePedido(precificador);

>>>>>> > > > }

>>>>>> > > > Assim você pode continuar usando o container para resolver o
>>>>>> Gerador.

>>>>>> > > > abraços,

>>>>>> > > > *Vinicius Quaiato*http://viniciusquaiato.com

>>>>>> > > > Twitter <vquaiato>
>>>>>> > > > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
>>>>>> > > > vinicius.quai...@gmail.com

>>>>>> > > > 2010/7/28 tucaz <tuca...@gmail.com>

>>>>>> > > > > Oi!

>>>>>> > > > > Temos falado muito em testes e DI/IoC ultimamente, mas
>>>>>> acabamos não
>>>>>> > > > > vendo código. Pra resolver isso tenho um problema que estou
>>>>>> > > > > enfrentando e queria os palpites de vocês.

>>>>>> > > > > Tenho duas classes: GeradorPedidos e Precificador. Para gerar
>>>>>> um
>>>>>> > > > > pedido, minha classe precisa de uma instância de Precificador
>>>>>> que é a
>>>>>> > > > > responsável por fornecer os preços dos produtos. Algo assim:

>>>>>> > > > > public class GeradorPedido
>>>>>> > > > > {
>>>>>> > > > >        private IPrecificador _precificador;
>>>>>> > > > >        public GeradorPedido(IPrecificador _precificador)
>>>>>> > > > >        {
>>>>>> > > > >                _precificador = precificador;
>>>>>> > > > >        }

>>>>>> > > > >        public void GerarPedido(Pedido novoPedido)
>>>>>> > > > >        {
>>>>>> > > > >                var total = 0;
>>>>>> > > > >                foreach(var item in novoPedido.Itens)
>>>>>> > > > >                {
>>>>>> > > > >                        total +=
>>>>>> _precificador.QuantoCusta(item);
>>>>>> > > > >                }
>>>>>> > > > >                //faz mais um monte de coisas
>>>>>> > > > >        }
>>>>>> > > > > }

>>>>>> > > > > Esquema bem simples pra qualquer container de DI/IoC resolver.
>>>>>> Peço
>>>>>> > > > > pro meu container uma instância da classe GeradorPedido e
>>>>>> > > > > automaticamente ele injeta uma nova instância da classe
>>>>>> Precificador
>>>>>> > > > > do jeitinho que eu esperava.

>>>>>> > > > > Agora vem o problema...

>>>>>> > > > > Aparece um novo requisito que diz que o preço deve variar de
>>>>>> acordo
>>>>>> > > > > com a loja, portanto Precificador depende agora também de
>>>>>> loja:

>>>>>> > > > > public class Precificador : IPrecificador
>>>>>> > > > > {

> Oi,

> Sobre o Builder,  para a solução em questão não vejo a necessidade de sua
> utilização. Só isso.

> O que eu quis ilustrar foi o seguinte trecho de código.

> //Trecho de código que você ilustrou
> public void ExecutarTodoEsseProcesso(Loja lojaSelecionada)
> {
>    var precificadorEscolhido =
> AbstracaoDoContainer.CriarInstanciaDe<IPrecificador>(lojaSelecionada);

>    var geradorDePedido = new GeradorDePedido(precificadorEscolhido);
>    geradorDePedido.GerarNovo(pedido);
> }

> Aqui um trecho de código que o método GerarNovo poderia encapsular.

> // Se desejar variar o algoritmo de geração de acordo com o tipo ou alguma
> outra informação do pedido de pedido.
> var estrategia =
> FabricaDeEstrategias.Fabricar<IEstrategiaDeGeracaoDePedidos>(pedido);

> this.GerarNovoPedidoBaseadoEm(estrategia, precificador);

> Aí está a minha idéia inicial.

> []'s

> Ricardo Simões

> 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

>> Puts Ricardo,
>> Ou eu não entendi nada do que vc falou, ou vc criou um monstro :P

>> Concordo com o que vc disse sobre a especialidade. Mas o que isso tem com
>> o Builder? Um Buider cria objetos em partes, só isso.

>> Pelo que entendi do Tuca, não existem vários Geradores diferentes, o que
>> muda é o Precificador que vai dentro do Gerador, este por sua vez que
>> depende da Loja conhecida em runtime.

>> Sendo assim, não dá mesmo para usar um container para o precificador, e
>> por isso sugeri uma estratégia baseada na Loja para conter o precificador.

>> *Vinicius Quaiato*
>> http://viniciusquaiato.com

>> Twitter <http://vquaiato>
>> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
>> vinicius.quai...@gmail.com

>> 2010/7/28 Ricardo Simões <rsc....@gmail.com>

>>> Oi, Vinicius,

>>> Achei mesmo que tinha entendido seu conceito.

>>> Contudo minha afirmação é realmente sobre o conceito da especialidade por
>>> domínio. Não consigo imaginar um domínio que precise de mais de um
>>> especialista na função de gerar pedidos.

>>> Claro que o algoritmo de geração de pedido pode variar, como é o caso do
>>> nosso amigo tuca, entretanto não é necessário solicitar isto para um outro
>>> especialista na função, basta que ele saiba qual é o algoritmo de geração
>>> que precisa utilizar e dar o resultado desejado.

>>> Por este motivo acredito que um Strategy mesclado com FactoryMethod e
>>> talvez um TemplateMethod resolva o problema.

>>> Eu só iria considerar utilizar um container para os Precificadores, que
>>> aí sim pode haver a necessidade de consultar mais que um neste domínio.

>>> []'s

>>> Ricardo Simões

>>> 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

>>>> Então ricardo, eu disse um Builder por que pelo que entendi mais de um
>>>> lugar usa o Gerador, e o gerador depende de um IPrecificador, que por sua
>>>> vez depende de uma loja.

>>>> Para matar essa dependência com a loja, crio uma fábrica de
>>>> EstratégiasDePrecificacao, e depois de obter passo a estratégia para o
>>>> Gerador.

>>>> Na verdade o Builder seria para ocultar os passos da criação do Gerador
>>>> apenas.

>>>> *Vinicius Quaiato*
>>>> http://viniciusquaiato.com

>>>> Twitter <http://vquaiato>
>>>> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
>>>> vinicius.quai...@gmail.com

>>>> 2010/7/28 Ricardo Simões <rsc....@gmail.com>

>>>>> Oi,

>>>>> Só não concordo com o Vinicius em ter que criar um Builder para isso,
>>>>> uma fabrica de estratégias já seria suficiente para criar seu especialista
>>>>> na precificação.

>>>>> Além do mais não estou entendendo porque o GeradorDePedido precisa de
>>>>> um container DI para ser criado.

>>>>> Ele me parece ser um serviço especialista na função, e normalmente
>>>>> teremos um único especialista na função por domínio.

>>>>> Digo isso, porque imagino que no seu domínio você não precise de um
>>>>> GeradorDePedidoDeCarros, GeradorDePedidosDeImoveis...

>>>>> Ao que parece o container vai morrer mesmo...

>>>>> []'s

>>>>> Ricardo Simões

>>>>> 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

>>>>>> Não sei se precisa de uma AbstractFactory Tuca.

>>>>>> Seu ponto é conseguir criar o GeradorDePedido, que agora depende de
>>>>>> uma Loja que só é conhecida em runtime.

>>>>>> Isso está mais para um Builder. E eu abriria mão do container nessa
>>>>>> situação. O builder recebendo uma Loja cria o seu Gerador.

>>>>>> Afinal o Gerado não muda por causa da loja, o que muda é o
>>>>>> Precificador, por isso acho que não cabe uma abstract factory.

>>>>>> E sobre a dependência de outro sobre IPrecificador, utilizaria uma
>>>>>> fábrica para eles, baseado na loja. E essa fábrica será também consumida
>>>>>> pelo Builder.

>>>>>> Acho que o container vai dançar. Ou se alguém souber umas mágicas mais
>>>>>> avançadas, manda aê.

>>>>>>  *Vinicius Quaiato*
>>>>>> http://viniciusquaiato.com

>>>>>> Twitter <http://vquaiato>
>>>>>> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
>>>>>> vinicius.quai...@gmail.com

>>>>>> 2010/7/28 tucaz <tuca...@gmail.com>

>>>>>> O container já existe. Estou mexendo em um código que criei
>>>>>>> anteriormente e inclusive já existem alguns objetos que dependem de
>>>>>>> GeradorPedido e outros que também dependem de IPrecificador.

>>>>>>> A idéia de abstract factory é boa, mas traz a dependência pra todo
>>>>>>> mundo que consome IPrecificador. Outra alternativa seria fazer
>>>>>>> injeção
>>>>>>> por Property ou usar um método pra Inicializar a classe, mas não
>>>>>>> gosto
>>>>>>> muito dessa idéia.

>>>>>>> On Jul 28, 12:12 pm, Vinicius Quaiato <vinicius.quai...@gmail.com>
>>>>>>> wrote:
>>>>>>> > É vdd...

>>>>>>> > Mas, você precisa mesmo de um container nesse ponto específico?
>>>>>>> Pelo que
>>>>>>> > vejo, o código está uando IoC e DI, só não está usando um
>>>>>>> container.

>>>>>>> > Qual sua intenção em usar um container nesse caso?

>>>>>>> > *Vinicius Quaiato*http://viniciusquaiato.com

>>>>>>> > Twitter <vquaiato>
>>>>>>> > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
>>>>>>> > vinicius.quai...@gmail.com

>>>>>>> > 2010/7/28 tucaz <tuca...@gmail.com>

>>>>>>> > > É esse o cenário mesmo Vinicius, mas não consigo ver uma forma de
>>>>>>> > > passar isso pro container. Seu exemplo não está cobrindo o uso do
>>>>>>> > > container.

>>>>>>> > > On Jul 28, 11:57 am, Vinicius Quaiato <
>>>>>>> vinicius.quai...@gmail.com>
>>>>>>> > > wrote:
>>>>>>> > > > Tuca,

>>>>>>> > > > Se você trabalhasse com isso não no nível do GeradorDePedido,
>>>>>>> mas no
>>>>>>> > > nível
>>>>>>> > > > da aplicação. A aplicação sabe qual a loja, cria então(ou
>>>>>>> obtém) um
>>>>>>> > > > Precificador para esta loja, e passa o precificador para o
>>>>>>> Gerador.

>>>>>>> > > > Na verdade acho que o Precificador nem deve conhecer a loja,
>>>>>>> mas talvez
>>>>>>> > > uma
>>>>>>> > > > estratégia de preços por loja, algo assim.

>>>>>>> > > > por exmeplo:

>>>>>>> > > > //classe que coordena esse processo
>>>>>>> > > > public void ExecutarTodoEsseProcesso(Loja lojaSelecionada)
>>>>>>> > > > {
>>>>>>> > > >    //interface que o precificador conhece
>>>>>>> > > >    var estrategiaDePrecosPorLoja =
>>>>>>> > > > FabricaDeEstrategiasDePreco(lojaSelecionada);

>>>>>>> > > >    var precificador = new
>>>>>>> Precificador(estrategiaDePrecosPorLoja);

>>>>>>> > > >    var geradorDePedido = new GeradorDePedido(precificador);

>>>>>>> > > > }

>>>>>>> > > > Assim você pode continuar usando o container para resolver o
>>>>>>> Gerador.

>>>>>>> > > > abraços,

>>>>>>> > > > *Vinicius Quaiato*http://viniciusquaiato.com

>>>>>>> > > > Twitter <vquaiato>
>>>>>>> > > > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
>>>>>>> > > > vinicius.quai...@gmail.com

>>>>>>> > > > 2010/7/28 tucaz <tuca...@gmail.com>

>>>>>>> > > > > Oi!

>>>>>>> > > > > Temos falado muito em testes e DI/IoC ultimamente, mas
>>>>>>> acabamos não
>>>>>>> > > > > vendo código. Pra resolver isso tenho um problema que estou
>>>>>>> > > > > enfrentando e queria os palpites de vocês.

>>>>>>> > > > > Tenho duas classes: GeradorPedidos e Precificador. Para gerar
>>>>>>> um
>>>>>>> > > > > pedido, minha classe precisa de uma instância de Precificador
>>>>>>> que é a
>>>>>>> > > > > responsável por fornecer os preços dos produtos. Algo assim:

>>>>>>> > > > > public class GeradorPedido
>>>>>>> > > > > {
>>>>>>> > > > >        private IPrecificador _precificador;
>>>>>>> > > > >        public GeradorPedido(IPrecificador _precificador)
>>>>>>> > > > >        {
>>>>>>> > > > >                _precificador = precificador;
>>>>>>> > > > >        }

>>>>>>> > > > >        public void GerarPedido(Pedido novoPedido)
>>>>>>> > > > >        {
>>>>>>> > > > >                var total = 0;
>>>>>>> > > > >                foreach(var item in novoPedido.Itens)
>>>>>>> > > > >                {
>>>>>>> > > > >                        total +=
>>>>>>> _precificador.QuantoCusta(item);
>>>>>>> > > > >                }
>>>>>>> > > > >                //faz mais um monte de coisas
>>>>>>> > > > >        }
>>>>>>> > > > > }

>>>>>>> > > > > Esquema bem simples pra qualquer container de DI/IoC

> Entendi.

> É uma outra abordagem :P

> *Vinicius Quaiato*http://viniciusquaiato.com

> Twitter <vquaiato>
> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> vinicius.quai...@gmail.com

> 2010/7/28 Ricardo Simões <rsc....@gmail.com>

> > Oi,

> > Sobre o Builder,  para a solução em questão não vejo a necessidade de sua
> > utilização. Só isso.

> > O que eu quis ilustrar foi o seguinte trecho de código.

> > //Trecho de código que você ilustrou
> > public void ExecutarTodoEsseProcesso(Loja lojaSelecionada)
> > {
> >    var precificadorEscolhido =
> > AbstracaoDoContainer.CriarInstanciaDe<IPrecificador>(lojaSelecionada);

> >    var geradorDePedido = new GeradorDePedido(precificadorEscolhido);
> >    geradorDePedido.GerarNovo(pedido);
> > }

> > Aqui um trecho de código que o método GerarNovo poderia encapsular.

> > // Se desejar variar o algoritmo de geração de acordo com o tipo ou alguma
> > outra informação do pedido de pedido.
> > var estrategia =
> > FabricaDeEstrategias.Fabricar<IEstrategiaDeGeracaoDePedidos>(pedido);

> > this.GerarNovoPedidoBaseadoEm(estrategia, precificador);

> > Aí está a minha idéia inicial.

> > []'s

> > Ricardo Simões

> > 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

> >> Puts Ricardo,
> >> Ou eu não entendi nada do que vc falou, ou vc criou um monstro :P

> >> Concordo com o que vc disse sobre a especialidade. Mas o que isso tem com
> >> o Builder? Um Buider cria objetos em partes, só isso.

> >> Pelo que entendi do Tuca, não existem vários Geradores diferentes, o que
> >> muda é o Precificador que vai dentro do Gerador, este por sua vez que
> >> depende da Loja conhecida em runtime.

> >> Sendo assim, não dá mesmo para usar um container para o precificador, e
> >> por isso sugeri uma estratégia baseada na Loja para conter o precificador.

> >> *Vinicius Quaiato*
> >>http://viniciusquaiato.com

> >> Twitter <http://vquaiato>
> >> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> >> vinicius.quai...@gmail.com

> >> 2010/7/28 Ricardo Simões <rsc....@gmail.com>

> >>> Oi, Vinicius,

> >>> Achei mesmo que tinha entendido seu conceito.

> >>> Contudo minha afirmação é realmente sobre o conceito da especialidade por
> >>> domínio. Não consigo imaginar um domínio que precise de mais de um
> >>> especialista na função de gerar pedidos.

> >>> Claro que o algoritmo de geração de pedido pode variar, como é o caso do
> >>> nosso amigo tuca, entretanto não é necessário solicitar isto para um outro
> >>> especialista na função, basta que ele saiba qual é o algoritmo de geração
> >>> que precisa utilizar e dar o resultado desejado.

> >>> Por este motivo acredito que um Strategy mesclado com FactoryMethod e
> >>> talvez um TemplateMethod resolva o problema.

> >>> Eu só iria considerar utilizar um container para os Precificadores, que
> >>> aí sim pode haver a necessidade de consultar mais que um neste domínio.

> >>> []'s

> >>> Ricardo Simões

> >>> 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

> >>>> Então ricardo, eu disse um Builder por que pelo que entendi mais de um
> >>>> lugar usa o Gerador, e o gerador depende de um IPrecificador, que por sua
> >>>> vez depende de uma loja.

> >>>> Para matar essa dependência com a loja, crio uma fábrica de
> >>>> EstratégiasDePrecificacao, e depois de obter passo a estratégia para o
> >>>> Gerador.

> >>>> Na verdade o Builder seria para ocultar os passos da criação do Gerador
> >>>> apenas.

> >>>> *Vinicius Quaiato*
> >>>>http://viniciusquaiato.com

> >>>> Twitter <http://vquaiato>
> >>>> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> >>>> vinicius.quai...@gmail.com

> >>>> 2010/7/28 Ricardo Simões <rsc....@gmail.com>

> >>>>> Oi,

> >>>>> Só não concordo com o Vinicius em ter que criar um Builder para isso,
> >>>>> uma fabrica de estratégias já seria suficiente para criar seu especialista
> >>>>> na precificação.

> >>>>> Além do mais não estou entendendo porque o GeradorDePedido precisa de
> >>>>> um container DI para ser criado.

> >>>>> Ele me parece ser um serviço especialista na função, e normalmente
> >>>>> teremos um único especialista na função por domínio.

> >>>>> Digo isso, porque imagino que no seu domínio você não precise de um
> >>>>> GeradorDePedidoDeCarros, GeradorDePedidosDeImoveis...

> >>>>> Ao que parece o container vai morrer mesmo...

> >>>>> []'s

> >>>>> Ricardo Simões

> >>>>> 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

> >>>>>> Não sei se precisa de uma AbstractFactory Tuca.

> >>>>>> Seu ponto é conseguir criar o GeradorDePedido, que agora depende de
> >>>>>> uma Loja que só é conhecida em runtime.

> >>>>>> Isso está mais para um Builder. E eu abriria mão do container nessa
> >>>>>> situação. O builder recebendo uma Loja cria o seu Gerador.

> >>>>>> Afinal o Gerado não muda por causa da loja, o que muda é o
> >>>>>> Precificador, por isso acho que não cabe uma abstract factory.

> >>>>>> E sobre a dependência de outro sobre IPrecificador, utilizaria uma
> >>>>>> fábrica para eles, baseado na loja. E essa fábrica será também consumida
> >>>>>> pelo Builder.

> >>>>>> Acho que o container vai dançar. Ou se alguém souber umas mágicas mais
> >>>>>> avançadas, manda aê.

> >>>>>>  *Vinicius Quaiato*
> >>>>>>http://viniciusquaiato.com

> >>>>>> Twitter <http://vquaiato>
> >>>>>> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> >>>>>> vinicius.quai...@gmail.com

> >>>>>> 2010/7/28 tucaz <tuca...@gmail.com>

> >>>>>> O container já existe. Estou mexendo em um código que criei
> >>>>>>> anteriormente e inclusive já existem alguns objetos que dependem de
> >>>>>>> GeradorPedido e outros que também dependem de IPrecificador.

> >>>>>>> A idéia de abstract factory é boa, mas traz a dependência pra todo
> >>>>>>> mundo que consome IPrecificador. Outra alternativa seria fazer
> >>>>>>> injeção
> >>>>>>> por Property ou usar um método pra Inicializar a classe, mas não
> >>>>>>> gosto
> >>>>>>> muito dessa idéia.

> >>>>>>> On Jul 28, 12:12 pm, Vinicius Quaiato <vinicius.quai...@gmail.com>
> >>>>>>> wrote:
> >>>>>>> > É vdd...

> >>>>>>> > Mas, você precisa mesmo de um container nesse ponto específico?
> >>>>>>> Pelo que
> >>>>>>> > vejo, o código está uando IoC e DI, só não está usando um
> >>>>>>> container.

> >>>>>>> > Qual sua intenção em usar um container nesse caso?

> >>>>>>> > *Vinicius Quaiato*http://viniciusquaiato.com

> >>>>>>> > Twitter <vquaiato>
> >>>>>>> > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> >>>>>>> > vinicius.quai...@gmail.com

> >>>>>>> > 2010/7/28 tucaz <tuca...@gmail.com>

> >>>>>>> > > É esse o cenário mesmo Vinicius, mas não consigo ver uma forma de
> >>>>>>> > > passar isso pro container. Seu exemplo não está cobrindo o uso do
> >>>>>>> > > container.

> >>>>>>> > > On Jul 28, 11:57 am, Vinicius Quaiato <
> >>>>>>> vinicius.quai...@gmail.com>
> >>>>>>> > > wrote:
> >>>>>>> > > > Tuca,

> >>>>>>> > > > Se você trabalhasse com isso não no nível do GeradorDePedido,
> >>>>>>> mas no
> >>>>>>> > > nível
> >>>>>>> > > > da aplicação. A aplicação sabe qual a loja, cria então(ou
> >>>>>>> obtém) um
> >>>>>>> > > > Precificador para esta loja, e passa o precificador para o
> >>>>>>> Gerador.

> >>>>>>> > > > Na verdade acho que o Precificador nem deve conhecer a loja,
> >>>>>>> mas talvez
> >>>>>>> > > uma
> >>>>>>> > > > estratégia de preços por loja, algo assim.

> >>>>>>> > > > por exmeplo:

> >>>>>>> > > > //classe que coordena esse processo
> >>>>>>> > > > public void ExecutarTodoEsseProcesso(Loja lojaSelecionada)
> >>>>>>> > > > {
> >>>>>>> > > >    //interface que o precificador conhece
> >>>>>>> > > >    var estrategiaDePrecosPorLoja =
> >>>>>>> > > > FabricaDeEstrategiasDePreco(lojaSelecionada);

> >>>>>>> > > >    var precificador = new
> >>>>>>> Precificador(estrategiaDePrecosPorLoja);

> >>>>>>> > > >    var geradorDePedido = new GeradorDePedido(precificador);

> >>>>>>> > > > }

> >>>>>>> > > > Assim você pode continuar usando o container para resolver o
> >>>>>>> Gerador.

> >>>>>>> > > > abraços,

> >>>>>>> > > > *Vinicius Quaiato*http://viniciusquaiato.com

> >>>>>>> > > > Twitter <vquaiato>
> >>>>>>> > > > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> >>>>>>> > > > vinicius.quai...@gmail.com

> >>>>>>> > > > 2010/7/28 tucaz <tuca...@gmail.com>

> >>>>>>> > > > > Oi!

> >>>>>>> > > > > Temos falado muito em testes e DI/IoC ultimamente, mas
> >>>>>>> acabamos não
> >>>>>>> > > > > vendo código. Pra resolver isso tenho um problema que estou
> >>>>>>> > > > > enfrentando e queria os palpites de vocês.

> >>>>>>> > > > > Tenho duas classes: GeradorPedidos e Precificador. Para gerar

> As soluções do @Vinicius e do @Ricardo eu já havia chegado. O problema
> é que no meu caso IPrecificador já é utilizado por diversos outros
> objetos então vou ter que criar uma fabrica especifica pra criar cada
> um desses objetos que usem IPrecificador. Além de ser utilizado em
> diversos objetos, como uso container de DI as vezes ele é instanciado
> em Nivel 2 do grafo de objetos, as vezes no Nivel 3.

> @Felipe,

> sua idéia é boa, mas onde vou passar a loja selecionada pra ser usada
> na criação?

> O método que vocês estão chamando de ExecutarTodoEsseProcesso é um
> serviço WCF. Ele é o cara que usa o container de DI pra instanciar o
> GeradorPedido e chamar os métodos que devem ser chamados.

> On Jul 28, 3:22 pm, Vinicius Quaiato <vinicius.quai...@gmail.com>
> wrote:
> > Entendi.

> > É uma outra abordagem :P

> > *Vinicius Quaiato*http://viniciusquaiato.com

> > Twitter <vquaiato>
> > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > vinicius.quai...@gmail.com

> > 2010/7/28 Ricardo Simões <rsc....@gmail.com>

> > > Oi,

> > > Sobre o Builder,  para a solução em questão não vejo a necessidade de
> sua
> > > utilização. Só isso.

> > > O que eu quis ilustrar foi o seguinte trecho de código.

> > > //Trecho de código que você ilustrou
> > > public void ExecutarTodoEsseProcesso(Loja lojaSelecionada)
> > > {
> > >    var precificadorEscolhido =
> > > AbstracaoDoContainer.CriarInstanciaDe<IPrecificador>(lojaSelecionada);

> > >    var geradorDePedido = new GeradorDePedido(precificadorEscolhido);
> > >    geradorDePedido.GerarNovo(pedido);
> > > }

> > > Aqui um trecho de código que o método GerarNovo poderia encapsular.

> > > // Se desejar variar o algoritmo de geração de acordo com o tipo ou
> alguma
> > > outra informação do pedido de pedido.
> > > var estrategia =
> > > FabricaDeEstrategias.Fabricar<IEstrategiaDeGeracaoDePedidos>(pedido);

> > > this.GerarNovoPedidoBaseadoEm(estrategia, precificador);

> > > Aí está a minha idéia inicial.

> > > []'s

> > > Ricardo Simões

> > > 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

> > >> Puts Ricardo,
> > >> Ou eu não entendi nada do que vc falou, ou vc criou um monstro :P

> > >> Concordo com o que vc disse sobre a especialidade. Mas o que isso tem
> com
> > >> o Builder? Um Buider cria objetos em partes, só isso.

> > >> Pelo que entendi do Tuca, não existem vários Geradores diferentes, o
> que
> > >> muda é o Precificador que vai dentro do Gerador, este por sua vez que
> > >> depende da Loja conhecida em runtime.

> > >> Sendo assim, não dá mesmo para usar um container para o precificador,
> e
> > >> por isso sugeri uma estratégia baseada na Loja para conter o
> precificador.

> > >> *Vinicius Quaiato*
> > >>http://viniciusquaiato.com

> > >> Twitter <http://vquaiato>
> > >> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > >> vinicius.quai...@gmail.com

> > >> 2010/7/28 Ricardo Simões <rsc....@gmail.com>

> > >>> Oi, Vinicius,

> > >>> Achei mesmo que tinha entendido seu conceito.

> > >>> Contudo minha afirmação é realmente sobre o conceito da especialidade
> por
> > >>> domínio. Não consigo imaginar um domínio que precise de mais de um
> > >>> especialista na função de gerar pedidos.

> > >>> Claro que o algoritmo de geração de pedido pode variar, como é o caso
> do
> > >>> nosso amigo tuca, entretanto não é necessário solicitar isto para um
> outro
> > >>> especialista na função, basta que ele saiba qual é o algoritmo de
> geração
> > >>> que precisa utilizar e dar o resultado desejado.

> > >>> Por este motivo acredito que um Strategy mesclado com FactoryMethod e
> > >>> talvez um TemplateMethod resolva o problema.

> > >>> Eu só iria considerar utilizar um container para os Precificadores,
> que
> > >>> aí sim pode haver a necessidade de consultar mais que um neste
> domínio.

> > >>> []'s

> > >>> Ricardo Simões

> > >>> 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

> > >>>> Então ricardo, eu disse um Builder por que pelo que entendi mais de
> um
> > >>>> lugar usa o Gerador, e o gerador depende de um IPrecificador, que
> por sua
> > >>>> vez depende de uma loja.

> > >>>> Para matar essa dependência com a loja, crio uma fábrica de
> > >>>> EstratégiasDePrecificacao, e depois de obter passo a estratégia para
> o
> > >>>> Gerador.

> > >>>> Na verdade o Builder seria para ocultar os passos da criação do
> Gerador
> > >>>> apenas.

> > >>>> *Vinicius Quaiato*
> > >>>>http://viniciusquaiato.com

> > >>>> Twitter <http://vquaiato>
> > >>>> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > >>>> vinicius.quai...@gmail.com

> > >>>> 2010/7/28 Ricardo Simões <rsc....@gmail.com>

> > >>>>> Oi,

> > >>>>> Só não concordo com o Vinicius em ter que criar um Builder para
> isso,
> > >>>>> uma fabrica de estratégias já seria suficiente para criar seu
> especialista
> > >>>>> na precificação.

> > >>>>> Além do mais não estou entendendo porque o GeradorDePedido precisa
> de
> > >>>>> um container DI para ser criado.

> > >>>>> Ele me parece ser um serviço especialista na função, e normalmente
> > >>>>> teremos um único especialista na função por domínio.

> > >>>>> Digo isso, porque imagino que no seu domínio você não precise de um
> > >>>>> GeradorDePedidoDeCarros, GeradorDePedidosDeImoveis...

> > >>>>> Ao que parece o container vai morrer mesmo...

> > >>>>> []'s

> > >>>>> Ricardo Simões

> > >>>>> 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

> > >>>>>> Não sei se precisa de uma AbstractFactory Tuca.

> > >>>>>> Seu ponto é conseguir criar o GeradorDePedido, que agora depende
> de
> > >>>>>> uma Loja que só é conhecida em runtime.

> > >>>>>> Isso está mais para um Builder. E eu abriria mão do container
> nessa
> > >>>>>> situação. O builder recebendo uma Loja cria o seu Gerador.

> > >>>>>> Afinal o Gerado não muda por causa da loja, o que muda é o
> > >>>>>> Precificador, por isso acho que não cabe uma abstract factory.

> > >>>>>> E sobre a dependência de outro sobre IPrecificador, utilizaria uma
> > >>>>>> fábrica para eles, baseado na loja. E essa fábrica será também
> consumida
> > >>>>>> pelo Builder.

> > >>>>>> Acho que o container vai dançar. Ou se alguém souber umas mágicas
> mais
> > >>>>>> avançadas, manda aê.

> > >>>>>>  *Vinicius Quaiato*
> > >>>>>>http://viniciusquaiato.com

> > >>>>>> Twitter <http://vquaiato>
> > >>>>>> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > >>>>>> vinicius.quai...@gmail.com

> > >>>>>> 2010/7/28 tucaz <tuca...@gmail.com>

> > >>>>>> O container já existe. Estou mexendo em um código que criei
> > >>>>>>> anteriormente e inclusive já existem alguns objetos que dependem
> de
> > >>>>>>> GeradorPedido e outros que também dependem de IPrecificador.

> > >>>>>>> A idéia de abstract factory é boa, mas traz a dependência pra
> todo
> > >>>>>>> mundo que consome IPrecificador. Outra alternativa seria fazer
> > >>>>>>> injeção
> > >>>>>>> por Property ou usar um método pra Inicializar a classe, mas não
> > >>>>>>> gosto
> > >>>>>>> muito dessa idéia.

> > >>>>>>> On Jul 28, 12:12 pm, Vinicius Quaiato <
> vinicius.quai...@gmail.com>
> > >>>>>>> wrote:
> > >>>>>>> > É vdd...

> > >>>>>>> > Mas, você precisa mesmo de um container nesse ponto específico?
> > >>>>>>> Pelo que
> > >>>>>>> > vejo, o código está uando IoC e DI, só não está usando um
> > >>>>>>> container.

> > >>>>>>> > Qual sua intenção em usar um container nesse caso?

> > >>>>>>> > *Vinicius Quaiato*http://viniciusquaiato.com

> > >>>>>>> > Twitter <vquaiato>
> > >>>>>>> > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > >>>>>>> > vinicius.quai...@gmail.com

> > >>>>>>> > 2010/7/28 tucaz <tuca...@gmail.com>

> > >>>>>>> > > É esse o cenário mesmo Vinicius, mas não consigo ver uma
> forma de
> > >>>>>>> > > passar isso pro container. Seu exemplo não está cobrindo o
> uso do
> > >>>>>>> > > container.

> > >>>>>>> > > On Jul 28, 11:57 am, Vinicius Quaiato <
> > >>>>>>> vinicius.quai...@gmail.com>
> > >>>>>>> > > wrote:
> > >>>>>>> > > > Tuca,

> > >>>>>>> > > > Se você trabalhasse com isso não no nível do
> GeradorDePedido,
> > >>>>>>> mas no
> > >>>>>>> > > nível
> > >>>>>>> > > > da aplicação. A aplicação sabe qual a loja, cria então(ou
> > >>>>>>> obtém) um
> > >>>>>>> > > > Precificador para esta loja, e passa o precificador para o
> > >>>>>>> Gerador.

> > >>>>>>> > > > Na verdade acho que o Precificador nem deve conhecer a
> loja,
> > >>>>>>> mas talvez
> > >>>>>>> > > uma
> > >>>>>>> > > > estratégia de preços por loja, algo assim.

> > >>>>>>> > > > por exmeplo:

> > >>>>>>> > > > //classe que coordena esse processo
> > >>>>>>> > > > public void ExecutarTodoEsseProcesso(Loja lojaSelecionada)
> > >>>>>>> > > > {
> > >>>>>>> > > >    //interface que o precificador conhece
> > >>>>>>> > > >    var estrategiaDePrecosPorLoja =
> > >>>>>>> > > > FabricaDeEstrategiasDePreco(lojaSelecionada);

> > >>>>>>> > > >    var precificador = new
> > >>>>>>> Precificador(estrategiaDePrecosPorLoja);

> > >>>>>>> > > >    var geradorDePedido = new GeradorDePedido(precificador);

> > >>>>>>> > > > }

> > >>>>>>> > > > Assim você pode continuar usando o container para resolver
> o
> > >>>>>>> Gerador.

> > >>>>>>> > > > abraços,

> Tuca, quando você dá o Resolve no container, você pode passar parâmetros não
> pode?

> (Qual container vc está usando?)

> *Vinicius Quaiato*http://viniciusquaiato.com

> Twitter <vquaiato>
> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> vinicius.quai...@gmail.com

> 2010/7/28 tucaz <tuca...@gmail.com>

> > As soluções do @Vinicius e do @Ricardo eu já havia chegado. O problema
> > é que no meu caso IPrecificador já é utilizado por diversos outros
> > objetos então vou ter que criar uma fabrica especifica pra criar cada
> > um desses objetos que usem IPrecificador. Além de ser utilizado em
> > diversos objetos, como uso container de DI as vezes ele é instanciado
> > em Nivel 2 do grafo de objetos, as vezes no Nivel 3.

> > @Felipe,

> > sua idéia é boa, mas onde vou passar a loja selecionada pra ser usada
> > na criação?

> > O método que vocês estão chamando de ExecutarTodoEsseProcesso é um
> > serviço WCF. Ele é o cara que usa o container de DI pra instanciar o
> > GeradorPedido e chamar os métodos que devem ser chamados.

> > On Jul 28, 3:22 pm, Vinicius Quaiato <vinicius.quai...@gmail.com>
> > wrote:
> > > Entendi.

> > > É uma outra abordagem :P

> > > *Vinicius Quaiato*http://viniciusquaiato.com

> > > Twitter <vquaiato>
> > > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > > vinicius.quai...@gmail.com

> > > 2010/7/28 Ricardo Simões <rsc....@gmail.com>

> > > > Oi,

> > > > Sobre o Builder,  para a solução em questão não vejo a necessidade de
> > sua
> > > > utilização. Só isso.

> > > > O que eu quis ilustrar foi o seguinte trecho de código.

> > > > //Trecho de código que você ilustrou
> > > > public void ExecutarTodoEsseProcesso(Loja lojaSelecionada)
> > > > {
> > > >    var precificadorEscolhido =
> > > > AbstracaoDoContainer.CriarInstanciaDe<IPrecificador>(lojaSelecionada);

> > > >    var geradorDePedido = new GeradorDePedido(precificadorEscolhido);
> > > >    geradorDePedido.GerarNovo(pedido);
> > > > }

> > > > Aqui um trecho de código que o método GerarNovo poderia encapsular.

> > > > // Se desejar variar o algoritmo de geração de acordo com o tipo ou
> > alguma
> > > > outra informação do pedido de pedido.
> > > > var estrategia =
> > > > FabricaDeEstrategias.Fabricar<IEstrategiaDeGeracaoDePedidos>(pedido);

> > > > this.GerarNovoPedidoBaseadoEm(estrategia, precificador);

> > > > Aí está a minha idéia inicial.

> > > > []'s

> > > > Ricardo Simões

> > > > 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

> > > >> Puts Ricardo,
> > > >> Ou eu não entendi nada do que vc falou, ou vc criou um monstro :P

> > > >> Concordo com o que vc disse sobre a especialidade. Mas o que isso tem
> > com
> > > >> o Builder? Um Buider cria objetos em partes, só isso.

> > > >> Pelo que entendi do Tuca, não existem vários Geradores diferentes, o
> > que
> > > >> muda é o Precificador que vai dentro do Gerador, este por sua vez que
> > > >> depende da Loja conhecida em runtime.

> > > >> Sendo assim, não dá mesmo para usar um container para o precificador,
> > e
> > > >> por isso sugeri uma estratégia baseada na Loja para conter o
> > precificador.

> > > >> *Vinicius Quaiato*
> > > >>http://viniciusquaiato.com

> > > >> Twitter <http://vquaiato>
> > > >> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > > >> vinicius.quai...@gmail.com

> > > >> 2010/7/28 Ricardo Simões <rsc....@gmail.com>

> > > >>> Oi, Vinicius,

> > > >>> Achei mesmo que tinha entendido seu conceito.

> > > >>> Contudo minha afirmação é realmente sobre o conceito da especialidade
> > por
> > > >>> domínio. Não consigo imaginar um domínio que precise de mais de um
> > > >>> especialista na função de gerar pedidos.

> > > >>> Claro que o algoritmo de geração de pedido pode variar, como é o caso
> > do
> > > >>> nosso amigo tuca, entretanto não é necessário solicitar isto para um
> > outro
> > > >>> especialista na função, basta que ele saiba qual é o algoritmo de
> > geração
> > > >>> que precisa utilizar e dar o resultado desejado.

> > > >>> Por este motivo acredito que um Strategy mesclado com FactoryMethod e
> > > >>> talvez um TemplateMethod resolva o problema.

> > > >>> Eu só iria considerar utilizar um container para os Precificadores,
> > que
> > > >>> aí sim pode haver a necessidade de consultar mais que um neste
> > domínio.

> > > >>> []'s

> > > >>> Ricardo Simões

> > > >>> 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

> > > >>>> Então ricardo, eu disse um Builder por que pelo que entendi mais de
> > um
> > > >>>> lugar usa o Gerador, e o gerador depende de um IPrecificador, que
> > por sua
> > > >>>> vez depende de uma loja.

> > > >>>> Para matar essa dependência com a loja, crio uma fábrica de
> > > >>>> EstratégiasDePrecificacao, e depois de obter passo a estratégia para
> > o
> > > >>>> Gerador.

> > > >>>> Na verdade o Builder seria para ocultar os passos da criação do
> > Gerador
> > > >>>> apenas.

> > > >>>> *Vinicius Quaiato*
> > > >>>>http://viniciusquaiato.com

> > > >>>> Twitter <http://vquaiato>
> > > >>>> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > > >>>> vinicius.quai...@gmail.com

> > > >>>> 2010/7/28 Ricardo Simões <rsc....@gmail.com>

> > > >>>>> Oi,

> > > >>>>> Só não concordo com o Vinicius em ter que criar um Builder para
> > isso,
> > > >>>>> uma fabrica de estratégias já seria suficiente para criar seu
> > especialista
> > > >>>>> na precificação.

> > > >>>>> Além do mais não estou entendendo porque o GeradorDePedido precisa
> > de
> > > >>>>> um container DI para ser criado.

> > > >>>>> Ele me parece ser um serviço especialista na função, e normalmente
> > > >>>>> teremos um único especialista na função por domínio.

> > > >>>>> Digo isso, porque imagino que no seu domínio você não precise de um
> > > >>>>> GeradorDePedidoDeCarros, GeradorDePedidosDeImoveis...

> > > >>>>> Ao que parece o container vai morrer mesmo...

> > > >>>>> []'s

> > > >>>>> Ricardo Simões

> > > >>>>> 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

> > > >>>>>> Não sei se precisa de uma AbstractFactory Tuca.

> > > >>>>>> Seu ponto é conseguir criar o GeradorDePedido, que agora depende
> > de
> > > >>>>>> uma Loja que só é conhecida em runtime.

> > > >>>>>> Isso está mais para um Builder. E eu abriria mão do container
> > nessa
> > > >>>>>> situação. O builder recebendo uma Loja cria o seu Gerador.

> > > >>>>>> Afinal o Gerado não muda por causa da loja, o que muda é o
> > > >>>>>> Precificador, por isso acho que não cabe uma abstract factory.

> > > >>>>>> E sobre a dependência de outro sobre IPrecificador, utilizaria uma
> > > >>>>>> fábrica para eles, baseado na loja. E essa fábrica será também
> > consumida
> > > >>>>>> pelo Builder.

> > > >>>>>> Acho que o container vai dançar. Ou se alguém souber umas mágicas
> > mais
> > > >>>>>> avançadas, manda aê.

> > > >>>>>>  *Vinicius Quaiato*
> > > >>>>>>http://viniciusquaiato.com

> > > >>>>>> Twitter <http://vquaiato>
> > > >>>>>> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > > >>>>>> vinicius.quai...@gmail.com

> > > >>>>>> 2010/7/28 tucaz <tuca...@gmail.com>

> > > >>>>>> O container já existe. Estou mexendo em um código que criei
> > > >>>>>>> anteriormente e inclusive já existem alguns objetos que dependem
> > de
> > > >>>>>>> GeradorPedido e outros que também dependem de IPrecificador.

> > > >>>>>>> A idéia de abstract factory é boa, mas traz a dependência pra
> > todo
> > > >>>>>>> mundo que consome IPrecificador. Outra alternativa seria fazer
> > > >>>>>>> injeção
> > > >>>>>>> por Property ou usar um método pra Inicializar a classe, mas não
> > > >>>>>>> gosto
> > > >>>>>>> muito dessa idéia.

> > > >>>>>>> On Jul 28, 12:12 pm, Vinicius Quaiato <
> > vinicius.quai...@gmail.com>
> > > >>>>>>> wrote:
> > > >>>>>>> > É vdd...

> > > >>>>>>> > Mas, você precisa mesmo de um container nesse ponto específico?
> > > >>>>>>> Pelo que
> > > >>>>>>> > vejo, o código está uando IoC e DI, só não está usando um
> > > >>>>>>> container.

> > > >>>>>>> > Qual sua intenção em usar um container nesse caso?

> > > >>>>>>> > *Vinicius Quaiato*http://viniciusquaiato.com

> > > >>>>>>> > Twitter <vquaiato>
> > > >>>>>>> > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > > >>>>>>> > vinicius.quai...@gmail.com

> > > >>>>>>> > 2010/7/28 tucaz <tuca...@gmail.com>

> > > >>>>>>> > > É esse o cenário mesmo Vinicius, mas não consigo ver uma
> > forma de
> > > >>>>>>> > > passar isso pro container. Seu exemplo não está cobrindo o
> > uso do
> > > >>>>>>> > > container.

> > > >>>>>>> > > On Jul 28, 11:57 am, Vinicius Quaiato <
> > > >>>>>>> vinicius.quai...@gmail.com>
> > > >>>>>>> > > wrote:
> > > >>>>>>> > > > Tuca,

> > > >>>>>>> > > > Se você trabalhasse com isso não no nível do
> > GeradorDePedido,
> > > >>>>>>> mas no
> > > >>>>>>> > > nível
> > > >>>>>>> > > > da aplicação. A aplicação sabe qual a loja, cria então(ou
> > > >>>>>>> obtém) um
> > > >>>>>>> > > > Precificador para esta loja, e passa o precificador para o
> > > >>>>>>> Gerador.

> > > >>>>>>> > > > Na verdade acho que o Precificador nem deve conhecer a
> > loja,
> > > >>>>>>> mas talvez
> > > >>>>>>> > > uma

> Ninject. Acredito que posso passar sim, mas só pra classe que estou
> instanciando diretamente. Pras outras dependências dela acho que não
> tem jeito. Pelo menos não consegui fazer.

> On Jul 28, 4:10 pm, Vinicius Quaiato <vinicius.quai...@gmail.com>
> wrote:

> > Tuca, quando você dá o Resolve no container, você pode passar parâmetros não
> > pode?

> > (Qual container vc está usando?)

> > *Vinicius Quaiato*http://viniciusquaiato.com

> > Twitter <vquaiato>
> > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > vinicius.quai...@gmail.com

> > 2010/7/28 tucaz <tuca...@gmail.com>

> > > As soluções do @Vinicius e do @Ricardo eu já havia chegado. O problema
> > > é que no meu caso IPrecificador já é utilizado por diversos outros
> > > objetos então vou ter que criar uma fabrica especifica pra criar cada
> > > um desses objetos que usem IPrecificador. Além de ser utilizado em
> > > diversos objetos, como uso container de DI as vezes ele é instanciado
> > > em Nivel 2 do grafo de objetos, as vezes no Nivel 3.

> > > @Felipe,

> > > sua idéia é boa, mas onde vou passar a loja selecionada pra ser usada
> > > na criação?

> > > O método que vocês estão chamando de ExecutarTodoEsseProcesso é um
> > > serviço WCF. Ele é o cara que usa o container de DI pra instanciar o
> > > GeradorPedido e chamar os métodos que devem ser chamados.

> > > On Jul 28, 3:22 pm, Vinicius Quaiato <vinicius.quai...@gmail.com>
> > > wrote:
> > > > Entendi.

> > > > É uma outra abordagem :P

> > > > *Vinicius Quaiato*http://viniciusquaiato.com

> > > > Twitter <vquaiato>
> > > > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > > > vinicius.quai...@gmail.com

> > > > 2010/7/28 Ricardo Simões <rsc....@gmail.com>

> > > > > Oi,

> > > > > Sobre o Builder,  para a solução em questão não vejo a necessidade de
> > > sua
> > > > > utilização. Só isso.

> > > > > O que eu quis ilustrar foi o seguinte trecho de código.

> > > > > //Trecho de código que você ilustrou
> > > > > public void ExecutarTodoEsseProcesso(Loja lojaSelecionada)
> > > > > {
> > > > >    var precificadorEscolhido =
> > > > > AbstracaoDoContainer.CriarInstanciaDe<IPrecificador>(lojaSelecionada);

> > > > >    var geradorDePedido = new GeradorDePedido(precificadorEscolhido);
> > > > >    geradorDePedido.GerarNovo(pedido);
> > > > > }

> > > > > Aqui um trecho de código que o método GerarNovo poderia encapsular.

> > > > > // Se desejar variar o algoritmo de geração de acordo com o tipo ou
> > > alguma
> > > > > outra informação do pedido de pedido.
> > > > > var estrategia =
> > > > > FabricaDeEstrategias.Fabricar<IEstrategiaDeGeracaoDePedidos>(pedido);

> > > > > this.GerarNovoPedidoBaseadoEm(estrategia, precificador);

> > > > > Aí está a minha idéia inicial.

> > > > > []'s

> > > > > Ricardo Simões

> > > > > 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

> > > > >> Puts Ricardo,
> > > > >> Ou eu não entendi nada do que vc falou, ou vc criou um monstro :P

> > > > >> Concordo com o que vc disse sobre a especialidade. Mas o que isso tem
> > > com
> > > > >> o Builder? Um Buider cria objetos em partes, só isso.

> > > > >> Pelo que entendi do Tuca, não existem vários Geradores diferentes, o
> > > que
> > > > >> muda é o Precificador que vai dentro do Gerador, este por sua vez que
> > > > >> depende da Loja conhecida em runtime.

> > > > >> Sendo assim, não dá mesmo para usar um container para o precificador,
> > > e
> > > > >> por isso sugeri uma estratégia baseada na Loja para conter o
> > > precificador.

> > > > >> *Vinicius Quaiato*
> > > > >>http://viniciusquaiato.com

> > > > >> Twitter <http://vquaiato>
> > > > >> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > > > >> vinicius.quai...@gmail.com

> > > > >> 2010/7/28 Ricardo Simões <rsc....@gmail.com>

> > > > >>> Oi, Vinicius,

> > > > >>> Achei mesmo que tinha entendido seu conceito.

> > > > >>> Contudo minha afirmação é realmente sobre o conceito da especialidade
> > > por
> > > > >>> domínio. Não consigo imaginar um domínio que precise de mais de um
> > > > >>> especialista na função de gerar pedidos.

> > > > >>> Claro que o algoritmo de geração de pedido pode variar, como é o caso
> > > do
> > > > >>> nosso amigo tuca, entretanto não é necessário solicitar isto para um
> > > outro
> > > > >>> especialista na função, basta que ele saiba qual é o algoritmo de
> > > geração
> > > > >>> que precisa utilizar e dar o resultado desejado.

> > > > >>> Por este motivo acredito que um Strategy mesclado com FactoryMethod e
> > > > >>> talvez um TemplateMethod resolva o problema.

> > > > >>> Eu só iria considerar utilizar um container para os Precificadores,
> > > que
> > > > >>> aí sim pode haver a necessidade de consultar mais que um neste
> > > domínio.

> > > > >>> []'s

> > > > >>> Ricardo Simões

> > > > >>> 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

> > > > >>>> Então ricardo, eu disse um Builder por que pelo que entendi mais de
> > > um
> > > > >>>> lugar usa o Gerador, e o gerador depende de um IPrecificador, que
> > > por sua
> > > > >>>> vez depende de uma loja.

> > > > >>>> Para matar essa dependência com a loja, crio uma fábrica de
> > > > >>>> EstratégiasDePrecificacao, e depois de obter passo a estratégia para
> > > o
> > > > >>>> Gerador.

> > > > >>>> Na verdade o Builder seria para ocultar os passos da criação do
> > > Gerador
> > > > >>>> apenas.

> > > > >>>> *Vinicius Quaiato*
> > > > >>>>http://viniciusquaiato.com

> > > > >>>> Twitter <http://vquaiato>
> > > > >>>> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > > > >>>> vinicius.quai...@gmail.com

> > > > >>>> 2010/7/28 Ricardo Simões <rsc....@gmail.com>

> > > > >>>>> Oi,

> > > > >>>>> Só não concordo com o Vinicius em ter que criar um Builder para
> > > isso,
> > > > >>>>> uma fabrica de estratégias já seria suficiente para criar seu
> > > especialista
> > > > >>>>> na precificação.

> > > > >>>>> Além do mais não estou entendendo porque o GeradorDePedido precisa
> > > de
> > > > >>>>> um container DI para ser criado.

> > > > >>>>> Ele me parece ser um serviço especialista na função, e normalmente
> > > > >>>>> teremos um único especialista na função por domínio.

> > > > >>>>> Digo isso, porque imagino que no seu domínio você não precise de um
> > > > >>>>> GeradorDePedidoDeCarros, GeradorDePedidosDeImoveis...

> > > > >>>>> Ao que parece o container vai morrer mesmo...

> > > > >>>>> []'s

> > > > >>>>> Ricardo Simões

> > > > >>>>> 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

> > > > >>>>>> Não sei se precisa de uma AbstractFactory Tuca.

> > > > >>>>>> Seu ponto é conseguir criar o GeradorDePedido, que agora depende
> > > de
> > > > >>>>>> uma Loja que só é conhecida em runtime.

> > > > >>>>>> Isso está mais para um Builder. E eu abriria mão do container
> > > nessa
> > > > >>>>>> situação. O builder recebendo uma Loja cria o seu Gerador.

> > > > >>>>>> Afinal o Gerado não muda por causa da loja, o que muda é o
> > > > >>>>>> Precificador, por isso acho que não cabe uma abstract factory.

> > > > >>>>>> E sobre a dependência de outro sobre IPrecificador, utilizaria uma
> > > > >>>>>> fábrica para eles, baseado na loja. E essa fábrica será também
> > > consumida
> > > > >>>>>> pelo Builder.

> > > > >>>>>> Acho que o container vai dançar. Ou se alguém souber umas mágicas
> > > mais
> > > > >>>>>> avançadas, manda aê.

> > > > >>>>>>  *Vinicius Quaiato*
> > > > >>>>>>http://viniciusquaiato.com

> > > > >>>>>> Twitter <http://vquaiato>
> > > > >>>>>> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > > > >>>>>> vinicius.quai...@gmail.com

> > > > >>>>>> 2010/7/28 tucaz <tuca...@gmail.com>

> > > > >>>>>> O container já existe. Estou mexendo em um código que criei
> > > > >>>>>>> anteriormente e inclusive já existem alguns objetos que dependem
> > > de
> > > > >>>>>>> GeradorPedido e outros que também dependem de IPrecificador.

> > > > >>>>>>> A idéia de abstract factory é boa, mas traz a dependência pra
> > > todo
> > > > >>>>>>> mundo que consome IPrecificador. Outra alternativa seria fazer
> > > > >>>>>>> injeção
> > > > >>>>>>> por Property ou usar um método pra Inicializar a classe, mas não
> > > > >>>>>>> gosto
> > > > >>>>>>> muito dessa idéia.

> > > > >>>>>>> On Jul 28, 12:12 pm, Vinicius Quaiato <
> > > vinicius.quai...@gmail.com>
> > > > >>>>>>> wrote:
> > > > >>>>>>> > É vdd...

> > > > >>>>>>> > Mas, você precisa mesmo de um container nesse ponto específico?
> > > > >>>>>>> Pelo que
> > > > >>>>>>> > vejo, o código está uando IoC e DI, só não está usando um
> > > > >>>>>>> container.

> > > > >>>>>>> > Qual sua intenção em usar um container nesse caso?

> > > > >>>>>>> > *Vinicius Quaiato*http://viniciusquaiato.com

> > > > >>>>>>> > Twitter <vquaiato>
> > > > >>>>>>> > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > > > >>>>>>> > vinicius.quai...@gmail.com

> As soluções do @Vinicius e do @Ricardo eu já havia chegado. O problema
> é que no meu caso IPrecificador já é utilizado por diversos outros
> objetos então vou ter que criar uma fabrica especifica pra criar cada
> um desses objetos que usem IPrecificador. Além de ser utilizado em
> diversos objetos, como uso container de DI as vezes ele é instanciado
> em Nivel 2 do grafo de objetos, as vezes no Nivel 3.

> @Felipe,

> sua idéia é boa, mas onde vou passar a loja selecionada pra ser usada
> na criação?

> O método que vocês estão chamando de ExecutarTodoEsseProcesso é um
> serviço WCF. Ele é o cara que usa o container de DI pra instanciar o
> GeradorPedido e chamar os métodos que devem ser chamados.

> On Jul 28, 3:22 pm, Vinicius Quaiato <vinicius.quai...@gmail.com>
> wrote:
> > Entendi.

> > É uma outra abordagem :P

> > *Vinicius Quaiato*http://viniciusquaiato.com

> > Twitter <vquaiato>
> > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > vinicius.quai...@gmail.com

> > 2010/7/28 Ricardo Simões <rsc....@gmail.com>

> > > Oi,

> > > Sobre o Builder,  para a solução em questão não vejo a necessidade de
> sua
> > > utilização. Só isso.

> > > O que eu quis ilustrar foi o seguinte trecho de código.

> > > //Trecho de código que você ilustrou
> > > public void ExecutarTodoEsseProcesso(Loja lojaSelecionada)
> > > {
> > >    var precificadorEscolhido =
> > > AbstracaoDoContainer.CriarInstanciaDe<IPrecificador>(lojaSelecionada);

> > >    var geradorDePedido = new GeradorDePedido(precificadorEscolhido);
> > >    geradorDePedido.GerarNovo(pedido);
> > > }

> > > Aqui um trecho de código que o método GerarNovo poderia encapsular.

> > > // Se desejar variar o algoritmo de geração de acordo com o tipo ou
> alguma
> > > outra informação do pedido de pedido.
> > > var estrategia =
> > > FabricaDeEstrategias.Fabricar<IEstrategiaDeGeracaoDePedidos>(pedido);

> > > this.GerarNovoPedidoBaseadoEm(estrategia, precificador);

> > > Aí está a minha idéia inicial.

> > > []'s

> > > Ricardo Simões

> > > 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

> > >> Puts Ricardo,
> > >> Ou eu não entendi nada do que vc falou, ou vc criou um monstro :P

> > >> Concordo com o que vc disse sobre a especialidade. Mas o que isso tem
> com
> > >> o Builder? Um Buider cria objetos em partes, só isso.

> > >> Pelo que entendi do Tuca, não existem vários Geradores diferentes, o
> que
> > >> muda é o Precificador que vai dentro do Gerador, este por sua vez que
> > >> depende da Loja conhecida em runtime.

> > >> Sendo assim, não dá mesmo para usar um container para o precificador,
> e
> > >> por isso sugeri uma estratégia baseada na Loja para conter o
> precificador.

> > >> *Vinicius Quaiato*
> > >>http://viniciusquaiato.com

> > >> Twitter <http://vquaiato>
> > >> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > >> vinicius.quai...@gmail.com

> > >> 2010/7/28 Ricardo Simões <rsc....@gmail.com>

> > >>> Oi, Vinicius,

> > >>> Achei mesmo que tinha entendido seu conceito.

> > >>> Contudo minha afirmação é realmente sobre o conceito da especialidade
> por
> > >>> domínio. Não consigo imaginar um domínio que precise de mais de um
> > >>> especialista na função de gerar pedidos.

> > >>> Claro que o algoritmo de geração de pedido pode variar, como é o caso
> do
> > >>> nosso amigo tuca, entretanto não é necessário solicitar isto para um
> outro
> > >>> especialista na função, basta que ele saiba qual é o algoritmo de
> geração
> > >>> que precisa utilizar e dar o resultado desejado.

> > >>> Por este motivo acredito que um Strategy mesclado com FactoryMethod e
> > >>> talvez um TemplateMethod resolva o problema.

> > >>> Eu só iria considerar utilizar um container para os Precificadores,
> que
> > >>> aí sim pode haver a necessidade de consultar mais que um neste
> domínio.

> > >>> []'s

> > >>> Ricardo Simões

> > >>> 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

> > >>>> Então ricardo, eu disse um Builder por que pelo que entendi mais de
> um
> > >>>> lugar usa o Gerador, e o gerador depende de um IPrecificador, que
> por sua
> > >>>> vez depende de uma loja.

> > >>>> Para matar essa dependência com a loja, crio uma fábrica de
> > >>>> EstratégiasDePrecificacao, e depois de obter passo a estratégia para
> o
> > >>>> Gerador.

> > >>>> Na verdade o Builder seria para ocultar os passos da criação do
> Gerador
> > >>>> apenas.

> > >>>> *Vinicius Quaiato*
> > >>>>http://viniciusquaiato.com

> > >>>> Twitter <http://vquaiato>
> > >>>> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > >>>> vinicius.quai...@gmail.com

> > >>>> 2010/7/28 Ricardo Simões <rsc....@gmail.com>

> > >>>>> Oi,

> > >>>>> Só não concordo com o Vinicius em ter que criar um Builder para
> isso,
> > >>>>> uma fabrica de estratégias já seria suficiente para criar seu
> especialista
> > >>>>> na precificação.

> > >>>>> Além do mais não estou entendendo porque o GeradorDePedido precisa
> de
> > >>>>> um container DI para ser criado.

> > >>>>> Ele me parece ser um serviço especialista na função, e normalmente
> > >>>>> teremos um único especialista na função por domínio.

> > >>>>> Digo isso, porque imagino que no seu domínio você não precise de um
> > >>>>> GeradorDePedidoDeCarros, GeradorDePedidosDeImoveis...

> > >>>>> Ao que parece o container vai morrer mesmo...

> > >>>>> []'s

> > >>>>> Ricardo Simões

> > >>>>> 2010/7/28 Vinicius Quaiato <vinicius.quai...@gmail.com>

> > >>>>>> Não sei se precisa de uma AbstractFactory Tuca.

> > >>>>>> Seu ponto é conseguir criar o GeradorDePedido, que agora depende
> de
> > >>>>>> uma Loja que só é conhecida em runtime.

> > >>>>>> Isso está mais para um Builder. E eu abriria mão do container
> nessa
> > >>>>>> situação. O builder recebendo uma Loja cria o seu Gerador.

> > >>>>>> Afinal o Gerado não muda por causa da loja, o que muda é o
> > >>>>>> Precificador, por isso acho que não cabe uma abstract factory.

> > >>>>>> E sobre a dependência de outro sobre IPrecificador, utilizaria uma
> > >>>>>> fábrica para eles, baseado na loja. E essa fábrica será também
> consumida
> > >>>>>> pelo Builder.

> > >>>>>> Acho que o container vai dançar. Ou se alguém souber umas mágicas
> mais
> > >>>>>> avançadas, manda aê.

> > >>>>>>  *Vinicius Quaiato*
> > >>>>>>http://viniciusquaiato.com

> > >>>>>> Twitter <http://vquaiato>
> > >>>>>> [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > >>>>>> vinicius.quai...@gmail.com

> > >>>>>> 2010/7/28 tucaz <tuca...@gmail.com>

> > >>>>>> O container já existe. Estou mexendo em um código que criei
> > >>>>>>> anteriormente e inclusive já existem alguns objetos que dependem
> de
> > >>>>>>> GeradorPedido e outros que também dependem de IPrecificador.

> > >>>>>>> A idéia de abstract factory é boa, mas traz a dependência pra
> todo
> > >>>>>>> mundo que consome IPrecificador. Outra alternativa seria fazer
> > >>>>>>> injeção
> > >>>>>>> por Property ou usar um método pra Inicializar a classe, mas não
> > >>>>>>> gosto
> > >>>>>>> muito dessa idéia.

> > >>>>>>> On Jul 28, 12:12 pm, Vinicius Quaiato <
> vinicius.quai...@gmail.com>
> > >>>>>>> wrote:
> > >>>>>>> > É vdd...

> > >>>>>>> > Mas, você precisa mesmo de um container nesse ponto específico?
> > >>>>>>> Pelo que
> > >>>>>>> > vejo, o código está uando IoC e DI, só não está usando um
> > >>>>>>> container.

> > >>>>>>> > Qual sua intenção em usar um container nesse caso?

> > >>>>>>> > *Vinicius Quaiato*http://viniciusquaiato.com

> > >>>>>>> > Twitter <vquaiato>
> > >>>>>>> > [image: Google Talk/]vinicius.quai...@gmail.com [image: MSN/]
> > >>>>>>> > vinicius.quai...@gmail.com

> > >>>>>>> > 2010/7/28 tucaz <tuca...@gmail.com>

> > >>>>>>> > > É esse o cenário mesmo Vinicius, mas não consigo ver uma
> forma de
> > >>>>>>> > > passar isso pro container. Seu exemplo não está cobrindo o
> uso do
> > >>>>>>> > > container.

> > >>>>>>> > > On Jul 28, 11:57 am, Vinicius Quaiato <
> > >>>>>>> vinicius.quai...@gmail.com>
> > >>>>>>> > > wrote:
> > >>>>>>> > > > Tuca,

> > >>>>>>> > > > Se você trabalhasse com isso não no nível do
> GeradorDePedido,
> > >>>>>>> mas no
> > >>>>>>> > > nível
> > >>>>>>> > > > da aplicação. A aplicação sabe qual a loja, cria então(ou
> > >>>>>>> obtém) um
> > >>>>>>> > > > Precificador para esta loja, e passa o precificador para o
> > >>>>>>> Gerador.

> > >>>>>>> > > > Na verdade acho que o Precificador nem deve conhecer a
> loja,
> > >>>>>>> mas talvez
> > >>>>>>> > > uma
> > >>>>>>> > > > estratégia de preços por loja, algo assim.

> > >>>>>>> > > > por exmeplo:

> > >>>>>>> > > > //classe que coordena esse processo
> > >>>>>>> > > > public void ExecutarTodoEsseProcesso(Loja lojaSelecionada)
> > >>>>>>> > > > {
> > >>>>>>> > > >    //interface que o precificador conhece
> > >>>>>>> > > >    var estrategiaDePrecosPorLoja =
> > >>>>>>> > > > FabricaDeEstrategiasDePreco(lojaSelecionada);

> > >>>>>>> > > >    var precificador = new