coply datatable to another table specific column in C#

 string[] selectedColumns = new[]
            {
               // "Title",
                "FirstName",
                //"MiddleName", "LastName", "Suffix", "Company", "InformalSalutation", "FormalSalutation",
                //"AddressName",
                "Address1","Address2"
                //,"City","State","Zip","Country"
                };
            DataTable dtTest = new DataView(dataTable1).ToTable(false, selectedColumns);

convert from csv to datatable

for  TextFieldParser

we need to add dll
Microsoft.VisualBasic

/// <summary>
        /// GetDataTabletFromCSVFile
        /// </summary>
        /// <param name="fileImportCriteria"></param>
        /// <returns></returns>
        private static DataTable GetDataTabletFromCsvFile(FileImportCriteriaModel fileImportCriteria)
        {
            DataTable csvData = new DataTable();
            try
            {
                using (TextFieldParser csvReader = new TextFieldParser(fileImportCriteria.FilePath))
                {
                    csvReader.SetDelimiters(new string[] { fileImportCriteria.ManualDelimiter });
                    csvReader.HasFieldsEnclosedInQuotes = true;
                    string[] colFields = csvReader.ReadFields();
                    foreach (string column in colFields)
                    {
                        DataColumn datecolumn = new DataColumn(column);
                        datecolumn.AllowDBNull = true;
                        csvData.Columns.Add(datecolumn);
                    }
                    while (!csvReader.EndOfData)
                    {
                        string[] fieldData = csvReader.ReadFields();
                        //Making empty value as null
                        for (int i = 0; i < fieldData.Length; i++)
                        {
                            if (fieldData[i] == "")
                            {
                                fieldData[i] = null;
                            }
                        }
                        csvData.Rows.Add(fieldData);
                    }
                }
            }
            catch (System.Exception ex)
            {
            }
            return csvData;
        }

ReadXmlFile

  public FileDataModel ReadXmlFile(string filePath)
        {
            try
            {
                if (!File.Exists(filePath))
                {
                    throw new PersistenceValidationException("Validation Error",
                        new List<BrokenRule>
                        {
                            new BrokenRule(BrokenRuleEnum.Data.ToStringValue(), "FileUpload", "File not found.")
                        });
                }

                XElement xele = XElement.Load(filePath); //get your file
                // declare a new DataTable and pass your XElement to it
                DataTable dataTable1 = XElementToDataTable(xele);
              
                // Convert From Table To Object
                var fileDataModel = ConvertFromTableToObject(dataTable1);
               return fileDataModel;
            }
            catch (XmlException)
            {
                throw new PersistenceValidationException("Validation Error", new List<BrokenRule>
                {
                    new BrokenRule("InvalidXml", "Invalid Xml file")
                });
            }
        }

------------------
 public DataTable XElementToDataTable(XElement x)
        {
            DataTable dtable = new DataTable();
            XElement setup = (from p in x.Descendants() select p).First();
            // build your DataTable
            foreach (XElement xe in setup.Descendants())
                dtable.Columns.Add(new DataColumn(xe.Name.ToString(), typeof(string))); // add columns to your dt
            var all = from p in x.Descendants(setup.Name.ToString()) select p;
            foreach (XElement xe in all)
            {
                DataRow dr = dtable.NewRow();
                foreach (XElement xe2 in xe.Descendants())
                    dr[xe2.Name.ToString()] = xe2.Value; //add in the values
                dtable.Rows.Add(dr);
            }
            return dtable;
        }

------------------

 private static FileDataModel ConvertFromTableToObject(DataTable dataTable1)
        {
            var fileDataModel = new FileDataModel();
            var listDataResult = new List<List<FieldImports>>();
            var columnList = new List<FieldImports>();
            for (var columnIndex = 0; columnIndex < dataTable1.Columns.Count; columnIndex++)
            {
                var result = new FieldImports();
                result.ColumnName = Convert.ToString(dataTable1.Columns[columnIndex]);
                columnList.Add(result);
            }
            for (var rowIndex = 0; rowIndex < dataTable1.Rows.Count; rowIndex++)
            {
                var fileData = new List<FieldImports>();
                for (var columnIndex = 0; columnIndex < dataTable1.Columns.Count; columnIndex++)
                {
                    var result = new FieldImports();
                    result.ColumnValue = Convert.ToString(dataTable1.Rows[rowIndex][columnIndex]);
                    fileData.Add(result);
                }
                listDataResult.Add(fileData);
            }
            fileDataModel.fileData = listDataResult;
            fileDataModel.columnList = columnList;
            return fileDataModel;
        }



 

ReadExcelFile

public FileDataModel ReadExcelFile(FileImportCriteriaModel fileImportCriteria)
        {
            var fileDataModel = new FileDataModel();
            var dataTable1 = new DataTable();
            using (SpreadsheetDocument spreadSheetDocument = SpreadsheetDocument.Open(fileImportCriteria.FilePath, false))
            {
                var worksheetPart = (WorksheetPart)spreadSheetDocument.WorkbookPart.GetPartById("rId7");
                var workSheet = worksheetPart.Worksheet;
                var sheetData = workSheet.GetFirstChild<SheetData>();
                IEnumerable<Row> rows = sheetData.Descendants<Row>();
                foreach (Cell cell in rows.ElementAt(0))
                {
                    dataTable1.Columns.Add(GetCellValue(spreadSheetDocument, cell));
                }
                foreach (Row row in rows)
                {
                    DataRow dataRow = dataTable1.NewRow();
                    for (int i = 0; i < row.Descendants<Cell>().Count(); i++)
                    {
                        dataRow[i] = GetCellValue(spreadSheetDocument, row.Descendants<Cell>().ElementAt(i));
                    }
                    dataTable1.Rows.Add(dataRow);
                }
                dataTable1.Rows.RemoveAt(0);
                // Convert From Table To Object
                fileDataModel = ConvertFromTableToObject(dataTable1);
            }
            return fileDataModel;
        }


 private static string GetCellValue(SpreadsheetDocument document, Cell cell)
        {
            var stringTablePart = document.WorkbookPart.SharedStringTablePart;
            string value = cell.CellValue.InnerXml;
            if (cell.DataType != null && cell.DataType.Value == CellValues.SharedString)
            {
                return stringTablePart.SharedStringTable.ChildElements[Int32.Parse(value)].InnerText;
            }
            else
            {
                return value;
            }
        }

ReadTxtFile

 public FileDataModel ReadTxtFile(string filePath)
        {
            string[] textData = System.IO.File.ReadAllLines(filePath);
            string[] headers = textData[0].Split('\t');
            DataTable dataTable1 = new DataTable();
            foreach (string header in headers)
                dataTable1.Columns.Add(header, typeof(string), null);
            for (int i = 1; i < textData.Length; i++)
            {
                dataTable1.Rows.Add(textData[i].Split('\t'));
            }
            var fileDataModel = new FileDataModel();
           
            // Convert From Table To Object
            fileDataModel = ConvertFromTableToObject(dataTable1);
            return fileDataModel;
        }



private static FileDataModel ConvertFromTableToObject(DataTable dataTable1)
        {
            var fileDataModel = new FileDataModel();
            var listDataResult = new List<List<FieldImports>>();
            var columnList = new List<FieldImports>();
            for (var columnIndex = 0; columnIndex < dataTable1.Columns.Count; columnIndex++)
            {
                var result = new FieldImports();
                result.ColumnName = Convert.ToString(dataTable1.Columns[columnIndex]);
                columnList.Add(result);
            }
            for (var rowIndex = 0; rowIndex < dataTable1.Rows.Count; rowIndex++)
            {
                var fileData = new List<FieldImports>();
                for (var columnIndex = 0; columnIndex < dataTable1.Columns.Count; columnIndex++)
                {
                    var result = new FieldImports();
                    result.ColumnValue = Convert.ToString(dataTable1.Rows[rowIndex][columnIndex]);
                    fileData.Add(result);
                }
                listDataResult.Add(fileData);
            }
            fileDataModel.fileData = listDataResult;
            fileDataModel.columnList = columnList;
            return fileDataModel;
        }

generate alphachar in C#

    private class ProgramTest
    {
        private static void Main(string[] args)
        {
            for (int i = 1; i < 100; i++)
            {
                var abc = TestA.GetColumnNameFromIndex(i);
                Console.WriteLine(abc);
            }
      }
}

----------------------

public  class TestA
    {
        public static int Number;
        public static String GetColumnNameFromIndex(int column)
        {
            column--;
            String col = Convert.ToString((char)('A' + (column % 26)));
            while (column >= 26)
            {
                column = (column / 26) - 1;
                col = Convert.ToString((char)('A' + (column % 26))) + col;
            }
            return col;
        }
    }

read txt file data in C# in datatable

public Tuple<List<FieldImports>, bool> ReadTxtFile(string filePath)
        {
            string[] textData = System.IO.File.ReadAllLines(filePath);
            string[] headers = textData[0].Split('\t');
            DataTable dataTable1 = new DataTable();
            foreach (string header in headers)
                dataTable1.Columns.Add(header, typeof(string), null);
            for (int i = 1; i < textData.Length; i++)
            {
                dataTable1.Rows.Add(textData[i].Split('\t'));
            }
            List<FieldImports> listDataColumn1 = new List<FieldImports>();
            var columnNames = dataTable1.Columns.Cast<DataColumn>()
               .Select(c => c.ColumnName)
               .ToList();

            List<FileDataModel> listDataResult = new List<FileDataModel>();
            for (int columnIndex = 0; columnIndex < dataTable1.Columns.Count; columnIndex++)
            {
                List<FieldImports> listData = new List<FieldImports>();
                FieldImports result = new FieldImports();
                // result.ColumnName = dataTable1.Rows[i][i].ToString();
                result.ColumnName = Convert.ToString(dataTable1.Rows[0][columnIndex]);
                listData.Add(result);
            }
            //listDataResult.Add(listData);
            for (int rowIndex = 0; rowIndex < dataTable1.Rows.Count; rowIndex++)
            {
                List<FieldImports> listData = new List<FieldImports>();
                for (int columnIndex = 0; columnIndex < dataTable1.Columns.Count; columnIndex++)
                {
                    FieldImports result = new FieldImports();
                    // result.ColumnName = dataTable1.Rows[i][i].ToString();
                    result.ColumnValue = Convert.ToString(dataTable1.Rows[rowIndex][columnIndex]);
                    listData.Add(result);  
                }
                listDataResult.Add(listData);
            }
        
         // return new Tuple<List<FieldImports>, bool>(columnListData, false);
            return null;
        }
    }

read txt file in C#

public Tuple<List<FieldImports>, bool> ReadTxtFile(string filePath)


{


 string[] textData = System.IO.File.ReadAllLines(filePath);

string[] headers = textData[0].Split('\t');

DataTable dataTable1 = new DataTable();

foreach (string header in headers)

 dataTable1.Columns.Add(header, typeof(string), null);

for (int i = 1; i < textData.Length; i++)


{


 dataTable1.Rows.Add(textData[i].Split('\t'));


}


 // var columnListData = new List<FieldImports>();

// var fileInLines = File.ReadAllLines(filePath);

//// foreach (var line in fileInLines)

// for (var line = 0; line < fileInLines.Length; line++)

// {

// var fileAttributes = fileInLines[0].Split('\t');

// var fieldImportsData = new FieldImports();

// var fieldAttributes = fileInLines[line + 1].Split('\t');

// fieldImportsData.ColumnName = fileAttributes[0];

// //for (var i = 0; i < fileAttributes[i+1].Length; i++)

// //{

// fieldImportsData.ColumnValue = fieldAttributes[line];

// // }

// columnListData.Add(fieldImportsData);

// }

// return new Tuple<List<FieldImports>, bool>(columnListData, false);

return null;


}

Parse XML file in C#

/// <summary>
        /// Parse XML file
        /// </summary>
        /// <param name="filePath"></param>
        public Tuple<List<FieldImports>, bool> ParseXmlFile(string filePath)
        {
            var columnList = new List<FieldImports>();
            try
            {
                if (!File.Exists(filePath))
                {
                    throw new PersistenceValidationException("Validation Error",
                        new List<BrokenRule>
                            {
                                new BrokenRule(BrokenRuleEnum.Data.ToStringValue(), "FileUpload", "File not found.")
                            });
                }
                var xmlDoc = new XmlDocument();
                xmlDoc.Load(filePath);
                if (xmlDoc.DocumentElement != null)
                    foreach (XmlNode xmlNode in xmlDoc.DocumentElement)
                    {
                      
                        //column name
                        var columnsName = xmlNode.Name;
                        //column value
                        var value = xmlNode.InnerText;
                        var fieldImports = new FieldImports
                        {
                            ColumnName = columnsName,
                            ColumnValue = value
                        };
                        columnList.Add(fieldImports);
                    }
                return new Tuple<List<FieldImports>, bool>(columnList, false);
            }
            catch (XmlException)
            {
                throw new PersistenceValidationException("Validation Error", new List<BrokenRule>
                    {
                        new BrokenRule("InvalidXml", "Invalid Xml file")
                    });
            }
        }

read data from text,csv,xml files using C#

XML=>     
                           var  Info = XDocument.Load(completeFilePath);
   var descendants = employeeInfo.Descendants("Element");
   var list = new List<Employee>();
   foreach (var descendant in descendants)
   {
    var emp = new Employee();
    emp.EmployeeId= descendant.Element("Id").Value;
    emp.Name = descendant.Element("Name").Value;
     list.Add(emp);
                            }

Text=>
                                                      var fileInLines = File.ReadAllLines(completeFilePath);
    foreach (var line in fileInLines)
   {
    var fileAttributes = line.Split(' ');
    var emp = new Employee();

    emp.Id = fileAttributes[0];
    emp.Name = fileAttributes[1];
    list.Add(emp);
   }

CSV=>
                         StreamWriter cfile = new StreamWriter(filepath);
     using (var wc = cfile)
   {
    var sb = new StringBuilder();

    foreach (var emp in employees)
    {
     sb.Append(emp.Id + ",");
     sb.Append(emp.Name + ",");
    }
    wc.WriteLine(sb.ToString());
    }