using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.IO;

using System.Data;

using System.ComponentModel.DataAnnotations;

using System.Globalization;

using System.Reflection;

using System.Collections.ObjectModel;

​

using NUnit.Framework; // Throws NUnit.Framework.AssertionException

​

using CsvHelper;

using CsvHelper.Configuration;

using CsvHelper.Configuration.Attributes;

using CsvHelper.Expressions;

using CsvHelper.TypeConversion;

​

//https://stackoverflow.com/questions/71844007/how-to-reformat-datetime-values-in-csv-file

​

using Newtonsoft.Json;

​

    class Record

    {

        [Name("mbox_id")]

        public string MailboxId { get; set; }

​

        [Name("email_address")]

        public string EmailAddress { get; set;}

​

        [Name("created")]

        public DateTime? Created { get; set; }

​

        [Name("updated")]

        public DateTime? Updated { get; set; }

​

        [Name("created_by")]

        public string CreatedBy { get; set;}

​

        [Name("memo")]

        public string Memo { get; set; }

    }

​

    public static class TypeConverterOptionsCacheExtensions

    {

        public static void AddOptionsForTypeAndNullable(this TypeConverterOptionsCache cache, Type type, TypeConverterOptions options)

        {

            if (type == null || cache == null)

                throw new ArgumentNullException();

​

            if (!type.IsValueType)

            {

                cache.AddOptions(type, options);

            }

            else

            {

                var underlying = Nullable.GetUnderlyingType(type) ?? type;

                var nullable = typeof(Nullable<>).MakeGenericType(underlying);

                cache.AddOptions(underlying, options);

                cache.AddOptions(nullable, options);

            }

        }

​

​

        public static void AddOptionsForTypeAndNullable<T>(this TypeConverterOptionsCache cache, TypeConverterOptions options) where T : struct

            => cache.AddOptionsForTypeAndNullable(typeof(T), options);

    }

​

    class TestClass

    {

        public static void Test()

        {

            var CsvPath = @"Question71844007.csv";

​

            CreateCSV(CsvPath);

            TestRead(CsvPath);

        }

​

        public static void TestRead(string CsvPath)

        {

            var csvConfiguration = new CsvConfiguration(CultureInfo.InvariantCulture);

            csvConfiguration.HasHeaderRecord = true;

            csvConfiguration.Delimiter = ";";

            csvConfiguration.TrimOptions = TrimOptions.Trim;

​

            Record[] records;

​

            using (var reader = new StreamReader(CsvPath, Encoding.UTF8))

                using (var csv = new CsvReader(reader, csvConfiguration))

            {

                records = csv.GetRecords<Record>().ToArray();

            }

​

            var outputPath = $@"reformatted71844007.csv";

            using (var writer = new StreamWriter(outputPath))

                using (var csv = new CsvWriter(writer, CultureInfo.CurrentCulture))

            {

                var options = new TypeConverterOptions { Formats = new[] { "yyyy-MM-dd HH:mm:ss" } };

                csv.Context.TypeConverterOptionsCache.AddOptionsForTypeAndNullable<DateTime>(options);

                csv.WriteRecords(records.Where(x => x.Memo != null));

            }

            var result = File.ReadAllText(outputPath);

            Console.WriteLine(result);

            Assert.IsTrue(result.Contains(@"1,foo@bar.net,2022-04-12 12:05:05,2022-04-12 12:06:07,,hello"));

        }   

        static void CreateCSV(string CsvPath)

        {

            var records = new List<Record> 

            {

                new Record

                {

                    MailboxId = "1",

                    EmailAddress = "foo@bar.net",

                    Created = new DateTime(2022, 4, 12, 12, 5, 5, 333, DateTimeKind.Local),

                    Updated = new DateTime(2022, 4, 12, 12, 6, 7, 444, DateTimeKind.Local),

                    Memo = "hello",

                },

            };

​

            var csvConfiguration = new CsvConfiguration(CultureInfo.InvariantCulture);

            csvConfiguration.HasHeaderRecord = true;

            csvConfiguration.Delimiter = ";";

            csvConfiguration.TrimOptions = TrimOptions.Trim;

            using (var writer = new StreamWriter(CsvPath, false, Encoding.UTF8))

                using (var csv = new CsvWriter(writer, csvConfiguration))

            {

                csv.WriteRecords(records);

            }

​

            Console.WriteLine(File.ReadAllText(CsvPath));

        }

    }

​

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: {0} ({1})", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription ,Environment.Version);

            Console.WriteLine("OS Version: {0}, NewLine: {1}", System.Environment.OSVersion, JsonConvert.SerializeObject(Environment.NewLine));

            Console.WriteLine("{0} version: {1}", typeof(CsvReader).Assembly.GetName().Name,  typeof(CsvReader).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Failed with unhandled exception: ");

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​