Wrappare un ORM…

diciamo che avete il vostro “bel” dominio mappato con il fido Linq to Sql e siete decisamente felici di come funzionano le cose, nonostante gli evidenti limiti di L2S, ma ad un certo punto succede che i requisiti vi impongono di integrare all’interno della vostra applicazione dati che arrivano da una sorgente dati diversa, nello specifico un preistorico database dbase (v.2), che ha il piccolo difetto di non supportare in alcun modo la multiutenza ergo il primo che arriva “locca” e gli altri si attaccano (in una “conversazione” via mail ho usato un termine più colorito :-D). La soluzione più ovvia è nascondere i file di dbase dietro un servizio (ho scelto Wcf ma è poco rilevante la tecnologia) e gestire li gli accessi concorrenti.

using( var dc = new DomainDataContext() )
{
    var subjects = dc.Subjects.Where( s => s.Addresses.Count > 0 );
}

using( var dc = new DomainDataContext() )
{
    var subjects = dc.Subjects.Where( s => s.Addresses.Count > 0 );

    var other = dc.DifferentSourceData.Where( ... ).Single();
    other.SampleProperty = "new value...";

    dc.SubmitChanges();
}

• programmate a fronte di una singola API;
• gestite il ciclo di vita della “sessione” sempre allo stesso modo e il comportamente sulle entità di dominio è sempre lo stesso;
• gestite la persistenza in un solo punto;
• gestite la persistenza in maniera transazionale su tutti gli storage, ove abbia senso, in maniera trasparente;
• etc…

• Backend: è tutta la parte che sta dietro il vostro “data context”, è a tutti gli effetti un ORM a cui manca solo la parte di mapping e di generazione delle query (praticamente le 2 parti veramente toste), ma di cui dovete realizzare, tra i tanti pezzi, come minimo:
  • Motore di persistenza;
  • Motore di data mapping;
  • IdentityMap;
• Frontend: è tutta la parte, l’API pubblica, che viene esposta e che consente di interrogare il vostro modello;

1. se lo faccio perchè è bello si chiama seg* architetturale => non ha senso;
2. se lo faccio perchè sono capace e sono figo si chiama seg* architetturale => non ha senso;
3. se lo faccio perchè penso di poter rimpiazzare l’ORM a caldo si chiama seg*issima architetturale => non ha senso;
4. se lo faccio perchè ritengo che il dominio generato dal tool non sia un dominio decente molto probabilmente è una se*a architetturale => ergo molto probabilmente non ha senso;
5. se lo faccio perchè penso che in questo modo posso passare da n-layer a n-tier senza problemi, semplicemente “s c o r d a t e v e l o” => non ha senso, e forse è meglio che rivediate le vostre convinzioni :-);
6. se lo faccio perchè devo integrare informazioni che arrivano da storage diversi e voglio gestirle in un dominio unificato allora probabilmente ho trovato un motivo decente, anche qui però dipende molto da quanto queste informazioni devono essere intergrate => forse ha senso;

interface IDataContextWrapper
{
    IOrderedQueryable<Linq2Sql.Subject> Subjects { get; }

    void SubmitChanges();
}

interface IDataContextWrapper
{
    IOrderedQueryable<MyDomain.Subject> Subjects { get; }

    void SubmitChanges();
}

• esporre IQueryable ha il pesantissimo difetto, in questo scenario, di produrre un expression tree che non potete “eseguire” ma che dovete tradurre nell’expression tree che il motore di query sottostante si aspetta… un delirio;
• caliamo la cosa in uno scenario più realistico, diciamo che Subject arriva da un servizio Wcf… domanda che ve ne fate di un expression tree sul “client”? proprio un bel nulla…

• state sviluppando un’applicazione non un framework quindi si suppone che conosciate mostruosamente bene il dominio;
• avete un set di informazioni e di possibili interrogazioni noto, probabilmente vasto, ma decisamente noto;

interface IDataContext
{
    IEnumerable GetByQuery( ?? querySpec );
    T GetScalar( ?? scalarSpec );
}

interface IQuery{ }

class SubjectByCode : IQuery
{
    public SubjectByCode( String code )
    {
        this.Code = code;
    }

    public String Code
    {
        get;
        private set;
    }
}

IDataContext dc;
using( dc )
{
    var query = new SubjectByCode( "my code" );
    var result = dc.GetByQuery<Subject>( query );
}

interface IDataContext
{
    IEnumerable GetByQuery( ?? querySpec );
    TResult GetScalar( ?? scalarSpec );
}

var result = dc.GetByQuery<Subject, Subject>( query );

public interface IQuerySpecification { }

public interface IQuerySpecification : IQuerySpecification { }

class SubjectByCode : IScalarSpecification<Subject, Subject>
{
    public SubjectByCode( String code )
    {
        this.Code = code;
    }

    public String Code { get; private set; }
}

class AddressStringBySubjectQuery : IQuerySpecification<Address, String>
{
    public AddressStringBySubjectQuery( Subject owner )
    {
        this.Subject = owner;
    }

    public Subject Subject { get; private set; }
}

class NHDataContext : IDisposable, IDataContext
{
    ISession session;
    IQuerySystemManager querySystemManager;
    
    public NHDataContext( ISession session, IQuerySystemManager querySystemManager )
    {
        this.session = session;
        this.querySystemManager = querySystemManager;
    }

    public IEnumerable GetByQuery( IQuerySpecification querySpec )
    {
        var engine = this.querySystemManager.GetQueryEngine( querySpec );
        
        var provider = this.session.Linq();
        var result = engine.ExecuteQuery( querySpec, provider );

        return result;
    }

    public TResult GetScalar( IScalarSpecification scalarSpec )
    {
        var evaluator = this.querySystemManager.GetScalarEvaluator( scalarSpec );

        var provider = this.session.Linq();
        var result = evaluator.Evaluate( scalarSpec, provider );

        return result;
    }
}

var engine = this.querySystemManager.GetQueryEngine( querySpec );

interface IQuerySystemManager
{
    IQueryEngine GetQueryEngine<TSource, TResult, TProvider>( IQuerySpecification querySpec );
    IScalarEvaluator GetScalarEvaluator<TSource, TResult, TProvider>( IScalarSpecification scalarSpec );
}

class AddressStringBySubjectQueryEngine : 
      AbstractQueryEngine<AddressStringBySubjectQuery, Address, String, Address>
{
   public overrideIEnumerable<string> ExecuteQuery( AddressStringBySubjectQueryquerySpec, IQueryable<Address> provider )
   { 
      var address = "{0} n° {1}, {2} {3} - {4}"; 
      return provider.Where( a => a.Subject == querySpec.Subject )
                     .Select( a => new 
                     { 
                        Street = a.Street, 
                        Number = a.Number, 
                        ZipCode = a.ZipCode, 
                        City = a.City, 
                        Country = a.Country 
                     } )
                     .AsEnumerable()
                     .Select( a => String.Format( address, a.Street, a.Number, a.ZipCode, a.City, a.Country ) ); 
   }
}

public IQueryEngine GetQueryEngine( IQuerySpecification querySpec )
{
    var qbt = typeof( IQueryEngine<,,,> )
        .MakeGenericType( 
            querySpec.GetType(),
            typeof( TSource ), 
            typeof( TResult ), 
            typeof( TProvider ) );

    return this.container.GetService( qbt ) as IQueryEngine;
}