none
Chamando metodo WCF RRS feed

  • Pergunta

  • Olá galera...

    aki estou mais uma vez...

    bom, minha duvida agora é na funcionalidade do WCF no silverlight.
    Imagine que eu tenha uma classe chamada pedido... eu criei um serviço que recupera pedidos...

    --> meuservico.GetPedidosCompleted = ...


    logo apos eu recuperar o pedido, irei fazer uma verificação se o mesmo pode ser alterado....

    --> if (pedido.PodeAlterar())....

    bom, aqui esta a duvida... esse tipo de chamada é possivel??? ou eu haveria de criar um metodo no serviço para fazer essa verificação?? tipo:

    --> meuServico.PodeAlterar(pedido)


    ??

    vlw
    Ozzyvegeta
    quinta-feira, 27 de agosto de 2009 06:49

Respostas

  • o MVC foi para exemplificar o que eh Camada de Negocio... uma vez q vc deu a impressao de estar meio confuso com a definiçao dela...

    foi so para dizer q camada de negocio nao necessariamente tem que estar em uma dll... enfim... vamos deixar isso para la que é meio confuso mesmo...

    What would Brian Boitano do ?
    • Marcado como Resposta Daniel Ferreira quarta-feira, 14 de julho de 2010 13:35
    sábado, 29 de agosto de 2009 19:03
    Moderador
  • Ah... web service nao esta descontinuado.... ele eh padrão para integração de sistemas.. uma vez q java nao acessa wcf e o .net nao acessa ejb....

    Sobre a sua duvida... na verdade herança funcionaria algo assim

    public class UsuarioDAO {
         public string Nome {get; set;}
         public int ID  {get; set;}

         public virtual void Incluir() {
            // Insert no banco de dados
         }
    }

    public class Usuario: UsuarioDAO {
         public override void Incluir() {
            // Validações de Negocio
            if (this.ID == 0) throw new Exception("Codigo Invalido");

            // Chama o metodo Incluir da classe UsuarioDAO
            base.Incluir();
         }
    }

    como funcionaria usando um Service (seja WCF, seja WebService.... a ideia eh a mesma) vou usar webservice pq ainda é a solução padrao para integração de sistemas conforme a W3C.....

    [Serializable]
    public interface IUsuario {
         string Nome {get; set;}
         int ID {get; set;}
        
        void Incluir();
    }

    public class UsuarioDAO: IUsuario  {
         public string Nome {get; set;}
         public int ID  {get; set;}

         public void Incluir() {
            // Insert no banco de dados
         }
      
         public UsuarioDAO(int id, string nome) {
             this.ID = id;
             this.Nome = nome;
         }
    }

    [WebService]
    public class Usuario: WebService {
         [WebMethod]
         public IUsuario Incluir(int id, string nome) {
            // Validações de Negocio
            if (id == 0) throw new Exception("Codigo Invalido");

            IUsuario usuario = new UsuarioDAO(id, nome);

            // Chama o metodo Incluir da classe UsuarioDAO
            usuario.Incluir();
            
            return usuario;
         }
    }


    como funionaria usando webservice e uma classe de negocio
    [Serializable]
    public interface IUsuario {
         string Nome {get; set;}
         int ID {get; set;}
    }

    public class UsuarioDAO: IUsuario  {
         public string Nome {get; set;}
         public int ID  {get; set;}

         public virtual void Incluir() {
            // Insert no banco de dados
         }
       
         public UsuarioDAO(int id, string nome) {
             this.ID = id;
             this.Nome = nome;
         }
    }

    public class Usuario: UsuarioDAO {
         public override void Incluir() {
            // Validações de Negocio
            if (this.ID == 0) throw new Exception("Codigo Invalido");

            // Chama o metodo Incluir da classe UsuarioDAO
            base.Incluir();
         }

        public Usuario(int id, string nome): base(id, nome) { }
    }

    [WebService]
    public class MeuSistema: WebService {
         [WebMethod]
         public IUsuario IncluirUsuario(int id, string nome) {
            IUsuario usuario = new Usuario(id, nome);
            usuario.Incluir();        
            return usuario;
         }
    }


    Agora sobre a questao do que é mais facil... do que usa mais linhas de comando... do que da mais trabalho.... na boa... esse nao é o caso... vc quer trabalhar com herança buscando uma melhor perfomance, portabilidade e etc é uma coisa.... nas ter menos linhas de codigo nao siginifica necessariamente ser melhor.... enfim... "linhas de codigo" nao eh metrica para ser usada em nenhum caso atualmente....


    o fato é... que usar herança otimo... no seu caso usa entao metodos virtuais e faz acesso aos metodos da classe pai utilizando o base
    quer passar o objeto como paramentro numa classe de negocio estatica.... entao usa interfaces... dessa forma vc mantem a sua classe de dados encapsulada e so propraga as informacoes necessarias para o cliente....


    eu particulamente gosto mais da 3 opção.... pq vc pode criar uma class library com as classes de negocio e dados.... e usar a classe direto no seu projeto ASP.NET, quando for usar um Windows Forms... vc pode usar ela no WCF.... se for usar em Silverlight vc pode usar em WCF tmb, ou um WCF for Silverlight ou WebService... e se prescisar de um cliente em Delphi (para maquinas win 98), em Java (para rodar em teminais Linux ou Mac) vc pode usar ela no WebService....


    What would Brian Boitano do ?
    • Marcado como Resposta Daniel Ferreira quarta-feira, 14 de julho de 2010 13:35
    segunda-feira, 31 de agosto de 2009 17:01
    Moderador
  • fala galera,

    Bom, oq quis dizer com a utilização de numero de linhas não foi no sentido de que isso é ruim ou bom..foi no sentido de ser DESNECESSARIA ja que meus metodos sempre vao receber por parametro a classe de dados referente a classe de negocio que esta executando... exemplo : UsuarioNegocio tem seus metodos que recebem UsuarioDAO e os metodos não são interligados, ou seja, nenhum popula uma varival privada para o outro poder utilizar... todos sao independentes sendo a unica entra os parametros do metodo.. foi pensando nessa ideia que vi que não havia a necessidade de manter essa classe para ser instanciada ja que os metodos tem comportamentos de metodos staticos... assim eu quis dizer que fica mais semantico utilizar dessa forma e queria saber se isso é legal... numero de linhas foi apenas um exemplo de como se "complica" desnecessariamente ...

    e voltando ao outro assunto de chamar um metodo de forma sincrona.. eu tentei isso que o rui sugeriu:

    namespace Namespace.Do.Seu.Proxy {
         partial class Usuario {
               private ManualEventRaise eventControl = new ManualEventRaise();
               private bool inserirResultado = false;

               public bool Inserir() {
                      var servico = new SeuWcfService();
                      service.PodeCadastrarCompleted += this.PodeCadastrarCompleted;
                      service.PodeCadastrarAsync(this, servico);      
                      
                      eventControl.WaitOne(20000); // Espera 20seg pela reposta
                      return inserirResultado;        
               }
              private void PodeCadastrarCompleted(object sender, PodeCadastrarCompletedEventArgs e) {
                     if (e.Result) {
                           var servico = e.UserState  as SerWcfService;
                           service.InserirAsync(this);                      
                     }

                     inserirResultado = e.Result;
                     eventControl.Set();
              }
               
         }
    }

    Porem, não funcionou :(

    o WaitOne pará toda a minha aplicação e só quando o TimeOut terminar o evento de completed é disparado... tentei utilizar a forma de IAsyncResult e nada tb... oq sera q pode ser? vc utiliza desta tecnica em silverlight sem esse erro??

    vlw galera

    Ozzyvegeta
    • Marcado como Resposta Daniel Ferreira quarta-feira, 14 de julho de 2010 13:35
    terça-feira, 1 de setembro de 2009 07:08

Todas as Respostas

  • Se a class Pedido no serviço tem um método chamado "PodeAlterar", este método não será importado pro cliente (Silverlight).

    Você tem duas opções para isso:
    - Criar um método no serviço - PodeAlterar(Pedido) - como você sugeriu
    - Ou se a decisão de poder alterar ou não o pedido for possível de ser feita a partir dos dados existentes na classe Pedido gerada no cliente, você pode "incrementar" a classe Pedido (que é definida como "partial class") com este método. Por exemplo, se a classe Pedido é gerada como abaixo:

    //
    // This code was auto-generated by Microsoft.Silverlight.ServiceReference, version 3.0.40624.0
    //
    namespace MeuServico.ServiceReference1 {
        using System.Runtime.Serialization;
       
        [System.Diagnostics.DebuggerStepThroughAttribute()]
        [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Runtime.Serialization", "3.0.0.0")]
        [System.Runtime.Serialization.DataContractAttribute(Name="Person", Namespace="http://schemas.datacontract.org/2004/07/WcfServiceLibrary1")]
        public partial class Person : object, System.ComponentModel.INotifyPropertyChanged {
           
            private int IdField;
           
            private string NomeField;
           
            [System.Runtime.Serialization.DataMemberAttribute()]
            public int Id {
                get {
                    return this.IdField;
                }
                set {
                    if ((this.IdField.Equals(value) != true)) {
                        this.IdField = value;
                        this.RaisePropertyChanged("Id");
                    }
                }
            }
           
            [System.Runtime.Serialization.DataMemberAttribute()]
            public string Nome {
                get {
                    return this.NomeField;
                }
                set {
                    if ((object.ReferenceEquals(this.NomeField, value) != true)) {
                        this.NomeField = value;
                        this.RaisePropertyChanged("Nome");
                    }
                }
            }
           
            public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
           
            protected void RaisePropertyChanged(string propertyName) {
                System.ComponentModel.PropertyChangedEventHandler propertyChanged = this.PropertyChanged;
                if ((propertyChanged != null)) {
                    propertyChanged(this, new System.ComponentModel.PropertyChangedEventArgs(propertyName));
                }
            }
        }
    }

    Você pode adicionar esta "outra" classe no seu projeto SL:

    namespace MeuServico.ServiceReference1 {
       
        public partial class Pedido {
           
            public bool PodeAlterar() {
                return this.Id > 1000 && this.Nome == "VIP";
            }
        }
    }

    Na compilação as duas classes parciais serão unificadas, e você poderá usar o método PodeAlterar nos objetos retornados pelo servidor.

    sexta-feira, 28 de agosto de 2009 20:22
  • iai carlos...

    entao... irei optar pela primeria opção.. não quero dexa minha regra de negocio no cliente...

    e outra... é normal deixar as regras de negocio no serviço?? vi que vc criou na classe Person os atribuitos do WCF... mais as regras de negocio não era pra estar na camada de negocio e não no serviço??... ou vc misturou as duas?? ta certo isso??

    vlww
    Ozzyvegeta
    sexta-feira, 28 de agosto de 2009 21:51
  • Ah sobre a pergunta acima... depende... vc pode fazer do seu service a camada de negocio... e ele acessando a camada de dados...

    mesmo pq Service nao é uma camada propriamente dita.... vc pode usar ele como camada de dados ou como camada de negocio..., porem a verificaçao q vc ta fazendo ta mais para controle de dados q regra de negocio:

    Camada de dados... acessa os dados, e faz as verificacoes basicas nas alteraçoes do mesmo (codigo validos, verificacao de campos obrigatorios, permicao para alteracao dos dados etc...) vc define a classe de dados de forma a garantir q os dados manipulados ali estao 100% validos... nao vai entrar nenhum dados sujo no seu BD, é algo meio generico q vale para qq sistema q va acessar esses dados

    Camada de negocio: ai sim vc poem os calculos, manipulacoes de dados... e etc caracteristicos do seu sistema que podem variar num mesmo sistema para clientes diferentes...

    Sobre a primeira pergunta.... tem uma forma de sincronizar os metodos asyncronos...

    ah... vo fazer meio de cor.... eh algo mais ou menos assim:

    private ManualRaiseEvent eventControl = new ManualRaiseEvent();

    private void Inicar() {
        callAlgoAsync()
        eventControl.WaitOne();  // Aguarda o comando "Set" para continuar
        
        /// Faz algo com o resultado de CallAlgoAsync();
    }

    private void CallAlgoAsyncResponse() {
        // Joga o resultadao numa propriedade...
        eventControl.Set(); // Contina a thread anterior...
    }
    What would Brian Boitano do ?
    sexta-feira, 28 de agosto de 2009 22:10
    Moderador
  • oq vc quis dizer é q o service não seria a camada de serviço correto?? e sim a camada de dados decorada de atributos para ser transportada pelo wcf?

    e não entendi bem essa ideia de utilizar o metodo sincrono... estou precisndo muito disso... eu preciso de algo parecido..

    public void Inserir()
    {
        if (!servico.PodeCadastrar(usuario))
        {
             exibemensagemdeerro()
             return;
        }

        servico.Inserir(usuario)
     }

    tem como fazer isso sem criar os metodos de evento?? do contrario como farei o msm utilizsando eventos??

    e outra... imendando a primeira duvida... como farei para a classe usuario do parametro ser a do tipo que o servidor ira receber sendo q o silver light não aceita que eu referencia projetos não silver light??
                

    Ozzyvegeta
    sexta-feira, 28 de agosto de 2009 22:33
  • ok... MVC = Model, View, Control:
    Model = Camada de Dados,
    View = Interface de manipulacao de dados
    Control = Regras de negocio...

    na verdade nao tem uma "camada de serviço" :P

    o que vc pode fazer para deixa o service como camada de dados... é criar uma class library para o silverlight para acesso ao seu WCF e nela coloca a sua regra de negocio e usar ela na sua aplicacao Silverlight que vai ser a sua camada de manipulacao de dados

    bem voltando ao foco....

    A Classe Usuario vem do Proxy do seu WCF... 

    o seu exemplo pode ser feito de 2 jeitos...


    namespace Namespace.Do.Seu.Proxy {
         partial class Usuario {
               private ManualEventRaise eventControl = new ManualEventRaise();
               private bool inserirResultado = false;

               public bool Inserir() {
                      var servico = new SeuWcfService();
                      service.PodeCadastrarCompleted += this.PodeCadastrarCompleted;
                      service.PodeCadastrarAsync(this, servico);      
                      
                      eventControl.WaitOne(20000); // Espera 20seg pela reposta
                      return inserirResultado;        
               }
              private void PodeCadastrarCompleted(object sender, PodeCadastrarCompletedEventArgs e) {
                     if (e.Result) {
                           var servico = e.UserState  as SerWcfService;
                           service.InserirAsync(this);                      
                     }

                     inserirResultado = e.Result;
                     eventControl.Set();
              }
               
         }
    }


    ai para usar vc faz o seguinte:

    void SalvarButton_MouseDown(...) {
           var usuario = new Usuario();
           // popula os dados do usuario
          if (!usuario.Incluir()) {
               // mensagem de erro
          }
    }

    What would Brian Boitano do ?
    sexta-feira, 28 de agosto de 2009 22:51
    Moderador
  • fala ruim....desculpe a ignorancia, mais oq tem haver MVC com meu problema??

    é a ideia de criar um projeto silverlight esta descartada pois tenho meu projeto funcionado em WebProjet e WindowsForm...

    assim, eu tenho uma camada de acesso a dados (um projeto) outra com as regras de negocio (outro projeto) e as interfaces são qualquer uma...

    e sobre esse aspecto de projeto eu gostaria muitooo de transportar minhas classes que estão na camada de acesso a dados para o silver light.. assim eu conseguiria trabalhar tipado em meu projeto... e fazer o transporte tranquilamente...

    tipo:

     public void Inserir()
    {
        if (!servico.PodeCadastrar(usuario))
        {
             exibemensagemdeerro()
             return;
        }

        servico.Inserir(usuario)
     }

    ou seja, essa camada esta visivel em todos os niveis pois ela soh tem propriedades para alocar os tipos primitivos...

    alguma ideia para esse meu problema?

    e mais uma vez não entendi essa classe de proxy... aonde eu deixo essa classe? ela serve apenas para encapsular as chamados do serviço??

    e esse comando WaitOne, pelo que entendi ele faz esperar 20 segundos, mais e se o servioç demorar 30 segundos, ele irá continuar o processo apos 20 segundos?? acho essa ideia é meio estranha pois como posso saber o tempo q meu metodo do serviço ira demorar?? pode demorar 2 segundos.. pode demorar 1...pode demora 0.00001 segundos... acho estranho d++..

    vlw
    Ozzyvegeta
    sábado, 29 de agosto de 2009 17:21
  • ok vamos por partes... agora q vc disse q ja tem os objetos em outras camadas... 

    Classe de Proxy e a classe gerada para acessar o seu Service pelo Visual Studio...

    A unica forma que eu vjo agora de vc fazer as suas regras de negocio serem acessivel pelas aplicacoes feitas em .NET e as feitas em Silverlight  é colocando todas no seu Service mesmo... pq Silverlight é uma coisa e .NET é outra... um usa um framework e o outro usa outro... vc pondo tudo no seu service... ai tanto faz ser silverlight, windows forms ou java e etc....

    entao o metodo 

    public void Inserir()
    {
        if (!servico.PodeCadastrar(usuario))
        {
             exibemensagemdeerro()
             return;
        }

        servico.Inserir(usuario)
     }

    teria q ficar dentro de um Web Service ou de um WCF... enfim... para poder ser portatil entre diferentes ambientes de desenvolvimento...


    o WaitOne espera ate vc executar o metodo Set ou ate acabar o tempo informado no parametro... se levar 30 seg... para chamar o Set... ele demora 30 seg... senao espera ate 20 min ... se vc nao passar o tempo maximo ele fica esperando eternamente pelo Set.... ele é usado para sincronizar 2 threads... isso é... vc tem uma thread q para continuar necessita q uma outra thread seje executada antes... vc poem o WaitOne para esperar a execuçao dela... e o Set na outra threade para informar que ja pode continuar...

    What would Brian Boitano do ?
    sábado, 29 de agosto de 2009 19:01
    Moderador
  • o MVC foi para exemplificar o que eh Camada de Negocio... uma vez q vc deu a impressao de estar meio confuso com a definiçao dela...

    foi so para dizer q camada de negocio nao necessariamente tem que estar em uma dll... enfim... vamos deixar isso para la que é meio confuso mesmo...

    What would Brian Boitano do ?
    • Marcado como Resposta Daniel Ferreira quarta-feira, 14 de julho de 2010 13:35
    sábado, 29 de agosto de 2009 19:03
    Moderador
  • Não compreendi...

    """A unica forma que eu vjo agora de vc fazer as suas regras de negocio serem acessivel pelas aplicacoes feitas em .NET e as feitas em Silverlight  é colocando todas no seu Service mesmo... pq Silverlight é uma coisa e .NET é outra... um usa um framework e o outro usa outro... vc pondo tudo no seu service... ai tanto faz ser silverlight, windows forms ou java e etc...."""

    Como assim colocar tudo em um Serviço??

    seria decorar minhas classes de negocio com os atributos de serviço??

    e como ficaria as classes de dados?? elas precisam estar visiveis em todos os niveis, como faria para o silverlight ve-las??

    opa... agora entendi a ideia do ManualEventRaise... ele serve pra aguardar o serviço executar a tarefa e continuar de forma sincrona...

    bom, achei legal a solução, mais meia trabalhosa sabendo que WCF é uma evolução do Web Service .... com web service era simples executar um metodo de servodor...

    bastava apenas:

    webservice.InserirUsuario(usuario)

    agora com WCF eu preciso criar metodos de evento e uma variavel global na classe... e detalhe... se eu executar esse metodo Inserir apartir de theads com a mesma instancia eu teria problemas ja q inserirResultado é global...

    ou existe outra forma que pareça com a chamada de webservice?? sem utilizar eventos e variaval gloval pra armazenar valores??

    vlwww
    Ozzyvegeta
    sábado, 29 de agosto de 2009 19:21
  • Ah... vc pode chamar um WebService pelo Silverlight... sem problemas...

    a ideia q eu tinha era isso mesmo... converte a sua biblioteca de negocio num webservice... assim vc pode usar ela tanto no silverlight como no .net normalmente...
    What would Brian Boitano do ?
    domingo, 30 de agosto de 2009 22:40
    Moderador
  • sei sim... até pensei em usar mais gostaria de estar atualizado com essa tecnologica ja que ela eh a evolução...

    por isso vou insistir nela mesmo com essas dificuldades que pra mim são apenas para complicar... uma vez sabendo que a facilidade do webservice não foi continuada...

    mais enfim, a ideia então seria deixar cada classe de negocio como sendo meus serviços, decorando-as...

    porem tenho um empace... minhas classes de negocio herdam as classes de dados...

    exempli..

    clss Usuario : UsuarioDAO
    {
    }

    e quando eu trabalho eu faço o seguinte:

    usuario.nome = "abc"
    usuario.inserir();

    agora eu terei que fazer o seguinte para funcionar com o serviço:

    usuario.Inserir(usuario)

    ou seja, agora eu tenho que passar o usuario por parametro gerando assim redundancia apenas para satisfazer o serviço... sera que isso esta certo??

    caso vc me responda SIM... eu te digo entao que NÃO HERDAR a classe usuarioDao e fazer com que meus metodos sejam TODOS estaticos é mais semantico e economiza linhas...

    exemplo;;

    var usuarioDao = new UsuarioDAO()
    usuarioDao.Nome = "abc";
    Usuario.Inserir(usuarioDao);

    e economiza linha nesses tipos de metodos

    antes:

    Usuario usuario = new Usuario()
    return  (usuario.GetUsuarios());

    depois:

    return Usuario.GetUsuarios();


    saca a ideia??

    ou seja, dessa forma não preciso de instancia pra minhas classes de negocio já que o serviço precisa sempre receber a classe de dao referente por parametro!

    oq axa dessa mudanã?? isso é correto em termos d arquitetura?

    vlw
    Ozzyvegeta
    segunda-feira, 31 de agosto de 2009 01:08
  • Ah... web service nao esta descontinuado.... ele eh padrão para integração de sistemas.. uma vez q java nao acessa wcf e o .net nao acessa ejb....

    Sobre a sua duvida... na verdade herança funcionaria algo assim

    public class UsuarioDAO {
         public string Nome {get; set;}
         public int ID  {get; set;}

         public virtual void Incluir() {
            // Insert no banco de dados
         }
    }

    public class Usuario: UsuarioDAO {
         public override void Incluir() {
            // Validações de Negocio
            if (this.ID == 0) throw new Exception("Codigo Invalido");

            // Chama o metodo Incluir da classe UsuarioDAO
            base.Incluir();
         }
    }

    como funcionaria usando um Service (seja WCF, seja WebService.... a ideia eh a mesma) vou usar webservice pq ainda é a solução padrao para integração de sistemas conforme a W3C.....

    [Serializable]
    public interface IUsuario {
         string Nome {get; set;}
         int ID {get; set;}
        
        void Incluir();
    }

    public class UsuarioDAO: IUsuario  {
         public string Nome {get; set;}
         public int ID  {get; set;}

         public void Incluir() {
            // Insert no banco de dados
         }
      
         public UsuarioDAO(int id, string nome) {
             this.ID = id;
             this.Nome = nome;
         }
    }

    [WebService]
    public class Usuario: WebService {
         [WebMethod]
         public IUsuario Incluir(int id, string nome) {
            // Validações de Negocio
            if (id == 0) throw new Exception("Codigo Invalido");

            IUsuario usuario = new UsuarioDAO(id, nome);

            // Chama o metodo Incluir da classe UsuarioDAO
            usuario.Incluir();
            
            return usuario;
         }
    }


    como funionaria usando webservice e uma classe de negocio
    [Serializable]
    public interface IUsuario {
         string Nome {get; set;}
         int ID {get; set;}
    }

    public class UsuarioDAO: IUsuario  {
         public string Nome {get; set;}
         public int ID  {get; set;}

         public virtual void Incluir() {
            // Insert no banco de dados
         }
       
         public UsuarioDAO(int id, string nome) {
             this.ID = id;
             this.Nome = nome;
         }
    }

    public class Usuario: UsuarioDAO {
         public override void Incluir() {
            // Validações de Negocio
            if (this.ID == 0) throw new Exception("Codigo Invalido");

            // Chama o metodo Incluir da classe UsuarioDAO
            base.Incluir();
         }

        public Usuario(int id, string nome): base(id, nome) { }
    }

    [WebService]
    public class MeuSistema: WebService {
         [WebMethod]
         public IUsuario IncluirUsuario(int id, string nome) {
            IUsuario usuario = new Usuario(id, nome);
            usuario.Incluir();        
            return usuario;
         }
    }


    Agora sobre a questao do que é mais facil... do que usa mais linhas de comando... do que da mais trabalho.... na boa... esse nao é o caso... vc quer trabalhar com herança buscando uma melhor perfomance, portabilidade e etc é uma coisa.... nas ter menos linhas de codigo nao siginifica necessariamente ser melhor.... enfim... "linhas de codigo" nao eh metrica para ser usada em nenhum caso atualmente....


    o fato é... que usar herança otimo... no seu caso usa entao metodos virtuais e faz acesso aos metodos da classe pai utilizando o base
    quer passar o objeto como paramentro numa classe de negocio estatica.... entao usa interfaces... dessa forma vc mantem a sua classe de dados encapsulada e so propraga as informacoes necessarias para o cliente....


    eu particulamente gosto mais da 3 opção.... pq vc pode criar uma class library com as classes de negocio e dados.... e usar a classe direto no seu projeto ASP.NET, quando for usar um Windows Forms... vc pode usar ela no WCF.... se for usar em Silverlight vc pode usar em WCF tmb, ou um WCF for Silverlight ou WebService... e se prescisar de um cliente em Delphi (para maquinas win 98), em Java (para rodar em teminais Linux ou Mac) vc pode usar ela no WebService....


    What would Brian Boitano do ?
    • Marcado como Resposta Daniel Ferreira quarta-feira, 14 de julho de 2010 13:35
    segunda-feira, 31 de agosto de 2009 17:01
    Moderador
  • fala galera,

    Bom, oq quis dizer com a utilização de numero de linhas não foi no sentido de que isso é ruim ou bom..foi no sentido de ser DESNECESSARIA ja que meus metodos sempre vao receber por parametro a classe de dados referente a classe de negocio que esta executando... exemplo : UsuarioNegocio tem seus metodos que recebem UsuarioDAO e os metodos não são interligados, ou seja, nenhum popula uma varival privada para o outro poder utilizar... todos sao independentes sendo a unica entra os parametros do metodo.. foi pensando nessa ideia que vi que não havia a necessidade de manter essa classe para ser instanciada ja que os metodos tem comportamentos de metodos staticos... assim eu quis dizer que fica mais semantico utilizar dessa forma e queria saber se isso é legal... numero de linhas foi apenas um exemplo de como se "complica" desnecessariamente ...

    e voltando ao outro assunto de chamar um metodo de forma sincrona.. eu tentei isso que o rui sugeriu:

    namespace Namespace.Do.Seu.Proxy {
         partial class Usuario {
               private ManualEventRaise eventControl = new ManualEventRaise();
               private bool inserirResultado = false;

               public bool Inserir() {
                      var servico = new SeuWcfService();
                      service.PodeCadastrarCompleted += this.PodeCadastrarCompleted;
                      service.PodeCadastrarAsync(this, servico);      
                      
                      eventControl.WaitOne(20000); // Espera 20seg pela reposta
                      return inserirResultado;        
               }
              private void PodeCadastrarCompleted(object sender, PodeCadastrarCompletedEventArgs e) {
                     if (e.Result) {
                           var servico = e.UserState  as SerWcfService;
                           service.InserirAsync(this);                      
                     }

                     inserirResultado = e.Result;
                     eventControl.Set();
              }
               
         }
    }

    Porem, não funcionou :(

    o WaitOne pará toda a minha aplicação e só quando o TimeOut terminar o evento de completed é disparado... tentei utilizar a forma de IAsyncResult e nada tb... oq sera q pode ser? vc utiliza desta tecnica em silverlight sem esse erro??

    vlw galera

    Ozzyvegeta
    • Marcado como Resposta Daniel Ferreira quarta-feira, 14 de julho de 2010 13:35
    terça-feira, 1 de setembro de 2009 07:08