public void CreateMap_PersonToPersonSwedish()
{
SafeMap.CreateMap <Person, PersonSwedish>(
cfg =>
{
cfg.Map(x => x.Id, x => x.PersonId);
cfg.Map(x => x.Name, x => x.Namn);
cfg.Map(x => x.Age, x => x.Ålder);
cfg.Map(x => x.Length, x => x.Längd);
cfg.Map(x => x.BirthDate, x => x.Födelsedag);
});
var person = new Person
{
Id = Guid.NewGuid(),
Name = "Magnus Unger",
Age = 38,
Length = 1.85m,
BirthDate = new DateTime(1977, 03, 04),
};
var result = SafeMap.Convert <Person, PersonSwedish>(person);
Assert.AreEqual(person.Id, result.PersonId);
Assert.AreEqual(person.Name, result.Namn);
Assert.AreEqual(person.Age, result.Ålder);
Assert.AreEqual(person.Length, result.Längd);
Assert.AreEqual(person.BirthDate, result.Födelsedag);
}
public void GetConverter_GenericWithFormat_StringToInt()
{
var converter = SafeMap.GetConverter <string, int>(CultureInfo.CurrentCulture);
var result = converter("10");
Assert.AreEqual(10, result);
}
public override void Execute()
{
var rand = new Random();
var fromType = typeof(List <int>);
var toType = typeof(decimal[]);
var intList = new List <int>(50);
for (int i = 0; i < 50; i++)
{
intList.Add(rand.Next());
}
var toElementType = typeof(decimal);
var fastConverter = SafeMap.GetConverter <List <int>, decimal[]>();
var emitMapper = ObjectMapperManager.DefaultInstance.GetMapper <List <int>, decimal[]>();
this.WriteHeader();
this.AddResult("Array.ConvertAll todecimal", i => Array.ConvertAll(intList.ToArray(), Convert.ToDecimal));
this.AddResult("Array.ConvertAll changetype", i => Array.ConvertAll(intList.ToArray(), v => (decimal)Convert.ChangeType(v, toElementType)));
this.AddResult("EmitMapper", i => emitMapper.Map(intList));
this.AddResult("SafeMapper", i => fastConverter(intList));
this.AddResult("FastMapper", i => TypeAdapter.Adapt(intList, fromType, toType));
this.AddResult("AutoMapper", i => Mapper.Map(intList, fromType, toType));
}
private IEnumerable <T> InnerMatches(string input)
{
foreach (Match match in _regex.Matches(input))
{
var valuesDictionary = new Dictionary <string, string[]>();
foreach (var groupName in _groupNames)
{
var matchGroup = match.Groups[groupName];
if (!matchGroup.Success)
{
valuesDictionary[groupName] = null;
}
else if (matchGroup.Captures.Count > 1)
{
valuesDictionary[groupName] = Enumerate(matchGroup.Captures).ToArray();
}
else
{
valuesDictionary[groupName] = new [] { matchGroup.Value };
}
}
yield return(SafeMap.Convert <Dictionary <string, string[]>, T>(valuesDictionary, _formatProvider));
}
}
private SafeMap <VocabModel> ProcessVocabBanks(List <FileInfo> fileInfoes)
{
var serialzer = new JsonSerializer();
var map = new SafeMap <VocabModel>();
foreach (var fileInfo in fileInfoes)
{
using (var fs = fileInfo.OpenRead())
using (var sr = new StreamReader(fs))
using (var jtr = new JsonTextReader(sr))
{
var raw = serialzer.Deserialize <VocabModelRaw>(jtr);
foreach (var l in raw)
{
var tags = (string)l[2];
var tags2 = (string)l[3];
var tagModels = TagHelper.SplitTags(tags, tags2).Select(x =>
{
if (Tags.TryGetValue(x, out var tagModel))
{
return(tagModel);
}
return(null);
}).Where(x => x != null).ToList();
var meanings = ((JArray)l[5]).ToObject <List <string> >();
var kanji = (string)l[0];
var kana = (string)l[1];
if (kanji == "〃")
{
kanji = kana;
}
if (kana == "")
{
kana = kanji;
}
var vocabModel = map[kanji];
if (vocabModel == null)
{
vocabModel = map[kanji] = new VocabModel
{
Kanji = kanji,
};
}
vocabModel.Meanings.Add(new VocabContextualMeaningModel
{
Kana = kana,
Tags = tagModels,
Meanings = meanings,
});
}
}
}
return(map);
}
public override void Execute()
{
var rand = new Random();
var fromType = typeof(int[]);
var toType = typeof(List <decimal>);
var intArray = new int[50];
for (int i = 0; i < 50; i++)
{
intArray[i] = rand.Next();
}
var toElementType = typeof(decimal);
var fastConverter = SafeMap.GetConverter <int[], List <decimal> >();
var emitMapper = ObjectMapperManager.DefaultInstance.GetMapper <int[], List <decimal> >();
this.WriteHeader();
this.AddResult("Array.ConvertAll todecimal", i => new List <decimal>(Array.ConvertAll(intArray, Convert.ToDecimal)));
this.AddResult("Array.ConvertAll changetype", i => new List <decimal>(Array.ConvertAll(intArray, v => (decimal)Convert.ChangeType(v, toElementType))));
this.AddResult("EmitMapper", i => emitMapper.Map(intArray));
this.AddResult("SafeMapper", i => fastConverter(intArray));
this.AddResult("FastMapper", i => TypeAdapter.Adapt(intArray, fromType, toType));
this.AddResult("AutoMapper", i => Mapper.Map(intArray, fromType, toType));
}
private SafeMap <FrequencyModel> Process(List <FileInfo> fileInfoes, bool skipSingleFrequency)
{
var serialzer = new JsonSerializer();
var map = new SafeMap <FrequencyModel>();
foreach (var fileInfo in fileInfoes)
{
using (var fs = fileInfo.OpenRead())
using (var sr = new StreamReader(fs))
using (var jtr = new JsonTextReader(sr))
{
var raw = serialzer.Deserialize <FrequencyModelRaw>(jtr);
var models = raw.Select(l =>
{
return(new FrequencyModel
{
Term = (string)l[0],
Frequency = Convert.ToInt32(l[2]),
});
});
foreach (var model in models.Where(x => !skipSingleFrequency || x.Frequency > 1))
{
map[model.Term] = model;
}
}
}
return(map);
}
public void GetConverter_Generic_StringToInt()
{
var converter = SafeMap.GetConverter <string, int>();
var result = converter("10");
Assert.AreEqual(10, result);
}
public void GetConverter_NonGenericWithFormat_StringToInt()
{
var converter = SafeMap.GetConverter(typeof(string), typeof(int), CultureInfo.CurrentCulture);
var result = converter("10");
Assert.AreEqual(10, result);
}
public void GetConverter_NonGeneric_StringToInt()
{
var converter = SafeMap.GetConverter(typeof(string), typeof(int));
var result = converter("10");
Assert.AreEqual(10, result);
}
protected void ProcessTagBanks(List <FileInfo> fileInfoes)
{
var serialzer = new JsonSerializer();
var map = new SafeMap <TagModel>();
foreach (var fileInfo in fileInfoes)
{
using (var fs = fileInfo.OpenRead())
using (var sr = new StreamReader(fs))
using (var jtr = new JsonTextReader(sr))
{
var raw = serialzer.Deserialize <TagModelRaw>(jtr);
var models = raw.Select(l =>
{
var key = (string)l[0];
var order = Convert.ToInt32(l[2]);
var value = (string)l[3];
return(new TagModel {
Key = key, Value = value, Order = order
});
});
foreach (var model in models)
{
map[model.Key] = model;
}
}
}
Tags = map;
}
private double ComparePerformance <TFrom, TTo>(Action compareAction, TFrom input, int iterations = 100000)
{
var safeMapConverter = SafeMap.GetConverter <TFrom, TTo>();
var compareTime = Profiler.Profile(compareAction, iterations, 100);
var safeMapperTime = Profiler.Profile(() => safeMapConverter(input), iterations, 100);
return((safeMapperTime - compareTime) / compareTime);
}
public async Task SetupAsync()
{
var kanjiFiles = await _dictionaryProvider.CollectKanjiFrequencyFilesAsync();
var vocabFiles = await _dictionaryProvider.CollectVocabFrequencyFilesAsync();
Kanjis = Process(kanjiFiles, false);
Vocabs = Process(vocabFiles, true);
}
public async Task SetupAsync()
{
var tagFiles = await _dictionaryProvider.CollectKanjiTagFilesAsync();
ProcessTagBanks(tagFiles);
var kanjiFiles = await _dictionaryProvider.CollectKanjiFilesAsync();
Kanjis = ProcessKanjiBanks(kanjiFiles);
}
public async Task SetupAsync()
{
var tagFiles = await _dictionaryProvider.CollectVocabTagFilesAsync();
ProcessTagBanks(tagFiles);
AddExtraTags();
var vocabFiles = await _dictionaryProvider.CollectVocabFilesAsync();
Vocabs = ProcessVocabBanks(vocabFiles);
}
public FileSettings Get(string fileName)
{
lock (threadLock)
{
if (!SafeMap.ContainsKey(fileName))
{
SafeMap.Add(fileName, FileSettings.Default);
}
return(SafeMap[fileName]);
}
}
public void SetConfiguration_ShouldResetPreviousConfiguredConverters()
{
SafeMap.Configuration.SetConvertMethod <int, string>(i => i.ToString(CultureInfo.InvariantCulture) + " pcs");
var result1 = SafeMap.Convert <int, string>(10);
SafeMap.Configuration = new MapConfiguration();
var result2 = SafeMap.Convert <int, string>(10);
Assert.AreEqual("10 pcs", result1);
Assert.AreEqual("10", result2);
}
private SafeMap <KanjiModel> ProcessKanjiBanks(List <FileInfo> fileInfoes)
{
var serialzer = new JsonSerializer();
var map = new SafeMap <KanjiModel>();
foreach (var fileInfo in fileInfoes)
{
using (var fs = fileInfo.OpenRead())
using (var sr = new StreamReader(fs))
using (var jtr = new JsonTextReader(sr))
{
var raw = serialzer.Deserialize <KanjiModelRaw>(jtr);
var models = raw.Select(l =>
{
var tags = (string)l[3];
var tagModels = TagHelper.SplitTags(tags).Select(x =>
{
if (Tags.TryGetValue(x, out var tagModel))
{
return(tagModel);
}
return(null);
}).Where(x => x != null).ToList();
var meanings = ((JArray)l[4]).ToObject <List <string> >();
var extras = ((JObject)l[5]).ToObject <Dictionary <string, string> >();
return(new KanjiModel
{
Kanji = (string)l[0],
Onyomi = (string)l[1],
Kunyomi = (string)l[2],
Tags = tagModels,
Meanings = meanings,
Grade = extras.ContainsKey("grade") ? int.Parse(extras["grade"]) : (int?)null,
Jlpt = extras.ContainsKey("jlpt") ? int.Parse(extras["jlpt"]) : (int?)null,
Strokes = int.Parse(extras["strokes"]),
});
});
foreach (var model in models)
{
map[model.Kanji] = model;
}
}
}
return(map);
}
public async Task SetupAsync()
{
var fileInfo = await _dictionaryProvider.GetSimilarKeiseiFileAsync();
var serialzer = new JsonSerializer();
using (var fs = fileInfo.OpenRead())
using (var sr = new StreamReader(fs))
using (var jtr = new JsonTextReader(sr))
{
var raw = serialzer.Deserialize <SimilarModelRaw>(jtr);
Model = raw.ToSafeMap();
}
}
public async Task SetupAsync()
{
SimilarRadicals = new SafeMap <NiaiSimilarRadicalsEntry>();
var fileInfo = await _dictionaryProvider.GetNiaiSimilarRadicalsAsync();
using var fs = fileInfo.OpenRead();
using var sr = new StreamReader(fs, Encoding.UTF8);
NiaiSimilarRadicalsEntry GetEntry(string radical)
{
if (!SimilarRadicals.TryGetValue(radical, out var entry1))
{
entry1 = SimilarRadicals[radical] = new NiaiSimilarRadicalsEntry
{
Radical = radical,
Similar = new System.Collections.Generic.List <(string Radical, double Score)>(),
};
}
return(entry1);
}
while (!sr.EndOfStream)
{
var line = await sr.ReadLineAsync();
if (string.IsNullOrWhiteSpace(line) || line.StartsWith("#"))
{
continue;
}
// Format is: R1 R2 Score
var r1 = line[0].ToString();
var r2 = line[2].ToString();
var score = double.Parse(line[4..]);
var e1 = GetEntry(r1);
var e2 = GetEntry(r2);
if (e1.Similar.Any(x => x.Radical == r2))
{
Console.WriteLine($"Found duplicates in niai/similar-radicals.txt: {r1} {r2}");
continue;
}
e1.Similar.Add((r2, score));
e2.Similar.Add((r1, score));
}
public void CreateMap_NameValueCollectionToClassPropertyInt_StringIndexer()
{
SafeMap.CreateMap <NameValueCollection, ClassProperty <int> >(
cfg =>
{
cfg.MapGetIndexer((x, key) => x[key]);
cfg.Map <string, int>("Value2", x => x.Value);
});
var input = new NameValueCollection {
{ "Value2", "1337" }
};
var result = SafeMap.Convert <NameValueCollection, ClassProperty <int> >(input);
Assert.AreEqual(1337, result.Value);
}
public void CreateMap_ClassPropertyIntToNameValueCollection_Add()
{
SafeMap.Configuration.SetConvertMethod <int, string>(i => i.ToString(CultureInfo.InvariantCulture));
SafeMap.CreateMap <ClassProperty <int>, NameValueCollection>(
cfg =>
{
cfg.MapSetIndexer <string>((x, key, val) => x.Add(key, val));
cfg.Map <int, string>(x => x.Value, "Value2");
});
var input = new ClassProperty <int> {
Value = 1337
};
var result = SafeMap.Convert <ClassProperty <int>, NameValueCollection>(input);
Assert.AreEqual("1337", result["Value2"]);
}
private SafeMap <VocabModel> ProcessVocabBanks(List <FileInfo> fileInfoes)
{
var serialzer = new JsonSerializer();
var map = new SafeMap <VocabModel>();
foreach (var fileInfo in fileInfoes)
{
using (var fs = fileInfo.OpenRead())
using (var sr = new StreamReader(fs))
using (var jtr = new JsonTextReader(sr))
{
var raw = serialzer.Deserialize <VocabModelRaw>(jtr);
var models = raw.Select(l =>
{
var tags = (string)l[2];
var tags2 = (string)l[3];
var tagModels = TagHelper.SplitTags(tags, tags2).Select(x =>
{
if (Tags.TryGetValue(x, out var tagModel))
{
return(tagModel);
}
return(null);
}).Where(x => x != null).ToList();
var meanings = ((JArray)l[5]).ToObject <List <string> >();
return(new VocabModel
{
Vocab = (string)l[0],
Kana = (string)l[1],
Tags = tagModels,
Meanings = meanings,
});
});
foreach (var model in models)
{
map[model.Vocab] = model;
}
}
}
return(map);
}
public async Task SetupAsync()
{
var fileInfo = await _dictionaryProvider.GetSimilarNotoFileAsync();
var serialzer = new JsonSerializer();
using (var fs = fileInfo.OpenRead())
using (var sr = new StreamReader(fs))
using (var jtr = new JsonTextReader(sr))
{
var raw = serialzer.Deserialize <SimilarModelWithScoreRaw>(jtr);
Model = SafeMap <List <SimilarKanji> > .Create(raw, list => list.Select(x => new SimilarKanji
{
Value = x.Kan,
Score = x.Score + 0.1, // Add base score.
}).ToList());
}
}
public async Task SetupAsync()
{
var fileInfo = await _dictionaryProvider.GetSimilarKeiseiFileAsync();
var serialzer = new JsonSerializer();
using (var fs = fileInfo.OpenRead())
using (var sr = new StreamReader(fs))
using (var jtr = new JsonTextReader(sr))
{
var raw = serialzer.Deserialize <SimilarModelRaw>(jtr);
Model = SafeMap <List <SimilarKanji> > .Create(raw, list => list.Select(x => new SimilarKanji
{
Value = x,
Score = 0.65, // Default score for Keisei dictionary.
}).ToList());
}
}
public void InitByAssembly(Assembly _assembly)
{
if (_assembly == null)
{
return;
}
mAssembly = _assembly;
if (mAssembType == null)
{
mAssembType = new SafeMap <string, Type>();
}
Type[] ttypes = mAssembly.GetTypes();
foreach (Type ttype in ttypes)
{
if (mAssembType.ContainsKey(ttype.FullName))
{
continue;
}
mAssembType.Add(ttype.FullName, ttype);
}
}
public async Task SetupAsync()
{
var file1 = await _dictionaryProvider.GetKradFileAsync();
// Currently not working correctly with the encoding.
//var file2 = await _dictionaryProvider.GetKradFile2Async();
var encoding = CodePagesEncodingProvider.Instance.GetEncoding(20932 /* EUC-JP */);
Model = new SafeMap <KradFileEntry>();
async Task ProcessFileAsync(FileInfo fileInfo)
{
using var fs = fileInfo.OpenRead();
using var sr = new StreamReader(fs, encoding);
while (!sr.EndOfStream)
{
var line = await sr.ReadLineAsync();
if (string.IsNullOrWhiteSpace(line) || line.StartsWith("#"))
{
continue;
}
// 0 4
// Format is: 亜 : ｜ 一 口
var kanji = line[0].ToString();
var radicalsString = line[4..];
var radicals = radicalsString.Split(' ')
.Select(x => x.Trim())
.Where(x => !string.IsNullOrEmpty(x) && !RadicalsToSkip.Contains(x))
.ToList();
Model[kanji] = new KradFileEntry
{
Kanji = kanji,
Radicals = radicals,
};
}
public override void Execute()
{
var rand = new Random();
var fromType = typeof(int[]);
var toType = typeof(decimal[]);
var intArray = new int[50];
for (int i = 0; i < 50; i++)
{
intArray[i] = rand.Next();
}
var toElementType = typeof(decimal);
this.WriteHeader();
var genericConvertType = typeof(Converter <,>).MakeGenericType(typeof(int), typeof(decimal));
var fasterflectConvertAll = typeof(Array).DelegateForCallMethod(
new Type[] { typeof(int), typeof(decimal) },
"ConvertAll",
new Type[] { fromType, genericConvertType });
var fastConverter = SafeMap.GetConverter <int[], decimal[]>();
var emitMapper = ObjectMapperManager.DefaultInstance.GetMapper <int[], decimal[]>();
this.AddResult("Array.ConvertAll todecimal", i => Array.ConvertAll(intArray, Convert.ToDecimal));
this.AddResult("Array.ConvertAll changetype", i => Array.ConvertAll(intArray, v => Convert.ChangeType(v, toElementType)));
this.AddResult("EmitMapper", i => emitMapper.Map(intArray));
this.AddResult("SafeMapper", i => fastConverter(intArray));
this.AddResult("FastMapper", i => TypeAdapter.Adapt(intArray, fromType, toType));
//this.AddResult("AutoMapper", i => Mapper.Map(intArray, fromType, toType));
this.AddResult("Manual forloop", i => this.ConvertArrayManual(intArray, toElementType, v => Convert.ToDecimal(v)));
this.AddResult("Manual forloop rev", i => this.ConvertArrayManualReverse(intArray, toElementType, v => Convert.ToDecimal(v)));
this.AddResult("Manual foreachloop", i => this.ConvertArrayManualForEach(intArray, toElementType, v => Convert.ToDecimal(v)));
}
private void ProfileConvert <TSource, TDestination>(TSource[] input, CultureInfo formatProvider, Action <int> compareFunc)
{
var safeMapper = SafeMap.GetConverter <TSource, TDestination>();
var sourceType = typeof(TSource);
var destinationType = typeof(TDestination);
var emitMapper = ObjectMapperManager.DefaultInstance.GetMapper <TSource, TDestination>();
//var fFastMapper = fFastMap.MapperFor<TSource, TDestination>();
if (typeof(TDestination) != typeof(string))
{
if (typeof(TDestination) == typeof(DateTime) && typeof(TSource) == typeof(string))
{
AutoMapper.Mapper.CreateMap(typeof(TSource), typeof(TDestination)).ConvertUsing(typeof(AutoMapperDateTimeTypeConverter));
}
else
{
AutoMapper.Mapper.CreateMap <TSource, TDestination>();
}
}
AutoMapper.Mapper.CreateMap <Address, AddressDto>();
AutoMapper.Mapper.CreateMap <AddressDto, Address>();
AutoMapper.Mapper.CreateMap <BenchSource.Int1, BenchDestination.Int1>();
AutoMapper.Mapper.CreateMap <BenchSource.Int2, BenchDestination.Int2>();
this.WriteHeader(string.Format("Profiling convert from {0} to {1}, {2} iterations", typeof(TSource).Name, typeof(TDestination).Name, input.Length));
if (compareFunc != null)
{
this.AddResult("Native", compareFunc);
}
this.AddResult("SafeMapper", i => safeMapper(input[i]));
this.AddResult("EmitMapper", i => emitMapper.Map(input[i]));
this.AddResult("FastMapper", i => TypeAdapter.Adapt(input[i], sourceType, destinationType));
//this.AddResult("fFastMapper", i => fFastMapper.Map(input[i]));
/*
* this.AddResult("ValueInjecter",
* i =>
* {
* var result = new TDestination();
* result.InjectFrom(input[i]);
* });*/
/*
* this.AddResult(
* "ServiceStack",
* i => AutoMappingUtils.ConvertTo<TDestination>(input[i]));
*
* this.AddResult(
* "SimpleTypeConverter",
* i => SimpleTypeConverter.ConvertTo(input[i], typeof(TDestination), formatProvider));
*
*
* this.AddResult(
* "UniversalTypeConverter",
* i => UniversalTypeConverter.Convert(input[i], typeof(TDestination), formatProvider));*/
this.AddResult("AutoMapper", i => AutoMapper.Mapper.Map <TSource, TDestination>(input[i]));
}
public SafeMapperBenchmark()
{
_simpleConverter = SafeMap.GetConverter <SimplePoco, SimplePocoDTO>();
_nestedConverter = SafeMap.GetConverter <NestedPoco, NestedPocoDTO>();
}
