Concurrence optimiste dans Entity Framework entre Oracle et T-SQL

Question

Je construis des premiers POCO EF Code qui seront utilisés entre une back-end Oracle et un backend MS SQL Server. J'ai un problème pour trouver la bonne façon de s'attaquer à une propriété Timestamp qui fonctionne sur l'une ou l'autre des bases de données.

MS SQL Server aurait-moi d'utiliser une propriété commune comme ceci:

[Timestamp] 
public byte[] Timestamp {get;set;} 

Et puis dans la cartographie fluent il ressemblerait à ceci

map.Property(p => p.Timestamp).IsRowVersion(); 

Cependant Oracle aurait me changer ma commune type de propriété à ce:

public int Timestamp {get;set;} 

Et puis dans la cartographie fluide, il ressemblerait ce

map.Property(p => p.Timestamp).HasColumnName("ORA_ROWSCN").HasDatabaseGeneratedOption(DatabaseGeneratedOption.Computed).IsConcurrencyToken(); 

Ma première estimation était peut-être je pourrais changer le type de données à long, car l'horodatage est de huit octets, mais SqlServer n'a pas aimé la cartographie. Ma prochaine proposition est d'abandonner Timestamp et Ora_RowScn et de créer ma propre propriété Optimistic Concurrency. Des suggestions ou savoir si un moyen d'avoir un bon modèle qui fonctionne à la fois entre Sql et Oracle? Merci.

Answer 1

Voici comment j'ai résolu le problème. Je me suis débarrassé de l'attribut [Timestamp]. Puis j'ai aussi créé deux assemblées pour mes dépôts, une pour Oracle et l'autre pour MSSQL. Ensuite, mon modèle de base ressemble à ceci.

[DataContract] 
    public abstract class DomainBase 
    { 
     /// <summary> 
     /// Gets or sets the id. 
     /// </summary> 
     [DataMember] 
     [Key] 
     public long Id { get; set; } 


     private byte[] _timestamp=new Guid().ToByteArray(); 

     /// <summary> 
     /// Gets or sets the timestamp. 
     /// </summary> 
     [DataMember] 
     public byte[] Timestamp { get { return _timestamp; } 
      set { _timestamp = value; 
      if (_timestamp != null && _signature != Convert.ToBase64String(_timestamp)) 
        _signature = Convert.ToBase64String(_timestamp); 
      } 
     } 

     private string _signature = Convert.ToBase64String(new Guid().ToByteArray()); 

     /// <summary> 
     /// Gets the signature. 
     /// </summary> 
     [DataMember] 
     public string Signature 
     { 
      get { return _signature ?? (Timestamp != null ? _signature = Convert.ToBase64String(Timestamp) : null); } 
      protected set { _signature = value; 
       if ((_timestamp == null && !String.IsNullOrWhiteSpace(_signature)) || 
        (_timestamp != null && !String.IsNullOrWhiteSpace(_signature) && Convert.ToBase64String(_timestamp) != _signature)) 
        _timestamp = Convert.FromBase64String(value); 
      } 
     } 

     /// <summary> 
     /// Gets a value indicating whether has signature. 
     /// </summary> 
     public bool HasSignature 
     { 
      get { return Timestamp != null; } 
     } 
    } 

Ensuite, voici comment je gère les mappages dans chaque configuration fluide.

Pour le serveur MSSQL.

Property(p => p.Timestamp).HasColumnType("timestamp").HasDatabaseGeneratedOption(DatabaseGeneratedOption.Computed).IsRowVersion(); 
      Ignore(p => p.Signature); 

Pour Oracle

Ignore(p => p.Timestamp); 
      Property(p => p.Signature).HasColumnName("Timestamp").IsConcurrencyToken();