Le migliori strategie quando si lavora con micro ORM?

Question

Ho iniziato a utilizzare PetaPOCO e Dapper e hanno entrambi i loro limiti. Al contrario, sono così fulminei di Entity Framework che tendo a lasciarne i limiti.

La mia domanda è: esiste un ORM che ci consente di definire concretamente le relazioni uno a molti, molti a uno e molti a molti? Sia Dapper.Net che PetaPOCO implementano il modo hack-ish per simulare queste relazioni e inoltre non si adattano molto bene quando si possono avere 5-6 join. Se non c'è un solo micro ORM che ci permetta di affrontarlo, allora la mia seconda domanda è che dovrei lasciar andare il fatto che questi micro ORM non sono così validi nella definizione delle relazioni e creare una nuova entità POCO per ogni singolo tipo di query che eseguirò che include questi tipi di multi-join? Può questa scala bene?

Spero di essere chiaro con la mia domanda. In caso contrario, fammi sapere.

Answer 1

Io generalmente attenersi alla seguente procedura.

1. Creo il mio viewmodel in modo tale che rappresenti esattamente i dati e il formato che voglio visualizzare in una vista.
2. Ho interrogato direttamente dal database tramite PetaPoco sui miei modelli di visualizzazione.

Nel mio ramo Ho un

T SingleInto<T>(T instance, string sql, params object[] args);

metodo che prende un oggetto esistente e in grado di mappare le colonne direttamente ad esso abbinato al nome. Questo funziona brillantemente per questo scenario.

Il mio ramo può essere trovato qui se necessario. https://github.com/schotime/petapoco/

Answer 2

non hanno nemmeno scalare molto bene quando si può avere 5-6 unisce

Sì, non lo fanno, ma che è una buona cosa, perché quando il sistema si sarà costruire inizia a diventare complesso, sei libero di fare i join che vuoi, senza penalizzazioni prestazionali o mal di testa.

Sì, mi manca quando non ho bisogno di scrivere tutto questo JOINS con Linq2SQL, ma poi ho creato un semplice strumento per scrivere i join comuni così ho ottenuto l'SQL di base per qualsiasi entità e quindi posso costruire da lì .

Esempio:

[TableName("Product")] 
[PrimaryKey("ProductID")] 
[ExplicitColumns] 
public class Product { 
    [PetaPoco.Column("ProductID")] 
    public int ProductID { get; set; } 

    [PetaPoco.Column("Name")] 
    [Display(Name = "Name")] 
    [Required] 
    [StringLength(50)] 
    public String Name { get; set; } 

      ... 
      ... 

    [PetaPoco.Column("ProductTypeID")] 
    [Display(Name = "ProductType")] 
    public int ProductTypeID { get; set; } 

    [ResultColumn] 
    public string ProductType { get; set; } 

      ... 
      ... 


    public static Product SingleOrDefault(int id) { 
     var sql = BaseQuery(); 
     sql.Append("WHERE Product.ProductID = @0", id); 
     return DbHelper.CurrentDb().SingleOrDefault<Product>(sql); 
    } 
    public static PetaPoco.Sql BaseQuery(int TopN = 0) { 
     var sql = PetaPoco.Sql.Builder; 
     sql.AppendSelectTop(TopN); 
     sql.Append("Product.*, ProductType.Name as ProductType"); 
     sql.Append("FROM Product"); 
     sql.Append(" INNER JOIN ProductType ON Product.ProductoTypeID = ProductType.ProductTypeID"); 
     return sql; 
    } 

Answer 3

QueryFirst aiuto? Ottieni la velocità dei micro orms, con il conforto aggiunto di ogni errore-a-errore-compile-time, più l'intellisense sia per le tue domande che per il loro output. Definisci i tuoi join in SQL come inteso da Dio. Se la digitazione delle condizioni di join ti disturba, la risposta è DBForge e, poiché stai lavorando in SQL, questi strumenti sono compatibili e non sei bloccato.