// Create new instance of t type
  t obj = Activator.CreateInstance<t>();

  // Filter: do not include any EntitySet properties
  IEnumerable<PropertyInfo> pic = obj.GetType().GetProperties().Where( p => !p.PropertyType.Name.Contains( "EntitySet" ) );

  // Iterate through valid properties
  foreach( PropertyInfo pi in pic ) {
   string propname = pi.Name.ToLower();
   bool matchFound = false;

   // Iterate through form values
   foreach( string s in formPost.AllKeys ) {
    if( matchFound ) break;

    string formname = s.ToLower();

    if( formname.EndsWith( "_" + propname ) || formname.EndsWith( "$" + propname ) || formname.Equals( propname ) ) {
     // Match - set value
     string fval = (formPost[s].Length == 0) ? null : formPost[s];
     matchFound = true;

     try {
      pi.SetValue( obj, ChangeType( fval, pi.PropertyType ), null );
     } catch( Exception ex ) {
      if( catchException ) throw ex;
     }
    }
   }
  }

  return obj;
 }

 /// <summary>
 /// Returns an Object with the specified Type and whose value is equivalent to the specified object.
 /// </summary>
 /// <param name="value">An Object that implements the IConvertible interface.</param>
 /// <param name="conversionType">The Type to which value is to be converted.</param>
 /// <returns>An object whose Type is conversionType (or conversionType's underlying type if conversionType
 /// is Nullable&lt;&gt;) and whose value is equivalent to value. -or- a null reference, if value is a null
 /// reference and conversionType is not a value type.</returns>
 /// <remarks>
 /// This method exists as a workaround to System.Convert.ChangeType(Object, Type) which does not handle
 /// nullables as of version 2.0 (2.0.50727.42) of the .NET Framework. The idea is that this method will
 /// be deleted once Convert.ChangeType is updated in a future version of the .NET Framework to handle
 /// nullable types, so we want this to behave as closely to Convert.ChangeType as possible.
 /// This method was written by Peter Johnson at:
 /// http://aspalliance.com/author.aspx?uId=1026.
 /// </remarks>
 public static object ChangeType( object value, Type conversionType )
 {
  // Note: This if block was taken from Convert.ChangeType as is, and is needed here since we're
  // checking properties on conversionType below.
  if( conversionType == null ) {
   throw new ArgumentNullException( "conversionType" );
  } // end if

  // If it's not a nullable type, just pass through the parameters to Convert.ChangeType

  if( conversionType.IsGenericType &&
    conversionType.GetGenericTypeDefinition().Equals( typeof( Nullable<> ) ) ) {
   // It's a nullable type, so instead of calling Convert.ChangeType directly which would throw a
   // InvalidCastException (per http://weblogs.asp.net/pjohnson/archive/2006/02/07/437631.aspx),
   // determine what the underlying type is
   // If it's null, it won't convert to the underlying type, but that's fine since nulls don't really
   // have a type--so just return null
   // Note: We only do this check if we're converting to a nullable type, since doing it outside
   // would diverge from Convert.ChangeType's behavior, which throws an InvalidCastException if
   // value is null and conversionType is a value type.
   if( value == null ) {
    return null;
   } // end if

   // It's a nullable type, and not null, so that means it can be converted to its underlying type,
   // so overwrite the passed-in conversion type with this underlying type
   NullableConverter nullableConverter = new NullableConverter( conversionType );
   conversionType = nullableConverter.UnderlyingType;
  } // end if

  // Now that we've guaranteed conversionType is something Convert.ChangeType can handle (i.e. not a
  // nullable type), pass the call on to Convert.ChangeType
  return Convert.ChangeType( value, conversionType );
 }