Architettura, SOA, Windows Communication Foundation, Eventi, Scalabilità, PDC, Configurazione, Deploy, Ajax, ASP.NET, Controls, UrlRewrite, Live, .NET

Ormai è un po' di tempo che sto realizzando una piccola applicazione con architettura a tre livelli, e mi si è posto subito un problema, ossia gestire una transazione tra più entity.

Per capirci, io ho la mia entity Fattura che al suo interno ha una collection di righeFattura, la entity Cliente e la entity Fornitore (direi che per l'esempio bastano).
Quando devo persistere la mia entity (con le rispettive sottoentity) devo avere la certezza che tutto sia andato a buon fine e nel caso si verifichi un errore si deve ripristinare la situazione originale e avvertire l'utente che qualcosa è andatao storto.

Per risolvere la il problema ho deciso di implementare questa soluzione:

1. Ogni classe di persistenza del DAL deve esporre un'interfaccia ITransactionable;
2. Il DAL deve esporre una classe che implementa un'interfaccia ITransactionManager;

I seguenti diagrammi mostrano le interfacce nel dettaglio:

Ora all'interno delle nostre classi di persistenza dove esponiamo ITransactionable prima della chiamata di update, delete, ecc dobbiamo verificare se l'oggetto transazionale è instanziato oppure no, lo possiamo fare con una semplice if.

public bool Update(Fattura item)
{
int rowsAffected;

if (Transaction == null)
{
rowsAffected = SqlHelper.ExecuteNonQuery(
ProviderHelper.ConnectionString,
CommandType.StoredProcedure,
"sp_Fattura_Update", CreateParameter(true, item));
}
else
{
rowsAffected = SqlHelper.ExecuteNonQuery(
Transaction,
CommandType.StoredProcedure,
"sp_Fattura_Update", CreateParameter(true, item));

}

if (rowsAffected <= 0)
throw new Domain.Exception.ConcurrencyException(Resource.Res.GetString("ConcurrencyException"));
else
return true;
} 

Transaction non è l'implementazione del'interfaccia ITransactionable ma un suo cast a SqlTransaction.

Il nostro Transaction Manager presente nel DAL sarà pittusto semplice quindi una roba tipo questa: 

private SqlConnection conn;
private SqlTransaction transaction;
private List coll;


public TransactionManager()
{
coll = new List();
}

 

public void Add(ITransactionable transactionObject)
{
coll.Add(transactionObject);
}


public void Remove(ITransactionable transactionObject)
{

transactionObject.ExternalTransaction = null;
coll.Remove(transactionObject);
}


public void StartTransaction()
{
conn = new SqlConnection(ProviderHelper.ConnectionString);
conn.Open();
transaction = conn.BeginTransaction();

for (int i = 0; i < coll.Count; i++)
coll[i].ExternalTransaction = transaction;


}


public void Commit()
{
transaction.Commit();
}


public void Rollback()
{
transaction.Rollback();
}

public void Dispose()
{
if(conn.State == ConnectionState.Open)
conn.Close();
for (int i = 0; i < coll.Count; i++)
{
coll[i].ExternalTransaction = null;
coll.RemoveAt(i);
}
transaction.Dispose();
} 

Dal Business Layer vado ad utilizzare il Transaction Manager in questo modo: 

using (ITransactionManager manager = AbstractFactory.ProviderFactory.TransactionManager)
{

IFatturaDataProvider aProvider = AbstractFactory.ProviderFactory.FatturaProvider;
IFornitoreDataProvider fProvider = AbstractFactory.ProviderFactory.FornitoreProvider;
IClienteDataProvider cProvider = AbstractFactory.ProviderFactory.ClienteProvider;

 

manager.Add(provider);
manager.Add(fProvider);
manager.Add(cProvider);

manager.StartTransaction();

try
{
provider.Update(item);
cProvider.Update(item.Cliente);
fProvider.Update(item.Fornitore);

manager.Commit();
}
catch
{
manager.Rollback();
throw;
}

}

Secondo voi l'implementazione è quella corretta?

This entry was posted on Monday, 11 December, 2006 and is filed under .NET . You can follow any responses to this entry through here . You can leave a response.

Volevo farne uno script ma mi sembrava troppo lungo, ma troppo corto per un articolo, insomma non sapevo dove metterlo e alla fine ho deciso di piazzarlo qui, in caso il boss mi dirà.

Cmq sono un'insieme di metodi che comprimono una cartella e tutto il suo contenuto in un unico file zip mantenendo la struttura.

public static void ZipFolder(string path, string path2Save, string name, bool recursive) 
{ 
Crc32 crc = new Crc32(); if (String.IsNullOrEmpty(name)) 
name = new DirectoryInfo(path).Name; if (!name.EndsWith(".zip")) 
name += ".zip" if (!Directory.Exists(path2Save)) 
Directory.CreateDirectory(path2Save); try 
{ 
using (ZipOutputStream s = new ZipOutputStream(File.Create(path2Save + name))) 
{ 
s.SetLevel(6); 
string basepath = path.Replace(new DirectoryInfo(path).Name, String.Empty); if (basepath.EndsWith("\\\\")) 
basepath = basepath.Replace("\\\\", "\\"); 
AddToZip(path, s, crc, basepath, recursive); s.Finish(); 
s.Close(); 
} 
} 
catch (Exception e) 
{ 
File.Delete(path2Save + name); 
throw e; 
} 
} 
 private static void AddToZip(string path, ZipOutputStream s, Crc32 crc, string basepath, bool recursive) 
{ 
foreach (string srcFileName in Directory.GetFiles(path)) 
{ 
string filepath = path + @"\" + new DirectoryInfo(srcFileName).Name; 
AddFile(s, filepath, crc, basepath); 
} foreach (string strSrcSubDirectory in Directory.GetDirectories(path)) 
AddFolder(s, strSrcSubDirectory, crc, basepath); if (recursive) 
foreach (string strSrcSubDirectory in Directory.GetDirectories(path)) 
{ 
path += @"\" + new DirectoryInfo(strSrcSubDirectory).Name; 
AddToZip(strSrcSubDirectory, s, crc, basepath, recursive); 
} 
} private static void AddFile(ZipOutputStream s, string file, Crc32 crc, string basepath) 
{ 
using (FileStream fs = File.OpenRead(file)) 
{ 
byte[] buffer = new byte[fs.Length]; 
fs.Read(buffer, 0, buffer.Length); ZipEntry entry; if (string.IsNullOrEmpty(basepath)) 
entry = new ZipEntry(file.Replace(basepath, String.Empty).ToLower()); 
else 
entry = new ZipEntry(file); entry.DateTime = DateTime.Now; 
entry.Size = fs.Length; crc.Reset(); 
crc.Update(buffer); entry.Crc = crc.Value; 
s.PutNextEntry(entry); 
s.Write(buffer, 0, buffer.Length); 
} 
} private static void AddFolder(ZipOutputStream s, string file, Crc32 crc, string basepath) 
{ 
ZipEntry entry; if (string.IsNullOrEmpty(basepath)) 
entry = new ZipEntry(file.Replace(basepath, String.Empty).ToLower()); 
else 
entry = new ZipEntry(file); entry.DateTime = DateTime.Now; crc.Reset(); entry.Crc = crc.Value; 
s.PutNextEntry(entry); 
}

Va sistemata un po, per gestire bene le eccezzioni e perchè l'ho solo provata al volo ma sicuramente il codice può essere ottimiccato, però in linea di massima funziona

This entry was posted on Wednesday, 08 November, 2006 and is filed under .NET . You can follow any responses to this entry through here . You can leave a response.