private void Convert(IConvert <double> fromUnit, IConvert <double> toUnit, RequestDto dto)
{
double siValue = fromUnit.ConvertToSI(dto.EnteredValue);
double resValue = toUnit.ConvertFromSI(siValue);
dto.ResultValue = Math.Round(resValue, 3);
}
internal static object[] Convert(string[] objects, ParameterInfo[] wantedTypes, IPlayer invoker, bool withOptional = false, string debug = "")
{
try
{
Wrapper.Server.Logger.Debug(debug + ": " + JsonConvert.SerializeObject(objects));
object[] arr = new object[wantedTypes.Length];
arr[0] = invoker;
for (int i = 1; i < wantedTypes.Length; i++)
{
ParameterInfo wantedType = wantedTypes[i];
if (withOptional && wantedType.IsOptional && (i - 1) >= objects.Length)
{
arr[i] = Type.Missing;
continue;
}
IConvert convert = FindConvert(wantedType.ParameterType);
if (convert != null)
{
arr[i] = convert.Convert(objects[i - 1], wantedType.ParameterType);
}
}
return(arr);
}
catch (Exception e)
{
Wrapper.Server.Logger.Error("An error occurred in converting process!", e);
return(null);
}
}
public object GetValue(NameValueCollection data)
{
object value = null;
bool succeed = false;
if (Binder != null)
{
value = Binder.GetConvert().Parse(data, Info.Name, Binder.Prefix, out succeed);
if (!succeed && Binder.Fungible != null)
{
value = Activator.CreateInstance(Binder.Fungible);
}
return(value);
}
else
{
IConvert convert = BindUtils.GetConvert(Info.PropertyType);
if (convert != null)
{
value = convert.Parse(data, Info.Name, null, out succeed);
}
else
{
if (Info.PropertyType.IsValueType)
{
value = BinderHelper.GetValue(Info.PropertyType, Info.Name);
}
else
{
value = GetObject(data);
}
}
}
return(value);
}
private static void Test(IContainer container, ConvertType ctype, int times)
{
IConvert convert = default(IConvert);
if (ctype == ConvertType.AutoMapper)
{
convert = container.ResolveKeyed <IConvert>(ctype);
}
else if (ctype == ConvertType.EmitMapper)
{
convert = new EmitConverter();
}
else if (ctype == ConvertType.TinyMapper)
{
convert = new TinyConverter();
}
if (times < 1)
{
Test(convert, ctype);
return;
}
Random r = new Random();
A2 obj = new A2 {
Id = r.Next(1, 1000), Name = "A1"
};
Stopwatch sw = new Stopwatch();
sw.Start();
for (int i = 0; i < times; i++)
{
A1 obj2 = convert.Convert <A2, A1>(obj);
}
sw.Stop();
Log.Information($"{ctype}执行了{times}次，耗时{sw.ElapsedMilliseconds}毫秒");
}
private void cbbSystem_SelectedIndexChanged(object sender, EventArgs e)
{
string system = cbbSystem.SelectedItem.ToString();
switch (system)
{
case "EndNote(sci-e,ssci,cpci,medline)":
iconvert = new EndNoteConvert();
break;
case "EI":
iconvert = new EIConvert();
break;
case "CSSCI":
iconvert = new CSSCIConvert();
break;
case "CSCD":
iconvert = new CSCDConverter();
break;
default:
break;
}
}
public ChapterController(IDatabase database, IChaptersLookup chapters, IAuthorizedProfileLookup profiles, IConvert <DbStats, Stats> stats)
{
_database = database;
_chapters = chapters;
_profiles = profiles;
_stats = stats;
}
public MainProccess(IConvert convert, IPublish publish, IValidate validate, IProcess process)
{
_validate = validate;
_convert = convert;
_publish = publish;
_process = process;
}
public static IList GetList(Type type, NameValueCollection data, string prefix)
{
IConvert listConvert = BinderHelper.GetListConvert(type);
bool flag;
return((IList)listConvert.Parse(data, "", prefix, out flag));
}
public ProjectService(IRepository <Project> projectRepository, IConvert <Project, ProjectDto> projectDtoConverter, IConvert <ProjectDto, Project> projectConverter, ILogger logger)
{
ProjectRepository = projectRepository;
ProjectDtoConverter = projectDtoConverter;
ProjectConverter = projectConverter;
this.logger = logger;
}
public static object GetValue(Type type, string key)
{
object result = null;
IConvert convert = null;
object obj = null;
if (!BindUtils.Converts.TryGetValue(type, out convert))
{
if (type.IsEnum)
{
Type type2 = typeof(ToEnum <>).MakeGenericType(new Type[]
{
type
});
convert = (IConvert)Activator.CreateInstance(type2);
BindUtils.AddCustomConvert(type, convert);
}
}
bool flag = false;
if (convert != null)
{
obj = convert.Parse(HttpContext.Current.Request.Params, key, null, out flag);
}
if (flag)
{
result = obj;
}
return(result);
}
public static IList <T> FullList <T>(NameValueCollection data, string prefix) where T : new()
{
IConvert convert = GetListConvert <T>();
bool succeed;
return((IList <T>)convert.Parse(data, "", prefix, out succeed));
}
internal static IConvert GetConvert(Type type)
{
IConvert result = null;
BindUtils.Converts.TryGetValue(type, out result);
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="GenericTargetConvertStrategy{TSource, TTarget, TIntention, TSourceInterface, TCriterion}"/> class.
/// </summary>
public GenericTargetConvertStrategy(
IConvert <TSourceInterface, TCriterion, TIntention> converter)
{
converter.NotNull(nameof(converter));
this.converter = converter;
}
public EmployeeService(ILogger logger, IRepository <Employee> employeeRepository, IConvert <Employee, EmployeeDto> employeeDtoConverter, IConvert <EmployeeDto, Employee> employeeConverter)
{
this.logger = logger;
EmployeeRepository = employeeRepository;
EmployeeDtoConverter = employeeDtoConverter;
EmployeeConverter = employeeConverter;
}
public DataService(IBetListClient client, IConvert convert, ITournamentClient tournamentClient, ITeamClient teamClient, IMatchService matchService)
{
this.betListClient = client;
this.convert = convert;
this.tournamentClient = tournamentClient;
this.teamClient = teamClient;
this.matchService = matchService;
}
public ChaptersLookup(IDatabase database, IStore <DbTranslatedChapter> chapters, IStore <DbStats> stats, IConvert <DbTranslatedChapter, Chapter> convertChapters, IConvert <DbStats, Stats> convertStats)
{
_database = database;
_chapters = chapters;
_stats = stats;
_convertChapters = convertChapters;
_convertStats = convertStats;
}
public Worker(ILogger <Worker> logger, IDBWriter writer, IParser parser, IConvert convert, Settings settings)
{
_logger = logger;
_writer = writer;
_parser = parser;
_settings = settings;
_converter = convert;
}
public ProfileController(IDatabase database, IStore <DbUserProfile> store, IStore <DbStats> stats, IAuthorizedProfileLookup profiles, IConvert <DbUserProfile, Profile> converter)
{
_database = database;
_store = store;
_stats = stats;
_profiles = profiles;
_converter = converter;
}
private void T_OnConversionCompleted(IConvert sender, ConversionCompleteEventArgs args)
{
if (CurrentThreadInProgress > 0)
{
CurrentThreadInProgress--;
}
StartTasks();
}
protected RuleKeyAI(int _KeyLength_Whole, string _KeyAI, int _fieldLength, Type _typeTextParsingStrategy, IConvert _Convert, string _DescriptionEn, string _DescriptionRu, string _Title)
{
DescriptionEn = _DescriptionEn;
DescriptionRu = _DescriptionRu;
Title = _Title;
iConvert = _Convert;
KeyAI = _KeyAI;
ParsingStrategy = (TextParsingStrategy)Activator.CreateInstance(_typeTextParsingStrategy, new object[] { _KeyLength_Whole, _fieldLength, _KeyAI });
}
public RpgMakerEncoder(string gamePath, string sourcePath, IRubyEncoder rubyEncoder, IConvert <RubyToken, JToken> sourceConverter, IConvert <JToken, RubyToken> gameConverter, IJsonFileProcessor jsonFileProcessor)
{
_jsonFileProcessor = jsonFileProcessor;
_rubyEncoder = rubyEncoder;
_sourceConverter = sourceConverter;
_gameConverter = gameConverter;
GamePath = gamePath;
SourcePath = sourcePath;
}
private static void Test(IConvert convert, ConvertType ctype)
{
A2 obj = new A2 {
Id = 1, Name = "A1"
};
A1 obj2 = convert.Convert <A2, A1>(obj);
Show(obj, obj2, ctype);
}
public static void AddCustomConvert(Type type, IConvert convert)
{
lock (BindUtils.mConverts)
{
if (!BindUtils.mConverts.ContainsKey(type))
{
BindUtils.mConverts.Add(type, convert);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CreateConvertStrategy{TSource, TConcreteSource, TTarget, TConcreteTarget, TConcreteTargetImpl, TIntention}"/> class.
/// </summary>
public CreateConvertStrategy(
IInstanceCreator <TConcreteTarget, TConcreteTargetImpl> creator,
IConvert <TConcreteSource, TConcreteTarget, TIntention> converter)
{
creator.NotNull(nameof(creator));
converter.NotNull(nameof(converter));
this.creator = creator;
this.converter = converter;
}
/// <summary>
/// Initializes a new instance of the <see cref="CreateTargetImplConvertTargetHelper{TSource,TTarget,TTargetImpl,TReverseRelation,TConvertIntention}" /> class.
/// </summary>
public CreateTargetImplConvertTargetHelper(
IInstanceCreator <TTarget, TTargetImpl> instanceCreator,
IConvert <TSource, TTarget, TConvertIntention> convert)
{
instanceCreator.NotNull(nameof(instanceCreator));
convert.NotNull(nameof(convert));
this.instanceCreator = instanceCreator;
this.convert = convert;
}
/// <summary>
/// Initializes a new instance of the <see cref="OperationConvertToMany{TSource,TTarget,TSourceValue,TTargetValue,TConvertIntention}" /> class.
/// </summary>
public OperationConvertToMany(
IConvert <TSourceValue, TTargetValue, TConvertIntention> convert,
IConvertHelper convertHelper)
{
convert.NotNull(nameof(convert));
convertHelper.NotNull(nameof(convertHelper));
this.convert = convert;
this.convertHelper = convertHelper;
}
private bool GetClassValue(System.Collections.Specialized.NameValueCollection data, string Prefix, out object value)
{
IConvert convert = null;
value = null;
Type createtype = Info.ParameterType;
if (Binder != null && Binder.Convert == null && Binder.Fungible != null)
{
createtype = Binder.Fungible;
}
bool succed = false;
if (Binder != null && !string.IsNullOrEmpty(Binder.Prefix))
{
Prefix = Binder.Prefix;
}
if (Binder != null)
{
convert = Binder.GetConvert();
}
if (convert == null)
{
if (BindUtils.Converts.ContainsKey(createtype))
{
convert = BindUtils.Converts[createtype];
}
}
if (convert != null)
{
value = convert.Parse(data, Info.Name, Prefix, out succed);
}
else if (createtype.IsArray)
{
if (createtype.GetElementType().IsEnum)
{
Type toenumtype = typeof(ToEnumArray <>).MakeGenericType(createtype.GetElementType());
IConvert tea = (IConvert)Activator.CreateInstance(toenumtype);
BindUtils.AddCustomConvert(toenumtype, tea);
value = tea.Parse(data, Info.Name, Prefix, out succed);
}
}
else
{
if (createtype.IsClass && !createtype.IsInterface &&
!createtype.IsAbstract)
{
ClassBinder cb = BindUtils.GetBinder(createtype);
succed = true;
value = cb.CreateObject(data, Prefix);
}
}
return(succed);
}
private void SetConvertMethod(string srcPath, Methods method)
{
m_method = method;
switch (method)
{
case Methods.ExcelToJson:
m_convertMethod = new ExcelToJson(srcPath);
break;
}
}
private bool GetClassValue(System.Collections.Specialized.NameValueCollection data, string Prefix, out object value)
{
IConvert convert = null;
value = null;
Type createtype = Info.ParameterType;
if (Binder != null && Binder.Convert == null && Binder.Fungible != null)
{
createtype = Binder.Fungible;
}
bool succed = false;
if (Binder != null && !string.IsNullOrEmpty(Binder.Prefix))
{
Prefix = Binder.Prefix;
}
if (Binder != null)
{
convert = Binder.GetConvert();
}
if (convert == null)
{
if (ConverCore.Converts.ContainsKey(createtype))
{
convert = ConverCore.Converts[createtype];
}
}
if (convert != null)
{
value = convert.Parse(data, Info.Name, Prefix, out succed);
}
else if (createtype.IsArray)
{
if (createtype.GetElementType().IsEnum)
{
ToEnumArray tea = new ToEnumArray();
tea.EnumType = createtype.GetElementType();
value = tea.Parse(data, Info.Name, Prefix, out succed);
}
}
else
{
if (createtype.IsClass && !createtype.IsInterface &&
!createtype.IsAbstract)
{
ClassBinder cb = ConverCore.GetBinder(createtype);
succed = true;
value = cb.CreateObject(data, Prefix);
}
}
return(succed);
}
public DataTableSerializeOperationBehavior(Type type)
{
if (type != null)
{
if (!typeof(IConvert).IsAssignableFrom(type))
{
throw new ArgumentException("类型" + type.FullName + "没有实现接口" + typeof(IConvert).FullName, "type");
}
m_Convertor = Activator.CreateInstance(type) as IConvert;
}
}
public IConvert GetConvert()
{
IConvert result;
if (this.Convert == null)
{
result = null;
}
else
{
if (this.mConvertHandler == null)
{
this.mConvertHandler = (IConvert)Activator.CreateInstance(this.Convert);
}
result = this.mConvertHandler;
}
return result;
}
public NEOperationBehavior(Type converterType, Type exceptionHandlerType)
{
if (converterType != null)
{
if (!typeof(IConvert).IsAssignableFrom(converterType))
{
throw new ArgumentException("类型" + converterType.FullName + "没有实现接口" + typeof(IConvert).FullName, "type");
}
m_Convertor = Activator.CreateInstance(converterType) as IConvert;
}
if (exceptionHandlerType != null)
{
if (!typeof(IExceptionHandle).IsAssignableFrom(exceptionHandlerType))
{
throw new ArgumentException("类型" + exceptionHandlerType.FullName + "没有实现接口" + typeof(IExceptionHandle).FullName, "type");
}
m_ExceptionHandler = Activator.CreateInstance(exceptionHandlerType) as IExceptionHandle;
}
}
public static void ClassInitialize(TestContext testContext)
{
_converter = new ShortLengths();
}
public NEOperationBehavior(IConvert convertor, IExceptionHandle exceptionHandler)
{
m_Convertor = convertor;
m_ExceptionHandler = exceptionHandler;
}
public static void ClassInitialize(TestContext testContext)
{
_converter = new Times();
}
//***** polymorphism ********//
private String readLetter(IConvert iConvert,String letter)
{
String word = iConvert.changeNumericToWords(letter);
return word;
}
