Konwersja listy ogólnej na ciąg CSV

Mam listę wartości całkowitych (Lista) i chciałbym wygenerować ciąg wartości rozdzielanych przecinkami. Oznacza to, że wszystkie pozycje z listy są wyświetlane na pojedynczej liście rozdzielanej przecinkami.

Moje myśli ... 1. Przekaż listę do metody. 2. Użyj narzędzia stringbuilder do iteracji listy i dołącz przecinki. 3. Przetestuj ostatni znak i jeśli jest to przecinek, usuń go.

Jakie są Twoje myśli? Czy to najlepszy sposób?

Jak zmieniłby się mój kod, gdybym chciał w przyszłości obsługiwać nie tylko liczby całkowite (mój obecny plan), ale także stringi, longs, double, bools itp.? Myślę, że zaakceptuje listę dowolnego typu.

To niesamowite, co Framework już dla nas robi.

List<int> myValues;
string csv = String.Join(",", myValues.Select(x => x.ToString()).ToArray());

W ogólnym przypadku:

IEnumerable<T> myList;
string csv = String.Join(",", myList.Select(x => x.ToString()).ToArray());

Jak widać, właściwie nie jest inaczej. Pamiętaj, że może być konieczne zawijanie x.ToString()cudzysłowów (tj. "\"" + x.ToString() + "\"") W przypadku, gdy x.ToString()zawiera przecinki.

Ciekawą lekturę na temat niewielkiego wariantu tego: zobacz Comma Quibbling na blogu Erica Lipperta.

Uwaga: zostało to napisane przed oficjalnym wydaniem .NET 4.0. Teraz możemy tylko powiedzieć

IEnumerable<T> sequence;
string csv = String.Join(",", sequence);

używając przeciążenia String.Join<T>(string, IEnumerable<T>). Ta metoda automatycznie rzutuje każdy element xna x.ToString().

w 3.5 nadal mogłem to zrobić. Jest znacznie prostszy i nie potrzebuje lambdy.

String.Join(",", myList.ToArray<string>());

Możesz utworzyć metodę rozszerzenia, którą możesz wywołać dla dowolnego IEnumerable:

public static string JoinStrings<T>(
    this IEnumerable<T> values, string separator)
{
    var stringValues = values.Select(item =>
        (item == null ? string.Empty : item.ToString()));
    return string.Join(separator, stringValues.ToArray());
}

Następnie możesz po prostu wywołać metodę z oryginalnej listy:

string commaSeparated = myList.JoinStrings(", ");

Możesz użyć String.Join.

String.Join(
  ",",
  Array.ConvertAll(
     list.ToArray(),
     element => element.ToString()
  )
);

Jeśli jakakolwiek treść chce przekonwertować listę niestandardowych obiektów klas zamiast listy ciągów, zastąp metodę ToString klasy za pomocą reprezentacji wiersza CSV swojej klasy.

Public Class MyClass{
   public int Id{get;set;}
   public String PropertyA{get;set;}
   public override string ToString()
   {
     return this.Id+ "," + this.PropertyA;
   }
}

Następnie można użyć poniższego kodu, aby przekonwertować tę listę klas na CSV z kolumną nagłówka

string csvHeaderRow = String.Join(",", typeof(MyClass).GetProperties(BindingFlags.Public | BindingFlags.Instance).Select(x => x.Name).ToArray<string>()) + Environment.NewLine;
string csv= csvHeaderRow + String.Join(Environment.NewLine, MyClass.Select(x => x.ToString()).ToArray());

Jak w kodzie w linku podanym przez @Frank Create a CSV File from a .NET Generic List był mały problem z zakończeniem każdej linii ,literą. Zmodyfikowałem kod, aby się go pozbyć. Mam nadzieję, że to komuś pomoże.

/// <summary>
/// Creates the CSV from a generic list.
/// </summary>;
/// <typeparam name="T"></typeparam>;
/// <param name="list">The list.</param>;
/// <param name="csvNameWithExt">Name of CSV (w/ path) w/ file ext.</param>;
public static void CreateCSVFromGenericList<T>(List<T> list, string csvCompletePath)
{
    if (list == null || list.Count == 0) return;

    //get type from 0th member
    Type t = list[0].GetType();
    string newLine = Environment.NewLine;

    if (!Directory.Exists(Path.GetDirectoryName(csvCompletePath))) Directory.CreateDirectory(Path.GetDirectoryName(csvCompletePath));

    if (!File.Exists(csvCompletePath)) File.Create(csvCompletePath);

    using (var sw = new StreamWriter(csvCompletePath))
    {
        //make a new instance of the class name we figured out to get its props
        object o = Activator.CreateInstance(t);
        //gets all properties
        PropertyInfo[] props = o.GetType().GetProperties();

        //foreach of the properties in class above, write out properties
        //this is the header row
        sw.Write(string.Join(",", props.Select(d => d.Name).ToArray()) + newLine);

        //this acts as datarow
        foreach (T item in list)
        {
            //this acts as datacolumn
            var row = string.Join(",", props.Select(d => item.GetType()
                                                            .GetProperty(d.Name)
                                                            .GetValue(item, null)
                                                            .ToString())
                                                    .ToArray());
            sw.Write(row + newLine);

        }
    }
}

Szczegółowo wyjaśniam to w tym poście . Po prostu wkleię tutaj kod z krótkimi opisami.

Oto metoda, która tworzy wiersz nagłówka. Używa nazw właściwości jako nazw kolumn.

private static void CreateHeader<T>(List<T> list, StreamWriter sw)
    {
        PropertyInfo[] properties = typeof(T).GetProperties();
        for (int i = 0; i < properties.Length - 1; i++)
        {
            sw.Write(properties[i].Name + ",");
        }
        var lastProp = properties[properties.Length - 1].Name;
        sw.Write(lastProp + sw.NewLine);
    }

Ta metoda tworzy wszystkie wiersze wartości

private static void CreateRows<T>(List<T> list, StreamWriter sw)
    {
        foreach (var item in list)
        {
            PropertyInfo[] properties = typeof(T).GetProperties();
            for (int i = 0; i < properties.Length - 1; i++)
            {
                var prop = properties[i];
                sw.Write(prop.GetValue(item) + ",");
            }
            var lastProp = properties[properties.Length - 1];
            sw.Write(lastProp.GetValue(item) + sw.NewLine);
        }
    }

A oto metoda, która łączy je razem i tworzy rzeczywisty plik.

public static void CreateCSV<T>(List<T> list, string filePath)
    {
        using (StreamWriter sw = new StreamWriter(filePath))
        {
            CreateHeader(list, sw);
            CreateRows(list, sw);
        }
    }

Dowolne rozwiązanie działa tylko wtedy, gdy wyświetla listę (ciąg)

Jeśli masz ogólną listę własnych obiektów, takich jak lista (of car), gdzie samochód ma n właściwości, musisz zapętlić PropertiesInfo każdego obiektu samochodu.

Spójrz na: http://www.csharptocsharp.com/generate-csv-from-generic-list

Podoba mi się ładna, prosta metoda rozszerzenia

 public static string ToCsv(this List<string> itemList)
         {
             return string.Join(",", itemList);
         }

Następnie możesz po prostu wywołać metodę z oryginalnej listy:

string CsvString = myList.ToCsv();

Czystsze i łatwiejsze do odczytania niż niektóre inne sugestie.

Problem z String.Join polega na tym, że nie zajmujesz się przypadkiem przecinka już istniejącego w wartości. Jeśli istnieje przecinek, należy otoczyć wartość w cudzysłowach i zastąpić wszystkie istniejące cudzysłowy podwójnymi cudzysłowami.

String.Join(",",{"this value has a , in it","This one doesn't", "This one , does"});

Zobacz moduł CSV

Biblioteka CsvHelper jest bardzo popularna w Nuget. Warto, stary! https://github.com/JoshClose/CsvHelper/wiki/Basics

Korzystanie z CsvHelper jest naprawdę łatwe. Jego ustawienia domyślne są skonfigurowane dla większości typowych scenariuszy.

Oto trochę danych konfiguracyjnych.

Actors.csv:

Id,FirstName,LastName  
1,Arnold,Schwarzenegger  
2,Matt,Damon  
3,Christian,Bale

Actor.cs (obiekt klasy niestandardowej reprezentujący aktora):

public class Actor
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

Odczytywanie pliku CSV za pomocą CsvReader:

var csv = new CsvReader( new StreamReader( "Actors.csv" ) );

var actorsList = csv.GetRecords ();

Zapisywanie do pliku CSV.

using (var csv = new CsvWriter( new StreamWriter( "Actors.csv" ) )) 
{
    csv.WriteRecords( actorsList );
}

Z jakiegoś powodu @AliUmair przywrócił edycję do swojej odpowiedzi, która naprawia jego kod, który nie działa tak, jak jest, więc oto działająca wersja, która nie ma błędu dostępu do pliku i poprawnie obsługuje wartości właściwości obiektu zerowego:

/// <summary>
/// Creates the CSV from a generic list.
/// </summary>;
/// <typeparam name="T"></typeparam>;
/// <param name="list">The list.</param>;
/// <param name="csvNameWithExt">Name of CSV (w/ path) w/ file ext.</param>;
public static void CreateCSVFromGenericList<T>(List<T> list, string csvCompletePath)
{
    if (list == null || list.Count == 0) return;

    //get type from 0th member
    Type t = list[0].GetType();
    string newLine = Environment.NewLine;

    if (!Directory.Exists(Path.GetDirectoryName(csvCompletePath))) Directory.CreateDirectory(Path.GetDirectoryName(csvCompletePath));

    using (var sw = new StreamWriter(csvCompletePath))
    {
        //make a new instance of the class name we figured out to get its props
        object o = Activator.CreateInstance(t);
        //gets all properties
        PropertyInfo[] props = o.GetType().GetProperties();

        //foreach of the properties in class above, write out properties
        //this is the header row
        sw.Write(string.Join(",", props.Select(d => d.Name).ToArray()) + newLine);

        //this acts as datarow
        foreach (T item in list)
        {
            //this acts as datacolumn
            var row = string.Join(",", props.Select(d => $"\"{item.GetType().GetProperty(d.Name).GetValue(item, null)?.ToString()}\"")
                                                    .ToArray());
            sw.Write(row + newLine);

        }
    }
}

http://cc.davelozinski.com/c-sharp/the-fastest-way-to-read-and-process-text-files

Ta strona internetowa przeprowadziła obszerne testy dotyczące tego, jak pisać do pliku przy użyciu buforowanego programu zapisującego, czytanie wiersz po wierszu wydaje się być najlepszym sposobem, a użycie narzędzia do tworzenia ciągów było jednym z najwolniejszych.

Używam jego technik bardzo często do pisania rzeczy, aby złożyć to dobrze.

Metoda rozszerzenia ToCsv () ogólnego przeznaczenia:

• Obsługuje Int16 / 32/64, float, double, decimal i cokolwiek obsługującego ToString ()
• Opcjonalny niestandardowy separator łączenia
• Opcjonalny selektor niestandardowy
• Opcjonalna null / pusta specyfikacja obsługi (przeciążenia * Opt ())

Przykłady użycia:

"123".ToCsv() // "1,2,3"
"123".ToCsv(", ") // "1, 2, 3"
new List<int> { 1, 2, 3 }.ToCsv() // "1,2,3"

new List<Tuple<int, string>> 
{ 
    Tuple.Create(1, "One"), 
    Tuple.Create(2, "Two") 
}
.ToCsv(t => t.Item2);  // "One,Two"

((string)null).ToCsv() // throws exception
((string)null).ToCsvOpt() // ""
((string)null).ToCsvOpt(ReturnNullCsv.WhenNull) // null

Realizacja

/// <summary>
/// Specifies when ToCsv() should return null.  Refer to ToCsv() for IEnumerable[T]
/// </summary>
public enum ReturnNullCsv
{
    /// <summary>
    /// Return String.Empty when the input list is null or empty.
    /// </summary>
    Never,

    /// <summary>
    /// Return null only if input list is null.  Return String.Empty if list is empty.
    /// </summary>
    WhenNull,

    /// <summary>
    /// Return null when the input list is null or empty
    /// </summary>
    WhenNullOrEmpty,

    /// <summary>
    /// Throw if the argument is null
    /// </summary>
    ThrowIfNull
}   

/// <summary>
/// Converts IEnumerable list of values to a comma separated string values.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="values">The values.</param>        
/// <param name="joinSeparator"></param>
/// <returns>System.String.</returns>
public static string ToCsv<T>(
    this IEnumerable<T> values,            
    string joinSeparator = ",")
{
    return ToCsvOpt<T>(values, null /*selector*/, ReturnNullCsv.ThrowIfNull, joinSeparator);
}

/// <summary>
/// Converts IEnumerable list of values to a comma separated string values.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="values">The values.</param>
/// <param name="selector">An optional selector</param>
/// <param name="joinSeparator"></param>
/// <returns>System.String.</returns>
public static string ToCsv<T>(
    this IEnumerable<T> values,
    Func<T, string> selector,            
    string joinSeparator = ",") 
{
    return ToCsvOpt<T>(values, selector, ReturnNullCsv.ThrowIfNull, joinSeparator);
}

/// <summary>
/// Converts IEnumerable list of values to a comma separated string values.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="values">The values.</param>
/// <param name="returnNullCsv">Return mode (refer to enum ReturnNullCsv).</param>
/// <param name="joinSeparator"></param>
/// <returns>System.String.</returns>
public static string ToCsvOpt<T>(
    this IEnumerable<T> values,
    ReturnNullCsv returnNullCsv = ReturnNullCsv.Never,
    string joinSeparator = ",")
{
    return ToCsvOpt<T>(values, null /*selector*/, returnNullCsv, joinSeparator);
}

/// <summary>
/// Converts IEnumerable list of values to a comma separated string values.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="values">The values.</param>
/// <param name="selector">An optional selector</param>
/// <param name="returnNullCsv">Return mode (refer to enum ReturnNullCsv).</param>
/// <param name="joinSeparator"></param>
/// <returns>System.String.</returns>
public static string ToCsvOpt<T>(
    this IEnumerable<T> values, 
    Func<T, string> selector,
    ReturnNullCsv returnNullCsv = ReturnNullCsv.Never,
    string joinSeparator = ",")
{
    switch (returnNullCsv)
    {
        case ReturnNullCsv.Never:
            if (!values.AnyOpt())
                return string.Empty;
            break;

        case ReturnNullCsv.WhenNull:
            if (values == null)
                return null;
            break;

        case ReturnNullCsv.WhenNullOrEmpty:
            if (!values.AnyOpt())
                return null;
            break;

        case ReturnNullCsv.ThrowIfNull:
            if (values == null)
                throw new ArgumentOutOfRangeException("ToCsvOpt was passed a null value with ReturnNullCsv = ThrowIfNull.");
            break;

        default:
            throw new ArgumentOutOfRangeException("returnNullCsv", returnNullCsv, "Out of range.");
    }

    if (selector == null)
    {
        if (typeof(T) == typeof(Int16) || 
            typeof(T) == typeof(Int32) || 
            typeof(T) == typeof(Int64))
        {                   
            selector = (v) => Convert.ToInt64(v).ToStringInvariant();
        }
        else if (typeof(T) == typeof(decimal))
        {
            selector = (v) => Convert.ToDecimal(v).ToStringInvariant();
        }
        else if (typeof(T) == typeof(float) ||
                typeof(T) == typeof(double))
        {
            selector = (v) => Convert.ToDouble(v).ToString(CultureInfo.InvariantCulture);
        }
        else
        {
            selector = (v) => v.ToString();
        }            
    }

    return String.Join(joinSeparator, values.Select(v => selector(v)));
}

public static string ToStringInvariantOpt(this Decimal? d)
{
    return d.HasValue ? d.Value.ToStringInvariant() : null;
}

public static string ToStringInvariant(this Decimal d)
{
    return d.ToString(CultureInfo.InvariantCulture);
}

public static string ToStringInvariantOpt(this Int64? l)
{
    return l.HasValue ? l.Value.ToStringInvariant() : null;
}

public static string ToStringInvariant(this Int64 l)
{
    return l.ToString(CultureInfo.InvariantCulture);
}

public static string ToStringInvariantOpt(this Int32? i)
{
    return i.HasValue ? i.Value.ToStringInvariant() : null;
}

public static string ToStringInvariant(this Int32 i)
{
    return i.ToString(CultureInfo.InvariantCulture);
}

public static string ToStringInvariantOpt(this Int16? i)
{
    return i.HasValue ? i.Value.ToStringInvariant() : null;
}

public static string ToStringInvariant(this Int16 i)
{
    return i.ToString(CultureInfo.InvariantCulture);
}

Oto moja metoda rozszerzenia, zwraca ciąg dla uproszczenia, ale moja implementacja zapisuje plik do jeziora danych.

Zapewnia dowolny separator, dodaje cudzysłowy do łańcucha (w przypadku, gdy zawierają separator) i rozdaje wartości null i spacje.

    /// <summary>
    /// A class to hold extension methods for C# Lists 
    /// </summary>
    public static class ListExtensions
    {
        /// <summary>
        /// Convert a list of Type T to a CSV
        /// </summary>
        /// <typeparam name="T">The type of the object held in the list</typeparam>
        /// <param name="items">The list of items to process</param>
        /// <param name="delimiter">Specify the delimiter, default is ,</param>
        /// <returns></returns>
        public static string ToCsv<T>(this List<T> items, string delimiter = ",")
        {
            Type itemType = typeof(T);
            var props = itemType.GetProperties(BindingFlags.Public | BindingFlags.Instance).OrderBy(p => p.Name);

            var csv = new StringBuilder();

            // Write Headers
            csv.AppendLine(string.Join(delimiter, props.Select(p => p.Name)));

            // Write Rows
            foreach (var item in items)
            {
                // Write Fields
                csv.AppendLine(string.Join(delimiter, props.Select(p => GetCsvFieldasedOnValue(p, item))));
            }

            return csv.ToString();
        }

        /// <summary>
        /// Provide generic and specific handling of fields
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="p"></param>
        /// <param name="item"></param>
        /// <returns></returns>
        private static object GetCsvFieldasedOnValue<T>(PropertyInfo p, T item)
        {
            string value = "";

            try
            {
                value = p.GetValue(item, null)?.ToString();
                if (value == null) return "NULL";  // Deal with nulls
                if (value.Trim().Length == 0) return ""; // Deal with spaces and blanks

                // Guard strings with "s, they may contain the delimiter!
                if (p.PropertyType == typeof(string))
                {
                    value = string.Format("\"{0}\"", value);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return value;
        }
    }

Stosowanie:

 // Tab Delimited (TSV)
 var csv = MyList.ToCsv<MyClass>("\t");