How to: Convert a string to an int (C# Programming Guide)

These examples show some different ways you can convert a string to an int. Such a conversion can be useful when obtaining numerical input from a command line argument, for example. Similar methods exist for converting strings to other numeric types, such as float or long. The table below lists some of those methods.

Numeric Type	Method
decimal	ToDecimal(String)
float	ToSingle(String)
double	ToDouble(String)
short	ToInt16(String)
int	ToInt32(String)
long	ToInt64(String)
ushort	ToUInt16(String)
uint	ToUInt32(String)
ulong	ToUInt64(String)

This example calls the ToInt32(String) method to convert an input string to an int . The program catches the two most common exceptions that can be thrown by this method, FormatException and OverflowException. If the number can be incremented without overflowing the integer storage location, the program adds 1 to the result and prints the output.

static void Main(string[] args)
{
    int numVal = -1;
    bool repeat = true;

    while (repeat == true)
    {
        Console.WriteLine("Enter a number between −2,147,483,648 and +2,147,483,647 (inclusive).");

        string input = Console.ReadLine();

        // ToInt32 can throw FormatException or OverflowException. 
        try
        {
            numVal = Convert.ToInt32(input);
        }
        catch (FormatException e)
        {
            Console.WriteLine("Input string is not a sequence of digits.");
        }
        catch (OverflowException e)
        {
            Console.WriteLine("The number cannot fit in an Int32.");
        }
        finally
        {
            if (numVal < Int32.MaxValue)
            {
                Console.WriteLine("The new value is {0}", numVal + 1);
            }
            else
            {
                Console.WriteLine("numVal cannot be incremented beyond its current value");
            }
        }
        Console.WriteLine("Go again? Y/N");
        string go = Console.ReadLine();
        if (go == "Y" || go == "y")
        {
            repeat = true;
        }
        else
        {
            repeat = false;
        }
    }
    // Keep the console open in debug mode.
    Console.WriteLine("Press any key to exit.");
    Console.ReadKey();    
}
// Sample Output: 
// Enter a number between -2,147,483,648 and +2,147,483,647 (inclusive). 
// 473 
// The new value is 474 
// Go again? Y/N 
// y 
// Enter a number between -2,147,483,648 and +2,147,483,647 (inclusive). 
// 2147483647 
// numVal cannot be incremented beyond its current value 
// Go again? Y/N 
// Y 
// Enter a number between -2,147,483,648 and +2,147,483,647 (inclusive). 
// -1000 
// The new value is -999 
// Go again? Y/N 
// n 
// Press any key to exit.

Another way of converting a string to an int is through the Parse or TryParse methods of the System.Int32 struct. The ToUInt32 method uses Parse internally. If the string is not in a valid format, Parse throws an exception whereas TryParse does not throw an exception but returns false. The examples below demonstrate both successful and unsuccessful calls to Parse and TryParse.

int numVal = Int32.Parse("-105");
Console.WriteLine(numVal);
// Output: -105

// TryParse returns true if the conversion succeeded 
// and stores the result in the specified variable. 
int j;
bool result = Int32.TryParse("-105", out j);
if (true == result)
    Console.WriteLine(j);
else
    Console.WriteLine("String could not be parsed.");
// Output: -105

try
{
    int m = Int32.Parse("abc");
}
catch (FormatException e)
{
    Console.WriteLine(e.Message);
}
// Output: Input string was not in a correct format.

string inputString = "abc";
int numValue;
bool parsed = Int32.TryParse(inputString, out numValue);

if (!parsed)
    Console.WriteLine("Int32.TryParse could not parse '{0}' to an int.\n", inputString);

// Output: Int32.TryParse could not parse 'abc' to an int.

LINQ to Datatable

private static DataTable JoinDataTablesWithLinq()
    {
    var query = from inv in _tblInvoice.AsEnumerable()
                join item in _tblLineItem.AsEnumerable()
                    on inv["InvoiceId"] equals item["InvoiceId"]
                select new
                        {
                            CustomerName = inv["CustomerName"],
                            ItemName = item["ItemName"],
                            Quantity = item["Quantity"]
                        };
 
    return query.CopyToDataTable();
    }

LINQ TO DATATABLE EXAMPLE:

public DataTable LINQToDataTable<T>(IEnumerable<T> varlist)
{ DataTable dtReturn = new DataTable();
// column names PropertyInfo[] oProps = null;

     if (varlist == null) return dtReturn;     foreach (T rec in varlist)
     {          // Use reflection to get property names, to create table, Only first time, others
          will follow           if (oProps == null)
          {
               oProps = ((Type)rec.GetType()).GetProperties();               foreach (PropertyInfo pi in oProps)
               {                    Type colType = pi.PropertyType;                    if ((colType.IsGenericType) && (colType.GetGenericTypeDefinition()                          ==typeof(Nullable<>)))
                     {
                         colType = colType.GetGenericArguments()[0];
                     }

                    dtReturn.Columns.Add(new DataColumn(pi.Name, colType));
               }
          }          DataRow dr = dtReturn.NewRow();          foreach (PropertyInfo pi in oProps)
          {
               dr[pi.Name] = pi.GetValue(rec, null) == null ?DBNull.Value :pi.GetValue               (rec,null);
          }

          dtReturn.Rows.Add(dr);
     }     return dtReturn;
}

Another way to convert linq to data table

public DataTable ToDataTable(System.Data.Linq.DataContext ctx, object query){     if (query == null)
     {          throw new ArgumentNullException("query");
     }     
     IDbCommand cmd = ctx.GetCommand(query as IQueryable);     SqlDataAdapter adapter = new SqlDataAdapter();
     adapter.SelectCommand = (SqlCommand)cmd;     DataTable dt = new DataTable("sd");
     try     {
          cmd.Connection.Open();
          adapter.FillSchema(dt, SchemaType.Source); 
          adapter.Fill(dt);
     }     finally     {
          cmd.Connection.Close();     }     return dt;
}

Another way using linq to conversion


var vrCountry = from country in objEmpDataContext.CountryMaster
                        select new {country.CountryID,country.CountryName}; 

DataTable dt = LINQToDataTable(objEmpDataContext,vrCountry);

To implement the custom CopyToDataTable<T> methods in your application

 public class ObjectShredder<T>
{
    private System.Reflection.FieldInfo[] _fi;
    private System.Reflection.PropertyInfo[] _pi;
    private System.Collections.Generic.Dictionary<string, int> _ordinalMap;
    private System.Type _type;

    // ObjectShredder constructor.
    public ObjectShredder()
    {
        _type = typeof(T);
        _fi = _type.GetFields();
        _pi = _type.GetProperties();
        _ordinalMap = new Dictionary<string, int>();
    }

    /// <summary>
    /// Loads a DataTable from a sequence of objects.
    /// </summary>
    /// <param name="source">The sequence of objects to load into the DataTable.</param>
    /// <param name="table">The input table. The schema of the table must match that 
    /// the type T.  If the table is null, a new table is created with a schema 
    /// created from the public properties and fields of the type T.</param>
    /// <param name="options">Specifies how values from the source sequence will be applied to 
    /// existing rows in the table.</param>
    /// <returns>A DataTable created from the source sequence.</returns>
    public DataTable Shred(IEnumerable<T> source, DataTable table, LoadOption? options)
    {
        // Load the table from the scalar sequence if T is a primitive type.
        if (typeof(T).IsPrimitive)
        {
            return ShredPrimitive(source, table, options);
        }

        // Create a new table if the input table is null.
        if (table == null)
        {
            table = new DataTable(typeof(T).Name);
        }

        // Initialize the ordinal map and extend the table schema based on type T.
        table = ExtendTable(table, typeof(T));

        // Enumerate the source sequence and load the object values into rows.
        table.BeginLoadData();
        using (IEnumerator<T> e = source.GetEnumerator())
        {
            while (e.MoveNext())
            {
                if (options != null)
                {
                    table.LoadDataRow(ShredObject(table, e.Current), (LoadOption)options);
                }
                else
                {
                    table.LoadDataRow(ShredObject(table, e.Current), true);
                }
            }
        }
        table.EndLoadData();

        // Return the table.
        return table;
    }

    public DataTable ShredPrimitive(IEnumerable<T> source, DataTable table, LoadOption? options)
    {
        // Create a new table if the input table is null.
        if (table == null)
        {
            table = new DataTable(typeof(T).Name);
        }

        if (!table.Columns.Contains("Value"))
        {
            table.Columns.Add("Value", typeof(T));
        }

        // Enumerate the source sequence and load the scalar values into rows.
        table.BeginLoadData();
        using (IEnumerator<T> e = source.GetEnumerator())
        {
            Object[] values = new object[table.Columns.Count];
            while (e.MoveNext())
            {
                values[table.Columns["Value"].Ordinal] = e.Current;

                if (options != null)
                {
                    table.LoadDataRow(values, (LoadOption)options);
                }
                else
                {
                    table.LoadDataRow(values, true);
                }
            }
        }
        table.EndLoadData();

        // Return the table.
        return table;
    }        

    public object[] ShredObject(DataTable table, T instance)
    {

        FieldInfo[] fi = _fi;
        PropertyInfo[] pi = _pi;

        if (instance.GetType() != typeof(T))
        {
            // If the instance is derived from T, extend the table schema
            // and get the properties and fields.
            ExtendTable(table, instance.GetType());
            fi = instance.GetType().GetFields();
            pi = instance.GetType().GetProperties();
        }

        // Add the property and field values of the instance to an array.
        Object[] values = new object[table.Columns.Count];
        foreach (FieldInfo f in fi)
        {
            values[_ordinalMap[f.Name]] = f.GetValue(instance);
        }

        foreach (PropertyInfo p in pi)
        {
            values[_ordinalMap[p.Name]] = p.GetValue(instance, null);
        }

        // Return the property and field values of the instance.
        return values;
    }

    public DataTable ExtendTable(DataTable table, Type type)
    {
        // Extend the table schema if the input table was null or if the value 
        // in the sequence is derived from type T.            
        foreach (FieldInfo f in type.GetFields())
        {
            if (!_ordinalMap.ContainsKey(f.Name))
            {
                // Add the field as a column in the table if it doesn't exist
                // already.
                DataColumn dc = table.Columns.Contains(f.Name) ? table.Columns[f.Name]
                    : table.Columns.Add(f.Name, f.FieldType);

                // Add the field to the ordinal map.
                _ordinalMap.Add(f.Name, dc.Ordinal);
            }
        }
        foreach (PropertyInfo p in type.GetProperties())
        {
            if (!_ordinalMap.ContainsKey(p.Name))
            {
                // Add the property as a column in the table if it doesn't exist
                // already.
                DataColumn dc = table.Columns.Contains(p.Name) ? table.Columns[p.Name]
                    : table.Columns.Add(p.Name, p.PropertyType);

                // Add the property to the ordinal map.
                _ordinalMap.Add(p.Name, dc.Ordinal);
            }
        }

        // Return the table.
        return table;
    }
}

 public static class CustomLINQtoDataSetMethods
{
    public static DataTable CopyToDataTable<T>(this IEnumerable<T> source)
    {
        return new ObjectShredder<T>().Shred(source, null, null);
    }

    public static DataTable CopyToDataTable<T>(this IEnumerable<T> source,
                                                DataTable table, LoadOption? options)
    {
        return new ObjectShredder<T>().Shred(source, table, options);
    }

}

 Convert datatable to list

STEP 1:

  List<MyClassObject> liMyClassObject=myConvesionObject.GetDetails(yourdatatable);

 STEP 2:

class myConvesionObject

 public List<MyClassObject> GetDetails(DataTable dtDetails)
        {
            return MyConversionClass.ConvertToList<MyClassObject>(dtDetails);
        }

STEP 3:  my conversion class

 public static class MyConversionClass
    {
       /// <summary>
       /// Convert DataTable ToList
       /// </summary>
       /// <typeparam name="T"></typeparam>
       /// <param name="table"></param>
       /// <returns></returns>
        public static List<T> ConvertToList<T>(this DataTable table) where T : new()
        {
            Type t = typeof(T);

            // Create a list of the entities we want to return
            List<T> returnObject = new List<T>();

            // Iterate through the DataTable's rows
            foreach (DataRow dr in table.Rows)
            {
                // Convert each row into an entity object and add to the list
                T newRow = dr.ConvertToEntity<T>();
                returnObject.Add(newRow);
            }

            // Return the finished list
            return returnObject;
        }
       /// <summary>
       /// ConvertTo Entity
       /// </summary>
       /// <typeparam name="T"></typeparam>
       /// <param name="tableRow"></param>
       /// <returns></returns>
        public static T ConvertToEntity<T>(this DataRow tableRow) where T : new()
        {
            // Create a new type of the entity I want
            Type t = typeof(T);
            T returnObject = new T();

            foreach (DataColumn col in tableRow.Table.Columns)
            {
                string colName = col.ColumnName;

                // Look for the object's property with the columns name, ignore case
                PropertyInfo pInfo = t.GetProperty(colName.ToUpper(),
                    BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance);

                // did we find the property ?
                if (pInfo != null)
                {
                    object val = tableRow[colName];

                    // is this a Nullable<> type
                    bool IsNullable = (Nullable.GetUnderlyingType(pInfo.PropertyType) != null);
                    if (IsNullable)
                    {
                        if (val is System.DBNull)
                        {
                            val = null;
                        }
                        else
                        {
                            // Convert the db type into the T we have in our Nullable<T> type
                            val = Convert.ChangeType
                    (val, Nullable.GetUnderlyingType(pInfo.PropertyType));
                        }
                    }
                    else
                    {
                        // Convert the db type into the type of the property in our entity
                        val = Convert.ChangeType(val, pInfo.PropertyType);
                    }
                    // Set the value of the property with the value from the db
                    pInfo.SetValue(returnObject, val.ToString().Trim().ToUpper(), null); 

                    //pInfo.SetValue(returnObject, val.ToString().ToUpper(), null);
                }
            }

            // return the entity object with values
            return returnObject;
        }
        /// <summary>
        /// Convert DataRow[]  ToList
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="table"></param>
        /// <returns></returns>
        public static List<T> ConvertToList<T>(this DataRow[] dtRows) where T : new()
        {
            Type t = typeof(T);

            // Create a list of the entities we want to return
            List<T> returnObject = new List<T>();

            // Iterate through the DataTable's rows
            foreach (DataRow dr in dtRows)
            {
                // Convert each row into an entity object and add to the list
                T newRow = dr.ConvertToEntity<T>();
                returnObject.Add(newRow);
            }

            // Return the finished list
            return returnObject;
        }
        public static List<EntityClass> ConvertGridEntity<T>(this List<T> liValues, int Pno, int RecPage, List<string> listr) where T : new()
        {

            Type t = typeof(T);
            Type Et = typeof(EntityClass);
            // Create a list of the entities we want to return
            List<EntityClass> returnObject = new List<EntityClass>();
            Type gType = typeof(T);
            int licount = liValues.Count;
            int StartInd = ((Pno) * RecPage + 1);
            int EndInd = Convert.ToInt32(((Pno + 1) * RecPage) > licount ? licount : ((Pno + 1) * RecPage));
            for (int ind = StartInd; ind <= EndInd; ind++)
            {
                T genType = liValues[ind - 1];
                EntityClass EC = new EntityClass();
                PropertyInfo[] EntitypropInfo = EC.GetType().GetProperties();
                //EntityClass E = new EntityClass();
                PropertyInfo[] propInfo = genType.GetType().GetProperties();




                Array.Sort(propInfo, new DeclarationOrderComparator());
    
                int j = 0;
                foreach (string str in listr)
                {
                    int i = Convert.ToInt32(str);
                    j = j + 1;
                    if (!string.IsNullOrEmpty(string.Format("{0}", propInfo[i].GetValue(genType, null)))&&j<16)
                    {
                        var value = propInfo[i].GetValue(genType, null).ToString().ToUpper();
                        // Look for the object's property with the columns name, ignore case
                     
                        PropertyInfo pInfo = Et.GetProperty("C" + j + "",
                        BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance);

                      
                        //pInfo.SetValue(genType, value, i);
                        pInfo.SetValue(EC, value, null);

                    }
                }
                returnObject.Add(EC);
            }

            // Return the finished list
            return returnObject;
        }
       
    }
   public class DeclarationOrderComparator : IComparer
   {
       int IComparer.Compare(Object x, Object y)
       {
           PropertyInfo first = x as PropertyInfo;
           PropertyInfo second = y as PropertyInfo;
           if (first.MetadataToken < second.MetadataToken)
               return -1;
           else if (first.MetadataToken > second.MetadataToken)
               return 1;

           return 0;
       }
   }

LIST TO XML CONVETIONS

STEP 1:

List<myListClass> mylistObjects=new  List<myListClass>();

string mystringxml=myclassconversion.PrepareSaveXml(mylistObjects)

STEP 2:

class myclassconversion

  public string PrepareSaveXml(List<myListClass> liValues)
        {
            return ListToXMLCLass.GetXml<myListClass>(liValues, "RootNode", "ChildNode");
        }

STEP 3:

 public static class ListToXMLCLass
    {
        /// <summary>
        /// Preparing Save XML string with GenericType
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="liValues"></param>
        /// <param name="parentRoot"></param>
        /// <param name="childRoot"></param>
        /// <returns></returns>
        public static string GetXml<T>(List<T> liValues,string parentRoot,string childRoot)
        {
            XDocument xDoc = new XDocument();
            var partentRoot = new XElement(parentRoot);
           
            foreach (T genType in liValues)
            {
                PropertyInfo[] propInfo = genType.GetType().GetProperties();
                var childroot = new XElement(childRoot);
                foreach (PropertyInfo prop in propInfo)
                {
                    if (prop.PropertyType.FullName.ToUpper() == typeof(System.String).ToString().ToUpper() || prop.PropertyType.FullName.ToUpper() == typeof(System.Int32).ToString().ToUpper() || prop.PropertyType.FullName.ToUpper() == typeof(System.Double).ToString().ToUpper())
                    {
                        if (prop.Name.ToLower() != "parentrootnode" && prop.Name.ToLower() != "parentnode" && prop.Name.ToLower() != "childnode")
                        {
                            if (!string.IsNullOrEmpty(string.Format("{0}", prop.GetValue(genType, null))))
                                childroot.SetAttributeValue(prop.Name, GTKString.ToEscapeSpecialChars(prop.GetValue(genType, null).ToString()));
                        }
                    }
                }
                 partentRoot.Add(childroot);
             }
            xDoc.Add(partentRoot);
            return xDoc.ToString();
         }

        public static XElement GetEntityXml<T>(T genClass, string RootNode)
        {
            XDocument xDoc = new XDocument();
            PropertyInfo[] propInfo = genClass.GetType().GetProperties();
            var childroot = new XElement(RootNode);
            foreach (PropertyInfo prop in propInfo)
            {
                if (prop.Name.ToLower() != "parentrootnode" && prop.Name.ToLower() != "parentnode" && prop.Name.ToLower() != "childnode")
                {
                    if (!string.IsNullOrEmpty(string.Format("{0}", prop.GetValue(genClass, null))))
                        childroot.SetAttributeValue(prop.Name, GTKString.ToEscapeSpecialChars(prop.GetValue(genClass, null).ToString()));
                }
            }
//
            xDoc.Add(childroot);
            return childroot;
        }
    }

TECHNICAL GUIDE

Specializations

Tuesday, November 20, 2012

conversion methods in c#.net

How to: Convert a string to an int (C# Programming Guide)

To implement the custom CopyToDataTable<T> methods in your application

No comments:

Post a Comment

Popular Posts