private static bool DoObjectMemberInitialization(object target, bool beforeFieldInit, object state) { if (target.GetType().IsPrimitive || target is string || target is Enum ) { } else { //Call the initialize to all members foreach (FieldInfo fieldInfo in ChoType.GetFields(target.GetType())) { if (fieldInfo.IsReadOnly()) { continue; } object fieldValue = ChoType.GetFieldValue(target, fieldInfo.Name); if (fieldValue == null) { continue; } if (!(fieldValue is string) && fieldValue is IEnumerable) { foreach (object fieldItemValue in (IEnumerable)fieldValue) { DoInitialize(fieldItemValue, beforeFieldInit, state); } DoInitialize(fieldValue, beforeFieldInit, state); } else { DoInitialize(fieldValue, beforeFieldInit, state); } } } if (target is IChoObjectInitializable) { return(((IChoObjectInitializable)target).Initialize(beforeFieldInit, state)); } else { return(false); } }
protected void SetFields(Type elementType, KeyValuePair <string, Type>[] membersInfo = null) { Dictionary <string, ChoObjectDataReaderProperty> prop = new Dictionary <string, ChoObjectDataReaderProperty>(); Fields = new List <ChoObjectDataReaderProperty>(); if (membersInfo != null) { var dict = membersInfo.GroupBy(kvp => kvp.Key).ToDictionary(g => g.Key, g => g.FirstOrDefault()); var m = ChoType.GetMembers(elementType).Where(m1 => dict.ContainsKey(m1.Name)); if (m.Any()) { foreach (var mi in m) { prop.Add(mi.Name, new ChoObjectDataReaderProperty(mi)); } } else { if (elementType.IsSimple()) { prop.Add("Value", new ChoObjectDataReaderProperty("Value", elementType, true)); } else { foreach (KeyValuePair <string, Type> kvp in membersInfo) { if (!prop.ContainsKey(kvp.Key)) { prop.Add(kvp.Key, new ChoObjectDataReaderProperty(kvp.Key, kvp.Value)); } } } } } else { foreach (MemberInfo info in ChoType.GetMembers(elementType)) { if (!prop.ContainsKey(info.Name)) { prop.Add(info.Name, new ChoObjectDataReaderProperty(info)); } } } Fields = new List <ChoObjectDataReaderProperty>(prop.Values.ToArray()); }
internal static void Initialize() { //ChoStreamProfile.Clean(ChoReservedDirectoryName.Others, ChoType.GetLogFileName(typeof(ChoTypesManager))); StringBuilder topMsg = new StringBuilder(); ChoStringMsgBuilder parseMethodsMsg = new ChoStringMsgBuilder("Below are the loaded parse methods"); ChoStringMsgBuilder formatMethodsMsg = new ChoStringMsgBuilder("Below are the loaded format methods"); ChoStringMsgBuilder msg = new ChoStringMsgBuilder("Below are the loaded type objects"); foreach (Type type in ChoType.GetTypes(typeof(ChoStringObjectFormattableAttribute))) { if (ChoTypesManagerSettings.IsExcludedType(type)) { continue; } ChoTypeObjectParseInfo typeObjectParseInfo = new ChoTypeObjectParseInfo(); ChoTypeObjectFormatInfo typeObjectFormatInfo = new ChoTypeObjectFormatInfo(); try { //typeObjectFormatInfo.TypeObject = typeObjectParseInfo.TypeObject = ChoObject.CreateInstance(type); msg.AppendFormatLine(type.FullName); } catch (ChoFatalApplicationException) { throw; } catch (Exception ex) { msg.AppendFormatLine("{0}: [{1}]", type.FullName, ex.Message); } LoadObjectParser(parseMethodsMsg, type, typeObjectParseInfo); LoadObjectFormatter(formatMethodsMsg, type, typeObjectFormatInfo); } _typeObjectsParseInfoArr = TypeObjectsParseInfo.Values.ToArray(); _typeObjectsFormatInfoArr = TypeObjectsFormatInfo.Values.ToArray(); //_typeObjectsParseInfo.Clear(); //_typeObjectsFormatInfo.Clear(); topMsg.Append(parseMethodsMsg.ToString() + Environment.NewLine + Environment.NewLine); topMsg.Append(formatMethodsMsg.ToString() + Environment.NewLine + Environment.NewLine); topMsg.Append(msg.ToString() + Environment.NewLine + Environment.NewLine); _helpText = topMsg.ToString(); }
public static IList <Property> CreatePropertyMethods(Type type) { var returnValue = new List <Property>(); //returnValue.Add(new Property("CustomerID", typeof(string))); //return returnValue; foreach (MemberInfo info in ChoType.GetMembers(type)) { } foreach (PropertyInfo prop in type.GetProperties()) { returnValue.Add(new Property(prop)); } return(returnValue); }
protected override void Init(Type recordType) { base.Init(recordType); ChoKVPRecordObjectAttribute recObjAttr = ChoType.GetAttribute <ChoKVPRecordObjectAttribute>(recordType); if (recObjAttr != null) { Separator = recObjAttr.Separator; RecordStart = recObjAttr.RecordStart; RecordEnd = recObjAttr.RecordEnd; LineContinuationChars = recObjAttr.LineContinuationChars; } DiscoverRecordFields(recordType); }
protected override void Init(Type recordType) { base.Init(recordType); ChoFixedLengthRecordObjectAttribute recObjAttr = ChoType.GetAttribute <ChoFixedLengthRecordObjectAttribute>(recordType); if (recObjAttr != null) { RecordLength = recObjAttr.RecordLength; } if (FixedLengthRecordFieldConfigurations.Count == 0) { DiscoverRecordFields(recordType); } }
public static object ConvertValueToObjectMemberType(object target, MemberInfo memberInfo, object value) { ChoGuard.ArgumentNotNull(target, "Target"); object memberValue = value; if (target is Type) { return(ChoConvert.ConvertFrom(null, memberValue, ChoType.GetMemberType((Type)target, memberInfo.Name), ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo))); } else { return(ChoConvert.ConvertFrom(target, memberValue, ChoType.GetMemberType(target.GetType(), memberInfo.Name), ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo))); } }
private static IEnumerable <MethodInfo> GetShellExtensionMethods() { Type[] shellExtTypes = ChoType.GetTypes <ChoShellExtensionAttribute>(); if (shellExtTypes.IsNullOrEmpty()) { yield break; } foreach (Type type in shellExtTypes) { foreach (MethodInfo methodInfo in ChoType.GetMethods(type, typeof(ChoShellExtensionContextMenuAttribute))) { yield return(methodInfo); } } }
public static bool IsValidFor(this object @this, string mn, out Exception aggEx) { ChoGuard.ArgumentNotNullOrEmpty(mn, "MemberName"); aggEx = null; MemberInfo mi = ChoType.GetMemberInfo(@this.GetType(), mn); if (mi != null) { return(IsValidFor(@this, mi, out aggEx)); } else { return(true); } }
public static void DoObjectLevelValidation(this object recObject, ChoRecordConfiguration configuration, IEnumerable <ChoRecordFieldConfiguration> fieldConfigurations) { if (recObject == null) { return; } if ((configuration.ObjectValidationMode & ChoObjectValidationMode.ObjectLevel) == ChoObjectValidationMode.ObjectLevel) { if (configuration.Validator == null) { if (configuration.HasConfigValidators) { IDictionary <string, Object> dict = null; if (recObject is IDictionary <string, object> ) { dict = recObject as IDictionary <string, Object>; } else { dict = new Dictionary <string, object>(); foreach (var pd in configuration.PIDict.Values) { dict.Add(pd.Name, ChoType.GetPropertyValue(recObject, pd)); } } ChoValidator.Validate(dict, configuration.ValDict); } else { if (!configuration.IsDynamicObject) { ChoValidator.Validate(recObject); } } } else { if (recObject != null && configuration.Validator(recObject)) { throw new ValidationException("Failed to validate '{0}' object. {1}".FormatString(recObject.GetType().FullName, Environment.NewLine)); } } } }
protected override void Init(Type recordType) { base.Init(recordType); if (recordType == null) { return; } ChoJSONRecordObjectAttribute recObjAttr = ChoType.GetAttribute <ChoJSONRecordObjectAttribute>(recordType); if (recObjAttr != null) { } DiscoverRecordFields(recordType); }
protected virtual object Serialize(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) { IList result = ChoActivator.CreateInstance(typeof(IList <>).MakeGenericType(targetType)) as IList; if (value != null && !value.GetType().IsCollectionType()) { if (targetType == typeof(object) || targetType.IsSimple()) { foreach (var p in ChoTypeDescriptor.GetProperties(value.GetType()).Where(pd => ChoTypeDescriptor.GetPropetyAttribute <ChoIgnoreMemberAttribute>(pd) == null)) { result.Add(ChoConvert.ConvertTo(ChoType.GetPropertyValue(value, p.Name), targetType, culture)); } } } return(result.OfType <object>().ToArray()); }
private void Init(Type recordType) { ChoFileHeaderAttribute recObjAttr = ChoType.GetAttribute <ChoFileHeaderAttribute>(recordType); if (recObjAttr != null) { HasHeaderRecord = true; IgnoreCase = recObjAttr.IgnoreCase; FillChar = recObjAttr.FillCharInternal; Justification = recObjAttr.JustificationInternal; if (recObjAttr.TrimOptionInternal != null) { TrimOption = recObjAttr.TrimOptionInternal.Value; } Truncate = recObjAttr.TruncateInternal; } }
public static object GetObjectMemberValue(object target, MemberInfo memberInfo) { ChoGuard.ArgumentNotNull(target, "Target"); object memberValue = ChoType.GetMemberValue(target, memberInfo); if (memberValue == null) { ChoPropertyInfoAttribute memberInfoAttribute = ChoType.GetMemberAttribute <ChoPropertyInfoAttribute>(memberInfo); if (memberInfoAttribute != null) { memberValue = memberInfoAttribute.DefaultValue; } } return(memberValue); }
private static MemberInfo CheckNExtractMemberInfo(object target, string memberName) { ChoGuard.ArgumentNotNull(target, "Target"); MemberInfo memberInfo = ChoType.GetMemberInfo(target.GetType(), memberName); if (memberInfo == null) { throw new NullReferenceException(String.Format("Can't find {0} member in {1} type.", memberName, target.GetType().FullName)); } if (memberInfo.MemberType != MemberTypes.Field && memberInfo.MemberType != MemberTypes.Property) { throw new ChoApplicationException(String.Format("Member `{0}` is not a field/property in {1} type.", memberName, target.GetType().FullName)); } return(memberInfo); }
protected override void Init(Type recordType) { base.Init(recordType); if (recordType == null) { return; } ChoFileRecordObjectAttribute recObjAttr = ChoType.GetAttribute <ChoFileRecordObjectAttribute>(recordType); if (recObjAttr != null) { AutoDiscoverFieldTypes = true; MaxScanRows = 0; if (recObjAttr.BufferSize > 0) { BufferSize = recObjAttr.BufferSize; } if (recObjAttr.Comments.IsNullOrWhiteSpace()) { Comments = new string[] { } } ; else { Comments = recObjAttr.Comments.SplitNTrim(','); } Culture = recObjAttr.Culture; EOLDelimiter = recObjAttr.EOLDelimiter; IgnoreEmptyLine = recObjAttr.IgnoreEmptyLine; ColumnCountStrict = recObjAttr.ColumnCountStrict; ColumnOrderStrict = recObjAttr.ColumnOrderStrict; QuoteChar = recObjAttr.QuoteChar; QuoteAllFields = recObjAttr.QuoteAllFieldsInternal; StringSplitOptions = recObjAttr.StringSplitOptions; if (!recObjAttr.Encoding.IsNullOrWhiteSpace()) { Encoding = Encoding.GetEncoding(recObjAttr.Encoding); } NullValue = recObjAttr.NullValue; } else { } }
private static void DoObjectMemberConversion(object ultimateParent, object target) { if (target == null) { return; } if (target.GetType().IsPrimitive || target is string || target is Enum ) { } else { DoPostObjectMemberConversion(ultimateParent, target); //Call the initialize to all members foreach (FieldInfo fieldInfo in ChoType.GetFields(target.GetType())) { if (fieldInfo.IsReadOnly()) { continue; } object fieldValue = ChoType.GetFieldValue(target, fieldInfo.Name); if (fieldValue == null) { continue; } if (!(fieldValue is string) && fieldValue is IEnumerable) { foreach (object fieldItemValue in (IEnumerable)fieldValue) { DoObjectMemberConversion(ultimateParent, fieldItemValue); } ChoType.SetFieldValue(target, fieldInfo.Name, fieldValue); } else { DoObjectMemberConversion(ultimateParent, fieldValue); } } } }
protected virtual void Init(Type recordType) { if (recordType == null) { return; } ChoRecordObjectAttribute recObjAttr = ChoType.GetAttribute <ChoRecordObjectAttribute>(recordType); if (recObjAttr != null) { ErrorMode = recObjAttr.ErrorMode; IgnoreFieldValueMode = recObjAttr.IgnoreFieldValueMode; ThrowAndStopOnMissingField = recObjAttr.ThrowAndStopOnMissingField; ObjectValidationMode = recObjAttr.ObjectValidationMode; } }
protected override void Init(Type recordType) { base.Init(recordType); ChoCSVRecordObjectAttribute recObjAttr = ChoType.GetAttribute <ChoCSVRecordObjectAttribute>(recordType); if (recObjAttr != null) { Delimiter = recObjAttr.Delimiter; HasExcelSeparator = recObjAttr.HasExcelSeparatorInternal; } if (CSVRecordFieldConfigurations.Count == 0) { DiscoverRecordFields(recordType); } }
// If the type of the value to convert is string, parses the string // and returns the integer to set the value of the property to. // This example first extends the integer array that supplies the // standard values collection if the user-entered value is not // already in the array. public override object ConvertFrom(System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value) { value = ChoType.GetMemberValue(Target, DependentMemberName); object convertedObject = null; using (ChoBufferProfileEx outerProfile = new ChoBufferProfileEx(LogFileName, "Converting file to objects....")) { try { if (value.GetType() == typeof(string)) { convertedObject = GetObject(value as string, outerProfile); } else if (value.GetType() == typeof(string[])) { Hashtable convertedObjects = new Hashtable(); foreach (string fileName in (string[])value) { object element = GetObject(fileName, outerProfile); if (KeyName == InternalHashKey) { convertedObjects.Add(element.GetHashCode().ToString(), element); } else { convertedObjects.Add(ChoType.GetMemberValue(element, KeyName).ToString(), element); } } convertedObject = convertedObjects; } } catch (ChoFatalApplicationException) { throw; } catch (Exception ex) { outerProfile.Append(ex); } } return(convertedObject); }
public ChoConfigurableObject() { _configurationElementAttribute = ChoType.GetAttribute(GetType(), typeof(ChoConfigurationSectionAttribute)) as ChoConfigurationSectionAttribute; //Discover and Hook the event handlers if (BeforeConfigurationObjectMemberLoaded == null) { EventHandlerEx.LoadHandlers <ChoPreviewConfigurationObjectMemberEventArgs>(ref BeforeConfigurationObjectMemberLoaded, ChoType.GetMethods(GetType(), typeof(ChoBeforeConfigurationObjectMemberLoadedHandlerAttribute)), this); } if (AfterConfigurationObjectMemberLoaded == null) { EventHandlerEx.LoadHandlers <ChoConfigurationObjectMemberEventArgs>(ref AfterConfigurationObjectMemberLoaded, ChoType.GetMethods(GetType(), typeof(ChoAfterConfigurationObjectMemberLoadedHandlerAttribute)), this); } if (ConfigurationObjectMemberLoadError == null) { EventHandlerEx.LoadHandlers <ChoConfigurationObjectMemberErrorEventArgs>(ref ConfigurationObjectMemberLoadError, ChoType.GetMethods(GetType(), typeof(ChoConfigurationObjectMemberLoadErrorHandlerAttribute)), this); } if (BeforeConfigurationObjectPersisted == null) { EventHandlerEx.LoadHandlers <ChoPreviewConfigurationObjectEventArgs>(ref BeforeConfigurationObjectPersisted, ChoType.GetMethods(GetType(), typeof(ChoBeforeConfigurationObjectPersistedHandlerAttribute)), this); } if (AfterConfigurationObjectPersisted == null) { EventHandlerEx.LoadHandlers <ChoConfigurationObjectEventArgs>(ref AfterConfigurationObjectPersisted, ChoType.GetMethods(GetType(), typeof(ChoAfterConfigurationObjectPersistedHandlerAttribute)), this); } if (BeforeConfigurationObjectMemberPersist == null) { EventHandlerEx.LoadHandlers <ChoPreviewConfigurationObjectMemberEventArgs>(ref BeforeConfigurationObjectMemberPersist, ChoType.GetMethods(GetType(), typeof(ChoBeforeConfigurationObjectMemberPersistHandlerAttribute)), this); } if (AfterConfigurationObjectMemberPersist == null) { EventHandlerEx.LoadHandlers <ChoConfigurationObjectMemberEventArgs>(ref AfterConfigurationObjectMemberPersist, ChoType.GetMethods(GetType(), typeof(ChoAfterConfigurationObjectMemberPersistHandlerAttribute)), this); } if (AfterConfigurationObjectLoadedInternal == null) { EventHandlerEx.LoadHandlers <ChoConfigurationObjectEventArgs>(ref AfterConfigurationObjectLoadedInternal, ChoType.GetMethods(GetType(), typeof(ChoAfterConfigurationObjectLoadedHandlerAttribute)), this); } if (ConfigurationObjectLoadError == null) { EventHandlerEx.LoadHandlers <ChoConfigurationObjectErrorEventArgs>(ref ConfigurationObjectLoadError, ChoType.GetMethods(GetType(), typeof(ChoConfigurationObjectLoadErrorHandlerAttribute)), this); } }
private bool ValidateOnWrite(ref object value) { var crs = Writer.ContractResolverState; var fc = crs.FieldConfig; crs.Name = _fc == null?_mi.GetFullName() : crs.Name; var rec = ChoType.GetMemberObjectMatchingType(crs.Name, crs.Record); var name = ChoType.GetFieldName(crs.Name); try { Validate(value); } catch (Exception ex) { ChoETLFramework.HandleException(ref ex); if (fc != null && fc.ErrorMode == ChoErrorMode.ThrowAndStop) { throw; } if (fc != null) { if (fc.ErrorMode == ChoErrorMode.IgnoreAndContinue) { return(false); } else { if (!RaiseRecordFieldWriteError(rec, crs.Index, name, ref value, ex)) { throw new ChoWriterException($"Failed to write '{value}' value of '{crs.Name}' member.", ex); } } } else { throw new ChoWriterException($"Failed to write '{value}' value of '{crs.Name}' member.", ex); } } return(true); }
public static Dictionary <string, object> ToDictionary(this object target) { ChoGuard.ArgumentNotNull(target, "Target"); if (target is IDictionary <string, object> ) { return((Dictionary <string, object>)target); } Dictionary <string, object> dict = new Dictionary <string, object>(); foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(target.GetType())) { dict.Add(pd.Name, ChoType.GetPropertyValue(target, pd.Name)); } return(dict); }
public static string GetName(Type objType, ChoTypeNameSpecifier typeNameSpecifier) { ChoGuard.ArgumentNotNull(objType, "Type"); ChoObjectNameableAttribute objectNameableAttribute = ChoType.GetAttribute(objType, typeof(ChoObjectNameableAttribute)) as ChoObjectNameableAttribute; string key = null; if (objectNameableAttribute != null) { key = objectNameableAttribute.Name; } else { key = objType.GetName(typeNameSpecifier); } return(key); }
internal static Type GetPlugInType(Type plugInBuilderType) { ChoPlugInAttribute plugInAttribute = ChoType.GetAttribute <ChoPlugInAttribute>(plugInBuilderType); if (plugInAttribute == null) { return(null); } Type type = plugInAttribute.PlugInType; if (type == null) { throw new ChoPlugInException("Can't find plugin for '{0}' plugin builder.".FormatString(plugInBuilderType.Name)); } return(type); }
public static IQueryable <T> StageOnSqlServer <T>(this IEnumerable <T> items, ChoETLSqlServerSettings sqlServerSettings = null) where T : class { if (typeof(T) == typeof(ExpandoObject) || typeof(T) == typeof(object)) { throw new NotSupportedException(); } Dictionary <string, PropertyInfo> PIDict = ChoType.GetProperties(typeof(T)).ToDictionary(p => p.Name); sqlServerSettings = ValidateSettings <T>(sqlServerSettings); LoadDataToDb(items, sqlServerSettings, PIDict); var ctx = new ChoETLSqlServerDbContext <T>(sqlServerSettings.ConnectionString); var dbSet = ctx.Set <T>(); return(dbSet); }
public virtual string GetParams() { StringBuilder stringBuilder = new StringBuilder(); foreach (Tuple <string, object> tuple in ChoObjectEx.AsDictionary((object)this, false, false)) { if (stringBuilder.Length > 0) { stringBuilder.Append(";"); } MemberInfo memberInfo = ChoType.GetMemberInfo(this.GetType(), tuple.Item1); if (memberInfo != (MemberInfo)null && ChoType.GetAttribute <BrowsableAttribute>(memberInfo, false) == null) { stringBuilder.AppendFormat(ChoStringEx.FormatString("{0}={1}", (object)tuple.Item1, NormalizeString(tuple.Item2 != null ? tuple.Item2.ToString() : string.Empty))); } } return(stringBuilder.ToString()); }
protected virtual void Init(Type recordType) { if (recordType == null) { return; } _recObject = new Lazy <object>(() => ChoActivator.CreateInstance(RecordType)); ChoRecordObjectAttribute recObjAttr = ChoType.GetAttribute <ChoRecordObjectAttribute>(recordType); if (recObjAttr != null) { ErrorMode = recObjAttr.ErrorMode; IgnoreFieldValueMode = recObjAttr.IgnoreFieldValueMode; ThrowAndStopOnMissingField = recObjAttr.ThrowAndStopOnMissingField; ObjectValidationMode = recObjAttr.ObjectValidationMode; } }
public string GetDescription(string name) { var m1 = ChoType.GetMembers(GetType()).Where(m => !ChoType.IsReadOnlyMember(m)).FirstOrDefault(); if (m1 == null) { return(null); } if (ChoType.HasMemberAttribute <DescriptionAttribute>(m1)) { return(m1.GetCustomAttribute <DescriptionAttribute>().Description); } else { return(null); } }
public static IQueryable <T> StageOnSQLite <T>(this IEnumerable <T> items, ChoETLSqliteSettings sqliteSettings = null) where T : class { if (typeof(T).IsDynamicType() || typeof(T) == typeof(object)) { throw new NotSupportedException(); } Dictionary <string, PropertyInfo> PIDict = ChoType.GetProperties(typeof(T)).ToDictionary(p => p.Name); sqliteSettings = ValidateSettings <T>(sqliteSettings); LoadDataToDb(items, sqliteSettings, PIDict); var ctx = new ChoETLSQLiteDbContext <T>(sqliteSettings.DatabaseFilePath); var dbSet = ctx.Set <T>(); return(dbSet); }