Maneiras de manter o método abstrato do lado do servidor para o WCF

Question

Estamos enfatizando a todos os nossos objetos de domínio para implementar GetHashCode.

namespace Core
{
  [Serializable]
  public abstract class DomainObject
  {
    public abstract override int GetHashCode();
  }
}

namespace Entity.Domain
{
  [Serializable]
  [DataContract]
  public partial class IdCard : DomainObject
  {
    private System.Int32 _effDte;

    [DataMember]
    public virtual System.Int32 EffDte
    {
        get { return _effDte; }
        set { _effDte = value; }
    }

    public override int GetHashCode()
    {
        return EffDte.GetHashCode();
    }
  }
}

Quando nós expor esses objetos de domínio através do WCF, o seguinte serviço gerado está exigindo uma pós-atualização de modificação para compilar.

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:2.0.50727.3053
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace IdCardManagerServiceReference {
using System.Runtime.Serialization;
using System;


[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Runtime.Serialization", "3.0.0.0")]
[System.Runtime.Serialization.DataContractAttribute(Name="IdCard", Namespace="http://schemas.datacontract.org/2004/07/Entity.Domain")]
[System.SerializableAttribute()]
public partial class IdCard : Core.DomainObject, System.Runtime.Serialization.IExtensibleDataObject, System.ComponentModel.INotifyPropertyChanged { 
    [System.NonSerializedAttribute()]
    private System.Runtime.Serialization.ExtensionDataObject extensionDataField;

    [System.Runtime.Serialization.OptionalFieldAttribute()]
    private int EffDteField;

    [global::System.ComponentModel.BrowsableAttribute(false)]
    public System.Runtime.Serialization.ExtensionDataObject ExtensionData {
        get {
            return this.extensionDataField;
        }
        set {
            this.extensionDataField = value;
        }
    }

    [System.Runtime.Serialization.DataMemberAttribute()]
    public int EffDte {
        get {
            return this.EffDteField;
        }
        set {
            if ((this.EffDteField.Equals(value) != true)) {
                this.EffDteField = value;
                this.RaisePropertyChanged("EffDte");
            }
        }
    }
}

Ideias sobre como manter a exigência de GetHashCode, mas remover o requisito para qualquer código no cliente (como uma atualização ou como classes parciais)?

Answer 1

Se você realmente exigir que todas as C# consumidores do serviço WCF usar os mesmos modelos com o código original intacto, em seguida, usar o "Add Service Reference" ferramenta "de Reutilização de tipos de assemblies referenciados" recurso.Certifique-se dividir os modelos / contratos / interfaces em um único assembly com nenhum outro código de implementação em que ela serve como um partilhada "definição" de montagem.Marcar esta assembléia, como a reutilização de tipos a partir de quando o "Add Service Reference" ferramenta gera o código de proxy do cliente.

Também, apenas de uma forma pró-aviso:simplificar as coisas para si mesmo, por ter apenas um "oficial" C# serviço de implementação do cliente para o serviço.Não adicione redundante serviço de referência proxies gerado pelo Visual Studio para cada projeto único, que requer conectividade com o seu serviço.

EDITAR:

Falando da sua experiência pessoal recente, tendo concebido um modular, compatível com o serviço de API, permita-me oferecer mais conselhos gerais sobre o tema da modularidade como ele se refere não só para serviços WCF, mas a centralização do projeto.

No nosso sistema, temos feito o que eu sugeri acima, na criação de um único "Definição" conjunto que contém apenas objetos marcados como [DataContract]:os objetos de domínio, modelos, dados, contratos, tudo o que você gosta de se referir a eles.

Nesta assembléia também é uma coleção de repositório de interfaces que define os métodos exclusivamente em termos destes objetos de domínio.Há também fortemente tipados identificador de estruturas definidas nesta assembleia, que são usados para armazenar valores de identidade, de acordo com cada modelo, uma vez que estes modelos são de banco de dados persistentes e cada um tem uma coluna de identidade.Usando estruturas de moldagem ints desta forma, é preferível utilizar int se desde agora temos compilador assistido por análise semântica, isto é, Model1ID não é conversível para Model2ID como eles semanticamente representam dois domínios diferentes, apesar do fato de que ambos os domínios são representáveis pelo int escreva.

O que impulsiona a modularidade é a definição destes repositório de interfaces.O serviço do WCF classe de implementação simplesmente implementa todas as interfaces necessárias, de forma semelhante com o cliente de serviço WCF classe de implementação, o banco de dados de repositório de classe de implementação, o cache de proxy classe de implementação, a invocação de método de log de classe de implementação, etc.Todo o concreto a implementação de classes existentes em outras montagens, i.é.não na "Definição" de assemblagem que contém as interfaces e modelos.Essas classes implementam as interfaces e aparecer o código de defesa do consumidor como o mesmo.

A chave é manter a sua API do código de defesa do consumidor agnóstico específico, a implementação de classes e referência apenas as interfaces.Os próprios modelos são mantidos como simples recipientes de dados com lógica comercial de implementação encontrado dentro deles.Eu acredito que este padrão é conhecido como anemia, mas para mim "anêmica" tem conotações negativas, então eu não gosto de usar esse termo ao descrever este projeto.

O que você ganha é o consumidor código de implementar a lógica de negócios que não se importa se ele está falando a um serviço WCF ou diretamente para um banco de dados, ou que o cache está a ser implementado de forma integrada, ou que suas invocações do método a ser registrada, ou qualquer outro proxy usa você pode vir acima com.

Em resumo, com design de interfaces e tornar a sua vida mais fácil para si mesmo.Mas só faça isso se você está confiante na sua capacidade para a prática de auto-restrição.No nosso sistema que eu concebi, temos modelos T4, que geram quase todos do código clichê que vem junto com os serviços do WCF para o ponto de onde todos nós temos que fazer manualmente é definir o modelo, design de interface, e escreve o banco de dados de código de acesso.O WCF fachada vem de graça com um simples clique com o botão direito e clique em "Executar a Ferramenta Personalizada" no T4 modelos.Eu adoro isso.:)

Answer 2

Corrija o espaço para nome da sua classe parcial. Pode ser necessário ajustar os atributos e a herança.

namespace DCS2000.IDCardExclude.UI.IdCardManagerServiceReference
{
  [Serializable]
  [DataContract]
  public partial class IdCard : DomainObject
  {
    public override int GetHashCode()
    {
        return EffDte.GetHashCode();
    }
  }
}