/// <summary>
/// Class of static methods to work with System.Type.
/// </summary>
public static class Types {
  
  /// <summary>
  /// Helper method to convert a type to another type.
  /// Note how this is slightly better than the traditional
  /// 'ConvertTo' method, which returns all as an object that 
  /// then needs to be boxed.
  /// </summary>
  /// <remarks>
  /// <para>
  /// Can accept <c>null</c> and <c>DbNull.Value</c> 
  /// (returns <c>null</c>).
  /// </para>
  /// <para>
  /// Note: 
  /// Converts Guid using ToString("D") format, 
  /// and can recreate Guid from string
  /// in all Formats.
  /// </para>
  /// </remarks>
  /// <param name="value">The value.</param>
  /// <returns></returns>
  public static TOut ConvertTo<TIn, TOut>(TIn value) {
    return (TOut)ConvertTo(value, typeof(TOut));
  }

  /// <summary>
  /// Converts a value from given type to a destination type.
  /// </summary>
  /// <remarks>
  /// <para>
  /// Can accept <c>null</c> and <c>DbNull.Value</c> 
  /// (returns <c>null</c>).
  /// </para>
  /// <para>
  /// Note: 
  /// Converts Guid using ToString("D") format, 
  /// and can recreate Guid from string
  /// in all Formats.
  /// </para>
  /// </remarks>
  /// <param name="value">The value to convert.</param>
  /// <returns>The value converted to the destination type.</returns>
  public static destinationT ConvertTo<destinationT>(object value) {
    return (destinationT)ConvertTo(value, typeof(destinationT));
  }


  /// <summary>
  /// Converts a value from given type to a destination type.
  /// </summary>
  /// <remarks>
  /// <para>
  /// Can accept <c>null</c> and <c>DbNull.Value</c> 
  /// (returns <c>null</c>).
  /// </para>
  /// <para>
  /// Note: 
  /// Converts Guid using ToString("D") format, 
  /// and can recreate Guid from string
  /// in all Formats.
  /// </para>
  /// </remarks>
  /// <param name="value">The value to convert.</param>
  /// <param name="destinationType">The destination Type wanted.</param>
  /// <returns>The value converted to the destination type.</returns>
  public static object ConvertTo(object value, Type destinationType) {

    if ((value == null) || (value == DBNull.Value)) {
      //The pre-generics equivalent of default(T):
      //Remark: strings are not ValueType, so are returned as null.
      //Remark: Guid are ValueType, so are returned as Guid.Empty.
      //Remark: int are ValueType, so are returned as Int32.Empty.
      return (destinationType.IsValueType) ? 
        System.Activator.CreateInstance(destinationType) 
        :
        null;
    }

    //Value is not null, so safe to get type:
    Type srcType = value.GetType();

    if (srcType == typeof(string)){
          if (destinationType == typeof(string)) {
            //Don't change the normal behavior then...
            //AND 
            //Might as well get out early...
            return value;
          }
        if (string.IsNullOrEmpty((string)value)) {
          //Empty string... Hum...
          //But being converted to a string, or something else?
            //But if going to be converted........
            //Much better results to let it decide from a null, 
            //rather than choke on an empty string:
            value = null;
          }
        else{
            //we know its not going to be a string
            //so trim it:
            value = ((string)value).Trim();
        }
    }


#if (!CE) && (!PocketPC) && (!pocketPC) && (!WindowsCE)
    //PC:
    //Unfortunately TypeConverter is not on CF...

    TypeConverter tc =
      TypeDescriptor.GetConverter(destinationType);


    if (tc.CanConvertFrom(srcType)) {
      try {
        return tc.ConvertFrom(value);
      }
      catch {
        return (destinationType.IsValueType) 
        ? 
        System.Activator.CreateInstance(destinationType) 
        : 
        null;
      }
    }

    tc = TypeDescriptor.GetConverter(srcType);

    if (tc.CanConvertTo(destinationType)) {
      return tc.ConvertTo(value, destinationType);
    }
#endif

    try {
      return System.Convert.ChangeType(
          value, 
          destinationType, 
          null);
    }
    catch {
    }

    //Ok  so we failed doing it the simplest way...
    //But is there a constructor that we can use?
    //For example, Version (which is a class) 
    //can take a string arg:
    System.Reflection.ConstructorInfo constructorInfo =
      destinationType.GetConstructor(new Type[] { srcType });
    if (constructorInfo != null) {
      try {
        return constructorInfo.Invoke(new object[] { value });
      }
      catch {
      }
    }
    return (destinationType.IsValueType) 
        ? 
        System.Activator.CreateInstance(destinationType) 
        : 
        null;

    //return System.Convert.ChangeType(
//        value, 
 //       destinationType, 
   //     null);
  }
}//Class:End

public enum Stuff {
 One, 
 Two, 
 Three
}

class Program
{
 static void Main()
 {
  try
  {
   List<object[]> argsAll = new List<object[]>();
   argsAll.Add(null);
   argsAll.Add(new object[] {typeof(int),null});
   argsAll.Add(new object[] {typeof(int),DBNull.Value});
   argsAll.Add(new object[] {typeof(int),string.Empty});
   argsAll.Add(new object[] {typeof(int),"0"});
   argsAll.Add(new object[] {typeof(int),"13"});
    argsAll.Add(new object[] {typeof(int),"13 "});
    argsAll.Add(new object[] {typeof(int)," 13"});
    argsAll.Add(new object[] {typeof(int),"13.25"});
    argsAll.Add(new object[] {typeof(int),13});
    argsAll.Add(new object[] {typeof(int),13.24});

    argsAll.Add(null);
    argsAll.Add(new object[] {typeof(double),null});
    argsAll.Add(new object[] {typeof(double),DBNull.Value});
    argsAll.Add(Read More »
          
        
  
        

          

          	
            Comments (0)
            
          
          
          

            
            
            
            
             
 
        
      

Type type = typeof(TraceListenerCollection);

ConstructorInfo constructor = 
    type.GetConstructor(
        BindingFlags.Instance | BindingFlags.NonPublic, 
        null, 
        new Type[] {}, 
        null);

        
TraceListenerCollection instance = 
    (TraceListenerCollection)
      constructor.Invoke(new object[0]{});