kamagra how much to take

AspnetSchemaversions Partial Class

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