DefaultClassMap C# (CSharp)のコード例

コード例 #1

0

ファイルを表示

ファイル: NumberStylesMapTests.cs プロジェクト: zhzy0077/CsvHelper

        public void Parameter_WithName_CreatesParameterMaps()
        {
            var map = new DefaultClassMap <Foo>();

            map.Parameter("id");
            map.Parameter("amount").TypeConverterOption.NumberStyles(NumberStyles.AllowParentheses);

            Assert.AreEqual(2, map.ParameterMaps.Count);
            Assert.IsNull(map.ParameterMaps[0].Data.TypeConverterOptions.NumberStyles);
            Assert.AreEqual(NumberStyles.AllowParentheses, map.ParameterMaps[1].Data.TypeConverterOptions.NumberStyles);
        }

コード例 #2

0

ファイルを表示

ファイル: NumberStylesMapTests.cs プロジェクト: zhzy0077/CsvHelper

        public void Parameter_WithConstructorFunctionAndName_CreatesParameterMaps()
        {
            var map = new DefaultClassMap <Foo>();

            map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "id");
            map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "amount").TypeConverterOption.NumberStyles(NumberStyles.AllowParentheses);

            Assert.AreEqual(2, map.ParameterMaps.Count);
            Assert.IsNull(map.ParameterMaps[0].Data.TypeConverterOptions.NumberStyles);
            Assert.AreEqual(NumberStyles.AllowParentheses, map.ParameterMaps[1].Data.TypeConverterOptions.NumberStyles);
        }

コード例 #3

0

ファイルを表示

ファイル: OptionalMapTests.cs プロジェクト: fvj-itminds/CsvHelper

        public void Parameter_WithName_CreatesParameterMaps()
        {
            var map = new DefaultClassMap <Foo>();

            map.Parameter("id");
            map.Parameter("name").Optional();

            Assert.Equal(2, map.ParameterMaps.Count);
            Assert.False(map.ParameterMaps[0].Data.IsOptional);
            Assert.True(map.ParameterMaps[1].Data.IsOptional);
        }

コード例 #4

0

ファイルを表示

        public void Parameter_WithConstructorFunctionAndName_CreatesParameterMaps()
        {
            var map = new DefaultClassMap <Foo>();

            map.Parameter(() => ConfigurationFunctions.GetConstructor(typeof(Foo)), "id").Name("Id");
            map.Parameter(() => ConfigurationFunctions.GetConstructor(typeof(Foo)), "name").Name("Name");

            Assert.AreEqual(2, map.ParameterMaps.Count);
            Assert.AreEqual("Id", map.ParameterMaps[0].Data.Names[0]);
            Assert.AreEqual("Name", map.ParameterMaps[1].Data.Names[0]);
        }

コード例 #5

0

ファイルを表示

        public void Parameter_WithName_CreatesParameterMaps()
        {
            var map = new DefaultClassMap <Foo>();

            map.Parameter("id");
            map.Parameter("name").Ignore();

            Assert.AreEqual(2, map.ParameterMaps.Count);
            Assert.IsFalse(map.ParameterMaps[0].Data.Ignore);
            Assert.IsTrue(map.ParameterMaps[1].Data.Ignore);
        }

コード例 #6

0

ファイルを表示

        public void Parameter_WithConstructorFunctionAndName_CreatesParameterMaps()
        {
            var map = new DefaultClassMap <Foo>();

            map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "id");
            map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "date").TypeConverterOption.DateTimeStyles(DateTimeStyles.AllowLeadingWhite);

            Assert.Equal(2, map.ParameterMaps.Count);
            Assert.Null(map.ParameterMaps[0].Data.TypeConverterOptions.DateTimeStyle);
            Assert.Equal(DateTimeStyles.AllowLeadingWhite, map.ParameterMaps[1].Data.TypeConverterOptions.DateTimeStyle);
        }

コード例 #7

0

ファイルを表示

        public void Parameter_WithName_CreatesParameterMaps()
        {
            var map = new DefaultClassMap <Foo>();

            map.Parameter("id");
            map.Parameter("date").TypeConverterOption.DateTimeStyles(DateTimeStyles.AllowLeadingWhite);

            Assert.Equal(2, map.ParameterMaps.Count);
            Assert.Null(map.ParameterMaps[0].Data.TypeConverterOptions.DateTimeStyle);
            Assert.Equal(DateTimeStyles.AllowLeadingWhite, map.ParameterMaps[1].Data.TypeConverterOptions.DateTimeStyle);
        }

コード例 #8

0

ファイルを表示

        public void Parameter_WithConstructorAndParameter_AddsParameter()
        {
            var map         = new DefaultClassMap <Foo>();
            var constructor = ConfigurationFunctions.GetConstructor(typeof(Foo));
            var parameter   = constructor.GetParameters().Single(p => p.Name == "id");

            map.Parameter(constructor, parameter);

            Assert.AreEqual(1, map.ParameterMaps.Count);
            Assert.AreEqual("id", map.ParameterMaps[0].Data.Parameter.Name);
        }

コード例 #9

0

ファイルを表示

        public void Parameter_WithName_CreatesParameterMaps()
        {
            var map = new DefaultClassMap <Foo>();

            map.Parameter("id");
            map.Parameter("name").TypeConverter <CustomConverter>();

            Assert.Equal(2, map.ParameterMaps.Count);
            Assert.Null(map.ParameterMaps[0].Data.TypeConverter);
            Assert.IsType <CustomConverter>(map.ParameterMaps[1].Data.TypeConverter);
        }

コード例 #10

0

ファイルを表示

        public void Parameter_WithConstructorFunctionAndName_CreatesParameterMaps()
        {
            var map = new DefaultClassMap <Foo>();

            map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "id");
            map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "name").TypeConverter <CustomConverter>();

            Assert.Equal(2, map.ParameterMaps.Count);
            Assert.Null(map.ParameterMaps[0].Data.TypeConverter);
            Assert.IsType <CustomConverter>(map.ParameterMaps[1].Data.TypeConverter);
        }

コード例 #11

0

ファイルを表示

ファイル: OptionalMapTests.cs プロジェクト: zhzy0077/CsvHelper

        public void Parameter_WithConstructorFunctionAndName_CreatesParameterMaps()
        {
            var map = new DefaultClassMap <Foo>();

            map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "id");
            map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "name").Optional();

            Assert.AreEqual(2, map.ParameterMaps.Count);
            Assert.IsFalse(map.ParameterMaps[0].Data.IsOptional);
            Assert.IsTrue(map.ParameterMaps[1].Data.IsOptional);
        }

コード例 #12

0

ファイルを表示

        public void Parameter_WithName_CreatesParameterMaps()
        {
            var map = new DefaultClassMap <Foo>();

            map.Parameter("id").Index(0);
            map.Parameter("name").Index(1);

            Assert.AreEqual(2, map.ParameterMaps.Count);
            Assert.AreEqual(0, map.ParameterMaps[0].Data.Index);
            Assert.AreEqual(1, map.ParameterMaps[1].Data.Index);
        }

コード例 #13

0

ファイルを表示

        public void Parameter_WithName_CreatesParameterMaps()
        {
            var map = new DefaultClassMap <Foo>();

            map.Parameter("id");
            map.Parameter("name").TypeConverter <CustomConverter>();

            Assert.AreEqual(2, map.ParameterMaps.Count);
            Assert.IsNull(map.ParameterMaps[0].Data.TypeConverter);
            Assert.IsInstanceOfType(map.ParameterMaps[1].Data.TypeConverter, typeof(CustomConverter));
        }

コード例 #14

0

ファイルを表示

        public void Parameter_WithName_CreatesParameterMaps()
        {
            var map = new DefaultClassMap <Foo>();

            map.Parameter("id").Name("Id");
            map.Parameter("name").Name("Name");

            Assert.AreEqual(2, map.ParameterMaps.Count);
            Assert.AreEqual("Id", map.ParameterMaps[0].Data.Names[0]);
            Assert.AreEqual("Name", map.ParameterMaps[1].Data.Names[0]);
        }

コード例 #15

0

ファイルを表示

ファイル: NameIndexMapTests.cs プロジェクト: fvj-itminds/CsvHelper

        public void Parameter_WithConstructorFunctionAndName_CreatesParameterMaps()
        {
            var map = new DefaultClassMap <Foo>();

            map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "id").NameIndex(0);
            map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "name").NameIndex(1);

            Assert.Equal(2, map.ParameterMaps.Count);
            Assert.Equal(0, map.ParameterMaps[0].Data.NameIndex);
            Assert.Equal(1, map.ParameterMaps[1].Data.NameIndex);
        }

コード例 #16

0

ファイルを表示

ファイル: CsvHelpers.cs プロジェクト: pluraltouch/Cake.CsvHelper

        /// <summary>
        /// Writes the records to the speficed file using the specified mapping and settings.
        /// </summary>
        /// <typeparam name="T">The record type.</typeparam>
        /// <param name="csvFile">The CSV file to write.</param>
        /// <param name="records">The records to write.</param>
        /// <param name="mapping">The property column mapping.</param>
        /// <param name="settings">The settings.</param>
        public void WriteRecords <T>(FilePath csvFile, List <T> records, Dictionary <string, string> mapping,
                                     CsvHelperSettings settings)
        {
            if (mapping == null)
            {
                throw new ArgumentNullException(nameof(mapping));
            }
            var customMap = new DefaultClassMap <T>();

            customMap.AutoMap();
            WriteRecords(csvFile, records, customMap, settings);
        }

コード例 #17

0

ファイルを表示

ファイル: NullValuesMapTests.cs プロジェクト: studentutu/CsvHelper

        public void AutoMap_WithBooleanFalseValuesAttribute_CreatesParameterMaps()
        {
            var map = new DefaultClassMap <Foo>();

            map.Parameter("id");
            map.Parameter("name").TypeConverterOption.NullValues("NULL");

            Assert.Equal(2, map.ParameterMaps.Count);
            Assert.Empty(map.ParameterMaps[0].Data.TypeConverterOptions.NullValues);
            Assert.Single(map.ParameterMaps[1].Data.TypeConverterOptions.NullValues);
            Assert.Equal("NULL", map.ParameterMaps[1].Data.TypeConverterOptions.NullValues[0]);
        }

コード例 #18

0

ファイルを表示

        public static List <T> Deserialize(string input)
        {
            DefaultClassMap <T> mapping = CreateMapping();

            using (var reader = new StringReader(input))
                using (var csv = new CsvReader(reader))
                {
                    csv.Configuration.RegisterClassMap(mapping);
                    csv.Configuration.Delimiter = ",";
                    return(csv.GetRecords <T>().ToList());
                }
        }

コード例 #19

0

ファイルを表示

        public void Parameter_WithName_CreatesParameterMaps()
        {
            var map = new DefaultClassMap <Foo>();

            map.Parameter("id");
            map.Parameter("date").TypeConverterOption.Format(FORMAT);

            Assert.AreEqual(2, map.ParameterMaps.Count);
            Assert.IsNull(map.ParameterMaps[0].Data.TypeConverterOptions.Formats);
            Assert.AreEqual(1, map.ParameterMaps[1].Data.TypeConverterOptions.Formats.Count());
            Assert.AreEqual(FORMAT, map.ParameterMaps[1].Data.TypeConverterOptions.Formats[0]);
        }

コード例 #20

0

ファイルを表示

ファイル: ConstantMapTests.cs プロジェクト: studentutu/CsvHelper

        public void Parameter_WithName_CreatesParameterMaps()
        {
            var map = new DefaultClassMap <Foo>();

            map.Parameter("id");
            map.Parameter("name").Constant("Bar");

            Assert.Equal(2, map.ParameterMaps.Count);
            Assert.False(map.ParameterMaps[0].Data.IsConstantSet);
            Assert.True(map.ParameterMaps[1].Data.IsConstantSet);
            Assert.Equal("Bar", map.ParameterMaps[1].Data.Constant);
        }

コード例 #21

0

ファイルを表示

        public void Parameter_WithConstructorFunctionAndName_CreatesParameterMaps()
        {
            var map = new DefaultClassMap <Foo>();

            map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "id");
            map.Parameter(() => ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo))), "date").TypeConverterOption.Format(FORMAT);

            Assert.Equal(2, map.ParameterMaps.Count);
            Assert.Null(map.ParameterMaps[0].Data.TypeConverterOptions.Formats);
            Assert.Single(map.ParameterMaps[1].Data.TypeConverterOptions.Formats);
            Assert.Equal(FORMAT, map.ParameterMaps[1].Data.TypeConverterOptions.Formats[0]);
        }

コード例 #22

0

ファイルを表示

ファイル: IgnoreBaseTests.cs プロジェクト: studentutu/CsvHelper

        public void GetRecordsWithFields_IgnoreBaseAttribute_DoesNotMapBaseClass()
        {
            var map = new DefaultClassMap <ChildFields>();

            map.AutoMap(new CsvConfiguration(CultureInfo.InvariantCulture)
            {
                MemberTypes = MemberTypes.Fields,
            });

            Assert.Single(map.MemberMaps);
            Assert.Null(map.MemberMaps.Find <ChildFields>(m => m.Id));
            Assert.NotNull(map.MemberMaps.Find <ChildFields>(m => m.Name));
        }

コード例 #23

0

ファイルを表示

ファイル: NumberStylesMapTests.cs プロジェクト: studentutu/CsvHelper

        public void Parameter_WithConstructorAndProperty_CreatesParameterMaps()
        {
            var constructor = ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo)));
            var parameters  = constructor.GetParameters();

            var map = new DefaultClassMap <Foo>();

            map.Parameter(constructor, parameters[0]);
            map.Parameter(constructor, parameters[1]).TypeConverterOption.NumberStyles(NumberStyles.AllowParentheses);

            Assert.Equal(2, map.ParameterMaps.Count);
            Assert.Null(map.ParameterMaps[0].Data.TypeConverterOptions.NumberStyles);
            Assert.Equal(NumberStyles.AllowParentheses, map.ParameterMaps[1].Data.TypeConverterOptions.NumberStyles);
        }

コード例 #24

0

ファイルを表示

ファイル: NameIndexMapTests.cs プロジェクト: studentutu/CsvHelper

        public void Parameter_WithConstructorAndProperty_CreatesParameterMaps()
        {
            var constructor = ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo)));
            var parameters  = constructor.GetParameters();

            var map = new DefaultClassMap <Foo>();

            map.Parameter(constructor, parameters[0]).NameIndex(0);
            map.Parameter(constructor, parameters[1]).NameIndex(1);

            Assert.Equal(2, map.ParameterMaps.Count);
            Assert.Equal(0, map.ParameterMaps[0].Data.NameIndex);
            Assert.Equal(1, map.ParameterMaps[1].Data.NameIndex);
        }

コード例 #25

0

ファイルを表示

ファイル: BooleanTrueValuesMapTests.cs プロジェクト: PeterNguyen0210/CsvHelper

        public void AutoMap_WithBooleanFalseValuesAttribute_CreatesParameterMaps()
        {
            var map = new DefaultClassMap <Foo>();

            map.Parameter("id");
            map.Parameter("boolean").TypeConverterOption.BooleanValues(true, true, "Bar");

            Assert.AreEqual(2, map.ParameterMaps.Count);
            Assert.AreEqual(0, map.ParameterMaps[0].Data.TypeConverterOptions.BooleanTrueValues.Count);
            Assert.AreEqual(0, map.ParameterMaps[0].Data.TypeConverterOptions.BooleanFalseValues.Count);
            Assert.AreEqual(1, map.ParameterMaps[1].Data.TypeConverterOptions.BooleanTrueValues.Count);
            Assert.AreEqual(0, map.ParameterMaps[1].Data.TypeConverterOptions.BooleanFalseValues.Count);
            Assert.AreEqual("Bar", map.ParameterMaps[1].Data.TypeConverterOptions.BooleanTrueValues[0]);
        }

コード例 #26

0

ファイルを表示

ファイル: DateTimeStylesMapTests.cs プロジェクト: zhzy0077/CsvHelper

        public void Parameter_WithConstructorAndProperty_CreatesParameterMaps()
        {
            var constructor = ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo)));
            var parameters  = constructor.GetParameters();

            var map = new DefaultClassMap <Foo>();

            map.Parameter(constructor, parameters[0]);
            map.Parameter(constructor, parameters[1]).TypeConverterOption.DateTimeStyles(DateTimeStyles.AllowLeadingWhite);

            Assert.AreEqual(2, map.ParameterMaps.Count);
            Assert.IsNull(map.ParameterMaps[0].Data.TypeConverterOptions.DateTimeStyle);
            Assert.AreEqual(DateTimeStyles.AllowLeadingWhite, map.ParameterMaps[1].Data.TypeConverterOptions.DateTimeStyle);
        }

コード例 #27

0

ファイルを表示

        public void Parameter_WithConstructorAndProperty_CreatesParameterMaps()
        {
            var constructor = ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo)));
            var parameters  = constructor.GetParameters();

            var map = new DefaultClassMap <Foo>();

            map.Parameter(constructor, parameters[0]);
            map.Parameter(constructor, parameters[1]).Ignore();

            Assert.AreEqual(2, map.ParameterMaps.Count);
            Assert.IsFalse(map.ParameterMaps[0].Data.Ignore);
            Assert.IsTrue(map.ParameterMaps[1].Data.Ignore);
        }

コード例 #28

0

ファイルを表示

ファイル: TypeConverterMapTests.cs プロジェクト: netcore-jroger/CsvHelper

        public void Parameter_WithConstructorAndProperty_CreatesParameterMaps()
        {
            var constructor = ConfigurationFunctions.GetConstructor(typeof(Foo));
            var parameters  = constructor.GetParameters();

            var map = new DefaultClassMap <Foo>();

            map.Parameter(constructor, parameters[0]);
            map.Parameter(constructor, parameters[1]).TypeConverter <CustomConverter>();

            Assert.AreEqual(2, map.ParameterMaps.Count);
            Assert.IsNull(map.ParameterMaps[0].Data.TypeConverter);
            Assert.IsInstanceOfType(map.ParameterMaps[1].Data.TypeConverter, typeof(CustomConverter));
        }

コード例 #29

0

ファイルを表示

        public void Parameter_WithConstructorAndProperty_CreatesParameterMaps()
        {
            var constructor = ConfigurationFunctions.GetConstructor(typeof(Foo));
            var parameters  = constructor.GetParameters();

            var map = new DefaultClassMap <Foo>();

            map.Parameter(constructor, parameters[0]).Name("Id");
            map.Parameter(constructor, parameters[1]).Name("Name");

            Assert.AreEqual(2, map.ParameterMaps.Count);
            Assert.AreEqual("Id", map.ParameterMaps[0].Data.Names[0]);
            Assert.AreEqual("Name", map.ParameterMaps[1].Data.Names[0]);
        }

コード例 #30

0

ファイルを表示

        public void Parameter_WithConstructorAndProperty_CreatesParameterMaps()
        {
            var constructor = ConfigurationFunctions.GetConstructor(new GetConstructorArgs(typeof(Foo)));
            var parameters  = constructor.GetParameters();

            var map = new DefaultClassMap <Foo>();

            map.Parameter(constructor, parameters[0]);
            map.Parameter(constructor, parameters[1]).TypeConverterOption.Format(FORMAT);

            Assert.Equal(2, map.ParameterMaps.Count);
            Assert.Null(map.ParameterMaps[0].Data.TypeConverterOptions.Formats);
            Assert.Single(map.ParameterMaps[1].Data.TypeConverterOptions.Formats);
            Assert.Equal(FORMAT, map.ParameterMaps[1].Data.TypeConverterOptions.Formats[0]);
        }

C# (CSharp) DefaultClassMapの例