शीर्ष लेख के साथ C # में CSV फ़ाइलों को पार्स करना


266

क्या CSV फ़ाइलों को C # में पार्स करने का एक डिफ़ॉल्ट / आधिकारिक / अनुशंसित तरीका है? मैं अपने खुद के पार्सर को रोल नहीं करना चाहता।

साथ ही, मैंने पाठ चालक के माध्यम से CSV को पढ़ने के लिए ODBC / OLE DB का उपयोग करने वाले लोगों के उदाहरणों को देखा है, और बहुत से लोग इसके "कमियों" के कारण इसे हतोत्साहित करते हैं। ये कमियां क्या हैं?

आदर्श रूप से, मैं एक ऐसा रास्ता खोज रहा हूँ जिसके माध्यम से मैं स्तंभ नाम से CSV पढ़ सकता हूँ, शीर्षलेख / फ़ील्ड नामों के रूप में पहले रिकॉर्ड का उपयोग कर सकता हूँ। दिए गए कुछ उत्तर सही हैं लेकिन मूल रूप से फाइल को कक्षाओं में रखने के लिए काम करते हैं।

जवाबों:


138

एक लाइब्रेरी को आपके लिए सभी नॉटी-ग्रिट्टी डिटेल्स को संभालने दें! :-)

FileHelpers की जाँच करें और DRY बने रहें - खुद को दोहराएं नहीं - पहिया को फिर से गज़बेल्थ का आविष्कार करने की आवश्यकता नहीं है…।

आपको मूल रूप से अपने डेटा के उस आकार को परिभाषित करने की आवश्यकता है - एक सार्वजनिक वर्ग के माध्यम से - CSV में आपकी व्यक्तिगत पंक्ति में फ़ील्ड (और डिफ़ॉल्ट मानों की तरह अच्छी तरह से सोची गई विशेषताओं, NULL मानों के लिए प्रतिस्थापन और इसके बाद), बिंदु एक फ़ाइल में FileHelpers इंजन, और बिंगो - आपको उस फ़ाइल से सभी प्रविष्टियाँ वापस मिल जाती हैं। एक साधारण ऑपरेशन - शानदार प्रदर्शन!


1
जब तक आपको वास्तव में कस्टम की आवश्यकता होती है (और इसमें से अधिकांश को विस्तार के रूप में लागू किया जा सकता है) तब तक
FileHelpers

3
1 जून 2015 तक, FileHelpers को डाउनलोड करने का एकमात्र तरीका sourceforge.net पर इसे खोजना था। यहाँ लिंक का उपयोग किया गया है: sourceforge.net/projects/filehelpers/?source=directory
सुधांशु मिश्रा

2
@dotnetguy हम 3.1 जारी करने के तरीके में हैं (वर्तमान में 3.1-आरसी 2) बाहर है। इसके अलावा, हमने साइट को फिर से डिज़ाइन किया: www.filehelpers.net आप वहां से नवीनतम संस्करण डाउनलोड कर सकते हैं
मार्कोस Meli

1
@MarcosMeli बहुत धन्यवाद! मैंने पहले से ही अपने एक प्रोजेक्ट में FileHelpers का उपयोग किया है और यह टीम के लिए - kudos का उपयोग करने के लिए एक हवा थी। मैं जल्द ही इस पर एक ब्लॉग की योजना बना रहा हूं और btw - नई साइट से प्यार करें - अच्छी तरह से किया!
सुधांशु मिश्रा

FileHelpers CSVs में उद्धृत कॉमा को ठीक से हैंडल नहीं करता है, या वास्तव में फ़ील्ड हेडर को मैप करता है, इसके बजाय यह अपेक्षा करता है कि कॉलम उसी क्रम में हैं जैसे फ़ील्ड आपके प्रकार में घोषित किए गए हैं। मैं व्यक्तिगत रूप से इसका इस्तेमाल नहीं करूंगा।
एलेस्टेयर मव

357

CSV पार्सर अब .NET फ्रेमवर्क का एक हिस्सा है।

Microsoft.VisualBasic.dll का संदर्भ जोड़ें (C # में ठीक काम करता है, नाम का बुरा न मानें)

using (TextFieldParser parser = new TextFieldParser(@"c:\temp\test.csv"))
{
    parser.TextFieldType = FieldType.Delimited;
    parser.SetDelimiters(",");
    while (!parser.EndOfData)
    {
        //Process row
        string[] fields = parser.ReadFields();
        foreach (string field in fields)
        {
            //TODO: Process field
        }
    }
}

डॉक्स यहाँ हैं - TextFieldParser क्लास

पुनश्च अगर आपको एक CSV निर्यातक की आवश्यकता है , तो CsvExport की कोशिश करें (खुलासा: मैं योगदानकर्ताओं में से एक हूं)


2
मेरे अनुभव से TextFieldParser बड़ी (उदाहरण> 250Mb) फ़ाइलों के साथ अच्छा प्रदर्शन नहीं करता है। :(
MBoros

6
TextFieldParser IDisposable को कार्यान्वित करता है, इसलिए इसका उपयोग क्लॉज में करना सबसे अच्छा हो सकता है। अच्छा जवाब अन्यथा।
क्रिस बुश

3
कंस्ट्रक्टर में आप डिफ़ॉल्ट रूप से एक से अधिक एन्कोडिंग का उपयोग करना चाह सकते हैं, जैसे: नया TextFieldParser ("c: \ temp \ test.csv", System.Text.Encoding.UTF8)
Nural5torm

1
ध्यान दें कि यदि आपके CSV के किसी भी क्षेत्र में रिक्त लाइनें हैं, तो वे द्वारा छोड़ दिया जाएगा TextFieldParser.ReadLine()। देखें TextFieldParser डॉक्स
mcNux

3
क्या .NET कोर में इसे पाने का कोई तरीका है?
ह्यूगो जिंक

183

CsvHelper (एक पुस्तकालय जिसे मैं बनाए रखता हूं) एक CSV फ़ाइल को कस्टम ऑब्जेक्ट में पढ़ेगा।

var csv = new CsvReader( File.OpenText( "file.csv" ) );
var myCustomObjects = csv.GetRecords<MyCustomObject>();

कभी-कभी आप उन वस्तुओं के स्वामी नहीं होते जिन्हें आप पढ़ने की कोशिश कर रहे हैं। इस स्थिति में, आप धाराप्रवाह मानचित्रण का उपयोग कर सकते हैं क्योंकि आप वर्ग पर विशेषताएँ नहीं डाल सकते हैं।

public sealed class MyCustomObjectMap : CsvClassMap<MyCustomObject>
{
    public MyCustomObjectMap()
    {
        Map( m => m.Property1 ).Name( "Column Name" );
        Map( m => m.Property2 ).Index( 4 );
        Map( m => m.Property3 ).Ignore();
        Map( m => m.Property4 ).TypeConverter<MySpecialTypeConverter>();
    }
}

संपादित करें:

CsvReader को अब constInor ( https://github.com/JoshClose/CsvHelper/issues/1441 ) में पास करने के लिए CultureInfo की आवश्यकता है ।

उदाहरण:

var csv = new CsvReader(File.OpenText("file.csv"), System.Globalization.CultureInfo.CurrentCulture);

18
मैं @ kubal5003 से सहमत हूं। इस पर मुझे क्या बेचा गया था क्या आपने इसे NuGet पैकेज के रूप में उपलब्ध किया है। धन्यवाद आदमी, यह तेज है, और मुझे पढ़ने की जरूरत है सभी सीएसवी।
ग्रोमर

7
यह बहुत तेज़ है। 1.3 मिलियन रिकॉर्ड पढ़े और 10 सेकंड में deserialized।
marisks

2
महान पुस्तकालय लागू करने के लिए बहुत आसान है। मैं बस जोश में अपने उत्तर को यहां अपडेट करने का सुझाव दूंगा क्योंकि इस उत्तर के लिखे जाने के बाद से पुस्तकालय थोड़ा बदल गया है और आप CsvHelper को अब और तुरंत नहीं भेज सकते (यह अब केवल एक नाम स्थान है) लेकिन आपको CsvReader वर्ग का उपयोग करना होगा।
मार्को

1
CsvClassMap CsvHelper के अंतिम संस्करण में मौजूद नहीं है?
knocte

1
knocte, इसे अब ClassMap कहा जाता है। अन्य परिवर्तन भी हैं, जैसे हेडर रिकॉर्ड के लिए पूछने से पहले एक रीडिंग करना (जो कि जिस तरह से सेट हो जाता है उसे रीड () के लिए पहली कॉल द्वारा पढ़ा गया था)। जैसा पहले दूसरों ने उल्लेख किया है, यह सुपरफास्ट है और इसके साथ काम करना आसान है।
norgie

31

एक व्यावसायिक अनुप्रयोग में, मैं codeproject.com, CSVReader पर ओपन सोर्स प्रोजेक्ट का उपयोग करता हूं

यह अच्छा काम करता है, और इसका प्रदर्शन अच्छा है। मेरे द्वारा दिए गए लिंक पर कुछ बेंचमार्किंग है।

एक सरल उदाहरण, प्रोजेक्ट पेज से कॉपी किया गया:

using (CsvReader csv = new CsvReader(new StreamReader("data.csv"), true))
{
    int fieldCount = csv.FieldCount;
    string[] headers = csv.GetFieldHeaders();

    while (csv.ReadNextRecord())
    {
        for (int i = 0; i < fieldCount; i++)
            Console.Write(string.Format("{0} = {1};", headers[i], csv[i]));

        Console.WriteLine();
    }
}

जैसा कि आप देख सकते हैं, इसके साथ काम करना बहुत आसान है।


20

मुझे इसकी थोड़ी देर मालूम है, लेकिन सिर्फ एक लाइब्रेरी मिली है, Microsoft.VisualBasic.FileIOजिसमें TextFieldParserसीएसएसवी फाइलों को प्रोसेस करने के लिए क्लास है।


1
उस एपि का उपयोग करके एक उदाहरण; msdn.microsoft.com/en-us/library/cakac7e6(v=vs.90).aspx
AnneTheAgile

12

यदि आपको केवल सीएसवी फाइलें पढ़ने की आवश्यकता है, तो मैं इस पुस्तकालय की सिफारिश करता हूं: एक फास्ट सीएसवी रीडर
यदि आपको सीएसवी फाइलें उत्पन्न करने की आवश्यकता है, तो इस एक का उपयोग करें: फाइल हेल्पर्स

वे दोनों स्वतंत्र और ओपनसोर्स हैं।


FileHelpers का एक आकर्षक सारांश है: filehelpers.com FileHelpers एक स्वतंत्र और आसान है। फाइलों, स्ट्रिंग्स या स्ट्रीम में तय लंबाई या सीमांकित रिकॉर्ड से डेटा आयात / निर्यात करने के लिए .NET लाइब्रेरी का उपयोग करना आसान है।
ऐनीअजाइल

हालांकि यह लिंक प्रश्न का उत्तर दे सकता है, केवल स्टैक ओवरफ्लो पर लिंक को हतोत्साहित किया जाता है, आप लिंक के महत्वपूर्ण हिस्सों को ले जाकर इस उत्तर को बेहतर बना सकते हैं और इसे अपने उत्तर में डाल सकते हैं, यह सुनिश्चित करता है कि आपका उत्तर अभी भी एक उत्तर है यदि लिंक बदल गया है या हटा दिया गया :)
WhatsThePoint

11

यहाँ एक सहायक वर्ग है जिसका उपयोग मैं अक्सर करता हूं, यदि कोई भी इस धागे पर वापस आता है (मैं इसे साझा करना चाहता था)।

मैं इसे उपयोग करने के लिए तैयार परियोजनाओं में पोर्ट करने की सादगी के लिए उपयोग करता हूं:

public class CSVHelper : List<string[]>
{
  protected string csv = string.Empty;
  protected string separator = ",";

  public CSVHelper(string csv, string separator = "\",\"")
  {
    this.csv = csv;
    this.separator = separator;

    foreach (string line in Regex.Split(csv, System.Environment.NewLine).ToList().Where(s => !string.IsNullOrEmpty(s)))
    {
      string[] values = Regex.Split(line, separator);

      for (int i = 0; i < values.Length; i++)
      {
        //Trim values
        values[i] = values[i].Trim('\"');
      }

      this.Add(values);
    }
  }
}

और इसका उपयोग करें:

public List<Person> GetPeople(string csvContent)
{
  List<Person> people = new List<Person>();
  CSVHelper csv = new CSVHelper(csvContent);
  foreach(string[] line in csv)
  {
    Person person = new Person();
    person.Name = line[0];
    person.TelephoneNo = line[1];
    people.Add(person);
  }
  return people;
}

[अद्यतित सीएसवी हेल्पर: बग फिक्स जहां अंतिम नई लाइन चरित्र ने एक नई लाइन बनाई]


17
अगर किसी भी csv प्रविष्टियों में अल्पविराम (,) है तो यह कोड काम नहीं करेगा।
हांक

चीजों को हल्का रखने के लिए, मैंने सेपरेटर के रूप में एक पाइप चरित्र का उपयोग किया। '|'
आधार 33

उत्कृष्ट समाधान। सिर्फ 2 स्निपेट के बारे में एक सवाल। किस प्रकार की वस्तु है व्यक्ति
कोको देव

@ कोकोआडेव यह एक ऐसा वर्ग है जिसमें दो स्ट्रिंग गुण होते हैं - नाम और टेलीफोन। हालांकि उदाहरण के लिए विशुद्ध रूप से। यदि गुणों में से कोई एक पूर्णांक था तो यह सिर्फ एक सीधे आगे रूपांतरण (चेक के साथ?) होना चाहिए।
बेस 33

10

यह समाधान CSV को पार्स करने के लिए आधिकारिक Microsoft.VisualBasic असेंबली का उपयोग कर रहा है ।

लाभ:

  • परिहार बचना
  • हैदर को अनदेखा करता है
  • ट्रिम स्पेस
  • टिप्पणियों पर ध्यान न दें

कोड:

    using Microsoft.VisualBasic.FileIO;

    public static List<List<string>> ParseCSV (string csv)
    {
        List<List<string>> result = new List<List<string>>();


        // To use the TextFieldParser a reference to the Microsoft.VisualBasic assembly has to be added to the project. 
        using (TextFieldParser parser = new TextFieldParser(new StringReader(csv))) 
        {
            parser.CommentTokens = new string[] { "#" };
            parser.SetDelimiters(new string[] { ";" });
            parser.HasFieldsEnclosedInQuotes = true;

            // Skip over header line.
            //parser.ReadLine();

            while (!parser.EndOfData)
            {
                var values = new List<string>();

                var readFields = parser.ReadFields();
                if (readFields != null)
                    values.AddRange(readFields);
                result.Add(values);
            }
        }

        return result;
    }

7

मैंने TinyCsvParser लिखा है .NET के लिए , जो कि सबसे तेज़ .NET पार्सर में से एक है और लगभग किसी भी CSV प्रारूप को पार्स करने के लिए अत्यधिक विन्यास योग्य है।

यह एमआईटी लाइसेंस के तहत जारी किया गया है:

आप इसे स्थापित करने के लिए NuGet का उपयोग कर सकते हैं । पैकेज प्रबंधक कंसोल में निम्न आदेश चलाएँ ।

PM> Install-Package TinyCsvParser

प्रयोग

कल्पना करें कि हमारे पास CSV फ़ाइल में व्यक्तियों का persons.csvनाम उनके पहले नाम, अंतिम नाम और जन्मतिथि के साथ है।

FirstName;LastName;BirthDate
Philipp;Wagner;1986/05/12
Max;Musterman;2014/01/02

हमारे सिस्टम में संबंधित डोमेन मॉडल इस तरह दिख सकता है।

private class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime BirthDate { get; set; }
}

TinyCsvParser का उपयोग करते समय आपको CSV डेटा और आपके डोमेन मॉडल में मौजूद प्रॉपर्टी के बीच मैपिंग को परिभाषित करना होगा।

private class CsvPersonMapping : CsvMapping<Person>
{

    public CsvPersonMapping()
        : base()
    {
        MapProperty(0, x => x.FirstName);
        MapProperty(1, x => x.LastName);
        MapProperty(2, x => x.BirthDate);
    }
}

और फिर हम CSV डेटा को पार्स करने के लिए मैपिंग का उपयोग कर सकते हैं a CsvParser

namespace TinyCsvParser.Test
{
    [TestFixture]
    public class TinyCsvParserTest
    {
        [Test]
        public void TinyCsvTest()
        {
            CsvParserOptions csvParserOptions = new CsvParserOptions(true, new[] { ';' });
            CsvPersonMapping csvMapper = new CsvPersonMapping();
            CsvParser<Person> csvParser = new CsvParser<Person>(csvParserOptions, csvMapper);

            var result = csvParser
                .ReadFromFile(@"persons.csv", Encoding.ASCII)
                .ToList();

            Assert.AreEqual(2, result.Count);

            Assert.IsTrue(result.All(x => x.IsValid));

            Assert.AreEqual("Philipp", result[0].Result.FirstName);
            Assert.AreEqual("Wagner", result[0].Result.LastName);

            Assert.AreEqual(1986, result[0].Result.BirthDate.Year);
            Assert.AreEqual(5, result[0].Result.BirthDate.Month);
            Assert.AreEqual(12, result[0].Result.BirthDate.Day);

            Assert.AreEqual("Max", result[1].Result.FirstName);
            Assert.AreEqual("Mustermann", result[1].Result.LastName);

            Assert.AreEqual(2014, result[1].Result.BirthDate.Year);
            Assert.AreEqual(1, result[1].Result.BirthDate.Month);
            Assert.AreEqual(1, result[1].Result.BirthDate.Day);
        }
    }
}

उपयोगकर्ता गाइड

एक पूर्ण उपयोगकर्ता गाइड यहां उपलब्ध है:


1

यहाँ मेरी KISS कार्यान्वयन है ...

using System;
using System.Collections.Generic;
using System.Text;

class CsvParser
{
    public static List<string> Parse(string line)
    {
        const char escapeChar = '"';
        const char splitChar = ',';
        bool inEscape = false;
        bool priorEscape = false;

        List<string> result = new List<string>();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < line.Length; i++)
        {
            char c = line[i];
            switch (c)
            {
                case escapeChar:
                    if (!inEscape)
                        inEscape = true;
                    else
                    {
                        if (!priorEscape)
                        {
                            if (i + 1 < line.Length && line[i + 1] == escapeChar)
                                priorEscape = true;
                            else
                                inEscape = false;
                        }
                        else
                        {
                            sb.Append(c);
                            priorEscape = false;
                        }
                    }
                    break;
                case splitChar:
                    if (inEscape) //if in escape
                        sb.Append(c);
                    else
                    {
                        result.Add(sb.ToString());
                        sb.Length = 0;
                    }
                    break;
                default:
                    sb.Append(c);
                    break;
            }
        }

        if (sb.Length > 0)
            result.Add(sb.ToString());

        return result;
    }

}

1
यह उद्धृत स्ट्रिंग्स के भीतर लाइन ब्रेक के साथ सौदा नहीं करता है जो एक सीएसवी फ़ाइल में मान्य है।
जॉन लेडिग्रेन

एलेक्स, जो जॉन कहने की कोशिश कर रहा है वह यह है कि RFC 4180 ( ietf.org/rfc/rfc4180.txt - अनुभाग 2 और आइटम 6 देखें) एक स्तंभ के बीच में एक स्तंभ के लिए CR LF को प्रभावी ढंग से इसे फैलाने की अनुमति देता है। एक फ़ाइल में 2 लाइनें। आपका समाधान संभवतः ज्यादातर मामलों में अच्छी तरह से काम करेगा (विशेषकर अगर CSV फ़ाइलों को एक्सेल से बचाकर बनाया गया था), लेकिन यह इस किनारे के मामले को कवर नहीं करता है। ऊपर उल्लिखित CsvHelper, इस मामले को ध्यान में रखना चाहिए।
डेविड येट्स

हां, यह सच है, लेकिन अगर आपके सीएसवी में सीआर एलएफ है, तो संभावना है कि आपको शायद सीएसवी का उपयोग नहीं करना चाहिए, लेकिन कुछ और अधिक उपयुक्त जैसे, json, या xml, या निश्चित लंबाई प्रारूप।
एलेक्स बेगुन

1

कुछ समय पहले मैंने Microsoft.VisualBasicलाइब्रेरी पर आधारित सीएसवी पढ़ने / लिखने के लिए सरल वर्ग लिखा था । इस सरल वर्ग का उपयोग करके आप 2 आयाम सरणी के साथ CSV के साथ काम कर पाएंगे। आप निम्न लिंक द्वारा मेरी कक्षा पा सकते हैं: https://github.com/ukushu/DataExporter

उपयोग का सरल उदाहरण:

Csv csv = new Csv("\t");//delimiter symbol

csv.FileOpen("c:\\file1.csv");

var row1Cell6Value = csv.Rows[0][5];

csv.AddRow("asdf","asdffffff","5")

csv.FileSave("c:\\file2.csv");

हेडर पढ़ने के लिए केवल आपको csv.Rows[0]कोशिकाओं को पढ़ना पड़ता है :)


1

सीधी पार्सिंग जरूरतों के लिए एकल स्रोत फ़ाइल समाधान, उपयोगी। सभी गंदे किनारे वाले मामलों से निपटते हैं। जैसे कि नई लाइन सामान्यीकरण और उद्धृत स्ट्रिंग शाब्दिक में नई लाइनें संभालना। आपका स्वागत है!

यदि आपके पास CSV फ़ाइल में एक हेडर है, तो आप पहली पंक्ति से केवल कॉलम नाम (और कॉलम इंडेक्स की गणना करें) पढ़ें। इतना ही आसान।

ध्यान दें कि Dumpएक LINQPad विधि है, आप चाहते हैं कि आप LINQPad का उपयोग नहीं कर रहे हैं को दूर करने के लिए कर सकते हैं।

void Main()
{
    var file1 = "a,b,c\r\nx,y,z";
    CSV.ParseText(file1).Dump();

    var file2 = "a,\"b\",c\r\nx,\"y,z\"";
    CSV.ParseText(file2).Dump();

    var file3 = "a,\"b\",c\r\nx,\"y\r\nz\"";
    CSV.ParseText(file3).Dump();

    var file4 = "\"\"\"\"";
    CSV.ParseText(file4).Dump();
}

static class CSV
{
    public struct Record
    {
        public readonly string[] Row;

        public string this[int index] => Row[index];

        public Record(string[] row)
        {
            Row = row;
        }
    }

    public static List<Record> ParseText(string text)
    {
        return Parse(new StringReader(text));
    }

    public static List<Record> ParseFile(string fn)
    {
        using (var reader = File.OpenText(fn))
        {
            return Parse(reader);
        }
    }

    public static List<Record> Parse(TextReader reader)
    {
        var data = new List<Record>();

        var col = new StringBuilder();
        var row = new List<string>();
        for (; ; )
        {
            var ln = reader.ReadLine();
            if (ln == null) break;
            if (Tokenize(ln, col, row))
            {
                data.Add(new Record(row.ToArray()));
                row.Clear();
            }
        }

        return data;
    }

    public static bool Tokenize(string s, StringBuilder col, List<string> row)
    {
        int i = 0;

        if (col.Length > 0)
        {
            col.AppendLine(); // continuation

            if (!TokenizeQuote(s, ref i, col, row))
            {
                return false;
            }
        }

        while (i < s.Length)
        {
            var ch = s[i];
            if (ch == ',')
            {
                row.Add(col.ToString().Trim());
                col.Length = 0;
                i++;
            }
            else if (ch == '"')
            {
                i++;
                if (!TokenizeQuote(s, ref i, col, row))
                {
                    return false;
                }
            }
            else
            {
                col.Append(ch);
                i++;
            }
        }

        if (col.Length > 0)
        {
            row.Add(col.ToString().Trim());
            col.Length = 0;
        }

        return true;
    }

    public static bool TokenizeQuote(string s, ref int i, StringBuilder col, List<string> row)
    {
        while (i < s.Length)
        {
            var ch = s[i];
            if (ch == '"')
            {
                // escape sequence
                if (i + 1 < s.Length && s[i + 1] == '"')
                {
                    col.Append('"');
                    i++;
                    i++;
                    continue;
                }
                i++;
                return true;
            }
            else
            {
                col.Append(ch);
                i++;
            }
        }
        return false;
    }
}

1

इस सूची में एक और, सेंचू ईटीएल - एक खुला स्रोत पुस्तकालय है जिसमें कई फ़ाइल प्रारूप (CSV, फ्लैट फ़ाइल, Xml, JSON आदि) पढ़ने और लिखने के लिए है

नीचे दिए गए नमूने से पता चलता है कि CSV फ़ाइल को जल्दी से कैसे पढ़ें (कोई POCO ऑब्जेक्ट की आवश्यकता नहीं)

string csv = @"Id, Name
1, Carl
2, Tom
3, Mark";

using (var p = ChoCSVReader.LoadText(csv)
    .WithFirstLineHeader()
    )
{
    foreach (var rec in p)
    {
        Console.WriteLine($"Id: {rec.Id}");
        Console.WriteLine($"Name: {rec.Name}");
    }
}

नीचे का नमूना दिखाता है कि POCO ऑब्जेक्ट का उपयोग करके CSV फ़ाइल कैसे पढ़ें

public partial class EmployeeRec
{
    public int Id { get; set; }
    public string Name { get; set; }
}

static void CSVTest()
{
    string csv = @"Id, Name
1, Carl
2, Tom
3, Mark";

    using (var p = ChoCSVReader<EmployeeRec>.LoadText(csv)
        .WithFirstLineHeader()
        )
    {
        foreach (var rec in p)
        {
            Console.WriteLine($"Id: {rec.Id}");
            Console.WriteLine($"Name: {rec.Name}");
        }
    }
}

कृपया इसे उपयोग करने के तरीके के बारे में CodeProject पर लेख देखें ।


0

कैसे सी # स्प्लिट () फ़ंक्शन का उपयोग करके CSV को ठीक से विभाजित करने के लिए अनलिमिटेड की पोस्ट के आधार पर ? :

string[] tokens = System.Text.RegularExpressions.Regex.Split(paramString, ",");

ध्यान दें: यह बच / नेस्टेड कॉमा, आदि को नहीं संभालता है, और इसलिए केवल कुछ सरल CSV सूचियों के लिए उपयुक्त है।


2
यह बहुत बुरा है और संभावना धीमी है :)
EKS 14

1
शायद, लेकिन यह मापदंडों के एक छोटे से सेट के लिए पूरी तरह से और बस काम करता है, इसलिए एक वैध और सहायक समाधान है। इसे नीचा क्यों? "बहुत बुरा" थोड़ा चरम है, क्या आपको नहीं लगता?
राडसौ

1
यह बच / नेस्टेड कॉमा इत्यादि से नहीं बचा है, कुछ मामलों में काम करेगा, लेकिन निश्चित रूप से सभी सीएसवी फाइलों के लिए काम नहीं करेगा
NStuke

तुम सही हो; मैं उत्तर को प्रतिबिंबित करने के लिए संपादित करूँगा। धन्यवाद। लेकिन यह अभी भी अपनी जगह है।
राडासौ

यह मेरे उपयोग के मामले के लिए पूरी तरह से काम करता है जहां मैं एक sql सर्वर clr dll का निर्माण कर रहा हूं और इनमें से किसी भी अन्य बाहरी पैकेज का उपयोग नहीं कर सकता। मैं सिर्फ एक फ़ाइल नाम और पंक्ति गणना के साथ एक सरल सीएसवी फ़ाइल पार्स करने की जरूरत है।
dubvfan87

0

यह कोड डेटाटेबल में सीएसवी पढ़ता है:

public static DataTable ReadCsv(string path)
{
    DataTable result = new DataTable("SomeData");
    using (TextFieldParser parser = new TextFieldParser(path))
    {
        parser.TextFieldType = FieldType.Delimited;
        parser.SetDelimiters(",");
        bool isFirstRow = true;
        //IList<string> headers = new List<string>();

        while (!parser.EndOfData)
        {
            string[] fields = parser.ReadFields();
            if (isFirstRow)
            {
                foreach (string field in fields)
                {
                    result.Columns.Add(new DataColumn(field, typeof(string)));
                }
                isFirstRow = false;
            }
            else
            {
                int i = 0;
                DataRow row = result.NewRow();
                foreach (string field in fields)
                {
                    row[i++] = field;
                }
                result.Rows.Add(row);
            }
        }
    }
    return result;
}

1
TextFieldParser Microsoft.VisualBasic.dll में है।
user3285954

0

अगर किसी को एक स्निपेट चाहिए, तो वे लाइब्रेरी को बाँधने या पैकेज डाउनलोड किए बिना अपने कोड में डाल सकते हैं। यहाँ एक संस्करण मैंने लिखा है:

    public static string FormatCSV(List<string> parts)
    {
        string result = "";

        foreach (string s in parts)
        {
            if (result.Length > 0)
            {
                result += ",";

                if (s.Length == 0)
                    continue;
            }

            if (s.Length > 0)
            {
                result += "\"" + s.Replace("\"", "\"\"") + "\"";
            }
            else
            {
                // cannot output double quotes since its considered an escape for a quote
                result += ",";
            }
        }

        return result;
    }

    enum CSVMode
    {
        CLOSED = 0,
        OPENED_RAW = 1,
        OPENED_QUOTE = 2
    }

    public static List<string> ParseCSV(string input)
    {
        List<string> results;

        CSVMode mode;

        char[] letters;

        string content;


        mode = CSVMode.CLOSED;

        content = "";
        results = new List<string>();
        letters = input.ToCharArray();

        for (int i = 0; i < letters.Length; i++)
        {
            char letter = letters[i];
            char nextLetter = '\0';

            if (i < letters.Length - 1)
                nextLetter = letters[i + 1];

            // If its a quote character
            if (letter == '"')
            {
                // If that next letter is a quote
                if (nextLetter == '"' && mode == CSVMode.OPENED_QUOTE)
                {
                    // Then this quote is escaped and should be added to the content

                    content += letter;

                    // Skip the escape character
                    i++;
                    continue;
                }
                else
                {
                    // otherwise its not an escaped quote and is an opening or closing one
                    // Character is skipped

                    // If it was open, then close it
                    if (mode == CSVMode.OPENED_QUOTE)
                    {
                        results.Add(content);

                        // reset the content
                        content = "";

                        mode = CSVMode.CLOSED;

                        // If there is a next letter available
                        if (nextLetter != '\0')
                        {
                            // If it is a comma
                            if (nextLetter == ',')
                            {
                                i++;
                                continue;
                            }
                            else
                            {
                                throw new Exception("Expected comma. Found: " + nextLetter);
                            }
                        }
                    }
                    else if (mode == CSVMode.OPENED_RAW)
                    {
                        // If it was opened raw, then just add the quote 
                        content += letter;
                    }
                    else if (mode == CSVMode.CLOSED)
                    {
                        // Otherwise open it as a quote 

                        mode = CSVMode.OPENED_QUOTE;
                    }
                }
            }
            // If its a comma seperator
            else if (letter == ',')
            {
                // If in quote mode
                if (mode == CSVMode.OPENED_QUOTE)
                {
                    // Just read it
                    content += letter;
                }
                // If raw, then close the content
                else if (mode == CSVMode.OPENED_RAW)
                {
                    results.Add(content);

                    content = "";

                    mode = CSVMode.CLOSED;
                }
                // If it was closed, then open it raw
                else if (mode == CSVMode.CLOSED)
                {
                    mode = CSVMode.OPENED_RAW;

                    results.Add(content);

                    content = "";
                }
            }
            else
            {
                // If opened quote, just read it
                if (mode == CSVMode.OPENED_QUOTE)
                {
                    content += letter;
                }
                // If opened raw, then read it
                else if (mode == CSVMode.OPENED_RAW)
                {
                    content += letter;
                }
                // It closed, then open raw
                else if (mode == CSVMode.CLOSED)
                {
                    mode = CSVMode.OPENED_RAW;

                    content += letter;
                }
            }
        }

        // If it was still reading when the buffer finished
        if (mode != CSVMode.CLOSED)
        {
            results.Add(content);
        }

        return results;
    }

0

यहाँ एक छोटा और सरल उपाय है।

                using (TextFieldParser parser = new TextFieldParser(outputLocation))
                 {
                        parser.TextFieldType = FieldType.Delimited;
                        parser.SetDelimiters(",");
                        string[] headers = parser.ReadLine().Split(',');
                        foreach (string header in headers)
                        {
                            dataTable.Columns.Add(header);
                        }
                        while (!parser.EndOfData)
                        {
                            string[] fields = parser.ReadFields();
                            dataTable.Rows.Add(fields);
                        }
                    }
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.