kamagra how much to take

AspnetPaths Partial Class

This is the base partial data object class for the “paths” table in the provider database. Using this class implies that there will be a singular relationship between the remaining provider tables and relevant data objects.

  1.  //*****************************************************************************
  2. // This file is part of the data access layer example to the ASP.NET 2.0 provider database
  3. // This file was written by Adam Buenz [WSS MVP] of ARB Security Solutions, LLC
  4. //                  http://www.sharepointsecurity.com
  5. //
  6. // This file and its parts is free for re-distribution, for use in both free
  7. // and commercial applications, however this header must remain intact for legal
  8. // use. The data access layer example is distributed in the hope that it will
  9. // be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  11. //*****************************************************************************
  12. using System;
  13. using System.Collections.Generic;
  14. using System.Data;
  15. using System.Data.SqlClient;
  16. using Aspnet.Provider.Datalayer.Commands;
  17. using Aspnet.Provider.Datalayer.DataTransferObjects;
  18.  
  19. namespace Aspnet.Provider.Datalayer
  20. {
  21.         /// <summary>
  22.         /// The AspnetPaths class.
  23.         /// </summary>
  24.         public partial class AspnetPaths : IPersistable
  25.         {
  26.                 #region Members
  27.  
  28.                 private bool isNew;
  29.                 private bool _isNew;
  30.                 private Guid applicationid;
  31.                 private Guid pathid;
  32.                 private string path;
  33.                 private string loweredpath;
  34.  
  35.                 #endregion
  36.  
  37.                 #region Properties
  38.  
  39.                 /// <summary>
  40.                 /// The Applicationid.
  41.                 /// </summary>
  42.                 public virtual Guid Applicationid
  43.                 {
  44.                         get { return this.applicationid; }
  45.                         set { this.applicationid = value; }
  46.                 }
  47.  
  48.                 /// <summary>
  49.                 /// The Pathid.
  50.                 /// </summary>
  51.                 public virtual Guid Pathid
  52.                 {
  53.                         get { return this.pathid; }
  54.                         set { this.pathid = value; }
  55.                 }
  56.  
  57.                 /// <summary>
  58.                 /// The Path.
  59.                 /// </summary>
  60.                 [StringInfo(256, true)]
  61.                 public virtual string Path
  62.                 {
  63.                         get { return this.path; }
  64.                         set { this.path = value; }
  65.                 }
  66.  
  67.                 /// <summary>
  68.                 /// The Loweredpath.
  69.                 /// </summary>
  70.                 [StringInfo(256, true)]
  71.                 public virtual string Loweredpath
  72.                 {
  73.                         get { return this.loweredpath; }
  74.                         set { this.loweredpath = value; }
  75.                 }
  76.  
  77.                 #endregion
  78.  
  79.                 #region ColumnNames
  80.  
  81.                 /// <summary>
  82.                 /// The corresponding schema name.
  83.                 /// </summary>
  84.                 internal const string SchemaName = "dbo";
  85.  
  86.                 /// <summary>
  87.                 /// The corresponding table name.
  88.                 /// </summary>
  89.                 internal const string TableName = "aspnet_Paths";
  90.  
  91.                 /// <summary>
  92.                 /// The column names.
  93.                 /// </summary>
  94.                 internal class ColumnNames
  95.                 {
  96.                         /// <summary>
  97.                         /// The column name of the Applicationid property.
  98.                         /// </summary>
  99.                         public const string Applicationid="ApplicationId";
  100.                         /// <summary>
  101.                         /// The column name of the Pathid property.
  102.                         /// </summary>
  103.                         public const string Pathid="PathId";
  104.                         /// <summary>
  105.                         /// The column name of the Path property.
  106.                         /// </summary>
  107.                         public const string Path="Path";
  108.                         /// <summary>
  109.                         /// The column name of the Loweredpath property.
  110.                         /// </summary>
  111.                         public const string Loweredpath="LoweredPath";
  112.                 }
  113.  
  114.                 #endregion
  115.  
  116.                 /// <summary>
  117.                 /// The default constructor.
  118.                 /// </summary>
  119.                 public AspnetPaths()
  120.                 {
  121.                         this.isNew = true;
  122.                         PersistenceManager.InvokeInstanceMethod(this, "CreationComplete", null);
  123.                 }
  124.  
  125.                 /// <summary>
  126.                 /// The constructor of the required fields.
  127.                 /// </summary>
  128.                 /// <param name="applicationid">The Applicationid.</param>
  129.                 /// <param name="pathid">The Pathid.</param>
  130.                 /// <param name="path">The Path.</param>
  131.                 /// <param name="loweredpath">The Loweredpath.</param>
  132.                 public AspnetPaths(Guid applicationid, Guid pathid, string path, string loweredpath)
  133.                 {
  134.                         this.applicationid = applicationid;
  135.                         this.pathid = pathid;
  136.                         this.path = path;
  137.                         this.loweredpath = loweredpath;
  138.  
  139.                         this.isNew = true;
  140.                         PersistenceManager.InvokeInstanceMethod(this, "CreationComplete", null);
  141.                 }
  142.  
  143.                 /// <summary>
  144.                 /// The constructor from IDataReader.
  145.                 /// </summary>
  146.                 /// <param name="reader">An initalized IDataReader.</param>
  147.                 internal AspnetPaths(IDataReader reader)
  148.                 {
  149.                         if ((reader["ApplicationId"] != null) && (reader["ApplicationId"] != DBNull.Value))
  150.                         this.applicationid = (Guid)reader["ApplicationId"];
  151.                         if ((reader["PathId"] != null) && (reader["PathId"] != DBNull.Value))
  152.                         this.pathid = (Guid)reader["PathId"];
  153.                         if ((reader["Path"] != null) && (reader["Path"] != DBNull.Value))
  154.                         this.path = (string)reader["Path"];
  155.                         if ((reader["LoweredPath"] != null) && (reader["LoweredPath"] != DBNull.Value))
  156.                         this.loweredpath = (string)reader["LoweredPath"];
  157.  
  158.                         this.isNew = false;
  159.                 }
  160.  
  161.                 /// <summary>
  162.                 /// Creates an IDbCommand to insert an object into the database.
  163.                 /// </summary>
  164.                 /// <returns>An initialized IDbCommand object.</returns>
  165.                 internal virtual IDbCommand CreateInsertCommand()
  166.                 {
  167.                         SqlCommand cmd = new SqlCommand();
  168.                         cmd.CommandText = "insert into [dbo].[aspnet_Paths] ([ApplicationId], [PathId], [Path], [LoweredPath]) values (@applicationid, @pathid, @path, @loweredpath)";
  169.                         cmd.Parameters.AddWithValue("@applicationid", this.applicationid);
  170.                         cmd.Parameters.AddWithValue("@pathid", this.pathid);
  171.                         cmd.Parameters.AddWithValue("@path", this.path);
  172.                         cmd.Parameters.AddWithValue("@loweredpath", this.loweredpath);
  173.  
  174.                         cmd.Connection = PersistenceManager.Connection;
  175.                         return cmd;
  176.                 }
  177.  
  178.                 /// <summary>
  179.                 /// Creates an IDbCommand to update an object in the database.
  180.                 /// </summary>
  181.                 /// <returns>An initialized IDbCommand object.</returns>
  182.                 internal virtual IDbCommand CreateUpdateCommand()
  183.                 {
  184.                         SqlCommand cmd = new SqlCommand();
  185.                         cmd.CommandText = "update [dbo].[aspnet_Paths] set [ApplicationId]=@applicationid, [Path]=@path, [LoweredPath]=@loweredpath where ([PathId]=@pathid)";
  186.                         cmd.Parameters.AddWithValue("@applicationid", this.applicationid);
  187.                         cmd.Parameters.AddWithValue("@path", this.path);
  188.                         cmd.Parameters.AddWithValue("@loweredpath", this.loweredpath);
  189.                         cmd.Parameters.AddWithValue("@pathid", this.pathid);
  190.  
  191.                         cmd.Connection = PersistenceManager.Connection;
  192.                         return cmd;
  193.                 }
  194.  
  195.                 /// <summary>
  196.                 /// Creates an IDbCommand to delete an object in the database.
  197.                 /// </summary>
  198.                 /// <returns>An initialized IDbCommand object.</returns>
  199.                 internal virtual IDbCommand CreateDeleteCommand()
  200.                 {
  201.                         SqlCommand cmd = new SqlCommand();
  202.                         cmd.CommandText = "delete from [dbo].[aspnet_Paths]  where ([PathId]=@pathid)";
  203.                         cmd.Parameters.AddWithValue("@pathid", this.pathid);
  204.  
  205.                         cmd.Connection = PersistenceManager.Connection;
  206.                         return cmd;
  207.                 }
  208.  
  209.                 /// <summary>
  210.                 /// Persists the object.
  211.                 /// </summary>
  212.                 public virtual void Persist()
  213.                 {
  214.                         PersistenceManager.InvokeInstanceMethod(this, "PrePersist", null);
  215.  
  216.                         IDbCommand cmd;
  217.  
  218.                         if (this.isNew)
  219.                         cmd = this.CreateInsertCommand();
  220.                         else
  221.                         cmd = this.CreateUpdateCommand();
  222.  
  223.                         cmd.Transaction = PersistenceManager.Transaction;
  224.                         PersistenceManager.RegisterInTransaction(this);
  225.  
  226.                         bool connWasClosed =
  227.                         PersistenceManager.Connection.State.Equals(ConnectionState.Closed) ||
  228.                         PersistenceManager.Connection.State.Equals(ConnectionState.Broken);
  229.  
  230.                         try
  231.                         {
  232.                                 if (connWasClosed)
  233.                                 PersistenceManager.Connection.Open();
  234.  
  235.                                 cmd.ExecuteNonQuery();
  236.  
  237.                                 this.isNew = false;
  238.  
  239.                                 if (connWasClosed)
  240.                                 PersistenceManager.Connection.Close();
  241.                         }
  242.                         catch (Exception ex)
  243.                         {
  244.                                 if (connWasClosed)
  245.                                 PersistenceManager.Connection.Close();
  246.                                 throw ex;
  247.                         }
  248.                 }
  249.  
  250.                 /// <summary>
  251.                 /// Deletes the object.
  252.                 /// </summary>
  253.                 public virtual void Delete()
  254.                 {
  255.                         PersistenceManager.InvokeInstanceMethod(this, "PreDelete", null);
  256.  
  257.                         IDbCommand cmd = this.CreateDeleteCommand();
  258.                         cmd.Transaction = PersistenceManager.Transaction;
  259.  
  260.                         bool connWasClosed =
  261.                         PersistenceManager.Connection.State.Equals(ConnectionState.Closed) ||
  262.                         PersistenceManager.Connection.State.Equals(ConnectionState.Broken);
  263.  
  264.                         try
  265.                         {
  266.                                 if (connWasClosed)
  267.                                 PersistenceManager.Connection.Open();
  268.  
  269.                                 cmd.ExecuteNonQuery();
  270.  
  271.                                 if (connWasClosed)
  272.                                 PersistenceManager.Connection.Close();
  273.                         }
  274.                         catch (Exception ex)
  275.                         {
  276.                                 if (connWasClosed)
  277.                                 PersistenceManager.Connection.Close();
  278.                                 throw ex;
  279.                         }
  280.                 }
  281.  
  282.                 /// <summary>
  283.                 /// Retrieves a AspnetPaths object by its primary key (Throws System.DataException).
  284.                 /// </summary>
  285.                 /// <param name="pathid">The Pathid.</param>
  286.                 /// <returns>The AspnetPaths object.</returns>
  287.                 public static AspnetPaths Get(Guid pathid)
  288.                 {
  289.                         AspnetPaths aspnetpaths;
  290.                         if (AspnetPaths.TryGet(pathid, out aspnetpaths))
  291.                         return aspnetpaths;
  292.                         else
  293.                         throw new DataException("'AspnetPaths' object not found.");
  294.                 }
  295.  
  296.                 /// <summary>
  297.                 /// Tries to retrieve a AspnetPaths object by its primary key.
  298.                 /// </summary>
  299.                 /// <param name="pathid">The Pathid.</param>
  300.                 /// <param name="aspnetpaths">The found AspnetPaths or null if the primary key value does not exist.</param>
  301.                 /// <returns>True if the AspnetPaths exists, else false.</returns>
  302.                 public static bool TryGet(Guid pathid, out AspnetPaths aspnetpaths)
  303.                 {
  304.                         SqlCommand cmd = new SqlCommand("select * from [dbo].[aspnet_Paths]  where ([PathId]=@pathid)");
  305.                         cmd.Parameters.AddWithValue("@pathid", pathid);
  306.  
  307.                         IList<AspnetPaths> list = AspnetPaths.Query(cmd);
  308.  
  309.                         if (list.Count == 0)
  310.                         {
  311.                                 aspnetpaths = null;
  312.                                 return false;
  313.                         }
  314.                         else
  315.                         {
  316.                                 aspnetpaths = list[0];
  317.                                 return true;
  318.                         }
  319.                 }
  320.  
  321.                 /// <summary>
  322.                 /// For internal use only.
  323.                 /// </summary>
  324.                 public virtual void SaveState()
  325.                 {
  326.                         this._isNew = this.isNew;
  327.                 }
  328.  
  329.                 /// <summary>
  330.                 /// For internal use only.
  331.                 /// </summary>
  332.                 public virtual void RestoreState()
  333.                 {
  334.                         this.isNew = this._isNew;
  335.                 }
  336.  
  337.                 /// <summary>
  338.                 /// Refreshes the internal state of the object.
  339.                 /// </summary>
  340.                 /// <remarks>This method should be called after xml deserialization to refresh internal flags.</remarks>
  341.                 public virtual void RefreshState()
  342.                 {
  343.                         AspnetPaths aspnetpaths;
  344.  
  345.                         if (AspnetPaths.TryGet(this.pathid, out aspnetpaths))
  346.                         {
  347.                                 this.isNew = false;
  348.                         }
  349.                         else
  350.                         {
  351.                                 this.isNew = true;
  352.                         }
  353.                 }
  354.  
  355.                 /// <summary>
  356.                 /// Returns a Data Transfer Object of this AspnetPaths.
  357.                 /// </summary>
  358.                 /// <returns>A Data Transfer Object of this AspnetPaths.</returns>
  359.                 public virtual AspnetPathsDTO GetDTO()
  360.                 {
  361.                         AspnetPathsDTO dto = new AspnetPathsDTO();
  362.  
  363.                         dto.Applicationid = this.Applicationid;
  364.                         dto.Pathid = this.Pathid;
  365.                         dto.Path = this.Path;
  366.                         dto.Loweredpath = this.Loweredpath;
  367.  
  368.                         return dto;
  369.                 }
  370.  
  371.                 /// <summary>
  372.                 /// Applies a Data Transfer Object data to this AspnetPaths.
  373.                 /// </summary>
  374.                 /// <param name="dto">The Data Transfer Object.</param>
  375.                 public virtual void SetDTO(AspnetPathsDTO dto)
  376.                 {
  377.                         this.Applicationid = dto.Applicationid;
  378.                         this.Pathid = dto.Pathid;
  379.                         this.Path = dto.Path;
  380.                         this.Loweredpath = dto.Loweredpath;
  381.                 }
  382.  
  383.                 /// <summary>
  384.                 /// Perfoms a query on AspnetPaths objects.
  385.                 /// </summary>
  386.                 /// <param name="command">An IDbCommand containing the select statement.</param>
  387.                 /// <returns>A result list of AspnetPaths objects.</returns>
  388.                 internal static IList<AspnetPaths> Query(IDbCommand command)
  389.                 {
  390.                         command.Connection = PersistenceManager.Connection;
  391.                         command.Transaction = PersistenceManager.Transaction;
  392.  
  393.                         bool connWasClosed =
  394.                         PersistenceManager.Connection.State.Equals(ConnectionState.Closed) ||
  395.                         PersistenceManager.Connection.State.Equals(ConnectionState.Broken);
  396.  
  397.                         try
  398.                         {
  399.                                 if (connWasClosed)
  400.                                 PersistenceManager.Connection.Open();
  401.  
  402.                                 List<AspnetPaths> list = new List<AspnetPaths>();
  403.                                 IDataReader reader = command.ExecuteReader();
  404.  
  405.                                 using (reader)
  406.                                 {
  407.                                         while (reader.Read())
  408.                                         list.Add(new AspnetPaths(reader));
  409.                                 }
  410.  
  411.                                 if (connWasClosed)
  412.                                 PersistenceManager.Connection.Close();
  413.  
  414.                                 return list;
  415.                         }
  416.                         catch (Exception ex)
  417.                         {
  418.                                 if (connWasClosed)
  419.                                 PersistenceManager.Connection.Close();
  420.                                 throw ex;
  421.                         }
  422.                 }
  423.  
  424.                 /// <summary>
  425.                 /// Finds all AspnetPaths objects with a certain Applicationid value.
  426.                 /// </summary>
  427.                 /// <param name="applicationid">The Applicationid value.</param>
  428.                 /// <returns>All AspnetPaths objects with a certain Applicationid value.</returns>
  429.                 public static IList<AspnetPaths> FindByApplicationid(Guid applicationid)
  430.                 {
  431.                         return AspnetPaths.Query(AspnetPathsCommands.FindByApplicationid(applicationid));
  432.                 }
  433.  
  434.                 /// <summary>
  435.                 /// Finds all AspnetPaths objects with a certain Path value.
  436.                 /// </summary>
  437.                 /// <param name="path">The Path value ('*' can be used as a wildcard).</param>
  438.                 /// <returns>All AspnetPaths objects with a certain Path value.</returns>
  439.                 public static IList<AspnetPaths> FindByPath(string path)
  440.                 {
  441.                         return AspnetPaths.Query(AspnetPathsCommands.FindByPath(path));
  442.                 }
  443.  
  444.                 /// <summary>
  445.                 /// Finds all AspnetPaths objects with a certain Loweredpath value.
  446.                 /// </summary>
  447.                 /// <param name="loweredpath">The Loweredpath value ('*' can be used as a wildcard).</param>
  448.                 /// <returns>All AspnetPaths objects with a certain Loweredpath value.</returns>
  449.                 public static IList<AspnetPaths> FindByLoweredpath(string loweredpath)
  450.                 {
  451.                         return AspnetPaths.Query(AspnetPathsCommands.FindByLoweredpath(loweredpath));
  452.                 }
  453.  
  454.         }
  455. }
Share

Leave a Reply

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>