C# CsvWriter.WriteField方法代码示例

        public void GenerateCsvStub(string targetPath)
        {
            Program.Write("Generating CSV stub ...");
            using (var stream = new StreamWriter(targetPath, false, Encoding.UTF8))
            {
                var writer = new CsvWriter(stream, CsvService.GetDefaultCsvConfiguration());

                var dummyLine = new Dictionary<string, string>();
                foreach (var column in _configuration.Columns)
                {
                    dummyLine[column.Header] = "";
                }

                foreach (var field in dummyLine.Keys)
                {
                    writer.WriteField(field);
                }
                writer.NextRecord();
                foreach (var field in dummyLine.Keys)
                {
                    writer.WriteField(dummyLine[field]);
                }
            }

            Program.Write("CSV stub saved at '" + targetPath + "'.");
        }

        private void writeEmailListToCSV(String[] emails, String CSVFileName)
        {
            try
            {
                using (var sr = new StreamWriter(@CSVFileName))
                {
                    var writer = new CsvWriter(sr);
                    /*-------------------------
                     * HEADER
                     * -----------------------*/
                    writer.WriteField("Email Address");
                    writer.NextRecord();
                    /*-------------------------
                     * Email List
                     * -----------------------*/
                    for(int i=0; i< emails.Length;i++)
                    {
                        writer.WriteField(emails[i]);
                        writer.NextRecord();
                    }

                }
            }
            catch(Exception e)
            {Console.WriteLine("CSV write failed");}
        }

        private static byte[] GetFile()
        {
            var items = new List<Order>()
                {
                    new Order()
                        {
                            Id = 1,
                            ShippingMethodName= "Test",
                        }
                };

            using (var ms = new MemoryStream())
            using (var sw = new StreamWriter(ms))
            using (var w = new CsvWriter(sw))
            {
                w.WriteField("Order Id");
                w.WriteField("Shipping Method");
                w.WriteField("Tracking Number");
                w.NextRecord();

                foreach (var item in items)
                {
                    w.WriteField(item.Id);
                    w.WriteField(item.ShippingMethodName);
                    w.WriteField("Courier");
                    w.NextRecord();
                }

                sw.Flush();
                var file = ms.ToArray();
                sw.Close();

                return file;
            }
        }

        static void Main(string[] args)
        {
            if (args.Length < 1)
            {
                System.Console.WriteLine("Syntax: ExportWMPMetadataToCSV.exe <outfile> [<top>]");
                return;
            }

            int? top = null;

            if (args.Length >= 2)
            {
                top = int.Parse(args[1]);
            }

            string output_filename = args[0];
            var normalized_names = new Dictionary<string, string>();
            foreach (var attr in all_attributes)
            {
                string name = attr.Replace("/", "_");
                normalized_names[attr] = name;
            }

            var wmp = new WMPLib.WindowsMediaPlayerClass();
            var item_collection = wmp.getAll();

            using (var writer = File.CreateText(output_filename))
            using (var csv = new CsvWriter(writer))
            {
                // Write CSV Header
                for (int i = 0; i < all_attributes.Length; i++)
                {
                    string h = normalized_names[all_attributes[i]];
                    csv.WriteField(h);
                }
                csv.NextRecord();

                for (int i = 0; i < item_collection.count; i++)
                {
                    if (top.HasValue && i>= top.Value)
                    {
                        break;
                    }

                    System.Console.WriteLine("WMP Item #: {0}", i + 1);
                    // write a csv line for each item in the collection
                    var item = item_collection.get_Item(i);

                    for (int j = 0; j < all_attributes.Length; j++)
                    {
                        var attr_value = item.getItemInfo(all_attributes[j]) ?? "";
                        csv.WriteField(attr_value);
                    }
                    csv.NextRecord();
                }
            }

            System.Console.WriteLine("DONE");

        }

        public void InitCsvFile()
        {
            const string subPath = "Analyzer";
            var isExists = Directory.Exists(subPath);
            if (!isExists) Directory.CreateDirectory(subPath);

            File.Create(_filePath).Close();
            using (var streamWriter = File.AppendText(_filePath))
            {
                var writer = new CsvWriter(streamWriter);
                writer.Configuration.Delimiter = ";";

                writer.WriteField("GENERAL:AXIS:X");
                for (var i = 1; i <= Analyzer.AnalyzerChannels.HighestId; i++)
                {
                    var fieldString = "";
                    var id = i;
                    foreach (var analyzerChannel in Analyzer.AnalyzerChannels.Children.Where(analyzerChannel => analyzerChannel.AnalyzerObservableVariable != null && analyzerChannel.Id == id))
                    {
                        fieldString = "VARIABLE:" + analyzerChannel.AnalyzerObservableVariable.Name + ":[" +
                                          analyzerChannel.AnalyzerObservableVariable.Unit + "]:AXIS:Y";
                    }

                    writer.WriteField(fieldString != "" ? fieldString : "VARIABLE:EMPTY:AXIS:Y");
                }

                writer.NextRecord();
                streamWriter.Close();
            }
        }

        public void Output(TableInfo table, DataTable data)
        {
            var outputFilename = string.Format("{0}.csv", data.TableName);

            _logger.Info("Writing data to {0}...", outputFilename);

            using (var stringWriter = new StringWriter())
            using (var csv = new CsvWriter(stringWriter))
            {
                foreach (DataColumn column in data.Columns)
                {
                    csv.WriteField(column.ColumnName);
                }
                csv.NextRecord();
                foreach (var row in data.AsEnumerable())
                {
                    foreach (var item in row.ItemArray)
                    {
                        csv.WriteField(item.ToString());
                    }
                    csv.NextRecord();
                }

                File.WriteAllText(outputFilename, stringWriter.ToString());
            }

            _logger.Info("Done writing data to {0}.", outputFilename);
        }

 protected virtual void OnWriteCsvRecord(CsvWriter csv, IEconomy economy)
 {
     foreach (var good in Goods)
     {
         csv.WriteField(economy.Market.History.GetSoldAmount(good, 15));
         csv.WriteField(economy.Market.History.GetAveragePrice(good, 15).ToString());
     }
 }

        private static void Main()
        {
            using (var csv = new CsvWriter(new StreamWriter("results.csv", false, Encoding.UTF8)))
            {
                WriteHeader(csv);

                var languagesToTest = new[] {Languages.EnglishUK, Languages.GermanGermany};
                foreach (var language in languagesToTest)
                {
                    var results = new AutoCorrectTester(language).Run();

                    foreach (var result in results)
                    {
                        foreach (var testResult in result.Results)
                        {
                            csv.WriteField(language);
                            csv.WriteField(result.AutoCompleteMethod);
                            csv.WriteField(result.MemorySize);
                            csv.WriteField(testResult.Misspelling);
                            csv.WriteField(testResult.TargetWord);
                            csv.WriteField(testResult.CharactersTyped);
                            csv.WriteField(testResult.TargetWord.Length);
                            csv.WriteField(testResult.TimeTaken.Milliseconds);
                            csv.WriteField(testResult.CharactersTyped != -1
                                ? (double) testResult.CharactersTyped/testResult.TargetWord.Length
                                : 2d);
                            csv.NextRecord();
                        }
                    }
                }
            }
        }

        public void TryCreateConfigFile()
        {
            if (File.Exists(GitDriveConfigFilePath)) return;

            using(var streamWriter = new StreamWriter(GitDriveConfigFilePath))
            using (var csv = new CsvWriter(streamWriter))
            {
                csv.WriteField("Name");
                csv.WriteField("Path");
                csv.NextRecord();
            }
        }

        public void MergerToOneCsv()
        {
            bool b = true;

            foreach (string item in CsvFilesPath)
            {
                using (var reader = new CsvReader(new StreamReader(item)))
                {
                    if (FirstLine.Count <= 0)
                    {
                        reader.Read();
                        FirstLine = new List<string>(reader.FieldHeaders);
                    }
                    if (b)
                    {
                        using (var writer = new CsvWriter(new StreamWriter(_strBatchResult, true)))
                        {
                            foreach (string s in FirstLine)
                            {
                                writer.WriteField(s);
                            }
                            writer.NextRecord();
                            foreach (string s in FirstLine)
                            {
                                writer.WriteField(reader.GetField(s));
                            }
                            writer.NextRecord();
                        }
                        b = false;
                    }

                    while (reader.Read())
                    {
                        using (var writer = new CsvWriter(new StreamWriter(_strBatchResult, true)))
                        {
                            foreach (string strHeader in reader.FieldHeaders)
                            {
                                Console.WriteLine(reader.GetField(strHeader));
                            }
                            foreach (string s in FirstLine)
                            {
                                writer.WriteField(reader.GetField(s));
                            }
                            writer.NextRecord();
                        }

                    }
                }
            }
        }

        protected void Page_Load(object sender, EventArgs e)
        {
            string methodName = Request["MethodName"];
            string afterDate = Request["AfterDate"];

            Response.ContentType = "text/plain";
            using (SqlConnection conn = new SqlConnection(profilesdb))
            {
                conn.Open();
                SqlCommand dbcommand = new SqlCommand("[UCSF.].[ReadActivityLog]", conn);
                dbcommand.CommandType = CommandType.StoredProcedure;
                dbcommand.Parameters.Add(methodName != null ? new SqlParameter("@methodName", methodName) : new SqlParameter("@methodName", DBNull.Value));
                dbcommand.Parameters.Add(afterDate != null ? new SqlParameter("@afterDT", afterDate) : new SqlParameter("@afterDT", DBNull.Value));
                using (SqlDataReader dbreader = dbcommand.ExecuteReader(CommandBehavior.CloseConnection))
                {
                    CsvWriter writer = new CsvWriter(Response.Output);
                    while (dbreader.Read())
                    {
                        writer.WriteField(dbreader.GetInt32(0));
                        writer.WriteField(dbreader[1].ToString());
                        writer.WriteField(dbreader[2].ToString());
                        writer.WriteField(dbreader[3].ToString());
                        writer.WriteField(dbreader.GetDateTime(4));
                        writer.WriteField(dbreader[5].ToString());
                        writer.WriteField(dbreader[6].ToString());
                        writer.WriteField(dbreader[7].ToString());
                        writer.NextRecord();
                    }
                    Response.Output.Flush();
                }
            }
        }

 private static void WriteHeader(CsvWriter csv)
 {
     csv.WriteField("Language");
     csv.WriteField("Method");
     csv.WriteField("MemoryUsedForTestSuite");
     csv.WriteField("Misspelling");
     csv.WriteField("Target");
     csv.WriteField("CharactersTyped");
     csv.WriteField("TargetLength");
     csv.WriteField("TimeTakenMs");
     csv.WriteField("%ageTyped");
     csv.NextRecord();
 }

 public static void WriteList(CsvWriter writer, IEnumerable list)
 {
     foreach (var item in list)
     {
         writer.WriteField(item);
     }
     writer.NextRecord();
 }

        public void SaveDataTableToCsv(DataTable dataTable, string pathToCsvFile)
        {
            using (var csvWriter = new CsvWriter(new StreamWriter(pathToCsvFile)))
            {
                var fr = dataTable.Rows.First();
                fr.Columns.ForEach(c => csvWriter.WriteField(c));
                csvWriter.NextRecord();

                dataTable.Rows.ForEach(
                    r =>
                    {
                        r.Values.ForEach(v => csvWriter.WriteField(v));
                        csvWriter.NextRecord();
                    }
                );
            }
        }

        public static void WriteToDisk(String fileName, ushort[] dataList)
        {
            if (File.Exists(fileName))
                throw new WarningException(fileName + "is overwritten");

            using (var sw = new StreamWriter(fileName))
            {
                CsvWriter csvWriter = new CsvWriter(sw, new CsvConfiguration());

                for (int i = 0; i < dataList.LongLength / 4; i++)
                {
                    csvWriter.WriteField(dataList[4 * i]);
                    csvWriter.WriteField(dataList[4 * i + 1]);
                    csvWriter.WriteField(dataList[4 * i + 2]);
                    csvWriter.WriteField(dataList[4 * i + 3]);
                    csvWriter.NextRecord();
                }
            }
        }