C# CsvRow类代码示例

        public void Generate()
        {
            foreach (IAdj adj in _adjs)
            {
                SortedList<DateTime, AdjRateDatum> adjRateData = CreateAdjRateData(adj);

                //String dir = Directory.GetCurrentDirectory();
                //String path = dir + "\\" + _excelAdjResultFileName;

                CsvFileWriter writer = new CsvFileWriter(String.Format("{0}_result.csv", adj.ToString()));
                WriteHeader(writer);

                foreach (KeyValuePair<DateTime, AdjRateDatum> datum in adjRateData)
                {
                    CsvRow row = new CsvRow();
                    row.Add(datum.Key.ToString("yyyy-MM-dd"));
                    row.Add(datum.Value.KospiRate.ToString("n5"));
                    row.Add(datum.Value.KtbRate.ToString("n5"));
                    row.Add(datum.Value.DollarRate.ToString("n5"));

                    writer.WriteRow(row);
                }

                writer.Close();
            }
        }

        public static void CsvLoadTripRoutes(string filename, bool lngFirst)
        {
            // load trip routes
            Dictionary<string, LinkedList<Waypoint>> routes = new Dictionary<string, LinkedList<Waypoint>>();
            using (CsvFileReader reader = new CsvFileReader(filename))
            {
                CsvRow row = new CsvRow();
                while (reader.ReadRow(row, ','))
                {
                    string routeID = row[0];
                    double distance = 0;
                    double lat = Convert.ToDouble(lngFirst ? row[2] : row[1]);
                    double lng = Convert.ToDouble(lngFirst ? row[1] : row[2]);
                    if (routes.ContainsKey(routeID))
                        distance = routes[routeID].First.Value.GetDistance(new Location(lat, lng, "null"));
                    Waypoint waypoint = new Waypoint(lat, lng, TimeSpan.Parse(row[3]), distance, row[4].Replace("\"", ""));

                    // Scenario #1
                    if (!routes.ContainsKey(routeID))
                        routes[routeID] = new LinkedList<Waypoint>();
                    routes[routeID].AddLast(waypoint);

                }
            }
            foreach (LinkedList<Waypoint> w in routes.Values)
            {
                Route r = new Route(w.ToArray());
                string key = Route.GetKey(r.start, r.end);
                MapTools.routes.Add(key, r);
            }
        }

        public static string kToSqlCreateTable(string tblFileName, string csvFilePath)
        {
            string cmdText = string.Empty;

            using (CsvFileReader reader = new CsvFileReader(csvFilePath))
            {
                CsvRow row = new CsvRow();
                bool isHeader = true;
                string tTblFile = tblFileName.Substring(0, tblFileName.IndexOf("_"));

                Console.WriteLine("c o d i n g . . .    t r a n s c o d i n g   . . .  t r a n s    . . . . .   ");

                cmdText += string.Format("DROP TABLE IF EXISTS `{0}`;", tTblFile) + Environment.NewLine;
                cmdText += string.Format("CREATE TABLE IF NOT EXISTS `{0}` (", tTblFile) + Environment.NewLine;
                while (reader.ReadRow(row))
                {
                    if (isHeader)
                    {
                        isHeader = false;
                        continue;
                    }
                    string tRowType = kToMySQLTypeStatement(row);
                    cmdText += "\t" +  (tRowType.Equals(",") ? "" : tRowType)  + Environment.NewLine;

                }
                cmdText = cmdText.Remove(cmdText.LastIndexOf(","), 1);
                cmdText += ") ENGINE=InnoDB DEFAULT CHARSET=utf8;" + Environment.NewLine;

                Console.WriteLine(cmdText);
                Console.WriteLine("DONE !!!");
                reader.Close();
            }
            return cmdText;
        }

        //static void Main(string[] args)
        //{
        //    CsvRow row = new CsvRow();
        //    CsvFileReader reader = new CsvFileReader("C:\\temp\\XICData.csv");
        //    while (reader.ReadRow(row))
        //    {
        //        Console.Out.WriteLine(row[0] + " -> " +  row[1]);
        //    }
        //    Console.Read();
        //}
        static void Main(string[] args)
        {
            List<XICDataPoint> xicData = new List<XICDataPoint>();

            CsvRow row = new CsvRow();
            CsvFileReader reader = new CsvFileReader("C:\\temp\\XICData.csv");
            while (reader.ReadRow(row))
            {
                Console.Out.WriteLine(row[0] + " -> " + row[1]);
                int scanNumber;
                double intensity;

                if (int.TryParse(row[0], out scanNumber) && double.TryParse(row[1], out intensity))
                    xicData.Add(new XICDataPoint { scanNumber = scanNumber, intensity = intensity });
            }

            PeakFinder finder = new PeakFinder();
            foreach (var peakData in finder.GetPeaks(xicData))
            {
                Console.Out.WriteLine(peakData.startScan + " -> " , peakData.endScan);
                foreach (var intensity in peakData.intensityValues)
                {
                    Console.Out.WriteLine("Intensity = " + intensity);
                }
            }

            Console.Read();
        }

 public void RunCommand(string cmd)
 {
     CsvRow row = new CsvRow();
     row.Add(DateTime.Now.format("dd-MM-yyyy HH:mm:ss"));
     row.Add(this.Com);
     row.Add(this.Name);           
     try
     {
         string msg = string.Format(cmd, this.board, this.pos);
          row.Add(msg);
         if (App.listSerialPort != null)
         {
             for (int i = 0; i < App.listSerialPort.Count; i++)
             {
                 if (this.Com.ToLower() == App.listSerialPort[i].PortName.ToLower())
                 {
                     App.listSerialPort[i].sendCommand(msg);
                     break;
                 }
             }
         }
     }
     catch (Exception)
     {
        
     }
     
     App.RowsSend.Add(row);
 }

 public void WriteRow(CsvRow row)
 {
     StringBuilder stringBuilder = new StringBuilder();
     bool flag = true;
     foreach (string current in row)
     {
         if (!flag)
         {
             stringBuilder.Append(',');
         }
         if (current.IndexOfAny(new char[]
         {
             '"',
             ','
         }) != -1)
         {
             stringBuilder.AppendFormat("\"{0}\"", current.Replace("\"", "\"\""));
         }
         else
         {
             stringBuilder.Append(current);
         }
         flag = false;
     }
     row.LineText = stringBuilder.ToString();
     this.WriteLine(row.LineText);
 }

 public Dictionary<string, Player> readPlayers()
 {
     Dictionary<string, Player> listPlayers = new Dictionary<string, Player>();
     using (CsvFileReader reader = new CsvFileReader(file))
     {
         CsvRow row = new CsvRow();
         while (reader.ReadRow(row))
         {
             listPlayers.Add(row[Constants.FName], new Player(row[Constants.FName], boolFromString(row[Constants.FBoolTerran]),
                 boolFromString(row[Constants.FBoolZerg]), boolFromString(row[Constants.FBoolProtoss]), boolFromString(row[Constants.FBoolRandom])));
             Player temp = listPlayers[row[Constants.FName]];
             int.TryParse(row[Constants.FVictoryTerran], out temp.Victory[Constants.Terran]);
             int.TryParse(row[Constants.FVictoryZerg], out temp.Victory[Constants.Zerg]);
             int.TryParse(row[Constants.FVictoryProtoss], out temp.Victory[Constants.Protoss]);
             int.TryParse(row[Constants.FVictoryRandom], out temp.Victory[Constants.Random]);
             int.TryParse(row[Constants.FDefeatTerran], out temp.Defeat[Constants.Terran]);
             int.TryParse(row[Constants.FDefeatZerg], out temp.Defeat[Constants.Zerg]);
             int.TryParse(row[Constants.FDefeatProtoss], out temp.Defeat[Constants.Protoss]);
             int.TryParse(row[Constants.FDefeatRandom], out temp.Defeat[Constants.Random]);
             int.TryParse(row[Constants.FEloTerran], out temp.Elo[Constants.Terran]);
             int.TryParse(row[Constants.FEloZerg], out temp.Elo[Constants.Zerg]);
             int.TryParse(row[Constants.FEloProtoss], out temp.Elo[Constants.Protoss]);
             int.TryParse(row[Constants.FEloRandom], out temp.Elo[Constants.Random]);
         }
     }
     return listPlayers;
 }

        public EventPointsReader(String filePath, Boolean skipHeader)
        {
            this.EventPoints = new List<EventPoint>();

            CsvFileReader reader = new CsvFileReader(filePath);

            Boolean headerSkipped = false;

            while (true)
            {
                CsvRow row = new CsvRow();
                if (reader.ReadRow(row))
                {
                    if ((skipHeader && headerSkipped) ||
                        !skipHeader)
                    {
                        EventPoint ep = new EventPoint();
                        ep.LongCode = row[0];
                        ep.ShortCode = row[1];
                        ep.DateTimeFrom = DateTime.ParseExact(row[2], "yyyy-MM-dd HH:mm:ss.fff", null);
                        ep.DateTimeTo = DateTime.ParseExact(row[3], "yyyy-MM-dd HH:mm:ss.fff", null);
                        ep.RangeMax = Convert.ToDouble(row[4]);
                        ep.RangeMin = Convert.ToDouble(row[5]);

                        this.EventPoints.Add(ep);
                    }
                    headerSkipped = true;
                }
                else
                {
                    break;
                }
            }
        }

        public static void WriteToCsvFile(this DataTable dataTable, string filePath)
        {
            CsvFileWriter writer = new CsvFileWriter(filePath);
            StringBuilder fileContent = new StringBuilder();

            CsvRow row = new CsvRow();
            foreach (var col in dataTable.Columns)
                row.Add(col.ToString());
            writer.WriteRow(row);

            foreach (DataRow dr in dataTable.Rows)
            {
                row = new CsvRow();

                foreach (var column in dr.ItemArray)
                {
                    row.Add(column.ToString());
                }

                writer.WriteRow(row);
            }
            writer.Close();
            dataTable = null;
            System.Console.WriteLine(string.Format("Done writing to {0}.", filePath));
        }

        private void loadSNPSPToolStripMenuItem_Click(object sender, EventArgs e)
        {
            _openFileDialog.FileName = "SNPCC.csv";
            _openFileDialog.Filter = "csv files (*.csv)|*.csv";
            _openFileDialog.DefaultExt = "txt";
            _openFileDialog.FilterIndex = 2;
            _openFileDialog.AddExtension = true;
            if (_openFileDialog.ShowDialog() == DialogResult.OK)
            {
                string fileName = _openFileDialog.FileName;
                CsvFileReader csv = new CsvFileReader(fileName);
                char[] _separators = new char[] { '\n', '"', ',' };
                CsvRow row = new CsvRow();
                bool entering = true;
                while (entering == true)
                {
                    entering = csv.ReadRow(row);
                    staters.Add(new Stater(row[1], row[0]));
                    char[] bar = row[2].ToCharArray();
                    string bs = Convert.ToString(bar[0]) + Convert.ToString(bar[1]) + Convert.ToString(bar[2]) + Convert.ToString(bar[3]);
                    staters[staters.Count - 1].Barcode = Convert.ToInt32(bs);
                    staters[staters.Count - 1].City = row[3];
                    staters[staters.Count - 1].County = row[4];
                }

                csv.Close();
                staters.RemoveAt(staters.Count - 1);
                List<Stater> testing = staters;
            }
        }

 public citTotalLoadsFload(CsvRow row)
 {
     this.KycrspFundno = Convert.ToInt32(row[0]);
     this.FrontLoad = Convert.ToDouble(row[1]);
     this.FrontGroupNo = row[2];
     this.Fflbegdt = FuncoesAux.StringToDateTime(row[3]);
     this.Fflenddt = FuncoesAux.StringToDateTime(row[4]);
 }

        public void import(string fileName, int headerRow)
        {
            List<string> columns = new List<string>();
            List<Dictionary<string, string>> rows = new List<Dictionary<string,string>>();

            // Read sample data from CSV file
            using (CsvFileReader reader = new CsvFileReader(fileName))
            {
                int lineNumber = 0;

                CsvRow row = new CsvRow();
                while (reader.ReadRow(row))
                {
                    if (lineNumber == headerRow)
                    {
                        // Read Header Values
                        foreach (string s in row)
                        {
                            columns.Add(s.Replace(" ", ""));
                        }
                    }
                    else if (lineNumber > headerRow)
                    {
                        int columnIndex = 0;
                        Dictionary<string, string> dataRow = new Dictionary<string,string>();

                        foreach (string s in row)
                        {
                            dataRow.Add(columns[columnIndex], s);
                            ++columnIndex;
                        }

                        rows.Add(dataRow);
                    }

                    ++lineNumber;
                }
            }

            // Output using code generator

            //  IList<BusinessRule> rules = new List<BusinessRule>();

            //  rules.Add(new BusinessRule
            //  {
            //    ErrorCode = "AIRBR1001",
            //    RuleNumber = "1095C-006",
            //    Description = "Form 1095C 'TINRequestTypeCd' in 'EmployeeInfoGrp' must have a value equal to 'INDIVIDUAL_TIN'.",
            //    ErrorCategory = "Incorrect Data",
            //    Severity = "Report Error",
            //    Status = "Active"
            //  });

            CodeCompileUnit code = new CodeCompileUnit();
            CodeNamespace namespaces = new CodeNamespace();
            namespaces.Imports.Add(new CodeNamespaceImport("System"));
        }

        void WriteHeader(CsvFileWriter writer)
        {
            CsvRow row = new CsvRow();
            row.Add("Date");
            row.Add("KospiRate");
            row.Add("KtbRate");
            row.Add("DollarRate");

            writer.WriteRow(row);
        }

 void WriteHeader(CsvFileWriter writer)
 {
     CsvRow row = new CsvRow();
     row.Add("DateTime");
     row.Add("EventPoint");
     foreach (String key in _indicators.GetKeys())
     {
         row.Add(key);
     }
     writer.WriteRow(row);
 }

 public citExpenseTurnoverFee(CsvRow row)
 {
     this.KycrspFundno = Convert.ToInt32(row[0]);
     this.FexpRatio = Convert.ToDouble(row[1]);
     if (!row[2].Equals("")){
         this.FmgmtFee = Convert.ToDouble(row[2]);
     }
     this.FturnRatio = Convert.ToDouble(row[3]);
     this.Ffebegdt = FuncoesAux.StringToDateTime(row[4]);
     this.Ffeenddt = FuncoesAux.StringToDateTime(row[5]);
 }