locked
I need help in understanding the logic of this login form RRS feed

  • Question

  • User-1004886483 posted

    Hi, i have a project i am looking into and i need some help in understanding the logic of this login form :

    In my solution Called MYFIRSTAPPWebsite i have differents projects that make working the main web project called MYFIRSTAPPWebsite

    Inside the main project MYFIRSTAPPWebsite i have the login form :

    Identification.aspx

    <tr>
    
                        <td class="Item">
    
                            <asp:Login ID="Login1" runat="server" TitleText="Authentification MYFIRSTAPP" LoginButtonText="Connexion" LoginButtonStyle-CssClass="BtnLoggin" TextBoxStyle-CssClass="TxtboxLogin" DestinationPageUrl="~/Default.aspx" OnAuthenticate="Login1_Authenticate"></asp:Login>
    
                        </td>
    
                    </tr>

    Identification.aspx.cs

    using System;
    
    using System.Collections.Generic;
    
    using System.Linq;
    
    using System.Web;
    
    using System.Web.UI;
    
    using System.Web.UI.WebControls;
    
    using MYFIRSTAPP.Domaine;
    
    using MYFIRSTAPP.Services;
    
    
    
    public partial class Identification : System.Web.UI.Page
    
    {
    
        protected void Page_Load(object sender, EventArgs e)
    
        {
    
    
    
        }
    
    
    
        #region Autentification
    
        /// <summary>
    
        /// Autentification 
    
        /// </summary>
    
        /// <param name="sender"></param>
    
        /// <param name="e"></param>
    
        protected void Login1_Authenticate(object sender, AuthenticateEventArgs e)
    
        {
    
            try
    
            {
    
                MyfirstappEntitesCollection Users = UtilisateurDatar_Srv.RechercherPar(Login1.UserName, Login1.Password);
    
                if (Users.Count > 0)
    
                {
    
                    ScriptManager.RegisterStartupScript(Page, Page.GetType(), "a", "alert('a');", true);
    
                    UtilisateurDatar User = (UtilisateurDatar)Users[0];
    
                    Session.Add("PerId", User.PerId);
    
                    Session.Add("PerProfil", User.PerProfil);
    
                    Session.Timeout = 200;
    
                    Server.ScriptTimeout = 12000;
    
                    e.Authenticated = true;
    
                }
    
                else
    
                {
    
                    Session.RemoveAll();
    
                    e.Authenticated = false;
    
                }
    
            }
    
            catch (Exception ex)
    
            {
    
            }
    
        }
    
    
    
        #endregion 
    
    }

    In here i need to understand this code bacause is using differents Classes and i am a bit lost.. i will put some questions about the code which i do not understand if someone can at least answer at some of the questions will e great

    I start with this line of code :

    MyfirstappEntitesCollection Users = UtilisateurDatar_Srv.RechercherPar(Login1.UserName, Login1.Password);

    MyfirstappEntitesCollection.cs is inside the project MYFIRSTAPP.Domaine

    - here the MyfirstappEntitesCollection.cs code :

    using System;
    
    using System.Collections;
    
    using System.Reflection;
    
    using System.Text;
    
    
    
    using MYFIRSTAPP.Common;
    
    using MYFIRSTAPP.Common.Exceptions;
    
    using System.Data;
    
    
    
    
    
    namespace MYFIRSTAPP.Domaine
    
    {
    
    	/// <summary>
    
    	/// Classe de base pour les collections d'entités métier
    
    	/// </summary>
    
        [Serializable]
    
    	public class MyfirstappEntitesCollection : MyfirstappCollectionBase ,IList
    
    	{
    
    		#region Item
    
    		/// <summary>
    
    		/// Accesseur direct par index
    
    		/// </summary>
    
    		public MyfirstappEntite this[int index]
    
    		{
    
    			get{return GetObjectByIndex(index);}
    
    			set
    
    			{
    
    				this.RemoveAt(index);
    
    				this.Insert(index,value);
    
    			}
    
    		}
    
    		#endregion
    
    
    
    		#region TypeEntites
    
    		/// <summary>
    
    		/// Renvoie le type des données contenues dans la collection.
    
    		/// Si la collection est vide, le type renvoyé est MyfirstappEntite
    
    		/// </summary>
    
    		/// <returns>Type des entités contenues dans la collection</returns>
    
    		public Type TypeEntites
    
    		{
    
    			get
    
    			{
    
    				Type typeEntites = null;
    
    				try
    
    				{
    
    					if (List.Count > 0)
    
    					{
    
    						typeEntites = List[0].GetType();
    
    					}
    
    					else
    
    					{
    
    						typeEntites = typeof(MyfirstappEntite);
    
    					}
    
    				}
    
    				catch (Exception e)
    
    				{
    
    					TraiterErreur(e, List.Count);
    
    				}
    
    				return typeEntites;
    
    			}
    
    
    
    		}
    
    
    
    		#endregion
    
    
    
    		#region Add
    
    		/// <summary>
    
    		/// Ajoute un objet à la collection, à condition que son type soit similaire 
    
    		/// au premier objet de la collection.
    
    		/// </summary>
    
    		/// <param name="objetAAjouter">Objet à ajouter</param>
    
    		/// <exception cref="MYFIRSTAPP.Common.Exceptions.TypePourCollectionTypeeNonValideException">
    
    		/// Si le type du nouvel objet n'est pas conforme au type du premier
    
    		/// objet de la collection
    
    		/// </exception>
    
    		/// <exception cref="ArgumentNullException">
    
    		/// Si l'objet à ajouter vaut null
    
    		/// </exception>
    
    		public virtual void Add(MyfirstappEntite objetAAjouter)
    
    		{
    
    			Type _typeCollection = null;
    
    			if (objetAAjouter == null)
    
    			{
    
    				throw new ArgumentNullException("objetAAjouter",
    
    													MessagesErreurs("AjoutObjetNull"));
    
    			}
    
    					
    
    			try
    
    			{
    
    				if (List.Count>0)
    
    				{
    
    					_typeCollection = this.TypeEntites;
    
    					if (objetAAjouter.GetType().Equals(_typeCollection))
    
    					{
    
    						List.Add(objetAAjouter);
    
    					}
    
    					else
    
    					{
    
    						throw new TypePourCollectionTypeeNonValideException(
    
    							_typeCollection.ToString(), objetAAjouter.GetType().ToString());
    
    					}
    
    				}
    
    					// Si la liste est vide, on peut ajouter n'importe quel type d'objet
    
    				else
    
    				{
    
    					List.Add(objetAAjouter);
    
    				}
    
    			}
    
    			catch (Exception e)
    
    			{
    
    				TraiterErreur(e, objetAAjouter);
    
    			}
    
    		}
    
    		#endregion
    
    
    
    		#region Insert
    
    		/// <summary>
    
    		/// Insert un objet à la collection à une position donnée,
    
    		/// à condition que son type soit similaire au premier objet de la collection.
    
    		/// </summary>
    
    		/// <param name="index">Index pour l'insertion</param>
    
    		/// <param name="objetAAjouter">Objet à ajouter</param>
    
    		/// <exception cref="MYFIRSTAPP.Common.Exceptions.TypePourCollectionTypeeNonValideException">
    
    		/// Si le type du nouvel objet n'est pas conforme au type du premier objet de la collection
    
    		/// </exception>
    
    		/// <exception cref="ArgumentNullException">
    
    		/// Si l'objet à insérer vaut null
    
    		/// </exception>
    
    		/// <exception cref="System.ArgumentOutOfRangeException">
    
    		/// Si l'index n'est pas valide
    
    		/// </exception>
    
    		public virtual void Insert(int index, MyfirstappEntite objetAAjouter)
    
    		{
    
    			Type _typeCollection = null;
    
    
    
    			if (objetAAjouter == null)
    
    			{
    
    				throw new ArgumentNullException("objetAAjouter",
    
    													MessagesErreurs("InsertionObjetNull"));
    
    			}
    
    
    
    			try
    
    			{
    
    				if (List.Count>0)
    
    				{
    
    					_typeCollection = this.TypeEntites;
    
    					if (objetAAjouter.GetType().Equals(_typeCollection))
    
    					{
    
    						List.Insert(index, objetAAjouter);
    
    					}
    
    					else
    
    					{
    
    						throw new TypePourCollectionTypeeNonValideException(
    
    							_typeCollection.ToString(), objetAAjouter.GetType().ToString());
    
    					}
    
    				}
    
    					// Si la liste est vide, on peut ajouter n'importe quel type d'objet
    
    				else
    
    				{
    
    					List.Insert(index, objetAAjouter);
    
    				}
    
    			}
    
    			catch (ArgumentOutOfRangeException)
    
    			{
    
    				throw;
    
    			}
    
    			catch (Exception _e)
    
    			{
    
    				TraiterErreur(_e, objetAAjouter);
    
    			}
    
    
    
    		}
    
    		#endregion
    
    
    
    		#region Update
    
    		/// <summary>
    
    		///	Met à jour la collection en modifiant l'objet passé en paramètre
    
    		///	(en fonction de son identifiant stocké dans la propriété Id)
    
    		/// </summary>
    
    		/// <param name="objetAModifier">Objet qui doit être mis à jour dans la liste</param>
    
    		/// <remarks>La Reflection est utilisée pour mettre à jour toutes les propriétés de 
    
    		/// l'objet à modifier.</remarks>
    
    		/// <exception cref="MYFIRSTAPP.Common.Exceptions.TypePourCollectionTypeeNonValideException">
    
    		/// Si l'objet à modifier n'est pas du type de la collection
    
    		/// </exception>
    
    		/// <exception cref="MYFIRSTAPP.Common.Exceptions.ObjetInexistantDansCollectionException">
    
    		/// Si l'objet à modifier n'est pas dans la collection (donc également si la collection est vide).
    
    		/// </exception>
    
    		/// <exception cref="ArgumentNullException">
    
    		/// Si l'objet à modifier vaut null
    
    		/// </exception>
    
    		public void Update(MyfirstappEntite objetAModifier)
    
    		{
    
    			MyfirstappEntite _objetCourant = null;
    
    
    
    			Type _typeCollection = null;
    
    			Object _valeurPropriete;
    
    			Object[] _args;
    
    
    
    			if (objetAModifier == null)
    
    			{
    
    				throw new ArgumentNullException("objetAModifier",
    
    					MessagesErreurs("ModificationObjetNull"));
    
    			}
    
    
    
    			try
    
    			{
    
    				if (this.Count == 0)
    
    				{
    
    					throw new ObjetInexistantDansCollectionException(objetAModifier.ToString());
    
    				}
    
    				else
    
    				{
    
    					// On récupère le type de la collection
    
    					_typeCollection = this.TypeEntites;
    
    					
    
    					// On vérifie que l'objet à modifier est du bon type
    
    					if (!objetAModifier.GetType().Equals(_typeCollection))
    
    					{
    
    						throw new TypePourCollectionTypeeNonValideException(
    
    							_typeCollection.ToString(), objetAModifier.GetType().ToString());
    
    					}
    
    
    
    					_objetCourant = GetObjectById(objetAModifier.Id);
    
    
    
    					if (_objetCourant == null)
    
    					{
    
    						throw new ObjetInexistantDansCollectionException(objetAModifier.ToString());
    
    					}
    
    
    
    					// On utilise la Reflection pour mettre à jour toutes les propriétés
    
    					PropertyInfo[] _proprietes = _typeCollection.GetProperties();
    
    					for (int _i=0; _i<_proprietes.Length; _i++)
    
    					{
    
    						//si la propriété courante comporte un SET
    
    						if(_typeCollection.GetProperty(_proprietes[_i].Name).CanWrite)
    
    						{
    
    							// On récupère le nouvelle valeur;
    
    							_valeurPropriete = _typeCollection.InvokeMember(_proprietes[_i].Name, 
    
    								BindingFlags.GetProperty, null, objetAModifier, null);
    
    
    
    							// et on l'affecte à l'objet de la collection
    
    							_args = new Object[]{_valeurPropriete};
    
    							_typeCollection.InvokeMember(_proprietes[_i].Name, 
    
    								BindingFlags.SetProperty, null, _objetCourant, _args);
    
    						}
    
    					}
    
    				}
    
    			}
    
    			catch (Exception e)
    
    			{
    
    				TraiterErreur(e, objetAModifier);
    
    			}
    
    		}
    
    		#endregion
    
    
    
    		#region Remove
    
    		/// <summary>
    
    		/// Suppression d'une entité dans la collection, sur la base de son ID
    
    		/// </summary>
    
    		/// <param name="objetASupprimer">Objet à supprimer</param>
    
    		public void Remove(MyfirstappEntite objetASupprimer)
    
    		{
    
    			//test si l'objet est null
    
    			if (objetASupprimer == null)
    
    			{
    
    				throw new ArgumentNullException("objetASupprimer",
    
    					MessagesErreurs("SuppressionObjetNull"));
    
    			}
    
    			else
    
    			{
    
    				try
    
    				{
    
    					//test si l'objet existe
    
    					int index = this.IndexOf(objetASupprimer);
    
    					//suppression à l'index indiqué
    
    					base.RemoveAt(index);
    
    				}
    
    				catch(Exception _e)
    
    				{
    
    					TraiterErreur(_e, objetASupprimer);
    
    				}
    
    			}	
    
    		}
    
    
    
    		#endregion
    
    
    
    		#region GetSousCollection
    
    		/// <summary>
    
    		///	Retourne la sous-collection de taille longueur et commencée à partir 
    
    		///	du debut-ème élément.
    
    		/// </summary>
    
    		/// <param name="debut">Numéro du premier élément à prendre (1 pour le premier)</param>
    
    		/// <param name="longueur">Longueur de la sous collection (si la longueur est trop grande, 
    
    		/// toute la finde la collection est ramyfirstappriée).</param>
    
    		/// <return>Sous-Collection attendue</return>
    
    		/// <exception cref="ArgumentOutOfRangeException">
    
    		/// Si le début ou la longueur est invalide (debut inferieur à  1 ou longueur négative ou null)
    
    		/// </exception>
    
    		public MyfirstappEntitesCollection GetSousCollection(int debut, int longueur)
    
    		{
    
    			MyfirstappEntitesCollection _sousCollection = null; // sous collection retournée
    
    			int _index = Int32.MinValue;
    
    			int _fin = Int32.MinValue;
    
    			
    
    			try
    
    			{
    
    				_sousCollection = new MyfirstappEntitesCollection();
    
    				if (longueur <= 0)
    
    				{
    
    					throw new ArgumentOutOfRangeException("longueur",longueur,
    
    						MessagesErreurs("LongueurPositive"));
    
    						
    
    				}
    
    				if (debut < 1 || debut > List.Count)
    
    				{
    
    					throw new ArgumentOutOfRangeException("debut",debut,
    
    						MessagesErreurs("DebutInvalide"));
    
    				}
    
    				if (List.Count > 0)
    
    				{
    
    					_index = debut - 1 ; // -1 car il faut commencer à 0
    
    					_fin = debut - 1 + longueur; 
    
    					// On vérifie que l'on ne dépasse pas la taille de la collection!
    
    					if (_fin > this.Count)
    
    					{
    
    						_fin = this.Count;
    
    					}
    
    					while ( _index < _fin)
    
    					{
    
    						_sousCollection.Add((MyfirstappEntite)List[_index]);
    
    						_index++;
    
    					}
    
    				}
    
    			}
    
    			catch (ArgumentOutOfRangeException)
    
    			{
    
    				throw;
    
    			}
    
    			catch (Exception _e)
    
    			{
    
    				TraiterErreur(_e, debut, longueur);
    
    			}
    
    			return _sousCollection;
    
    		}
    
    		#endregion
    
    
    
    		#region GetObjectByIndex
    
    		/// <summary>
    
    		/// Retourne l'objet situé à l'index spécifié
    
    		/// </summary>
    
    		/// <param name="index">Index de recherche</param>
    
    		/// <returns>Objet situé à l'index spécifié dans la collection</returns>
    
    		/// <exception cref="ArgumentOutOfRangeException">
    
    		/// Si l'index spécifié n'existe pas
    
    		/// </exception>
    
    		public MyfirstappEntite GetObjectByIndex(int index)
    
    		{
    
    			MyfirstappEntite entite = null;
    
    			try
    
    			{
    
    				entite = (MyfirstappEntite)List[index];
    
    			}
    
    			catch (ArgumentOutOfRangeException)
    
    			{
    
    				throw;
    
    			}
    
    			catch (Exception e)
    
    			{
    
    				TraiterErreur(e, index);
    
    			}
    
    			return entite;
    
    		}
    
    		#endregion
    
    
    
    		#region GetObjectById
    
    		/// <summary>
    
    		/// Retourne un objet de la collection en fonction de son identifiant
    
    		/// </summary>
    
    		/// <param name="id">Identifiant de l'objet recherché</param>
    
    		/// <returns>
    
    		/// Objet dont l'identifiant a été passé en paramètre.
    
    		/// </returns>
    
    		/// <exception cref="MYFIRSTAPP.Common.Exceptions.ObjetInexistantDansCollectionException">
    
    		/// Si l'identifiant demandé n'existe pas
    
    		/// </exception>
    
    		public MyfirstappEntite GetObjectById(long id)
    
    		{
    
    			//test si null => on renvoit null
    
    			if(id==Int64.MinValue)
    
    			{
    
    				return null;
    
    			}
    
    			else
    
    			{
    
    				IEnumerator enumerator = null;;
    
    				MyfirstappEntite objetCourant = null;
    
    				bool trouve = false;
    
    
    
    				try
    
    				{
    
    					enumerator = List.GetEnumerator();
    
    					while (enumerator.MoveNext() && !trouve)
    
    					{
    
    						objetCourant = (MyfirstappEntite)enumerator.Current;
    
    						if ( objetCourant.Id == id)
    
    						{
    
    							trouve = true;
    
    							break;
    
    						}
    
    					}
    
    					if (!trouve)
    
    					{
    
    						throw new ObjetInexistantDansCollectionException(id.ToString());
    
    					}
    
    				}
    
    				catch (Exception e)
    
    				{
    
    					TraiterErreur(e, id);
    
    				}
    
    				return objetCourant;
    
    			}
    
    		}
    
    
    
    		#endregion
    
    
    
            #region GetObjectByIdOrNull
    
            /// <summary>
    
            /// Retourne un objet de la collection en fonction de son identifiant
    
            /// </summary>
    
            /// <param name="id">Identifiant de l'objet recherché</param>
    
            /// <returns>
    
            /// Objet dont l'identifiant a été passé en paramètre.
    
            /// </returns>
    
            /// null Si l'identifiant demandé n'existe pas
    
            /// </exception>
    
            public MyfirstappEntite GetObjectByIdOrNull(long id)
    
            {
    
                //test si null => on renvoit null
    
                if (id == Int64.MinValue)
    
                {
    
                    return null;
    
                }
    
                else
    
                {
    
                    IEnumerator enumerator = null; ;
    
                    MyfirstappEntite objetCourant = null;
    
                    bool trouve = false;
    
    
    
                    try
    
                    {
    
                        enumerator = List.GetEnumerator();
    
                        while (enumerator.MoveNext() && !trouve)
    
                        {
    
                            objetCourant = (MyfirstappEntite)enumerator.Current;
    
                            if (objetCourant.Id == id)
    
                            {
    
                                trouve = true;
    
                                break;
    
                            }
    
                        }
    
                        if (!trouve)
    
                        {
    
                            return null;
    
                        }
    
                    }
    
                    catch (Exception e)
    
                    {
    
                        return null;
    
                    }
    
                    return objetCourant;
    
                }
    
            }
    
    
    
            #endregion
    
    
    
    		#region IndexOf
    
    		/// <summary>
    
    		/// Retourne l'index d'un objet de la collection en fonction de son ID
    
    		/// </summary>
    
    		/// <param name="objetARechercher">Entité recherchée</param>
    
    		/// <returns>
    
    		/// Index dont l'identifiant a été passé en paramètre.
    
    		/// </returns>
    
    		/// <exception cref="MYFIRSTAPP.Common.Exceptions.ObjetInexistantDansCollectionException">
    
    		/// Si l'objet recherché n'existe pas
    
    		/// </exception>
    
    		public int IndexOf(MyfirstappEntite objetARechercher)
    
    		{
    
    			//test si l'objet est null
    
    			if (objetARechercher == null)
    
    			{
    
    				throw new ArgumentNullException("objetARechercher",
    
    					MessagesErreurs("RechercheObjetNull"));
    
    			}
    
    			else
    
    			{
    
    				//on vérifie que l'objet est bien du type de la collection :
    
    				if(!this.TypeEntites.Equals(objetARechercher.GetType()))
    
    				{
    
    					throw new ObjetInexistantDansCollectionException(objetARechercher.GetType().ToString());
    
    				}
    
    				else
    
    				{
    
    					IEnumerator enumerator = null;
    
    					MyfirstappEntite objetCourant = null;
    
    					bool trouve = false;
    
    					int index = 0;
    
    
    
    					try
    
    					{
    
    						enumerator = List.GetEnumerator();
    
    						while (enumerator.MoveNext() && !trouve)
    
    						{
    
    							objetCourant = (MyfirstappEntite)enumerator.Current;
    
    							if ( objetCourant.Id == objetARechercher.Id)
    
    							{
    
    								trouve = true;
    
    								break;
    
    							}
    
    							index++;
    
    						}
    
    						if(!trouve)
    
    						{
    
    							throw new ObjetInexistantDansCollectionException(objetARechercher.Id.ToString());
    
    						}	
    
    					}
    
    					catch (Exception e)
    
    					{
    
    						TraiterErreur(e, objetARechercher);
    
    					}
    
    					return index;
    
    				}
    
    			}
    
    		}
    
    
    
    		#endregion
    
    
    
    		#region Contains
    
    		/// <summary>
    
    		/// Vérification que la collection contient un objet spécifique (sur la base de son ID)
    
    		/// </summary>
    
    		/// <param name="objetARechercher">Objet à rechercher</param>
    
    		/// <returns></returns>
    
    		public bool Contains(MyfirstappEntite objetARechercher)
    
    		{
    
    			//test si l'objet est null
    
    			if (objetARechercher == null)
    
    			{
    
    				throw new ArgumentNullException("objetARechercher",
    
    					MessagesErreurs("RechercheObjetNull"));
    
    			}
    
    			else
    
    			{
    
    				//on vérifie que l'objet est bien du type de la collection :
    
    				if(!this.TypeEntites.Equals(objetARechercher.GetType()))
    
    				{
    
    					return false;
    
    				}
    
    				else
    
    				{
    
    					IEnumerator enumerator = null;
    
    					MyfirstappEntite objetCourant = null;
    
    					bool trouve = false;
    
    
    
    					try
    
    					{
    
    						enumerator = List.GetEnumerator();
    
    						while (enumerator.MoveNext() && !trouve)
    
    						{
    
    							objetCourant = (MyfirstappEntite)enumerator.Current;
    
    							if ( objetCourant.Id == objetARechercher.Id)
    
    							{
    
    								return true;
    
    							}
    
    						}
    
    					}
    
    					catch (Exception e)
    
    					{
    
    						TraiterErreur(e, objetARechercher);
    
    					}
    
    					return false;
    
    				}
    
    			}
    
    		}
    
    		#endregion
    
    
    
    		#region CopyTo
    
    		/// <summary>
    
    		/// Méthode de recopie d'une collection
    
    		/// </summary>
    
    		/// <param name="collCopie">Collection de destination</param>
    
    		/// <param name="index">Index de départ</param>
    
    		public void CopyTo(ref MyfirstappEntitesCollection collCopie, int index)
    
    		{
    
    			collCopie = GetSousCollection(index, this.Count+1-index);
    
    		}
    
    		#endregion
    
    
    
    		#region Vérification d'une valeur de propriété
    
    		/// <summary>
    
    		/// Vérifie que la valeur d'une propriété est la même dans tous 
    
    		/// les objets de la collection
    
    		/// </summary>
    
    		/// <param name="propriete">Nom de la propriété</param>
    
    		/// <returns>Valeur commune à tous les objets (null si la liste est vide)</returns>
    
    		/// <exception cref="MYFIRSTAPP.Common.Exceptions.ValeurProprieteNonValideException">
    
    		/// Si la propriété d'au moins un objet n'est pas identique à celle des autres 
    
    		/// de la liste
    
    		/// </exception>
    
    		public object VerifierValeurProprieteUnique(string propriete)
    
    		{
    
    			object _valeurCommune = null;
    
    			object _valeurTmp = null;
    
    			IEnumerator _enumerateur = null;
    
    			Type _typeCollection = null;
    
    			try
    
    			{
    
    				if (List.Count > 0)
    
    				{
    
    					_typeCollection = TypeEntites;
    
    					_valeurCommune = _typeCollection.InvokeMember(propriete, BindingFlags.GetProperty,
    
    						null, InnerList[0] , null);
    
    					_enumerateur = InnerList.GetEnumerator();
    
    					while (_enumerateur.MoveNext())
    
    					{
    
    						_valeurTmp = _typeCollection.InvokeMember(propriete, BindingFlags.GetProperty,
    
    							null, _enumerateur.Current, null);
    
    						if (!_valeurTmp.Equals(_valeurCommune))
    
    						{
    
    							throw new ValeurProprieteNonValideException(_valeurCommune.ToString(), 
    
    								_valeurTmp.ToString());
    
    						}
    
    					}
    
    				}
    
    			}
    
    			catch(Exception _e)
    
    			{
    
    				TraiterErreur(_e, propriete);
    
    			}
    
    			return _valeurCommune;
    
    		}
    
    
    
    		/// <summary>
    
    		/// Vérifie que la valeur d'une propriété est la même dans tous 
    
    		/// les objets de la collection et vaut la valeur spécifiée
    
    		/// </summary>
    
    		/// <param name="propriete">Nom de la propriété</param>
    
    		/// <param name="valeur">Valeur qui doit être commune à tous les objets </param>
    
    		/// <returns>
    
    		/// Vrai si les propriétés sont identiques et égales au paramètre passé ou 
    
    		/// si la liste est vide
    
    		/// </returns>
    
    		/// <exception cref="MYFIRSTAPP.Common.Exceptions.ValeurProprieteNonValideException">
    
    		/// Si la propriété d'au moins un objet n'est pas identique à celle spécifiée
    
    		/// </exception>
    
    		public bool VerifierValeurPropriete(string propriete, object valeur)
    
    		{
    
    			//si valeur est null on renvoit false par défaut
    
    			if(valeur==null)
    
    			{
    
    				return false;
    
    			}
    
    			else
    
    			{
    
    				bool _retour = false;
    
    				object _valeurCommune = null;
    
    				try
    
    				{
    
    					_valeurCommune = VerifierValeurProprieteUnique(propriete);
    
    					if (_valeurCommune==null)
    
    					{
    
    						_retour = true;
    
    					}
    
    					else
    
    					{
    
    						if (!_valeurCommune.Equals(valeur))
    
    						{
    
    							throw new ValeurProprieteNonValideException(valeur.ToString(), 
    
    								_valeurCommune.ToString());
    
    						}
    
    						else
    
    						{
    
    							_retour = true;
    
    						}
    
    					}
    
    				}
    
    				catch (Exception _e)
    
    				{
    
    					TraiterErreur(_e, propriete, valeur);
    
    				}
    
    				return _retour;
    
    			}
    
    		}
    
    		#endregion
    
    
    
    		#region ToStringArray
    
    
    
    		/// <summary>
    
    		///		Transforme la collection d'entité en un tableau contenant les valeurs de la 
    
    		///		propriété passée en paramètre (valeurs castées en string)
    
    		/// </summary>
    
    		/// <example>
    
    		///		maCollection.ToStringArray("Id") renvoie un tableau contenant les 
    
    		///		chaines de caractères correspondant aux identifiants de la collection.
    
    		/// </example>
    
    		/// <param name="propriete">Nom de la propriété dans laquelle lire les valeurs</param>
    
    		/// <returns>Tableau contenant les valeurs (en string) de la propriété spécifiée</returns>
    
    		public string[] ToStringArray(string propriete)
    
    		{
    
    			ArrayList _tableau = null;
    
    			string[] _valeurRetour = null;
    
    			IEnumerator _enumerateur = null;
    
    			Type _type = null;
    
    			Object _valeur = null;
    
    
    
    			try
    
    			{
    
    				_tableau = new ArrayList();
    
    				if (List.Count > 0)
    
    				{
    
    					_type = this.TypeEntites;
    
    					_enumerateur = List.GetEnumerator();
    
    					while (_enumerateur.MoveNext())
    
    					{
    
    						_valeur = _type.InvokeMember(propriete, BindingFlags.GetProperty,
    
    							null, _enumerateur.Current, null);
    
    						_tableau.Add(_valeur.ToString());
    
    					}
    
    				}
    
    				_valeurRetour = (string[])_tableau.ToArray(typeof(string));
    
    			}
    
    			catch (MissingMethodException)
    
    			{
    
    				// nom de propriete incorrect
    
    				throw;
    
    			}
    
    			catch (Exception _e)
    
    			{
    
    				TraiterErreur(_e, this, propriete);
    
    			}
    
    			return _valeurRetour;
    
    		}
    
    
    
    		#endregion
    
    
    
            #region ToStringArray
    
    
    
            /// <summary>
    
            ///		Transforme la collection d'entité en un tableau contenant les valeurs de la 
    
            ///		propriété passée en paramètre (valeurs castées en string)
    
            /// </summary>
    
            /// <example>
    
            ///		maCollection.ToStringArray("Id") renvoie un tableau contenant les 
    
            ///		chaines de caractères correspondant aux identifiants de la collection.
    
            /// </example>
    
            /// <param name="propriete">Nom de la propriété dans laquelle lire les valeurs</param>
    
            /// <returns>Tableau contenant les valeurs (en string) de la propriété spécifiée</returns>
    
            public DataTable ToDataTable()
    
            {
    
                DataTable _tableau = null;
    
                IEnumerator _enumerateur = null;
    
                Type _type = null;
    
               // Object _valeur = null;
    
                DataRow dr;
    
    
    
                try
    
                {
    
                    _tableau = new DataTable();
    
                    if (List.Count > 0)
    
                    {
    
                        _type = this.TypeEntites;
    
                        _enumerateur = List.GetEnumerator();
    
                        while (_enumerateur.MoveNext())
    
                        {
    
                            /*_valeur = _type.InvokeMember(_enumerateur.ToString(), BindingFlags.GetProperty,
    
                                null, _enumerateur.Current, null);*/
    
                            if (_tableau.Columns.Count == 0)
    
                                _tableau.Columns.AddRange(((MyfirstappEntite)_enumerateur.Current).GetColumns());
    
                            dr = _tableau.NewRow();
    
                            dr.ItemArray = ((MyfirstappEntite)_enumerateur.Current).ToDataRow().ItemArray;
    
                            _tableau.Rows.Add(dr);
    
                        }
    
                    }
    
                }
    
                catch (MissingMethodException)
    
                {
    
                    // nom de propriete incorrect
    
                    throw;
    
                }
    
                catch (Exception)
    
                {
    
                    //TraiterErreur(_e, this);
    
                }
    
                return _tableau;
    
            }
    
    
    
            #endregion
    
    
    
    
    
    		#region Méthodes de tri
    
    		
    
    		/// <summary>
    
    		/// Tri de la collection en utilisant l'identifiant
    
    		/// </summary>
    
    		public void Trier()
    
    		{
    
    			InnerList.Sort();
    
    		}
    
    
    
    		/// <summary>
    
    		/// Tri de la collection en utilisant une classe implémentant IComparer
    
    		/// </summary>
    
    		/// <param name="classeComparaison">
    
    		/// Classe à utiliser pour la comparaison
    
    		/// </param>
    
    		public void Trier(IComparer classeComparaison)
    
    		{
    
    			InnerList.Sort(classeComparaison);
    
    		}
    
    		#endregion
    
    
    
    		#region ToString
    
    		public override string ToString()
    
    		{
    
    			StringBuilder _str = new StringBuilder();
    
    			_str.Append("Type : ").Append(this.TypeEntites).Append(
    
    				" - Nombre d'éléments: ").Append(this.Count.ToString());
    
    			return _str.ToString();
    
    		}
    
    		#endregion
    
    
    
    	}
    
    }

    Question (1)

    public class MyfirstappEntitesCollection : MyfirstappCollectionBase ,IList

    Why MyfirstappEntitesCollection class inherit to MyfirstappCollectionBase 

    Question (2) 

    why we inherit this : ,IList ? we use this for what?

    MyfirstappCollectionBase.cs is inside the project MYFIRSTAPP.Common

    - here the MyfirstappCollectionBase.cs code :

    using System;
    
    using System.Collections;
    
    
    
    namespace MYFIRSTAPP.Common
    
    {
    
    	/// <summary>
    
    	/// Classe de base pour les collections
    
    	/// </summary>
    
    	/// <remarks>Pour la définition de la méthode générique de traitement d'une erreur</remarks>
    
        [Serializable]
    
    	public class MyfirstappCollectionBase : CollectionBase
    
    	{
    
    		#region TraiterErreur
    
    		/// <summary>
    
    		/// Méthode générique de traitement d'une erreur
    
    		/// </summary>
    
    		/// <param name="e">Exception à traiter</param>
    
    		/// <param name="contexte">Contexte à afficher (par ToString())</param>
    
    		/// <remarks>Doit être défini car héritage de CollectionBase (donc pas de CommonBase)</remarks>
    
    		protected static void TraiterErreur(Exception e, params object[] contexte)
    
    		{
    
               
    
    			MYFIRSTAPPBase.TraiterErreur(e, contexte);
    
    		}
    
    		#endregion
    
    
    
    		#region Méthode de récupération d'un message d'erreur
    
    		/// <summary>
    
    		/// Récupère le message d'erreur dans le fichier de ressource
    
    		/// </summary>
    
    		/// <param name="clef">Identifiant du message d'erreur</param>
    
    		/// <returns>Message d'erreur correspondant</returns>
    
    		protected static string MessagesErreurs(string clef)
    
    		{
    
    			return MYFIRSTAPPBase.MessagesErreurs(clef);
    
    		}
    
    		#endregion
    
    
    
    	}
    
    }

    Question (3)

    Why i create a MyfirstappEntitesCollection Users, i mean what i actually use inside the MyfirstappEntitesCollection.cs ?

    after this i guess i initiate my Users variable : 

    = UtilisateurDatar_Srv.RechercherPar(Login1.UserName, Login1.Password);

    UtilisateurDatar_Srv.cs is inside the project MYFIRSTAPP.Services

    - here the UtilisateurDatar_Srv.cs code :

    using System;
    
    using System.Collections;
    
    using System.Data;
    
    using MYFIRSTAPP.Services;
    
    
    
    using MYFIRSTAPP.Domaine;
    
    using MYFIRSTAPP.DAL;
    
    using MYFIRSTAPP.Common.Exceptions;
    
    using System.Collections.Generic;
    
    using MYFIRSTAPP.Services.Logging;
    
    
    
    namespace MYFIRSTAPP.Services
    
    {
    
    	/// <summary>
    
    	/// Classe de services pour les objets UtilisateurDatar.
    
    	///	</summary>
    
    	public class UtilisateurDatar_Srv : UtilisateurDatar_SrvBase
    
    	{
    
    		#region Constructeur privé
    
    		/// <summary>
    
    		/// Constructeur privé car exposition de méthodes statiques
    
    		///</summary>
    
    		private UtilisateurDatar_Srv() : base()
    
    		{
    
    		}
    
    		#endregion
    
    		
    
    		
    
    		#region méthodes de Tests
    
    		
    
    		#region IsValide
    
            /// <summary>
    
            /// Validation métier des données d'un UtilisateurDatar (Hors validation des  entités liées.)
    
            /// </summary>
    
            /// <param name="entite">Objet à valider</param>
    
            /// <param name="erreurs">Collection d'exception permettant de récupérer les erreurs trouvées</param>
    
            /// <returns>true sir le UtilisateurDatar est valide, false sinon</returns>
    
            public static bool IsValide(UtilisateurDatar entite, MyfirstappExceptionCollection erreurs)
    
            {
    
                try
    
                {
    
                    return IsValideBase(entite, erreurs);
    
                }
    
                catch (Exception e)
    
                {        
    
    				Log.TraiterException(e , "Exception IsValide!"); // on peut passer aussi entite
    
    				// Log.AddLog(new Msg(MsgType.Exception, "Exception IsValide!"), entite , e );
    
                    return false;
    
                }
    
                
    
            }
    
            #endregion
    
    		
    
    		#region IsSupprimable
    
            /// <summary>
    
            /// Vérifier si un UtilisateurDatar peut être supprimé
    
            /// </summary>
    
            /// <param name="entite">Objet à vérifier</param>
    
            /// <param name="erreurs">Collection d'exception permettant de récupérer les erreurs trouvées</param>
    
            /// <returns>true si le UtilisateurDatar est supprimable, false sinon</returns>
    
            public static bool IsSupprimable(UtilisateurDatar entite, MyfirstappExceptionCollection erreurs)
    
            {            
    
                try
    
                {
    
                    return IsSupprimableBase(entite, erreurs);
    
                }
    
                catch (Exception e)
    
                {   
    
    				Log.TraiterException(e, "Exception IsSupprimable!"); // on peut passer aussi entite
    
    				// Log.AddLog(new Msg(MsgType.Exception, "Exception IsSupprimable!"), entite , e , );        
    
                    return false;
    
                }
    
             
    
            }
    
            #endregion
    
    		
    
    		#region IsModifiable
    
            /// <summary>
    
            /// Vérifier si un UtilisateurDatar peut être modifié
    
            /// </summary>
    
            /// <param name="entite">Objet à vérifier</param>
    
            /// <param name="erreurs">Collection d'exception permettant de récupérer les erreurs trouvées</param>
    
            /// <returns>true si le UtilisateurDatar est modifiable, false sinon</returns>
    
            public static bool IsModifiable(UtilisateurDatar entite, MyfirstappExceptionCollection erreurs)
    
            {    
    
    			
    
    			try
    
                {
    
    				return IsModifiableBase(entite, erreurs);
    
                }
    
                catch (Exception e)
    
                {
    
    				Log.TraiterException(e , "Exception IsModifiable!"); // on peut passer aussi entite
    
    				// Log.AddLog(new Msg(MsgType.Exception, "Exception IsModifiable!"), entite , e );        
    
                    return false;
    
                }
    
            }
    
            #endregion	
    
    
    
    
    
    		#region HasDroit
    
            /// <summary>
    
            /// Vérifier si un profil a les droit nécessaire pour éffectuer une action
    
            /// le test se fait en fonction du :
    
            /// profil de l'utilisateur
    
            /// </summary>
    
            /// <param name="profil">EnumPerProfil : Profil de l'utilisateur</param>
    
            /// <param name="module">IHMModule : module (IHM)</param>
    
            /// <param name="element">IHMElement : élément (IHM) </param>
    
            /// <param name="action">TypeActe : type l'action a efféctuer</param>
    
            /// <returns>True si l'action est autorisée pour le profil, False sinon</returns>
    
            public static bool HasDroit(EnumPerProfil profil
    
                                        , IHMModule module
    
    									, IHMElement element
    
                                        , TypeActe action)
    
            {		
    
                #region Déclaration de variables
    
                bool hasDroit = false;
    
                #endregion
    
    
    
                if (profil == EnumPerProfil.Administrateur)
    
                    return true;
    
    
    
                try
    
                {
    
    				return DroitsProfiles_Srv.RechercherDroit(profil, module, element, action);
    
    			}
    
                catch (Exception e)
    
                {
    
    				Log.TraiterException(e , "Exception HasDroit!"); // on peut passer aussi profil
    
    				// Log.AddLog(new Msg(MsgType.Exception, "Exception HasDroit!"), profil , e );        				
    
                }
    
    
    
                return hasDroit;
    
    
    
            }
    
            #endregion
    
    		
    
    		
    
    		#endregion
    
    
    
    		#region ChargerSimple
    
    		/// <summary>
    
    		/// Chargement d'un objet UtilisateurDatar sans aucun objet lié
    
    		///	</summary>
    
    		/// <returns>Objet recherché (sans aucun objet lié)</returns>
    
    		public static UtilisateurDatar ChargerSimple(long perId)
    
    		{			
    
    			UtilisateurDatar _entite = null;
    
    			try
    
    			{				
    
    				_entite = (UtilisateurDatar)ChargerSimpleBase(perId);
    
    			}
    
    			catch (Exception e)
    
    			{
    
    				Log.TraiterException(e , "ChargerTous()"); // on peut passer aussi perId
    
    				// Log.AddLog(new Msg(MsgType.Exception, "Exception!" ), _entite , e);
    
    			}
    
    			return _entite;
    
    		}
    
    		#endregion
    
    
    
    		#region ChargerTous
    
    		/// <summary>
    
    		/// Chargement de tous les objets UtilisateurDatar sans aucun objet lié
    
    		///	</summary>
    
    		/// <returns>Collection d'objets (sans aucun objet lié)</returns>
    
    		public static MyfirstappEntitesCollection ChargerTous()
    
    		{			
    
    			MyfirstappEntitesCollection _liste = null;
    
    			try
    
    			{				
    
    				_liste = ChargerTousBase();
    
    			}
    
    			catch (Exception e)
    
    			{
    
    				Log.TraiterException(e , "ChargerTous()");
    
    				// Log.AddLog(new Msg(MsgType.Exception, "ChargerTous()"), null , e);
    
    			}
    
    			return _liste;
    
    		}
    
    		#endregion
    
    				
    
    		#region Méthodes liées aux clés étrangères
    
    		#endregion
    
    
    
    		#region Modifier
    
    		/// <summary>
    
    		/// Modification d'un objet UtilisateurDatar
    
    		///	</summary>
    
    		/// <param name="entite">Objet à modifier</param>
    
    		/// <returns>Une liste de messages d'erreur, où Msg c'est une classe qui contient deux attributs: -Le texte  -Le Type du message qui est liée avec un couleur</returns>
    
    		public static List<Msg> Modifier(UtilisateurDatar entite , MyfirstappExceptionCollection erreurs)
    
    		{
    
    			List<Msg> messagesErreur = new List<Msg>();
    
    			try
    
    			{
    
                    bool isModifiable = IsModifiableBase(entite, erreurs);
    
    				if(isModifiable)
    
    				{
    
    					
    
    					isModifiable = IsValide(entite , erreurs);
    
    					if (isModifiable)
    
    					{
    
    						ModifierBase(entite);
    
    					}
    
    					else
    
    					{
    
                            erreurs.Add(new MyfirstappMetierException("l'entité n'est pas modifiable"));
    
    					}
    
    				}
    
    				else
    
    				{
    
                        erreurs.Add(new MyfirstappMetierException("l'entité n'est pas modifiable"));
    
    				}
    
    			
    
    				
    
    			}
    
    			catch (Exception e)
    
    			{
    
                    TraiterErreur(e);
    
    			}
    
    
    
                return messagesErreur;
    
    		}
    
    	
    
    		#endregion
    
    					
    
    		#region Supprimer
    
    		/// <summary>
    
    		/// Suppression d'une entité UtilisateurDatar
    
    		///	</summary>
    
    		public static void Supprimer(UtilisateurDatar entite)
    
    		{
    
    			try
    
    			{
    
    				SupprimerBase(entite);
    
    			}
    
    			catch (Exception e)
    
    			{				
    
    				// Log.TraiterException(e , "Supprimer", entite); // on peut passer aussi entite
    
    				// Log.AddLog(new Msg(MsgType.Exception, "Exception!" ), entite , e);
    
    			}
    
    		}
    
    	
    
    		#endregion
    
    		
    
    		#region Créer
    
    		/// <summary>
    
    		/// Création d'une entité UtilisateurDatar
    
    		///	</summary>
    
    		public static long Creer(UtilisateurDatar entite)
    
    		{
    
    			long _id = long.MinValue;
    
    			try
    
    			{
    
    				_id = CreerBase(entite);
    
    			} 
    
    			catch (Exception e)
    
    			{
    
    				TraiterErreur(e, entite);
    
    			}
    
    			 return _id;
    
    		}
    
    		
    
    		#endregion
    
    
    
            #region RechercherPar PER_LOGIN, PER_PASSWORD
    
            /// <summary>
    
            /// Chargement de tous les objets Contrat répondant à certains critères de recherche (sans aucun objet lié)
    
            ///	</summary>
    
            /// <returns>Collection d'objets (sans aucun objet lié)</returns>
    
            public static MyfirstappEntitesCollection RechercherPar(string PerLogin, string PerPassword)
    
            {
    
                UtilisateurDatar_Dac _dac = null;
    
                MyfirstappEntitesCollection _liste = null;
    
                try
    
                {
    
                    _dac = UtilisateurDatar_Dac.GetInstance();
    
                    _liste = _dac.RechercherPar(PerLogin, PerPassword);
    
                }
    
                catch (Exception _e)
    
                {
    
                    TraiterErreur(_e);
    
                }
    
                return _liste;
    
            }
    
            #endregion
    
    
    
            #region Rechercher Liste des utilisateurs
    
            /// <summary>
    
            /// 
    
            /// </summary>
    
            /// <param name="SousChaine"></param>
    
            /// <param name="count"></param>
    
            /// <returns></returns>
    
            public static string[] RechercherUtilisateurs(string SousChaine, int count)
    
            {
    
                List<string> _listeResultat = new List<string>();
    
    
    
                try
    
                {
    
                    MyfirstappEntitesCollection _coll = ChargerTous();
    
                    if (_coll != null)
    
                    {
    
                        MyfirstappEntitesCollection _collResultat = new MyfirstappEntitesCollection();
    
                        foreach (UtilisateurDatar _per in _coll)
    
                        {
    
                            if (!string.IsNullOrEmpty(_per.PerNom))
    
                            {
    
                                if (_per.PerNom.ToLower().StartsWith(SousChaine))
    
                                    _listeResultat.Add(_per.LibelleComplet);
    
                            }
    
                            if (_listeResultat.Count >= count)
    
                                return _listeResultat.ToArray();
    
                        }
    
                    }
    
                }
    
                catch (Exception _e)
    
                {
    
                    TraiterErreur(_e);
    
                }
    
                return _listeResultat.ToArray();
    
            }
    
    
    
            #endregion
    
    		
    
    	}
    
    

    Question (4)

    why we inherit this : : UtilisateurDatar_SrvBase

    UtilisateurDatar_SrvBase.cs is inside the project MYFIRSTAPP.Services inside the folder ObjetsMetiers

    - here the UtilisateurDatar_SrvBase.cs code :

    using System;
    
    using System.Collections;
    
    using System.Data;
    
    using MYFIRSTAPP.Services;
    
    
    
    using MYFIRSTAPP.Domaine;
    
    using MYFIRSTAPP.DAL;
    
    using MYFIRSTAPP.Common.Exceptions;
    
    using System.Collections.Generic;
    
    using MYFIRSTAPP.Services.Logging;
    
    
    
    namespace MYFIRSTAPP.Services
    
    {
    
    	/// <summary>
    
    	/// Classe de services pour les objets UtilisateurDatar.
    
    	///	</summary>
    
    	public class UtilisateurDatar_Srv : UtilisateurDatar_SrvBase
    
    	{
    
    		#region Constructeur privé
    
    		/// <summary>
    
    		/// Constructeur privé car exposition de méthodes statiques
    
    		///</summary>
    
    		private UtilisateurDatar_Srv() : base()
    
    		{
    
    		}
    
    		#endregion
    
    		
    
    		
    
    		#region méthodes de Tests
    
    		
    
    		#region IsValide
    
            /// <summary>
    
            /// Validation métier des données d'un UtilisateurDatar (Hors validation des  entités liées.)
    
            /// </summary>
    
            /// <param name="entite">Objet à valider</param>
    
            /// <param name="erreurs">Collection d'exception permettant de récupérer les erreurs trouvées</param>
    
            /// <returns>true sir le UtilisateurDatar est valide, false sinon</returns>
    
            public static bool IsValide(UtilisateurDatar entite, MyfirstappExceptionCollection erreurs)
    
            {
    
                try
    
                {
    
                    return IsValideBase(entite, erreurs);
    
                }
    
                catch (Exception e)
    
                {        
    
    				Log.TraiterException(e , "Exception IsValide!"); // on peut passer aussi entite
    
    				// Log.AddLog(new Msg(MsgType.Exception, "Exception IsValide!"), entite , e );
    
                    return false;
    
                }
    
                
    
            }
    
            #endregion
    
    		
    
    		#region IsSupprimable
    
            /// <summary>
    
            /// Vérifier si un UtilisateurDatar peut être supprimé
    
            /// </summary>
    
            /// <param name="entite">Objet à vérifier</param>
    
            /// <param name="erreurs">Collection d'exception permettant de récupérer les erreurs trouvées</param>
    
            /// <returns>true si le UtilisateurDatar est supprimable, false sinon</returns>
    
            public static bool IsSupprimable(UtilisateurDatar entite, MyfirstappExceptionCollection erreurs)
    
            {            
    
                try
    
                {
    
                    return IsSupprimableBase(entite, erreurs);
    
                }
    
                catch (Exception e)
    
                {   
    
    				Log.TraiterException(e, "Exception IsSupprimable!"); // on peut passer aussi entite
    
    				// Log.AddLog(new Msg(MsgType.Exception, "Exception IsSupprimable!"), entite , e , );        
    
                    return false;
    
                }
    
             
    
            }
    
            #endregion
    
    		
    
    		#region IsModifiable
    
            /// <summary>
    
            /// Vérifier si un UtilisateurDatar peut être modifié
    
            /// </summary>
    
            /// <param name="entite">Objet à vérifier</param>
    
            /// <param name="erreurs">Collection d'exception permettant de récupérer les erreurs trouvées</param>
    
            /// <returns>true si le UtilisateurDatar est modifiable, false sinon</returns>
    
            public static bool IsModifiable(UtilisateurDatar entite, MyfirstappExceptionCollection erreurs)
    
            {    
    
    			
    
    			try
    
                {
    
    				return IsModifiableBase(entite, erreurs);
    
                }
    
                catch (Exception e)
    
                {
    
    				Log.TraiterException(e , "Exception IsModifiable!"); // on peut passer aussi entite
    
    				// Log.AddLog(new Msg(MsgType.Exception, "Exception IsModifiable!"), entite , e );        
    
                    return false;
    
                }
    
            }
    
            #endregion	
    
    
    
    
    
    		#region HasDroit
    
            /// <summary>
    
            /// Vérifier si un profil a les droit nécessaire pour éffectuer une action
    
            /// le test se fait en fonction du :
    
            /// profil de l'utilisateur
    
            /// </summary>
    
            /// <param name="profil">EnumPerProfil : Profil de l'utilisateur</param>
    
            /// <param name="module">IHMModule : module (IHM)</param>
    
            /// <param name="element">IHMElement : élément (IHM) </param>
    
            /// <param name="action">TypeActe : type l'action a efféctuer</param>
    
            /// <returns>True si l'action est autorisée pour le profil, False sinon</returns>
    
            public static bool HasDroit(EnumPerProfil profil
    
                                        , IHMModule module
    
    									, IHMElement element
    
                                        , TypeActe action)
    
            {		
    
                #region Déclaration de variables
    
                bool hasDroit = false;
    
                #endregion
    
    
    
                if (profil == EnumPerProfil.Administrateur)
    
                    return true;
    
    
    
                try
    
                {
    
    				return DroitsProfiles_Srv.RechercherDroit(profil, module, element, action);
    
    			}
    
                catch (Exception e)
    
                {
    
    				Log.TraiterException(e , "Exception HasDroit!"); // on peut passer aussi profil
    
    				// Log.AddLog(new Msg(MsgType.Exception, "Exception HasDroit!"), profil , e );        				
    
                }
    
    
    
                return hasDroit;
    
    
    
            }
    
            #endregion
    
    		
    
    		
    
    		#endregion
    
    
    
    		#region ChargerSimple
    
    		/// <summary>
    
    		/// Chargement d'un objet UtilisateurDatar sans aucun objet lié
    
    		///	</summary>
    
    		/// <returns>Objet recherché (sans aucun objet lié)</returns>
    
    		public static UtilisateurDatar ChargerSimple(long perId)
    
    		{			
    
    			UtilisateurDatar _entite = null;
    
    			try
    
    			{				
    
    				_entite = (UtilisateurDatar)ChargerSimpleBase(perId);
    
    			}
    
    			catch (Exception e)
    
    			{
    
    				Log.TraiterException(e , "ChargerTous()"); // on peut passer aussi perId
    
    				// Log.AddLog(new Msg(MsgType.Exception, "Exception!" ), _entite , e);
    
    			}
    
    			return _entite;
    
    		}
    
    		#endregion
    
    
    
    		#region ChargerTous
    
    		/// <summary>
    
    		/// Chargement de tous les objets UtilisateurDatar sans aucun objet lié
    
    		///	</summary>
    
    		/// <returns>Collection d'objets (sans aucun objet lié)</returns>
    
    		public static MyfirstappEntitesCollection ChargerTous()
    
    		{			
    
    			MyfirstappEntitesCollection _liste = null;
    
    			try
    
    			{				
    
    				_liste = ChargerTousBase();
    
    			}
    
    			catch (Exception e)
    
    			{
    
    				Log.TraiterException(e , "ChargerTous()");
    
    				// Log.AddLog(new Msg(MsgType.Exception, "ChargerTous()"), null , e);
    
    			}
    
    			return _liste;
    
    		}
    
    		#endregion
    
    				
    
    		#region Méthodes liées aux clés étrangères
    
    		#endregion
    
    
    
    		#region Modifier
    
    		/// <summary>
    
    		/// Modification d'un objet UtilisateurDatar
    
    		///	</summary>
    
    		/// <param name="entite">Objet à modifier</param>
    
    		/// <returns>Une liste de messages d'erreur, où Msg c'est une classe qui contient deux attributs: -Le texte  -Le Type du message qui est liée avec un couleur</returns>
    
    		public static List<Msg> Modifier(UtilisateurDatar entite , MyfirstappExceptionCollection erreurs)
    
    		{
    
    			List<Msg> messagesErreur = new List<Msg>();
    
    			try
    
    			{
    
                    bool isModifiable = IsModifiableBase(entite, erreurs);
    
    				if(isModifiable)
    
    				{
    
    					
    
    					isModifiable = IsValide(entite , erreurs);
    
    					if (isModifiable)
    
    					{
    
    						ModifierBase(entite);
    
    					}
    
    					else
    
    					{
    
                            erreurs.Add(new MyfirstappMetierException("l'entité n'est pas modifiable"));
    
    					}
    
    				}
    
    				else
    
    				{
    
                        erreurs.Add(new MyfirstappMetierException("l'entité n'est pas modifiable"));
    
    				}
    
    			
    
    				
    
    			}
    
    			catch (Exception e)
    
    			{
    
                    TraiterErreur(e);
    
    			}
    
    
    
                return messagesErreur;
    
    		}
    
    	
    
    		#endregion
    
    					
    
    		#region Supprimer
    
    		/// <summary>
    
    		/// Suppression d'une entité UtilisateurDatar
    
    		///	</summary>
    
    		public static void Supprimer(UtilisateurDatar entite)
    
    		{
    
    			try
    
    			{
    
    				SupprimerBase(entite);
    
    			}
    
    			catch (Exception e)
    
    			{				
    
    				// Log.TraiterException(e , "Supprimer", entite); // on peut passer aussi entite
    
    				// Log.AddLog(new Msg(MsgType.Exception, "Exception!" ), entite , e);
    
    			}
    
    		}
    
    	
    
    		#endregion
    
    		
    
    		#region Créer
    
    		/// <summary>
    
    		/// Création d'une entité UtilisateurDatar
    
    		///	</summary>
    
    		public static long Creer(UtilisateurDatar entite)
    
    		{
    
    			long _id = long.MinValue;
    
    			try
    
    			{
    
    				_id = CreerBase(entite);
    
    			} 
    
    			catch (Exception e)
    
    			{
    
    				TraiterErreur(e, entite);
    
    			}
    
    			 return _id;
    
    		}
    
    		
    
    		#endregion
    
    
    
            #region RechercherPar PER_LOGIN, PER_PASSWORD
    
            /// <summary>
    
            /// Chargement de tous les objets Contrat répondant à certains critères de recherche (sans aucun objet lié)
    
            ///	</summary>
    
            /// <returns>Collection d'objets (sans aucun objet lié)</returns>
    
            public static MyfirstappEntitesCollection RechercherPar(string PerLogin, string PerPassword)
    
            {
    
                UtilisateurDatar_Dac _dac = null;
    
                MyfirstappEntitesCollection _liste = null;
    
                try
    
                {
    
                    _dac = UtilisateurDatar_Dac.GetInstance();
    
                    _liste = _dac.RechercherPar(PerLogin, PerPassword);
    
                }
    
                catch (Exception _e)
    
                {
    
                    TraiterErreur(_e);
    
                }
    
                return _liste;
    
            }
    
            #endregion
    
    
    
            #region Rechercher Liste des utilisateurs
    
            /// <summary>
    
            /// 
    
            /// </summary>
    
            /// <param name="SousChaine"></param>
    
            /// <param name="count"></param>
    
            /// <returns></returns>
    
            public static string[] RechercherUtilisateurs(string SousChaine, int count)
    
            {
    
                List<string> _listeResultat = new List<string>();
    
    
    
                try
    
                {
    
                    MyfirstappEntitesCollection _coll = ChargerTous();
    
                    if (_coll != null)
    
                    {
    
                        MyfirstappEntitesCollection _collResultat = new MyfirstappEntitesCollection();
    
                        foreach (UtilisateurDatar _per in _coll)
    
                        {
    
                            if (!string.IsNullOrEmpty(_per.PerNom))
    
                            {
    
                                if (_per.PerNom.ToLower().StartsWith(SousChaine))
    
                                    _listeResultat.Add(_per.LibelleComplet);
    
                            }
    
                            if (_listeResultat.Count >= count)
    
                                return _listeResultat.ToArray();
    
                        }
    
                    }
    
                }
    
                catch (Exception _e)
    
                {
    
                    TraiterErreur(_e);
    
                }
    
                return _listeResultat.ToArray();
    
            }
    
    
    
            #endregion
    
    		
    
    	}
    
    }

    Question (5)

    about the code :

    UtilisateurDatar_Srv.RechercherPar(Login1.UserName, Login1.Password);

    Could you explain to me what this code actually doing?

    we use this (i already writed the full code of this class above):

    #region RechercherPar PER_LOGIN, PER_PASSWORD
    
            /// <summary>
    
            /// Chargement de tous les objets Contrat répondant à certains critères de recherche (sans aucun objet lié)
    
            ///	</summary>
    
            /// <returns>Collection d'objets (sans aucun objet lié)</returns>
    
            public static MyfirstappEntitesCollection RechercherPar(string PerLogin, string PerPassword)
    
            {
    
                UtilisateurDatar_Dac _dac = null;
    
                MyfirstappEntitesCollection _liste = null;
    
                try
    
                {
    
                    _dac = UtilisateurDatar_Dac.GetInstance();
    
                    _liste = _dac.RechercherPar(PerLogin, PerPassword);
    
                }
    
                catch (Exception _e)
    
                {
    
                    TraiterErreur(_e);
    
                }
    
                return _liste;
    
            }
    
            #endregion
    
    

     This code :

    UtilisateurDatar User = (UtilisateurDatar)Users[0];

    Question (6)

    i guess here we create the user and we put it in session, someone can explain to me the logic of this class :

    UtilisateurDatar.cs is inside the project MYFIRSTAPP.Domaine inside the folder Comparers

    - here the UtilisateurDatar_Srv.cs code :

    using System;
    
    using MYFIRSTAPP.Domaine;
    
    
    
    namespace MYFIRSTAPP.Domaine
    
    
    
    {
    
    	/// <summary>
    
    	/// Entité métier de base pour UtilisateurDatar
    
    	/// </summary>
    
    	/// <remarks>
    
    	/// Ce code est généré automatiquement à partir de la base de données et ne doit pas être modifié.
    
    	/// Toutes les modifications doivent être réalisées dans la classe <see cref="UtilisateurDatar"> en dérivant.
    
    	/// </remarks>
    
    	public class UtilisateurDatar : UtilisateurDatarBase
    
    	{
    
    
    
    		#region Propriete ChampsObligatoires
    
            /// <summary>
    
            /// Constante à remplir avec la liste des propriétés obligatoires de l'objet métier.
    
            /// Respecter la casse sur la base des accesseurs aux propriétés
    
            /// Ne pas mettre l'identifiant de l'objet (Id) ni l'identifiant de l'objet métier (ObjetId) dans cette liste
    
            /// </summary>
    
            private const string CHAMPS_OBLIGATOIRES = "PerId PerLogin PerPassword PerProfil PerNom PerPrenom PerCivilite ";
    
            /// <summary>
    
            /// Chaine contenant la liste des propriétés obligatoires de l'objet
    
            /// </summary>
    
            public string ChampsObligatoires
    
            {
    
                get { return CHAMPS_OBLIGATOIRES; }
    
            }
    
            #endregion
    
    
    
            #region Constructeurs
    
    
    
            /// <summary>
    
            /// Constructeur avec un identifiant
    
            /// </summary>
    
            /// <param name="id">Identifiant de l'entité métier</param>
    
            public UtilisateurDatar(long id)
    
                : base(id)
    
            {
    
            }
    
    
    
            /// <summary>
    
            /// Constructeur vide
    
            /// </summary>
    
            public UtilisateurDatar()
    
                : base()
    
            {
    
            }
    
    
    
            #endregion // Constructeurs
    
    
    
            #region CalculerLibelleComplet
    
            /// <summary>
    
            /// Méthode permettant de calculer le libellé complet de la classe. A modifier
    
            /// </summary>
    
            /// <returns>Le libellé complet de la classe [string]</returns>
    
            public override string CalculerLibelleComplet()
    
            {
    
                string libelleComplet = PerId + " - "+PerPrenom+" " + PerNom;
    
                // To do : return this.champLibelle;
    
                return libelleComplet;
    
            }
    
            #endregion // CalculerLibelleComplet
    
    	
    
    	}
    
    }

    UtilisateurDatarBase.cs is inside the project MYFIRSTAPP.Domaine inside the folder Comparers

    - here the UtilisateurDatar_Srv.cs code :

    using System;
    
    using MYFIRSTAPP.Domaine;
    
    
    
    
    
    namespace MYFIRSTAPP.Domaine
    
    
    
    {
    
    	/// <summary>
    
    	/// Entité métier de base pour UtilisateurDatar
    
    	/// </summary>
    
    	/// <remarks>
    
    	/// Ce code est généré automatiquement à partir de la base de données et ne doit pas être modifié.
    
    	/// Toutes les modifications doivent être réalisées dans la classe <see cref="UtilisateurDatar"> en dérivant.
    
    	/// </remarks>
    
    	public abstract class UtilisateurDatarBase : MyfirstappEntite
    
    	{
    
    
    
    		#region Champs propres  l'objet (Propriétés et champs privés)
    
    		
    
    		#region PerId (Clé primaire)
    
    		private long _perId;
    
    		///<summary>Clef primaire PerId</summary>
    
    		public long PerId
    
    		{
    
    			get{ return _perId; }
    
    			set{ _perId = value; }
    
    		}
    
    		#endregion
    
    		
    
    		#region Champ PerProfil
    
    		private int _perProfil = int.MinValue;
    
    		///<summary>Champ PerProfil</summary>
    
    		public int PerProfil
    
    		{
    
    			get{return _perProfil;}
    
    			set
    
    			{
    
    				_perProfil=value;
    
    			LibelleComplet = CalculerLibelleComplet();
    
    			}
    
    		}
    
    		#endregion
    
    		
    
    		#region Champ PerNom
    
    		private string _perNom = String.Empty;
    
    		///<summary>Champ PerNom</summary>
    
    		public string PerNom
    
    		{
    
    			get{return _perNom;}
    
    			set
    
    			{
    
    				_perNom=TraiterChaine(value);
    
    			LibelleComplet = CalculerLibelleComplet();
    
    			}
    
    		}
    
    		#endregion
    
    		
    
    		#region Champ PerPrenom
    
    		private string _perPrenom = String.Empty;
    
    		///<summary>Champ PerPrenom</summary>
    
    		public string PerPrenom
    
    		{
    
    			get{return _perPrenom;}
    
    			set
    
    			{
    
    				_perPrenom=TraiterChaine(value);
    
    			LibelleComplet = CalculerLibelleComplet();
    
    			}
    
    		}
    
    		#endregion
    
    
    
            #region Champ PerCivilite
    
            private int _perCivilite = int.MinValue;
    
            ///<summary>Champ PerCivilite</summary>
    
            public int PerCivilite
    
            {
    
                get { return _perCivilite; }
    
                set
    
                {
    
                    _perCivilite = value;
    
                    LibelleComplet = CalculerLibelleComplet();
    
                }
    
            }
    
            #endregion
    
    		
    
    		#region Champ PerMail
    
    		private string _perMail = String.Empty;
    
    		///<summary>Champ PerMail</summary>
    
    		public string PerMail
    
    		{
    
    			get{return _perMail;}
    
    			set
    
    			{
    
    				_perMail=TraiterChaine(value);
    
    			LibelleComplet = CalculerLibelleComplet();
    
    			}
    
    		}
    
    		#endregion
    
    
    
    
    
    
    
            #region Champ PerTelephone1
    
            private string _perTelephone1 = string.Empty;
    
            ///<summary>Champ PerTelephone1</summary>
    
            public string PerTelephone1
    
            {
    
                get { return _perTelephone1; }
    
                set
    
                {
    
                    _perTelephone1 = TraiterChaine(value);
    
                    LibelleComplet = CalculerLibelleComplet();
    
                }
    
            }
    
            #endregion
    
    
    
            #region Champ PerTelephone2
    
            private string _perTelephone2 = string.Empty;
    
            ///<summary>Champ PerTelephone2</summary>
    
            public string PerTelephone2
    
            {
    
                get { return _perTelephone2; }
    
                set
    
                {
    
                    _perTelephone2 = TraiterChaine(value);
    
                    LibelleComplet = CalculerLibelleComplet();
    
                }
    
            }
    
            #endregion
    
    
    
            #region Champ PerTelephone3
    
            private string _perTelephone3 = string.Empty;
    
            ///<summary>Champ PerTelephone3</summary>
    
            public string PerTelephone3
    
            {
    
                get { return _perTelephone3; }
    
                set
    
                {
    
                    _perTelephone3 = TraiterChaine(value);
    
                    LibelleComplet = CalculerLibelleComplet();
    
                }
    
            }
    
            #endregion
    
    
    
            #region Champ PerFax
    
            private string _perFax = string.Empty;
    
            ///<summary>Champ PerFax</summary>
    
            public string PerFax
    
            {
    
                get { return _perFax; }
    
                set
    
                {
    
                    _perFax = TraiterChaine(value);
    
                    LibelleComplet = CalculerLibelleComplet();
    
                }
    
            }
    
            #endregion
    
    
    
    
    
    
    
    		#region Champ PerLogin
    
    		private string _perLogin = String.Empty;
    
    		///<summary>Champ PerLogin</summary>
    
    		public string PerLogin
    
    		{
    
    			get{return _perLogin;}
    
    			set
    
    			{
    
    				_perLogin=TraiterChaine(value);
    
    			LibelleComplet = CalculerLibelleComplet();
    
    			}
    
    		}
    
    		#endregion
    
    		
    
    		#region Champ PerPassword
    
    		private string _perPassword = String.Empty;
    
    		///<summary>Champ PerPassword</summary>
    
    		public string PerPassword
    
    		{
    
    			get{return _perPassword;}
    
    			set
    
    			{
    
    				_perPassword=TraiterChaine(value);
    
    			LibelleComplet = CalculerLibelleComplet();
    
    			}
    
    		}
    
    		#endregion
    
    		
    
    
    
    		#endregion
    
    
    
    		#region Constructeurs
    
    
    
    		/// <summary>
    
    		/// Constructeur vide
    
    		/// </summary>
    
    		public UtilisateurDatarBase() : base()
    
    		{
    
    		}
    
    
    
    
    
    		/// <summary>
    
    		/// Constructeur avec identifiant
    
    		/// </summary>
    
    		// <param name="id">Identifiant de l'entité métier</param>
    
    		public UtilisateurDatarBase(long id) : base(id)
    
    		{
    
    		}
    
    		#endregion
    
    
    
    		
    
    		
    
    		#region Objets liés par clefs étrangères
    
    		#endregion
    
    
    
    		#region Collections liées par clés étrangères
    
    		#region ListeDocument
    
    		private MyfirstappEntitesCollection _listeDocument = null;
    
    		///<summary>Collection d'objets <see href="Document"> liés.</summary>
    
    		public MyfirstappEntitesCollection ListeDocument
    
    		{
    
    			get{return _listeDocument;}
    
    			set{
    
    				_listeDocument = value;
    
    				LibelleComplet = CalculerLibelleComplet();
    
    			   }
    
    		}
    
    		#endregion
    
    			
    
    		#region ListeDroitsProfiles
    
    		private MyfirstappEntitesCollection _listeDroitsProfiles = null;
    
    		///<summary>Collection d'objets <see href="DroitsProfiles"> liés.</summary>
    
    		public MyfirstappEntitesCollection ListeDroitsProfiles
    
    		{
    
    			get{return _listeDroitsProfiles;}
    
    			set{
    
    				_listeDroitsProfiles = value;
    
    				LibelleComplet = CalculerLibelleComplet();
    
    			   }
    
    		}
    
    		#endregion
    
    			
    
    		#region ListeLogApplicative
    
    		private MyfirstappEntitesCollection _listeLogApplicative = null;
    
    		///<summary>Collection d'objets <see href="LogApplicative"> liés.</summary>
    
    		public MyfirstappEntitesCollection ListeLogApplicative
    
    		{
    
    			get{return _listeLogApplicative;}
    
    			set{
    
    				_listeLogApplicative = value;
    
    				LibelleComplet = CalculerLibelleComplet();
    
    			   }
    
    		}
    
    		#endregion
    
    			
    
    		#region ListeMyfirstapp
    
    		private MyfirstappEntitesCollection _listeMyfirstapp = null;
    
    		///<summary>Collection d'objets <see href="Myfirstapp"> liés.</summary>
    
    		public MyfirstappEntitesCollection ListeMyfirstapp
    
    		{
    
    			get{return _listeMyfirstapp;}
    
    			set{
    
    				_listeMyfirstapp = value;
    
    				LibelleComplet = CalculerLibelleComplet();
    
    			   }
    
    		}
    
    		#endregion
    
    			
    
    		#endregion
    
    		
    
    			
    
    	}
    
    }

    If you need more code, just ask me, i really need to understand this!!

    i am a beginner, thanks for your understanding

     

     

     

     

     

     

     

     

     

     

     

     

    Friday, December 15, 2017 10:16 AM

All replies

  • User61956409 posted

    Hi devquestionsanswers,<o:p></o:p>

    If you are not the developer of that project, but you want to understand the application design and code logic, you had better to contact and consult the project developer(s).  <o:p></o:p>

    <o:p> </o:p>I will share my idea and understanding to your code and questions: <o:p></o:p>

    • Some of your questions are related to Inheritance that provides an opportunity to reuse the code functionality and speeds up implementation time. For detailed information about Inheritance, please check this documentation.<o:p></o:p>
    • Question 3: Why i create a MyfirstappEntitesCollection Users. In your code, I can find that it will check if user is authenticated via check the count of MyfirstappEntitesCollection Users in Login1_Authenticate method.<o:p></o:p>
    • It seems use multi-tier architecture in project, which will be friendly for new feature addition and maintenance. If you’d like to know the relationship between different tiers and code logic, debugging the code step by step and tracing the key variables changes would be a good choice.

    <o:p></o:p>With Regards, <o:p></o:p>

    Fei Han<o:p></o:p>

    Tuesday, December 19, 2017 6:31 AM