Overblog Suivre ce blog
Administration Créer mon blog

Présentation

  • : Romagny13 - Du .NET,du pur .NET
  • Romagny13 - Du .NET,du pur .NET
  • : Cycle de progression Faire (quelque chose qui marche) -> comprendre ce que l’on fait/comment cela marche -> pousser plus loin les notions
  • Contact

Recherche

Articles Récents

23 septembre 2007 7 23 /09 /septembre /2007 10:24


repositorygenerator-.JPG

    J'avais développé il y a quelques années un générateur de codes pour Enterprise Library .Je laisse le lien , ce n'était pas si mal pour l'époque .


http://www.codeplex.com/entlibrepositorygen

Repost 0
21 septembre 2007 5 21 /09 /septembre /2007 15:48
Enterprise Library –
récupérer des valeurs en retour de Procédures stockées
 
1 – solution : retourner un paramètre contenant une valeur (exemple l’identifiant d’une clé auto incrémentée)
CREATE PROCEDURE [dbo].[InsertContact]
(
     @ContactName char(100),
     @ContactFirstName char(100),
     @ContactAge int,@ContactCategoryID int
)
AS
declare @ContactID int;
INSERT INTO [Contact]([ContactName] ,[ContactFirstName] ,[ContactAge] ,[ContactCategoryID] )
VALUES(@ContactName,@ContactFirstName,@ContactAge,@ContactCategoryID)
SET @ContactID= SCOPE_IDENTITY();
return @ContactID;
 
Depuis enterprise Library
A-Création de la commande
public DbCommand ConstructInsertCommand(Database db,Contact Contact)
            {
                  DbCommand command = db.GetStoredProcCommand("dbo.AddContact");
                  db.AddInParameter(command, "ContactAge",DbType.Int32,Contact.ContactAge);
                  db.AddInParameter(command, "ContactCategoryID",DbType.Int32,Contact.ContactCategoryID);
                  db.AddInParameter(command, "ContactFirstName",DbType.String,Contact.ContactFirstName);
                  db.AddInParameter(command, "ContactName",DbType.String,Contact.ContactName);
                 db.AddParameter(command, "ContactID", DbType.Int32,ParameterDirection.ReturnValue,"ContactID",DataRowVersion.Default,null);
            return command;
            }
B – éxecution de la commande puis récupération du nouvel identifiant
        public int Add(IInsertFactory<TDomainObject> insertFactory,TDomainObject domainObj)
        {
            using (DbCommand command = insertFactory.ConstructInsertCommand(db, domainObj))
            {
                int result = db.ExecuteNonQuery(command);
                insertFactory.SetNewID(db, command, domainObj);
                return result;
            }
        }
        public void SetNewID(Database db, DbCommand command, Contact domainObj)
       {
            domainObj.ContactID = (int)db.GetParameterValue(command, "ContactID");
       }
 
2- Autre solution : passer un paramètre OUT à la procédure stockée
CREATE PROCEDURE [dbo].[InsertContact]
(
      @ContactID int OUT,
      @ContactName char(100),
      @ContactFirstName char(100),
      @ContactAge int,@ContactCategoryID int
)
AS
INSERT INTO [Contact]([ContactName] ,[ContactFirstName] ,[ContactAge] ,[ContactCategoryID] )
VALUES(@ContactName,@ContactFirstName,@ContactAge,@ContactCategoryID);
/* affectation à la variable du nouvel identifiant (la column ContactID etant auto incrémentée */
SET @ContactID= SCOPE_IDENTITY();
 
 
 
Depuis enterprise Library
A-Création de la commande
public DbCommand ConstructInsertCommand(Database db,Contact Contact)
            {
                  DbCommand command = db.GetStoredProcCommand("dbo.AddContact");
                  db.AddInParameter(command, "ContactAge",DbType.Int32,Contact.ContactAge);
                  db.AddInParameter(command, "ContactCategoryID",DbType.Int32,Contact.ContactCategoryID);
                  db.AddInParameter(command, "ContactFirstName",DbType.String,Contact.ContactFirstName);
                  db.AddInParameter(command, "ContactName",DbType.String,Contact.ContactName);
                 db.AddOutParameter(command, "ContactID", DbType.Int32, 4);
            return command;
            }
      B – éxecution de la commande puis récupération du nouvel identifiant
        public int Add(IInsertFactory<TDomainObject> insertFactory,TDomainObject domainObj)
        {
            using (DbCommand command = insertFactory.ConstructInsertCommand(db, domainObj))
            {
                int result = db.ExecuteNonQuery(command);
                insertFactory.SetNewID(db, command, domainObj);
                return result;
            }
        }
        public void SetNewID(Database db, DbCommand command, Contact domainObj)
       {
            domainObj.ContactID = (int)db.GetParameterValue(command, "ContactID");
       }
 
La seconde soltuion est peut être la mieux , en tout cas la plus utilisée

Note dans la méthode SetNewID j'affecte le nouvel identifiant,à mon objet métier (ici un contact) c'est à dire donc la valeur récupérée aprés execution de la procédure stockée
 
Repost 0
12 septembre 2007 3 12 /09 /septembre /2007 10:06
Une classe d’expiration basée sur SqlDependency pour le cache d’Enterprise Library
 
    ///<summary>
    ///     This class tracks a SQL Server dependency.
    ///</summary>
    [Serializable]
    [ComVisible(false)]
    public class SqlServerDependency :ICacheItemExpiration
    {
        private bool isExpired;
 
        ///<summary>
        /// Get expiration state
        ///</summary>
        public bool IsExpired
        {
            get { return isExpired; }
        }
 
        ///<summary>
        /// Constructor with one argument.
        ///</summary>
        ///<param name="command"></param>
        public SqlServerDependency(SqlCommand command)
        {
            SqlDependency.Stop(command.Connection.ConnectionString);
            SqlDependency.Start(command.Connection.ConnectionString);
 
            command.Notification = null;
            SqlDependency sqlDependency = new SqlDependency(command);
            sqlDependency.OnChange += new OnChangeEventHandler(OnChanged);
 
            if (command.Connection.State == ConnectionState.Closed)
                command.Connection.Open();
 
            command.ExecuteReader(CommandBehavior.CloseConnection);
        }
 
        void OnChanged(object sender, SqlNotificationEventArgs e)
        {
            SqlDependency sqlDependency = sender as SqlDependency;
            sqlDependency.OnChange -= OnChanged;
            isExpired = true;
        }
        ///<summary>
        /// Specifies if the item has expired or not.
        ///</summary>
        ///<returns>Returns true if the item has expired, otherwise false.</returns>
        public bool HasExpired()
        {
            return isExpired;
        }
 
        ///<summary>
        /// Notifies that the item was recently used.
        ///</summary>
        public void Notify()
        {
        }
 
        ///<summary>
        /// Not used
        ///</summary>
        ///<param name="owningCacheItem">Not used</param>
        public void Initialize(CacheItem owningCacheItem)
        {
        }
    }
 
Exemple d’utilisation
CacheManager cacheManager = CacheFactory.GetCacheManager();
 
        private void button1_Click(object sender, EventArgs e)
        {
            DataSet dataSet=null;
            if (cacheManager.Contains("AllContacts"))
            {
                dataSet = (DataSet)cacheManager["AllContacts"];
                label1.Text = "from cache";
            }
            else
            {
                Database db = DatabaseFactory.CreateDatabase();
                DbCommand command = db.GetStoredProcCommand("dbo.GetAllContacts");
                dataSet = db.ExecuteDataSet(command);
                //
                SqlServerDependency dependency = new SqlServerDependency(
                    new SqlCommand("select ContactID,ContactName,ContactFirstName,ContactAge from dbo.Contact",
                    new SqlConnection((ConfigurationManager.GetSection("connectionStrings") as ConnectionStringsSection).ConnectionStrings[1].ConnectionString)
                        )
                    );
                cacheManager.Add("AllContacts", dataSet, CacheItemPriority.Normal, null, new ICacheItemExpiration[] { dependency });
                label1.Text = "from database";
            }
 
            dataGridView1.DataSource = dataSet.Tables[0];
        }

sqlserverdependency.JPG

La classe SqlServerDependency ici
Repost 0
11 septembre 2007 2 11 /09 /septembre /2007 21:45
Enterprise Library – Repository (partie 1)


Document word complet(comprenant 3 parties)ici
sources ici

Avec Web Service Software Factory on dispose d’outils permettant de générer automatiquement toute ses entités métiers, sa couche accès aux données,etc. 
ce ‘est malheureusement pas le cas avec Enterprise Library même si RepositoryFactory pointe le bout de son nez
Cet article présente comment coder mais également les quelques nuances personnelles.
 
I partie generic – classes pouvant être réutilisées telles quelles dans tous projets (couche DataAccess)
II Création d’entités métiers (couche BusinessEntities)
III Classes de création de commandes (couche DataAccess)
IV Classes repository héritant de la classe abstraite généric Repository<TDomainObject> et implémentant leur interface (couche DataAccess)
V Repositories classe « façade » offrant un accès (static) à toutes les classes Repository de la couche DataAccess
VI couche présentation (fichier de configuration et exemple)

I la partie Generic
r1.JPG
C’est un peu le framework,c’est un ensemble d’interfaces,de classes que les classes que nous définirons devront respecter et pourront utiliser,
Ces classes pourront être utilisées « telles quelles » dans tous les projets
a-Interfaces qui devront être respectées par les classe de fabrication de commandes :
-          ISelectionFactory<TIdentity> : pour les commandes select
-          IInsertFactory <TDomainObject>: pour les commandes insert
-          IUpdateFactory<TDomainObject>: pour les commandes update
-          IDeleteFactory<TDomainObject>: pour les commandes delete
 
 
b-Repository<TDomainObject>
classe abstraite générique permettant d’exécuter n’importe quelle requête vers une base de données, toutes les classes en héritant utilisent donc ces méthodes (Find,FindOne,AddUpdate,Delete) pour lire ou mettre à jour la base de données
J’apporte une légère nuance personnelle pour les méthodes de mises à jour pour lesquels je retourne un entier
    public class Repository<TDomainObject>
    {
        private string databaseName;
        private Database db;
 
        public Repository(string databaseName)
        {
            this.databaseName = databaseName;
            this.db = DatabaseFactory.CreateDatabase(databaseName);
        }
 
          public List<TDomainObject> Find<TIdentity>(
            ISelectionFactory<TIdentity> selectionFactory,
            IDomainObjectFactory<TDomainObject> domainObjectFactory,
            TIdentity identity)
        {
            List<TDomainObject> results = new List<TDomainObject>();
 
            using (DbCommand command = selectionFactory.ConstructSelectCommand(db, identity))
            {
                using (IDataReader rdr = db.ExecuteReader(command))
                {
                    while (rdr.Read())
                    {
                        results.Add(domainObjectFactory.Construct(rdr));
                    }
                }
            }
            return results;
        }
 
        public TDomainObject FindOne<TIdentity>(
            ISelectionFactory<TIdentity> selectionFactory,
            IDomainObjectFactory<TDomainObject> domainObjectFactory,
            TIdentity identity)
        {
            TDomainObject result = default(TDomainObject);
            using (DbCommand command = selectionFactory.ConstructSelectCommand(db, identity))
            {
                using (IDataReader rdr = db.ExecuteReader(command))
                {
                    if (rdr.Read())
                    {
                        result = domainObjectFactory.Construct(rdr);
                    }
                }
            }
            return result;
        }
 
        public int Add(IInsertFactory<TDomainObject> insertFactory,
            TDomainObject domainObj)
        {
            using (DbCommand command = insertFactory.ConstructInsertCommand(db, domainObj))
            {
                int result = db.ExecuteNonQuery(command);
                insertFactory.SetNewID(db, command, domainObj);
                return result;
            }
        }
        public int Update(IUpdateFactory<TDomainObject> updateFactory, TDomainObject domainObj)
        {
            using (DbCommand command = updateFactory.ConstructUpdateCommand(db, domainObj))
            {
               return db.ExecuteNonQuery(command);
            }
        }
        public int Remove<TIdentityObject>(IDeleteFactory<TIdentityObject> deleteFactory,
            TIdentityObject identityObj)
        {
            using (DbCommand command = deleteFactory.ConstructDeleteCommand(db, identityObj))
            {
               return db.ExecuteNonQuery(command);
            }
        }    
    }
Repost 0
11 septembre 2007 2 11 /09 /septembre /2007 21:43

Enterprise Library - Repository (partie 2)


II Création des entités métiers
Ici dans la couche BusinessEntities
Exemple :
public class Contact
      {
            private int _ContactID;
 
            public int ContactID
            {
                  get { return _ContactID; }
                  set { _ContactID = value; }
            }
 
            private string _ContactName;
 
            public string ContactName
            {
                  get { return _ContactName; }
                  set { _ContactName = value; }
            }
 
            private string _ContactFirstName;
 
            public string ContactFirstName
            {
                  get { return _ContactFirstName; }
                  set { _ContactFirstName = value; }
            }
 
            private Nullable<int> _ContactAge;
 
            public Nullable<int> ContactAge
            {
                  get { return _ContactAge; }
                  set { _ContactAge = value; }
            }
 
            private int _ContactCategoryID;
 
            public int ContactCategoryID
            {
                  get { return _ContactCategoryID; }
                  set { _ContactCategoryID = value; }
            }
 
            public Contact()
            { }
 
            public Contact(int ContactID,string ContactName,string ContactFirstName,Nullable<int> ContactAge,int ContactCategoryID)
            {
                  this.ContactID = ContactID;
                  this.ContactName = ContactName;
                  this.ContactFirstName = ContactFirstName;
                  this.ContactAge = ContactAge;
                  this.ContactCategoryID = ContactCategoryID;
            }
 
        public override string ToString()
        {
            return "Name : " + ContactName + "rFirstname : " + ContactFirstName + (ContactAge.HasValue ? "rAge : " + ContactAge : string.Empty) + "rCategory : " + ContactCategoryID.ToString();
        }
      }
 
III Classes de création des commandes
-          Celles-ci implémentent toutes une interface liée à la création commandes(ISelectionFactory<TIdentity> ,IInsertFactory <TDomainObject>,IUpdateFactory<TDomainObject>,IDeleteFactory<TDomainObject>)
 r2.JPG
Exemple avec la classe Contact
    internal class GetAllContactsSelectionFactory : ISelectionFactory<NullableIdentity>
    {
        public DbCommand ConstructSelectCommand(Database db, NullableIdentity nullableIdentity)
        {
            DbCommand command = db.GetStoredProcCommand("dbo.GetAllContacts");
            return command;
        }
 
        public string MapDbParameterToBusinessEntityProperty(string dbParameter)
        {
            switch (dbParameter)
            {
                default:
                    throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, GenericResources.InvalidParameterName), dbParameter);
            }
        }
    }
    internal class GetContactsOfCategorySelectionFactory : ISelectionFactory<int>
    {
        public DbCommand ConstructSelectCommand(Database db, int contactCategoryID)
        {
            DbCommand command = db.GetStoredProcCommand("dbo.GetContactsOfCategory");
            db.AddInParameter(command, "ContactCategoryID", DbType.Int32, contactCategoryID);
            return command;
        }
        public string MapDbParameterToBusinessEntityProperty(string dbParameter)
        {
            switch (dbParameter)
            {
                case "ContactCategoryID":
                    return "ContactCategoryID";
                default:
                    throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, GenericResources.InvalidParameterName), dbParameter);
            }
        }
    }
    internal class GetContactSelectionFactory : ISelectionFactory<int>
    {
        public DbCommand ConstructSelectCommand(Database db, int contactID)
        {
 
            DbCommand command = db.GetStoredProcCommand("dbo.GetContact");
            db.AddInParameter(command, "ContactID", DbType.Int32, contactID);
            return command;
        }
        public string MapDbParameterToBusinessEntityProperty(string dbParameter)
        {
            switch (dbParameter)
            {
                case "ContactID":
                    return "ContactID";
                default:
                    throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, GenericResources.InvalidParameterName), dbParameter);
            }
        }
    }
    internal class ContactInsertFactory : IDbToBusinessEntityNameMapper, IInsertFactory<Contact>
    {
       public DbCommand ConstructInsertCommand(Database db, Contact contact)
        {
            DbCommand command = db.GetStoredProcCommand("dbo.AddContact");
            db.AddInParameter(command, "ContactName", DbType.String, contact.ContactName);
            db.AddInParameter(command, "ContactFirstName", DbType.String, contact.ContactFirstName);
            if (contact.ContactAge.HasValue)
                db.AddInParameter(command, "ContactAge", DbType.Int32, contact.ContactAge);
            else
                db.AddInParameter(command, "ContactAge", DbType.Int32, DBNull.Value);
            db.AddInParameter(command, "ContactCategoryID", DbType.String, contact.ContactCategoryID);
 
            return command;
        }
        public void SetNewID(Database db, DbCommand command, Contact contact)
        {
 
        }
        public string MapDbParameterToBusinessEntityProperty(string dbParameter)
        {
            switch (dbParameter)
            {
                case "ContactAge":
                    return "ContactAge";
                case "ContactCategoryID":
                    return "ContactCategoryID";
                case "ContactFirstName":
                    return "ContactFirstName";
                case "ContactName":
                    return "ContactName";
                default:
                    throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, GenericResources.InvalidParameterName), dbParameter);
            }
        }
    }
    internal class ContactUpdateFactory : IDbToBusinessEntityNameMapper, IUpdateFactory<Contact>
    {
        public DbCommand ConstructUpdateCommand(Database db, Contact contact)
        {
            DbCommand command = db.GetStoredProcCommand("dbo.UpdateContact");
            db.AddInParameter(command, "ContactID", DbType.String, contact.ContactID);
            db.AddInParameter(command, "ContactName", DbType.String, contact.ContactName);
            db.AddInParameter(command, "ContactFirstName", DbType.String, contact.ContactFirstName);
            if (contact.ContactAge.HasValue)
                db.AddInParameter(command, "ContactAge", DbType.Int32, contact.ContactAge);
            else
                db.AddInParameter(command, "ContactAge", DbType.Int32, DBNull.Value);
            db.AddInParameter(command, "ContactCategoryID", DbType.String, contact.ContactCategoryID);
 
            return command;
 
        }
        public string MapDbParameterToBusinessEntityProperty(string dbParameter)
        {
            switch (dbParameter)
            {
                case "ContactAge":
                    return "ContactAge";
                case "ContactCategoryID":
                    return "ContactCategoryID";
                case "ContactFirstName":
                    return "ContactFirstName";
                case "ContactID":
                    return "ContactID";
                case "ContactName":
                    return "ContactName";
                default:
                    throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, GenericResources.InvalidParameterName), dbParameter);
            }
        }
    }
   internal class ContactDeleteFactory : IDeleteFactory<int>
    {
        public DbCommand ConstructDeleteCommand(Database db, int contactID)
        {
            DbCommand command = db.GetStoredProcCommand("dbo.DeleteContact");
            db.AddInParameter(command, "ContactID", DbType.Int32, contactID);
            return command;
        }
        public string MapDbParameterToBusinessEntityProperty(string dbParameter)
        {
            switch (dbParameter)
            {
                case "ContactID":
                    return "ContactID";
                default:
                    throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, GenericResources.InvalidParameterName), dbParameter);
            }
        }
    }
 
Repost 0
11 septembre 2007 2 11 /09 /septembre /2007 21:40

Enterprise Library - Repository (partie 3)


IV Repository 
r3.JPG
 
Toujours avec Contact pour exemple
On crée une interface listant les méthodes qui devront être implémenté
public interface IContactRepository
    {
        List<Contact> GetAllContacts();
        List<Contact> GetContactsOfCategory(int categoryID);
        Contact GetContact(int contactID);
        int AddContact(Contact contact);
        int UpdateContact(Contact contact);
        int RemoveContact(int contactID);
    }
 
La classe hérite de Repository<TDomainObject> et implémente son interface
public class ContactRepository : Repository<Contact>,IContactRepository
    {
        public ContactRepository(string databaseName)
            : base(databaseName)
        {
        }
 
        public List<Contact> GetAllContacts()
        {
            ISelectionFactory<NullableIdentity> selectionFactory = new GetAllContactsSelectionFactory();
 
            try
            {
                NullableIdentity nullableIdentity = new NullableIdentity();
                return Find(selectionFactory, new ContactFactory(), nullableIdentity);
            }
            catch (SqlException ex)
            {
                HandleSqlException(ex, selectionFactory);
            }
          
            return new List<Contact>();
        }
        public List<Contact> GetContactsOfCategory(int contactCategoryID)
        {
            ISelectionFactory<int> selectionFactory = new GetContactsOfCategorySelectionFactory();
            try
            {
                return Find<int>(selectionFactory, new ContactFactory(), contactCategoryID);
            }
            catch (SqlException ex)
            {
                HandleSqlException(ex, selectionFactory);
            }
            return new List<Contact>();
        }
        public Contact GetContact(int contactID)
        {
            ISelectionFactory<int> selectionFactory = new GetContactSelectionFactory();
            try
            {
                return FindOne(selectionFactory, new ContactFactory(), contactID);
            }
            catch (SqlException ex)
            {
                HandleSqlException(ex, selectionFactory);
            }
            return new Contact();
        }
        public int AddContact(Contact contact)
        {
            IInsertFactory<Contact> insertFactory = new ContactInsertFactory();
            try
            {
                return Add(insertFactory, contact);
            }
            catch (SqlException ex)
            {
                HandleSqlException(ex, insertFactory);
            }
            return 0;
        }
        public int UpdateContact(Contact contact)
        {
            IUpdateFactory<Contact> updateFactory = new ContactUpdateFactory();
            try
            {
                return Update(updateFactory, contact);
            }
            catch (SqlException ex)
            {
                HandleSqlException(ex, updateFactory);
            }
            return 0;
        }
        public int RemoveContact(int contactID)
        {
            IDeleteFactory<int> deleteFactory = new ContactDeleteFactory();
            try
            {
                return Remove(deleteFactory, contactID);
            }
            catch (SqlException ex)
            {
                HandleSqlException(ex, deleteFactory);
            }
            return 0;
        }
        private void HandleSqlException(SqlException ex, IDbToBusinessEntityNameMapper mapper)
        {
            if (ex.Number == ErrorCodes.SqlUserRaisedError)
            {
                switch (ex.State)
                {
                    case ErrorCodes.ValidationError:
                        string[] messageParts = ex.Errors[0].Message.Split(':');
                        throw new RepositoryValidationException(
                            mapper.MapDbParameterToBusinessEntityProperty(messageParts[0]),
                            messageParts[1], ex);
 
                    case ErrorCodes.ConcurrencyViolationError:
                        throw new ConcurrencyViolationException(ex.Message, ex);
 
                }
            }
            throw new RepositoryFailureException(ex);
        }
    }
 
J’utilise une et une seule fabrique pour la création d’instances à partir d’un datareader
Exemple ici ContactFactory
internal class ContactFactory : IDomainObjectFactory<Contact>
    {
        public Contact Construct(System.Data.IDataReader reader)
        {
            Contact contact = new Contact();
 
            contact.ContactID = Convert.ToInt32(reader["ContactID"]);
            contact.ContactName = Convert.ToString(reader["ContactName"]);
            contact.ContactFirstName = Convert.ToString(reader["ContactFirstName"]);
 
            if (reader["ContactAge"] != DBNull.Value)
                contact.ContactAge = Convert.ToInt32(reader["ContactAge"]);
            contact.ContactCategoryID = Convert.ToInt32(reader["ContactCategoryID"]);
 
            return contact;
        }
    }
 
V Création d’une «classe façade » Repositories
Ici dans la couche BusinessLogic, c’est avec cette classe que la couche présentation dialoguera
public static class Repositories
    {
        private const string databaseName = "ContactDBConnectionString";
        private static IContactRepository contactRepository = new ContactRepository(databaseName);
        private static ICategoryRepository categoryRepository = new CategoryRepository(databaseName);
 
        public static IContactRepository Contacts
        {
            get { return contactRepository; }
        }
 
        public static ICategoryRepository Categories
        {
            get { return categoryRepository; }
        }
    }
 
VI Couche présentation
Le fichier de configuration peut être au plus simple :
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
      <connectionStrings>
            <add name="ContactDBConnectionString"
                  connectionString="Data Source=.SQLEXPRESS;AttachDbFilename=|DataDirectory|ContactDB.mdf;Integrated Security=True;User Instance=True" providerName="System.Data.SqlClient"/>
      </connectionStrings>
</configuration>
 
Exemple de code
       private void button1_Click(object sender, EventArgs e)
        {
            List<Contact> contacts = Repositories.Contacts.GetAllContacts();
            dataGridView1.DataSource = contacts;
        }
 
 
Repost 0
4 septembre 2007 2 04 /09 /septembre /2007 19:02
Repost 0
18 juillet 2007 3 18 /07 /juillet /2007 23:03
Repost 0
18 juillet 2007 3 18 /07 /juillet /2007 21:14

Codus - générateur de code pour NHibernate

Codus est un petit générateur de code qui permet de générer les entités métiers,les classes de couches accès aux données(DAO) ainsi que les fichiers de mapping,etc.,
http://www.adapdev.com/codus/ 

SharpToolBox.com
http://sharptoolbox.com/categories/object-relational-mappers

Repost 0
18 juillet 2007 3 18 /07 /juillet /2007 10:20

CodeSmith + NetTiers  + Enterprise Library

Build a Data Access Layer in less than 15 minutes

http://www.codeproject.com/showcase/CodeSmith.asp 

pour générer tout son code d'accès aux données avec Enterprise Library rapidement
Repost 0