C'è un modo per ereditare FAKE in C#/VB.NET?

Question

Supponiamo di voler ereditare da System.Data.SqlClient.SqlTransaction che è sigillato. Supere Voglio solo inserire un wrapper attorno allo SqlTransaction e utilizzare sempre MyTransaction anziché SqlTransaction. C'è un modo in cui potrei potenzialmente trasmettere MyTransaction a SqlTransaction utilizzando un operatore Implicito/Ampliamento?

Answer 1

Se davvero vuole conversione implicita (anche se io non lo consiglio, in quanto è un'idea orribile e un design orribile, IMO), si può fare qualcosa di simile:

class MyTransaction 
    { 
     private readonly SqlTransaction _transaction; 

     public MyTransaction(SqlConnection conn) 
     { 
      _transaction = conn.BeginTransaction(); 
     } 

     public SqlTransaction Transaction 
     { 
      get 
      { 
       return _transaction; 
      } 
     } 

     public static implicit operator SqlTransaction(MyTransaction t) 
     { 
      return t.Transaction; 
     } 
    } 

Answer 2

È possibile creare una classe con una variabile di transazione interna e quindi esporre i metodi e le proprietà. Un po 'come questo:

public class MyTransaction 
{ 
    System.Data.SqlTransaction myTx = someConnection.CreateTransaction(); 

    public void CommitTransaction() : { 
     myTx.CommitTransaction() 
    } 
} 

Si potrebbe anche rendere ereditare da DbTransaction e poi riscrivere le procedure astratte e virtuali per utilizzare la variabile myTx interna, ma comincia a diventare un po' complessa per nessun motivo reale apparente ...

Answer 3

Se si è solo interessati ad aggiungere metodi aggiuntivi a una classe, è possibile utilizzare i metodi di estensione. Ciò non ti darà accesso a nessuno stato interno, né ti permetterà di sovrascrivere i comportamenti, ma ti permetterà di aggiungere funzionalità limitate. Non sono a conoscenza di alcun modo di ereditare da una classe sigillata.

È possibile creare un vero oggetto wrapper come altri hanno menzionato, ma non sarà possibile utilizzarlo in modo polimorfico al posto dell'oggetto originale.

Answer 4

È possibile definire la propria classe MyTransaction come wrapper su SqlTransaction. Mantieni un'istanza di SqlTransaction in un campo privato in MyTransaction. Il tuo wrapper non sarà compatibile con SqlTransaction, ma se implementi le stesse interfacce SqlTransaction implementate puoi ottenere un risultato molto vicino.

Answer 5

No, non è possibile ereditare la propria classe personalizzata da SqlTransaction o fare in modo che questo venga simulato.

Tuttavia, se il contesto di ciò che si sta facendo consente di utilizzare un DbTransaction, è possibile ereditare la classe di transazione personalizzata da DbTransaction, avvolgendo un SqlTransaction all'interno con qualsiasi altra funzionalità richiesta.

Answer 6

Fate avere un'altra opzione, è possibile utilizzare Reflection.Emit() per aggiungere un'interfaccia di propria scelta a SqlTransaction e quindi utilizzare la stessa interfaccia nella nuova classe MyTransaction e quindi è possibile effettuare chiamate all'interfaccia, anziché alla classe.

Assicurarsi che questo funzioni solo all'interno delle librerie create dall'utente, oppure modificare in modo specifico i tipi caricati utilizzando Reflection.

Answer 7

È possibile creare metodi di estensione.

public static class SqlTransactionExtensions 
{ 
    public static void DoSomething(this SqlTransaction transaction, int myParameter) 
    { 
     // do something here 
    } 
} 

La classe deve essere statica. Posiziona la parola magica this davanti al parametro pugno che deve essere del tipo della classe che stai estendendo. È anche possibile estendere le interfacce. Se si desidera utilizzare questo metodo di estensione, è necessario disporre di uno using namspace con lo spazio dei nomi di questa classe di estensione, se non è definito nello stesso spazio dei nomi in cui si sta lavorando.

È quindi possibile chiamare il metodo di estensione, come se fosse un metodo regolare di SqlTransaction:

SqlTransaction t = new SqlTransaction(); 
t.DoSomething(5); 

Answer 8

OK, in modo da escludere l'eredità e concentrandosi sul compito che si vuole veramente risolvere (sulla base del commento thread).

Ho avuto successo in passato eseguendo tutte le chiamate attraverso una libreria di supporto e implementando la logica lì. In passato, ho usato SqlHelper, che è pubblicato in Microsoft Data Application Block. Questo è un modulo sorgente, che puoi adattare alle tue esigenze. È possibile aggiungere qualsiasi registrazione o altra logica richiesta.

Rende anche il codice molto leggibile. Si possono fare cose come:

SqlHelper.ExecuteDataset() per le query che ritornano insiemi di dati,

SqlHelper.ExecuteScalar() per le query di restituzione di valori singoli,

SqlHelper.ExecuteNonQuery() per i comandi che non hanno rendimenti (come INSERT 's).

ecc