1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
// Copyright 2009-2022 Josh Close
// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0.
// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0.
// https://github.com/JoshClose/CsvHelper
using System;
using System.Linq.Expressions;
using System.Reflection;
namespace CsvHelper.Configuration
{
/// <summary>
/// Maps class members to CSV fields.
/// </summary>
/// <typeparam name="TClass">The <see cref="System.Type"/> of class to map.</typeparam>
public abstract class ClassMap<TClass> : ClassMap
{
/// <summary>
/// Creates an instance of <see cref="ClassMap{TClass}"/>.
/// </summary>
public ClassMap() : base(typeof(TClass)) { }
/// <summary>
/// Maps a member to a CSV field.
/// </summary>
/// <param name="expression">The member to map.</param>
/// <param name="useExistingMap">If true, an existing map will be used if available.
/// If false, a new map is created for the same member.</param>
/// <returns>The member mapping.</returns>
public virtual MemberMap<TClass, TMember> Map<TMember>(Expression<Func<TClass, TMember>> expression, bool useExistingMap = true)
{
var (classMap, member) = GetMemberMap(expression);
var memberMap = classMap.Map(typeof(TClass), member, useExistingMap); ;
return (MemberMap<TClass, TMember>)memberMap;
}
/// <summary>
/// Maps a member to a CSV field.
/// </summary>
/// <param name="expression">The member to map.</param>
/// <param name="useExistingMap">If true, an existing map will be used if available.
/// If false, a new map is created for the same member.</param>
/// <returns>The member mapping.</returns>
public virtual MemberMap Map<T>(Expression<Func<T, object>> expression, bool useExistingMap = true)
{
var (classMap, member) = GetMemberMap(expression);
var memberMap = classMap.Map(typeof(TClass), member, useExistingMap);
return memberMap;
}
/// <summary>
/// Meant for internal use only.
/// Maps a member to another class map. When this is used, accessing a property through
/// sub-property mapping later won't work. You can only use one or the other. When using
/// this, ConvertUsing will also not work.
/// </summary>
/// <typeparam name="TClassMap">The type of the class map.</typeparam>
/// <param name="expression">The expression.</param>
/// <param name="constructorArgs">Constructor arguments used to create the reference map.</param>
/// <returns>The reference mapping for the member.</returns>
public virtual MemberReferenceMap References<TClassMap>(Expression<Func<TClass, object>> expression, params object[] constructorArgs) where TClassMap : ClassMap
{
var member = ReflectionHelper.GetMember(expression);
return References(typeof(TClassMap), member, constructorArgs);
}
private (ClassMap, MemberInfo) GetMemberMap<TModel, TProperty>(Expression<Func<TModel, TProperty>> expression)
{
var stack = ReflectionHelper.GetMembers(expression);
if (stack.Count == 0)
{
throw new InvalidOperationException($"No members were found in expression '{expression}'.");
}
ClassMap currentClassMap = this;
MemberInfo member;
if (stack.Count > 1)
{
// We need to add a reference map for every sub member.
while (stack.Count > 1)
{
member = stack.Pop();
Type mapType;
var property = member as PropertyInfo;
var field = member as FieldInfo;
if (property != null)
{
mapType = typeof(DefaultClassMap<>).MakeGenericType(property.PropertyType);
}
else if (field != null)
{
mapType = typeof(DefaultClassMap<>).MakeGenericType(field.FieldType);
}
else
{
throw new InvalidOperationException("The given expression was not a property or a field.");
}
var referenceMap = currentClassMap.References(mapType, member);
currentClassMap = referenceMap.Data.Mapping;
}
}
// Add the member map to the last reference map.
member = stack.Pop();
return (currentClassMap, member);
}
}
}
|
