private void DrawFieldListValueLabel(Element element, object obj, ITypeHandler handler) { string valueText; if (element.type == Element.Type.ValueRow) { valueText = obj == null ? "null" : EscapeNewlines(handler.GetStringValue(obj)); } else { valueText = ""; } GUILayout.Label(valueText, FieldListValueLabelStyle); }
/// <summary> /// Performs processing on a value before it is used to set /// the parameter of a IDbCommand. /// </summary> /// <param name="dataParameter"></param> /// <param name="parameterValue">The value to be set</param> /// <param name="dbType">Data base type</param> public override void SetParameter(IDataParameter dataParameter, object parameterValue, string dbType) { if (parameterValue != null) { ITypeHandler handler = _factory.GetTypeHandler(parameterValue.GetType(), dbType); handler.SetParameter(dataParameter, parameterValue, dbType); } else { // When sending a null parameter value to the server, // the user must specify DBNull, not null. dataParameter.Value = System.DBNull.Value; } }
public object Read(Format format, FormatReader reader) { if (format.IsArrayFamily) { floatHandler = floatHandler ?? context.TypeHandlers.Get <float>(); Vector4 vector = new Vector4(); vector.x = (float)floatHandler.Read(reader.ReadFormat(), reader); vector.y = (float)floatHandler.Read(reader.ReadFormat(), reader); vector.z = (float)floatHandler.Read(reader.ReadFormat(), reader); vector.w = (float)floatHandler.Read(reader.ReadFormat(), reader); return(vector); } throw new FormatException(this, format, reader); }
private IList <Element> GetChildren(object parent, ITypeHandler parentHandler) { if (!childrenCached) { var enumerator = parentHandler.GetChildren(parent, displayOptions); while (enumerator.MoveNext()) { childrenCache.Add(enumerator.Current); } childrenCached = true; } return(childrenCache); }
/// <summary> /// /// </summary> /// <param name="type"></param> /// <returns></returns> public bool IsSimpleType(Type type) { bool result = false; if (type != null) { ITypeHandler handler = this.GetTypeHandler(type, null); if (handler != null) { result = handler.IsSimpleType; } } return(result); }
public void Register(TypeHandler typeHandlerConfig) { ITypeHandler typeHandler = null; if (typeHandlerConfig.HandlerType.IsGenericType) { var genericArgs = typeHandlerConfig.HandlerType.GetGenericArguments(); switch (genericArgs.Length) { case 2: { typeHandler = _typeHandlerBuilder.Build(typeHandlerConfig.HandlerType , typeHandlerConfig.PropertyType, typeHandlerConfig.FieldType, typeHandlerConfig.Properties); break; } case 1: { if (typeHandlerConfig.PropertyType != null) { typeHandler = _typeHandlerBuilder.Build(typeHandlerConfig.HandlerType, typeHandlerConfig.PropertyType, typeHandlerConfig.Properties); } if (typeHandlerConfig.FieldType != null) { typeHandler = _typeHandlerBuilder.Build(typeHandlerConfig.HandlerType, typeHandlerConfig.FieldType, typeHandlerConfig.Properties); } break; } default: { throw new SmartSqlException($"Wrong TypeHandlerConfig.Type:{typeHandlerConfig.HandlerType.FullName}."); } } } else { typeHandler = _typeHandlerBuilder.Build(typeHandlerConfig.HandlerType, typeHandlerConfig.Properties); } if (!String.IsNullOrEmpty(typeHandlerConfig.Name)) { Register(typeHandlerConfig.Name, typeHandler); } else { Register(typeHandler); } }
/// <summary> /// Builds the type handlers. /// </summary> /// <param name="store">The store.</param> private void BuildTypeHandlers(IConfigurationStore store) { for (int i = 0; i < store.TypeHandlers.Length; i++) { IConfiguration handlerConfig = store.TypeHandlers[i]; try { //_configScope.ErrorContext.Activity = "loading typeHandler"; TypeHandler handler = TypeHandlerDeSerializer.Deserialize(handlerConfig); //configScope.ErrorContext.MoreInfo = "Check the callback attribute '" + handler.CallBackName + "' (must be a classname)."; ITypeHandler typeHandler = null; Type type = modelStore.DataExchangeFactory.TypeHandlerFactory.GetType(handler.Callback); object impl = Activator.CreateInstance(type); if (impl is ITypeHandlerCallback) { typeHandler = new CustomTypeHandler((ITypeHandlerCallback)impl); } else if (impl is ITypeHandler) { typeHandler = (ITypeHandler)impl; } else { throw new ConfigurationException("The callBack type is not a valid implementation of ITypeHandler or ITypeHandlerCallback"); } //configScope.ErrorContext.MoreInfo = "Check the type attribute '" + handler.ClassName + "' (must be a class name) or the dbType '" + handler.DbType + "' (must be a DbType type name)."; if (handler.DbType != null && handler.DbType.Length > 0) { modelStore.DataExchangeFactory.TypeHandlerFactory.Register(handler.Type, handler.DbType, typeHandler); } else { modelStore.DataExchangeFactory.TypeHandlerFactory.Register(handler.Type, typeHandler); } } catch (Exception e) { throw new ConfigurationException( String.Format("Error registering TypeHandler class \"{0}\" for handling .Net type \"{1}\" and dbType \"{2}\". Cause: {3}", handlerConfig.GetAttributeValue("callback"), handlerConfig.GetAttributeValue("type"), handlerConfig.GetAttributeValue("dbType"), e.Message), e); } } }
string GenTypeCode(Type type, ITypeHandler typeHandler) { var fileds = FilterFields(type.GetFields(bindingAttr)); IFiledHandler[] Handlers = typeHandler.GetFiledHandlers(); List <string> sbfs = new List <string>(); foreach (var Handler in Handlers) { var sbf = GetFiledInfo(fileds, Handler); sbfs.Add(sbf); } return(typeHandler.DealType(type, sbfs)); }
public void Write(object obj, FormatWriter writer) { switch (context.EnumOptions.PackingFormat) { case EnumPackingFormat.Integer: intHandler = intHandler ?? context.TypeHandlers.Get <int>(); intHandler.Write(obj, writer); break; case EnumPackingFormat.String: stringHandler = stringHandler ?? context.TypeHandlers.Get <string>(); stringHandler.Write(obj.ToString(), writer); break; } }
private void BuildDbParameters(AbstractRequestContext reqConetxt) { if (reqConetxt.CommandType == CommandType.StoredProcedure) { foreach (var sqlParameter in reqConetxt.Parameters.Values) { if (sqlParameter.SourceParameter != null) { sqlParameter.OnSetSourceParameter.Invoke(sqlParameter); continue; } var sourceParam = _dbProviderFactory.CreateParameter(); InitSourceDbParameter(sourceParam, sqlParameter); sourceParam.ParameterName = sqlParameter.Name; sourceParam.Value = sqlParameter.Value; sqlParameter.TypeHandler?.SetParameter(sourceParam, sqlParameter.Value); sqlParameter.SourceParameter = sourceParam; } } else { reqConetxt.RealSql = _sqlParamAnalyzer.Replace(reqConetxt.RealSql, (paramName, nameWithPrefix) => { if (!reqConetxt.Parameters.TryGetValue(paramName, out var sqlParameter)) { return(nameWithPrefix); } ITypeHandler typeHandler = (reqConetxt.ParameterMap?.GetParameter(paramName)?.Handler ?? sqlParameter.TypeHandler) ?? _typeHandlerFactory.GetTypeHandler(sqlParameter.ParameterType); var sourceParam = _dbProviderFactory.CreateParameter(); InitSourceDbParameter(sourceParam, sqlParameter); sourceParam.ParameterName = sqlParameter.Name; typeHandler.SetParameter(sourceParam, sqlParameter.Value); sqlParameter.SourceParameter = sourceParam; if (sqlParameter.Name != paramName) { return ($"{reqConetxt.ExecutionContext.SmartSqlConfig.Database.DbProvider.ParameterPrefix}{sqlParameter.Name}"); } return(nameWithPrefix); }); } }
private void BuildDbParameters(AbstractRequestContext reqConetxt) { var dbParameterNames = _sqlParamAnalyzer.Analyse(reqConetxt.RealSql); if (reqConetxt.CommandType == CommandType.StoredProcedure) { foreach (var sqlParameter in reqConetxt.Parameters.Values) { var sourceParam = _dbProviderFactory.CreateParameter(); sourceParam.ParameterName = sqlParameter.Name; sourceParam.Value = sqlParameter.Value; sqlParameter.SourceParameter = sourceParam; InitSourceDbParameter(sourceParam, sqlParameter); } } else { foreach (var paramName in dbParameterNames) { var parameter = reqConetxt.ParameterMap?.GetParameter(paramName); var propertyName = paramName; ITypeHandler typeHandler = null; if (parameter != null) { propertyName = parameter.Property; typeHandler = parameter.Handler; } if (!reqConetxt.Parameters.TryGetValue(propertyName, out var sqlParameter)) { continue; } var sourceParam = _dbProviderFactory.CreateParameter(); sourceParam.ParameterName = paramName; if (typeHandler == null) { typeHandler = sqlParameter.TypeHandler ?? _typeHandlerFactory.GetTypeHandler(sqlParameter.ParameterType); } typeHandler.SetParameter(sourceParam, sqlParameter.Value); sqlParameter.SourceParameter = sourceParam; InitSourceDbParameter(sourceParam, sqlParameter); } } }
/// <summary> /// Processes the specified <see cref="IDataReader"/> /// when a ResultClass is specified on the statement and /// the ResultClass is a SimpleType. /// </summary> /// <param name="request">The request.</param> /// <param name="reader">The reader.</param> /// <param name="resultObject">The result object.</param> public object Process(RequestScope request, ref IDataReader reader, object resultObject) { object outObject = resultObject; AutoResultMap resultMap = (AutoResultMap)request.CurrentResultMap; if (outObject == null) { outObject = resultMap.CreateInstanceOfResult(null); } if (!resultMap.IsInitalized) { lock (resultMap) { if (!resultMap.IsInitalized) { // Create a ResultProperty const string propertyName = "value"; const int columnIndex = 0; ITypeHandler typeHandler = request.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(outObject.GetType()); ResultProperty property = new ResultProperty( propertyName, string.Empty, columnIndex, string.Empty, string.Empty, string.Empty, false, string.Empty, null, string.Empty, null, null, typeHandler); //property.PropertyStrategy = PropertyStrategyFactory.Get(property); resultMap.Properties.Add(property); resultMap.DataExchange = request.DataExchangeFactory.GetDataExchangeForClass(typeof(int));// set the PrimitiveDataExchange resultMap.IsInitalized = true; } } } //为outObject类的属性property赋值 resultMap.Properties[0].PropertyStrategy.Set(request, resultMap, resultMap.Properties[0], ref outObject, reader, null); return(outObject); }
//-------------------------------------------------------------------------------- // Lookup //-------------------------------------------------------------------------------- private bool LookupTypeHandler(Type type, out ITypeHandler handler) { type = Nullable.GetUnderlyingType(type) ?? type; if (typeHandlers.TryGetValue(type, out handler)) { return(true); } if (type.IsEnum && typeHandlers.TryGetValue(Enum.GetUnderlyingType(type), out handler)) { return(true); } handler = null; return(false); }
/// <summary> /// Processes the specified <see cref="IDataReader"/> /// when a 'resultClass' attribute is specified on the statement and /// the 'resultClass' attribute is a <see cref="IDictionary"/>. /// </summary> /// <param name="request">The request.</param> /// <param name="reader">The reader.</param> /// <param name="resultObject">The result object.</param> public object Process(RequestScope request, ref IDataReader reader, object resultObject) { object outObject = resultObject; //AutoResultMap resultMap = request.CurrentResultMap as AutoResultMap; if (outObject == null) { outObject = request.CurrentResultMap.CreateInstanceOfResult(null); } //将reader当前行中的所有字段加入到IDictionary对象中 int count = reader.FieldCount; IDictionary dictionary = (IDictionary)outObject; for (int i = 0; i < count; i++) { //ResultProperty property = new ResultProperty(); //property.PropertyName = "value"; //property.ColumnIndex = i; //property.TypeHandler = request.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(reader.GetFieldType(i)); const string propertyName = "value"; int columnIndex = i; ITypeHandler typeHandler = request.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(reader.GetFieldType(i)); ResultProperty property = new ResultProperty( propertyName, string.Empty, columnIndex, string.Empty, string.Empty, string.Empty, false, string.Empty, null, string.Empty, typeof(IDictionary), request.DataExchangeFactory, typeHandler); dictionary.Add( reader.GetName(i), property.GetDataBaseValue(reader)); } return(outObject); }
/// <summary> /// Register (add) a type handler for a type and dbType /// </summary> /// <param name="type">the type</param> /// <param name="dbType">the dbType (optional, if dbType is null the handler will be used for all dbTypes)</param> /// <param name="handler">the handler instance</param> public void Register(Type type, string dbType, ITypeHandler handler) { IDictionary <string, ITypeHandler> map = null; typeHandlerMap.TryGetValue(type, out map); if (map == null) { map = new Dictionary <string, ITypeHandler>(); typeHandlerMap.Add(type, map); } if (dbType == null) { if (logger.IsInfoEnabled) { // notify the user that they are no longer using one of the built-in type handlers ITypeHandler oldTypeHandler = null; map.TryGetValue(NULL, out oldTypeHandler); if (oldTypeHandler != null) { // the replacement will always(?) be a CustomTypeHandler CustomTypeHandler customTypeHandler = handler as CustomTypeHandler; string replacement = string.Empty; if (customTypeHandler != null) { // report the underlying type replacement = customTypeHandler.Callback.ToString(); } else { replacement = handler.ToString(); } // should oldTypeHandler be checked if its a CustomTypeHandler and if so report the Callback property ??? logger.Info("Replacing type handler [" + oldTypeHandler + "] with [" + replacement + "]."); } } map[NULL] = handler; } else { map.Add(dbType, handler); } }
/// <summary> /// Set parameter value, replace the null value if any. /// </summary> /// <param name="mapping"></param> /// <param name="dataParameter"></param> /// <param name="parameterValue"></param> public void SetParameter(ParameterProperty mapping, IDataParameter dataParameter, object parameterValue) { object value = dataExchange.GetData(mapping, parameterValue); ITypeHandler typeHandler = mapping.TypeHandler; // Apply Null Value if (mapping.HasNullValue) { if (typeHandler.Equals(value, mapping.NullValue)) { value = null; } } typeHandler.SetParameter(dataParameter, value, mapping.DbType); }
public void AddTypeHandler(Type type, ITypeHandler typeHandler) { if (type == null) { throw new ArgumentNullException("type"); } if (typeHandler == null) { throw new ArgumentNullException("typeHandler"); } if (typeHandlerMap == null) { typeHandlerMap = new Dictionary <Type, ITypeHandler>(); } typeHandlerMap[type] = typeHandler; }
public void HandleRead(TypeHandlingContext context) { IDeclaredType valueType = context.Type.GetScalarType(); if (valueType == null) { throw new NotSupportedException(); } ITypeHandler valueHandler = TypeHandlers.All.SingleOrDefault(h => h.CanHandle(context.WithType(valueType))); if (valueHandler == null) { throw new NotSupportedException(); } var indexName = context.Variables.Declare(Index); var lengthName = context.Variables.Declare(Length); var exists = context.Variables.Declare(VariableKeys.NotNull); TypeHandlers.Boolean.HandleRead(new TypeHandlingContext(context) { TypeOwnerName = String.Format("var {0}", exists) }); context.Builder.AppendFormat("if({0})", exists); context.Builder.Append("{"); context.Builder.AppendFormat("var {0} = BitConverter.ToInt32(bytes, index);", lengthName); context.Builder.Append("index += sizeof(Int32);"); context.Builder.AppendFormat("{0} = new {1}[{2}];", context.TypeOwnerName, valueType.GetPresentableName(context.PresentationLanguage), lengthName); context.Builder.AppendFormat("if({0} > 0)", lengthName); context.Builder.Append("{"); context.Builder.AppendFormat("for(Int32 {0} = 0; {0} < {1}; {0}++)", indexName, lengthName); context.Builder.Append("{"); valueHandler.HandleRead(new TypeHandlingContext(context) { TypeOwnerName = String.Format("{0}[{1}]", context.TypeOwnerName, indexName), Type = valueType, TypeName = valueType.GetPresentableName(context.PresentationLanguage), TypeOwner = context.TypeOwner }); context.Builder.Append("}}}"); context.Variables.Dispose(Index); context.Variables.Dispose(Length); }
/// <summary> /// Register (add) a type handler for a type and dbType /// </summary> /// <param name="type">the type</param> /// <param name="dbType">the dbType (optional, if dbType is null the handler will be used for all dbTypes)</param> /// <param name="handler">the handler instance</param> public void Register(Type type, string dbType, ITypeHandler handler) { HybridDictionary map = (HybridDictionary)_typeHandlerMap[type]; if (map == null) { map = new HybridDictionary(); _typeHandlerMap.Add(type, map); } if (dbType == null) { if (_logger.IsDebugEnabled) { // notify the user that they are no longer using one of the built-in type handlers ITypeHandler oldTypeHandler = (ITypeHandler)map[NULL]; if (oldTypeHandler != null) { // the replacement will always(?) be a CustomTypeHandler CustomTypeHandler customTypeHandler = handler as CustomTypeHandler; string replacement = string.Empty; if (customTypeHandler != null) { // report the underlying type replacement = customTypeHandler.Callback.ToString(); } else { replacement = handler.ToString(); } // should oldTypeHandler be checked if its a CustomTypeHandler and if so report the Callback property ??? _logger.Debug("Replacing type handler [" + oldTypeHandler.ToString() + "] with [" + replacement + "]."); } } map[NULL] = handler; } else { map.Add(dbType, handler); } }
/// <summary> /// Register (add) a type handler for a type and dbType /// </summary> /// <param name="type">the type</param> /// <param name="dbType">the dbType (optional, if dbType is null the handler will be used for all dbTypes)</param> /// <param name="handler">the handler instance</param> public void Register(Type type, string dbType, ITypeHandler handler) { HybridDictionary map = (HybridDictionary)_typeHandlerMap[type]; if (map == null) { map = new HybridDictionary(); _typeHandlerMap.Add(type, map); } if (dbType == null) { map[NULL] = handler; } else { map.Add(dbType, handler); } }
public object Read(Format format, FormatReader reader) { if (format.IsIntFamily) { intHandler = intHandler ?? context.TypeHandlers.Get <int>(); return(Enum.ToObject(type, intHandler.Read(format, reader))); } if (format.IsStringFamily) { stringHandler = stringHandler ?? context.TypeHandlers.Get <string>(); return(Enum.Parse(type, (string)stringHandler.Read(format, reader), true)); } if (format.IsNil) { return(Enum.ToObject(type, 0)); } throw new FormatException(this, format, reader); }
public void HandleWrite(TypeHandlingContext context) { IDeclaredType valueType = context.Type.GetScalarType(); if (valueType == null) { throw new NotSupportedException(); } ITypeHandler valueHandler = TypeHandlers.All.SingleOrDefault(h => h.CanHandle(context.WithType(valueType))); if (valueHandler == null) { throw new NotSupportedException(); } String indexName = context.Variables.Declare(Index); var exists = context.Variables.Declare(VariableKeys.NotNull); context.Builder.AppendFormat("var {0} = {1} != null;", exists, context.TypeOwnerName); TypeHandlers.Boolean.HandleWrite(new TypeHandlingContext(context) { TypeOwnerName = exists }); context.Builder.AppendFormat("if({0})", exists); context.Builder.Append("{"); TypeHandlers.Int32.HandleWrite(new TypeHandlingContext(context) { TypeName = TypeHandlers.Int32.TypeName, TypeOwnerName = String.Format("{0}.Length", context.TypeOwnerName) }); context.Builder.AppendFormat("if({0}.Length > 0)", context.TypeOwnerName); context.Builder.Append("{"); context.Builder.AppendFormat("for(Int32 {0} = 0; {0} < {1}.Length; {0}++)", indexName, context.TypeOwnerName); context.Builder.Append("{"); valueHandler.HandleWrite(new TypeHandlingContext(context) { TypeName = valueType.GetPresentableName(context.PresentationLanguage), TypeOwnerName = String.Format("{0}[{1}]", context.TypeOwnerName, indexName) }); context.Builder.Append("}}}"); context.Variables.Dispose(Index); }
public ITypeHandler ResolveTypeHandler(ConfigurationScope configScope, Type argumenType, string clrType, string dbType) { ITypeHandler typeHandler = null; if (argumenType == null) { return(configScope.DataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler()); } if (typeof(IDictionary).IsAssignableFrom(argumenType)) { if ((clrType == null) || (clrType.Length == 0)) { return(configScope.DataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler()); } try { Type type = TypeUtils.ResolveType(clrType); return(configScope.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(type, dbType)); } catch (Exception exception) { throw new ConfigurationErrorsException("Error. Could not set TypeHandler. Cause: " + exception.Message, exception); } } if (configScope.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(argumenType, dbType) != null) { return(configScope.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(argumenType, dbType)); } if ((clrType == null) || (clrType.Length == 0)) { return(configScope.DataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler()); } try { Type type2 = TypeUtils.ResolveType(clrType); typeHandler = configScope.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(type2, dbType); } catch (Exception exception2) { throw new ConfigurationErrorsException("Error. Could not set TypeHandler. Cause: " + exception2.Message, exception2); } return(typeHandler); }
public static void Build(DbCommand cmd, string name, DbType dbType, ITypeHandler handler, object value) { var p = cmd.CreateParameter(); p.ParameterName = name; if (value is null) { p.Value = DBNull.Value; } else if (handler is null) { p.DbType = dbType; p.Value = value; } else { handler.Build(p, value); } }
/// <summary> /// /// </summary> /// <param name="type"></param> /// <returns></returns> public bool IsSimpleType(Type type) { bool result = false; if (!simpleTypes.TryGetValue(type, out result)) { if (type != null) { ITypeHandler handler = GetTypeHandler(type, null); if (handler != null) { result = handler.IsSimpleType; } simpleTypes[type] = result; } } return(result); }
public ComponentInfo(Type componentType, ITypeHandler typeHandler) { if (componentType == null) throw new ArgumentNullException("componentType"); if (typeHandler == null) throw new ArgumentNullException("typeHandler"); ComponentType = componentType; this.typeHandler = typeHandler; properties = typeHandler.GetProperties(componentType); if (properties.Length == 0) { propertyNames = emptyPropertyNames; } else { propertyNames = new string[properties.Length]; for (int i = 0; i < properties.Length; i++) propertyNames[i] = properties[i].Name; } }
public void Register(ITypeHandler typeHandler) { if (!_typeHandlerMap.TryGetValue(typeHandler.PropertyType, out var fieldTypeHandlerMap)) { fieldTypeHandlerMap = new Dictionary <Type, ITypeHandler>(); _typeHandlerMap.Add(typeHandler.PropertyType, fieldTypeHandlerMap); } if (fieldTypeHandlerMap.ContainsKey(typeHandler.FieldType)) { fieldTypeHandlerMap[typeHandler.FieldType] = typeHandler; } else { fieldTypeHandlerMap.Add(typeHandler.FieldType, typeHandler); } TypeHandlerCacheType.SetHandler(typeHandler); PropertyTypeHandlerCacheType.SetHandler(typeHandler); }
/// <summary> /// Resolve TypeHandler /// </summary> /// <param name="parameterClassType"></param> /// <param name="propertyName"></param> /// <param name="propertyType"></param> /// <param name="dbType"></param> /// <param name="typeHandlerFactory"></param> /// <returns></returns> private ITypeHandler ResolveTypeHandler(TypeHandlerFactory typeHandlerFactory, Type parameterClassType, string propertyName, string propertyType, string dbType) { ITypeHandler handler = null; if (parameterClassType == null) { handler = typeHandlerFactory.GetUnkownTypeHandler(); } else if (typeof(IDictionary).IsAssignableFrom(parameterClassType)) { if (propertyType == null || propertyType.Length == 0) { handler = typeHandlerFactory.GetUnkownTypeHandler(); } else { try { Type typeClass = TypeUtils.ResolveType(propertyType); handler = typeHandlerFactory.GetTypeHandler(typeClass, dbType); } catch (Exception e) { throw new ConfigurationException("Error. Could not set TypeHandler. Cause: " + e.Message, e); } } } else if (typeHandlerFactory.GetTypeHandler(parameterClassType, dbType) != null) { handler = typeHandlerFactory.GetTypeHandler(parameterClassType, dbType); } else { Type typeClass = ObjectProbe.GetMemberTypeForGetter(parameterClassType, propertyName); handler = typeHandlerFactory.GetTypeHandler(typeClass, dbType); } return(handler); }
/// <summary> /// Deserialize a TypeHandler object /// </summary> /// <param name="node"></param> /// <param name="configScope"></param> /// <returns></returns> public static void Deserialize(XmlNode node, ConfigurationScope configScope) { TypeHandler handler = new TypeHandler(); NameValueCollection prop = NodeUtils.ParseAttributes(node, configScope.Properties); handler.CallBackName = NodeUtils.GetStringAttribute(prop, "callback"); handler.ClassName = NodeUtils.GetStringAttribute(prop, "type"); handler.DbType = NodeUtils.GetStringAttribute(prop, "dbType"); handler.Initialize(); configScope.ErrorContext.MoreInfo = "Check the callback attribute '" + handler.CallBackName + "' (must be a classname)."; ITypeHandler typeHandler = null; Type type = configScope.SqlMapper.TypeHandlerFactory.GetType(handler.CallBackName); object impl = Activator.CreateInstance(type); if (impl is ITypeHandlerCallback) { typeHandler = new CustomTypeHandler((ITypeHandlerCallback)impl); } else if (impl is ITypeHandler) { typeHandler = (ITypeHandler)impl; } else { throw new ConfigurationErrorsException("The callBack type is not a valid implementation of ITypeHandler or ITypeHandlerCallback"); } // configScope.ErrorContext.MoreInfo = "Check the type attribute '" + handler.ClassName + "' (must be a class name) or the dbType '" + handler.DbType + "' (must be a DbType type name)."; if (handler.DbType != null && handler.DbType.Length > 0) { configScope.DataExchangeFactory.TypeHandlerFactory.Register(TypeUtils.ResolveType(handler.ClassName), handler.DbType, typeHandler); } else { configScope.DataExchangeFactory.TypeHandlerFactory.Register(TypeUtils.ResolveType(handler.ClassName), typeHandler); } }
public string GenTypeCode(ITypeHandler typeHandler, params Type[] types) { this.typeHandler = typeHandler; foreach (var t in types) { AddType(t); } var type = GetNextType(); StringBuilder sb = new StringBuilder(); while (type != null) { var typeStr = GenTypeCode(type, typeHandler); sb.AppendLine(typeStr); type = GetNextType(); } return(sb.ToString()); }
private void DrawFieldListButton(Element element, object obj, ITypeHandler handler) { var buttonText = element.text; if (element.type == Element.Type.ValueRow) { GUI.enabled = !handler.IsLeaf(obj); if (GUILayout.Button(buttonText, FieldListButtonStyle, FieldListButtonLayout)) { action = () => SelectChild(element); } GUI.enabled = true; } else if (element.type == Element.Type.Header) { var color = GUI.color; GUI.color = element.textColor; GUILayout.Label(element.text, FieldListHeaderLabelStyle); GUI.color = color; } }
/// <summary> /// Initialize the PropertyInfo of the result property. /// </summary> /// <param name="resultClass"></param> /// <param name="configScope"></param> public void Initialize( ConfigurationScope configScope, Type resultClass ) { if ( _propertyName.Length>0 && _propertyName != "value" && !typeof(IDictionary).IsAssignableFrom(resultClass) ) { if (!_isComplexMemberName) { _setAccessor = configScope.DataExchangeFactory.AccessorFactory.SetAccessorFactory.CreateSetAccessor(resultClass, _propertyName); } else // complex member name FavouriteLineItem.Id { MemberInfo propertyInfo = ObjectProbe.GetMemberInfoForSetter(resultClass, _propertyName); string memberName = _propertyName.Substring( _propertyName.LastIndexOf('.')+1); _setAccessor = configScope.DataExchangeFactory.AccessorFactory.SetAccessorFactory.CreateSetAccessor(propertyInfo.ReflectedType, memberName); } _isGenericIList = TypeUtils.IsImplementGenericIListInterface(this.MemberType); _isIList = typeof(IList).IsAssignableFrom(this.MemberType); // set the list factory if (_isGenericIList) { if (this.MemberType.IsArray) { _listFactory = _arrayListFactory; } else { Type[] typeArgs = this.MemberType.GetGenericArguments(); if (typeArgs.Length == 0)// Custom collection which derive from List<T> { _listFactory = configScope.DataExchangeFactory.ObjectFactory.CreateFactory(this.MemberType, Type.EmptyTypes); } else { Type genericIList = typeof(IList<>); Type interfaceListType = genericIList.MakeGenericType(typeArgs); Type genericList = typeof(List<>); Type listType = genericList.MakeGenericType(typeArgs); if ((interfaceListType == this.MemberType) || (listType == this.MemberType)) { Type constructedType = genericList.MakeGenericType(typeArgs); _listFactory = configScope.DataExchangeFactory.ObjectFactory.CreateFactory( constructedType, Type.EmptyTypes); } else // Custom collection which derive from List<T> { _listFactory = configScope.DataExchangeFactory.ObjectFactory.CreateFactory(this.MemberType, Type.EmptyTypes); } } } } else if (_isIList) { if (this.MemberType.IsArray) { _listFactory = _arrayListFactory; } else { if (this.MemberType == typeof(IList)) { _listFactory = _arrayListFactory; } else // custom collection { _listFactory = configScope.DataExchangeFactory.ObjectFactory.CreateFactory(this.MemberType, Type.EmptyTypes); } } } } if (this.CallBackName!=null && this.CallBackName.Length >0) { configScope.ErrorContext.MoreInfo = "Result property '"+_propertyName+"' check the typeHandler attribute '" + this.CallBackName + "' (must be a ITypeHandlerCallback implementation)."; try { Type type = configScope.SqlMapper.TypeHandlerFactory.GetType(this.CallBackName); ITypeHandlerCallback typeHandlerCallback = (ITypeHandlerCallback) Activator.CreateInstance( type ); _typeHandler = new CustomTypeHandler(typeHandlerCallback); } catch (Exception e) { throw new ConfigurationException("Error occurred during custom type handler configuration. Cause: " + e.Message, e); } } else { configScope.ErrorContext.MoreInfo = "Result property '"+_propertyName+"' set the typeHandler attribute."; _typeHandler = configScope.ResolveTypeHandler( resultClass, _propertyName, _clrType, _dbType, true); } if (this.IsLazyLoad) { _lazyFactory = new LazyFactoryBuilder().GetLazyFactory(_setAccessor.MemberType); } }
/// <summary> /// Constructor /// </summary> public TypeHandlerFactory() { ITypeHandler handler = null; handler = new DBNullTypeHandler(); this.Register(typeof(DBNull), handler); handler = new BooleanTypeHandler(); this.Register(typeof(bool), handler); // key= "System.Boolean" handler = new ByteTypeHandler(); this.Register(typeof(Byte), handler); handler = new CharTypeHandler(); this.Register(typeof(Char), handler); handler = new DateTimeTypeHandler(); this.Register(typeof(DateTime), handler); handler = new DecimalTypeHandler(); this.Register(typeof(Decimal), handler); handler = new DoubleTypeHandler(); this.Register(typeof(Double), handler); handler = new Int16TypeHandler(); this.Register(typeof(Int16), handler); handler = new Int32TypeHandler(); this.Register(typeof(Int32), handler); handler = new Int64TypeHandler(); this.Register(typeof(Int64), handler); handler = new SingleTypeHandler(); this.Register(typeof(Single), handler); handler = new StringTypeHandler(); this.Register(typeof(String), handler); handler = new GuidTypeHandler(); this.Register(typeof(Guid), handler); handler = new TimeSpanTypeHandler(); this.Register(typeof(TimeSpan), handler); handler = new ByteArrayTypeHandler(); this.Register(typeof(Byte[]), handler); handler = new ObjectTypeHandler(); this.Register(typeof(object), handler); handler = new EnumTypeHandler(); this.Register(typeof(System.Enum), handler); handler = new UInt16TypeHandler(); this.Register(typeof(UInt16), handler); handler = new UInt32TypeHandler(); this.Register(typeof(UInt32), handler); handler = new UInt64TypeHandler(); this.Register(typeof(UInt64), handler); handler = new SByteTypeHandler(); this.Register(typeof(SByte), handler); handler = new NullableBooleanTypeHandler(); this.Register(typeof(bool?), handler); handler = new NullableByteTypeHandler(); this.Register(typeof(byte?), handler); handler = new NullableCharTypeHandler(); this.Register(typeof(char?), handler); handler = new NullableDateTimeTypeHandler(); this.Register(typeof(DateTime?), handler); handler = new NullableDecimalTypeHandler(); this.Register(typeof(decimal?), handler); handler = new NullableDoubleTypeHandler(); this.Register(typeof(double?), handler); handler = new NullableGuidTypeHandler(); this.Register(typeof(Guid?), handler); handler = new NullableInt16TypeHandler(); this.Register(typeof(Int16?), handler); handler = new NullableInt32TypeHandler(); this.Register(typeof(Int32?), handler); handler = new NullableInt64TypeHandler(); this.Register(typeof(Int64?), handler); handler = new NullableSingleTypeHandler(); this.Register(typeof(Single?), handler); handler = new NullableUInt16TypeHandler(); this.Register(typeof(UInt16?), handler); handler = new NullableUInt32TypeHandler(); this.Register(typeof(UInt32?), handler); handler = new NullableUInt64TypeHandler(); this.Register(typeof(UInt64?), handler); handler = new NullableSByteTypeHandler(); this.Register(typeof(SByte?), handler); handler = new NullableTimeSpanTypeHandler(); this.Register(typeof(TimeSpan?), handler); _unknownTypeHandler = new UnknownTypeHandler(this); }
/// <summary> /// Register (add) a type handler for a type and dbType /// </summary> /// <param name="type">the type</param> /// <param name="dbType">the dbType (optional, if dbType is null the handler will be used for all dbTypes)</param> /// <param name="handler">the handler instance</param> public void Register(Type type, string dbType, ITypeHandler handler) { HybridDictionary map = (HybridDictionary)_typeHandlerMap[type]; if (map == null) { map = new HybridDictionary(); _typeHandlerMap.Add(type, map); } if (dbType == null) { if (_logger.IsInfoEnabled) { // notify the user that they are no longer using one of the built-in type handlers ITypeHandler oldTypeHandler = (ITypeHandler)map[NULL]; if (oldTypeHandler != null) { // the replacement will always(?) be a CustomTypeHandler CustomTypeHandler customTypeHandler = handler as CustomTypeHandler; string replacement = string.Empty; if (customTypeHandler != null) { // report the underlying type replacement = customTypeHandler.Callback.ToString(); } else { replacement = handler.ToString(); } // should oldTypeHandler be checked if its a CustomTypeHandler and if so report the Callback property ??? _logger.Info("Replacing type handler [" + oldTypeHandler.ToString() + "] with [" + replacement + "]."); } } map[NULL] = handler; } else { map.Add(dbType, handler); } }
/// <summary> /// Register (add) a type handler for a type /// </summary> /// <param name="type">the type</param> /// <param name="handler">the handler instance</param> public void Register(Type type, ITypeHandler handler) { this.Register(type, null, handler); }
public IEnumerable<ITypeHandler> Handlers(ITypeHandler rootHandler) => _variableTypes._customHandlers.Select(h => h(rootHandler));
/// <summary> /// Initializes the parameter property /// </summary> /// <param name="scope">The scope.</param> /// <param name="parameterClass">The parameter class.</param> public void Initialize(IScope scope, Type parameterClass) { if(_directionAttribute.Length >0) { _direction = (ParameterDirection)Enum.Parse( typeof(ParameterDirection), _directionAttribute, true ); } if (!typeof(IDictionary).IsAssignableFrom(parameterClass) // Hashtable parameter map && parameterClass !=null // value property && !scope.DataExchangeFactory.TypeHandlerFactory.IsSimpleType(parameterClass) ) // value property { if (!_isComplexMemberName) { IGetAccessorFactory getAccessorFactory = scope.DataExchangeFactory.AccessorFactory.GetAccessorFactory; _getAccessor = getAccessorFactory.CreateGetAccessor(parameterClass, _propertyName); } else // complex member name FavouriteLineItem.Id { string memberName = _propertyName.Substring( _propertyName.LastIndexOf('.')+1); string parentName = _propertyName.Substring(0,_propertyName.LastIndexOf('.')); Type parentType = ObjectProbe.GetMemberTypeForGetter(parameterClass, parentName); IGetAccessorFactory getAccessorFactory = scope.DataExchangeFactory.AccessorFactory.GetAccessorFactory; _getAccessor = getAccessorFactory.CreateGetAccessor(parentType, memberName); } } scope.ErrorContext.MoreInfo = "Check the parameter mapping typeHandler attribute '" + this.CallBackName + "' (must be a ITypeHandlerCallback implementation)."; if (this.CallBackName.Length >0) { try { Type type = scope.DataExchangeFactory.TypeHandlerFactory.GetType(this.CallBackName); ITypeHandlerCallback typeHandlerCallback = (ITypeHandlerCallback) Activator.CreateInstance( type ); _typeHandler = new CustomTypeHandler(typeHandlerCallback); } catch (Exception e) { throw new ConfigurationException("Error occurred during custom type handler configuration. Cause: " + e.Message, e); } } else { if (this.CLRType.Length == 0 ) // Unknown { if (_getAccessor!= null && scope.DataExchangeFactory.TypeHandlerFactory.IsSimpleType(_getAccessor.MemberType)) { // Primitive _typeHandler = scope.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(_getAccessor.MemberType, _dbType); } else { _typeHandler = scope.DataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler(); } } else // If we specify a CLR type, use it { Type type = TypeUtils.ResolveType(this.CLRType); if (scope.DataExchangeFactory.TypeHandlerFactory.IsSimpleType(type)) { // Primitive _typeHandler = scope.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(type, _dbType); } else { // .NET object type = ObjectProbe.GetMemberTypeForGetter(type, this.PropertyName); _typeHandler = scope.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(type, _dbType); } } } }
/// <summary> /// Initializes a new instance of the <see cref="ResultProperty"/> class. /// </summary> /// <param name="propertyName">Name of the property.</param> /// <param name="columnName">Name of the column.</param> /// <param name="columnIndex">Index of the column.</param> /// <param name="clrType">Type of the CLR.</param> /// <param name="callBackName">Name of the call back.</param> /// <param name="dbType">Type of the db.</param> /// <param name="isLazyLoad">if set to <c>true</c> [is lazy load].</param> /// <param name="nestedResultMapName">Name of the nested result map.</param> /// <param name="nullValue">The null value.</param> /// <param name="select">The select.</param> /// <param name="resultClass">The result class.</param> /// <param name="dataExchangeFactory">The data exchange factory.</param> /// <param name="typeHandler">The type handler.</param> public ResultProperty( string propertyName, string columnName, int columnIndex, string clrType, string callBackName, string dbType, bool isLazyLoad, string nestedResultMapName, string nullValue, string select, Type resultClass, DataExchangeFactory dataExchangeFactory, ITypeHandler typeHandler ) { Contract.Require.That(propertyName, Is.Not.Null & Is.Not.Empty).When("retrieving argument propertyName in ResultProperty constructor"); this.propertyName = propertyName; this.columnName = columnName; this.callBackName = callBackName; this.dbType = dbType; this.clrType = clrType; this.select = select; this.nestedResultMapName = nestedResultMapName; this.isLazyLoad = isLazyLoad; this.nullValue = nullValue; this.columnIndex = columnIndex; this.typeHandler = typeHandler; #region isComplexMemberName if (propertyName.IndexOf('.') < 0) { isComplexMemberName = false; } else // complex member name FavouriteLineItem.Id { isComplexMemberName = true; } #endregion if ( propertyName.Length>0 && propertyName != "value" && !typeof(IDictionary).IsAssignableFrom(resultClass)&& !typeof(DataRow).IsAssignableFrom(resultClass)) { #region SetAccessor if (!isComplexMemberName) { setAccessor = dataExchangeFactory.AccessorFactory.SetAccessorFactory.CreateSetAccessor(resultClass, propertyName); } else // complex member name FavouriteLineItem.Id { MemberInfo propertyInfo = ObjectProbe.GetMemberInfoForSetter(resultClass, propertyName); string memberName = propertyName.Substring(propertyName.LastIndexOf('.') + 1); setAccessor = dataExchangeFactory.AccessorFactory.SetAccessorFactory.CreateSetAccessor(propertyInfo.ReflectedType, memberName); } #endregion isGenericIList = TypeUtils.IsImplementGenericIListInterface(MemberType); isIList = typeof(IList).IsAssignableFrom(MemberType); #region Set the list factory if (isGenericIList) { if (MemberType.IsArray) { listFactory = arrayListFactory; } else { Type[] typeArgs = MemberType.GetGenericArguments(); if (typeArgs.Length == 0)// Custom collection which derive from List<T> { listFactory = dataExchangeFactory.ObjectFactory.CreateFactory(MemberType, Type.EmptyTypes); } else { Type genericIList = typeof(IList<>); Type interfaceListType = genericIList.MakeGenericType(typeArgs); Type genericList = typeof(List<>); Type listType = genericList.MakeGenericType(typeArgs); if ((interfaceListType == MemberType) || (listType == MemberType)) { Type constructedType = genericList.MakeGenericType(typeArgs); listFactory = dataExchangeFactory.ObjectFactory.CreateFactory( constructedType, Type.EmptyTypes); } else // Custom collection which derive from List<T> { listFactory = dataExchangeFactory.ObjectFactory.CreateFactory(MemberType, Type.EmptyTypes); } } } } else if (isIList) { if (MemberType.IsArray) { listFactory = arrayListFactory; } else { if (MemberType == typeof(IList)) { listFactory = arrayListFactory; } else // custom collection { listFactory = dataExchangeFactory.ObjectFactory.CreateFactory(MemberType, Type.EmptyTypes); } } } #endregion } #region TypeHandler if (!string.IsNullOrEmpty(CallBackName)) { try { Type type = dataExchangeFactory.TypeHandlerFactory.GetType(CallBackName); ITypeHandlerCallback typeHandlerCallback = (ITypeHandlerCallback)Activator.CreateInstance(type); this.typeHandler = new CustomTypeHandler(typeHandlerCallback); } catch (Exception e) { throw new ConfigurationException("Error occurred during custom type handler configuration. Cause: " + e.Message, e); } } else { if (typeHandler == null) { //configScope.ErrorContext.MoreInfo = "Result property '" + propertyName + "' set the typeHandler attribute."; this.typeHandler = dataExchangeFactory.TypeHandlerFactory.ResolveTypeHandler(resultClass, propertyName, clrType, dbType, true); } } #endregion #region LazyLoad if (IsLazyLoad) { lazyFactory = new LazyFactoryBuilder().GetLazyFactory(setAccessor.MemberType); } #endregion if (!GetType().IsSubclassOf(typeof(ResultProperty))) { propertyStrategy = PropertyStrategyFactory.Get(this); } }
/// <summary> /// Initializes a new instance of the <see cref="ParameterProperty"/> class. /// </summary> /// <param name="propertyName">Name of the property.</param> /// <param name="columnName">Name of the column.</param> /// <param name="callBackName">Name of the call back.</param> /// <param name="clrType">Type of the CLR.</param> /// <param name="dbType">Type of the db.</param> /// <param name="directionAttribute">The direction attribute.</param> /// <param name="nullValue">The null value.</param> /// <param name="precision">The precision.</param> /// <param name="scale">The scale.</param> /// <param name="size">The size.</param> /// <param name="parameterClass">The parameter class.</param> /// <param name="dataExchangeFactory">The data exchange factory.</param> public ParameterProperty( string propertyName, string columnName, string callBackName, string clrType, string dbType, string directionAttribute, string nullValue, Byte precision, Byte scale, int size, Type parameterClass, DataExchangeFactory dataExchangeFactory ) { Contract.Require.That(propertyName, Is.Not.Null & Is.Not.Empty).When("retrieving argument propertyName in ParameterProperty constructor"); this.columnName = columnName; this.callBackName = callBackName; this.clrType = clrType; this.dbType = dbType; this.nullValue = nullValue; this.precision = precision; this.scale = scale; this.size = size; #region Direction if (directionAttribute.Length > 0) { direction = (ParameterDirection)Enum.Parse(typeof(ParameterDirection), directionAttribute, true); this.directionAttribute = direction.ToString(); } #endregion #region Property Name this.propertyName = propertyName; if (propertyName.IndexOf('.') < 0) { isComplexMemberName = false; } else // complex member name FavouriteLineItem.Id { isComplexMemberName = true; } #endregion #region GetAccessor if (!typeof(IDictionary).IsAssignableFrom(parameterClass) // Hashtable parameter map && parameterClass != null // value property && !dataExchangeFactory.TypeHandlerFactory.IsSimpleType(parameterClass)) // value property { if (!isComplexMemberName) { IGetAccessorFactory getAccessorFactory = dataExchangeFactory.AccessorFactory.GetAccessorFactory; getAccessor = getAccessorFactory.CreateGetAccessor(parameterClass, propertyName); } else // complex member name FavouriteLineItem.Id { string memberName = propertyName.Substring(propertyName.LastIndexOf('.') + 1); string parentName = propertyName.Substring(0, propertyName.LastIndexOf('.')); Type parentType = ObjectProbe.GetMemberTypeForGetter(parameterClass, parentName); IGetAccessorFactory getAccessorFactory = dataExchangeFactory.AccessorFactory.GetAccessorFactory; getAccessor = getAccessorFactory.CreateGetAccessor(parentType, memberName); } } #endregion #region TypeHandler if (CallBackName.Length > 0) { try { Type type = dataExchangeFactory.TypeHandlerFactory.GetType(CallBackName); ITypeHandlerCallback typeHandlerCallback = (ITypeHandlerCallback)Activator.CreateInstance(type); typeHandler = new CustomTypeHandler(typeHandlerCallback); } catch (Exception e) { throw new ConfigurationException("Error occurred during custom type handler configuration. Cause: " + e.Message, e); } } else { if (CLRType.Length == 0) // Unknown { if (getAccessor != null && dataExchangeFactory.TypeHandlerFactory.IsSimpleType(getAccessor.MemberType)) { // Primitive typeHandler = dataExchangeFactory.TypeHandlerFactory.GetTypeHandler(getAccessor.MemberType, dbType); } else { typeHandler = dataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler(); } } else // If we specify a CLR type, use it { Type type = TypeUtils.ResolveType(CLRType); if (dataExchangeFactory.TypeHandlerFactory.IsSimpleType(type)) { // Primitive typeHandler = dataExchangeFactory.TypeHandlerFactory.GetTypeHandler(type, dbType); } else { // .NET object type = ObjectProbe.GetMemberTypeForGetter(parameterClass, PropertyName); typeHandler = dataExchangeFactory.TypeHandlerFactory.GetTypeHandler(type, dbType); } } } #endregion }
/// <summary> /// Initializes a new instance of the <see cref="ArgumentProperty"/> class. /// </summary> /// <param name="argumentName">Name of the argument.</param> /// <param name="columnName">Name of the column.</param> /// <param name="columnIndex">Index of the column.</param> /// <param name="clrType">Type of the CLR.</param> /// <param name="callBackName">Name of the call back.</param> /// <param name="dbType">Type of the db.</param> /// <param name="nestedResultMapName">Name of the nested result map.</param> /// <param name="nullValue">The null value.</param> /// <param name="select">The select.</param> /// <param name="type">The argument type.</param> /// <param name="resultClass">The result class.</param> /// <param name="dataExchangeFactory">The data exchange factory.</param> /// <param name="typeHandler">The type handler.</param> public ArgumentProperty( string argumentName, string columnName, int columnIndex, string clrType, string callBackName, string dbType, string nestedResultMapName, string nullValue, string select, Type type, Type resultClass, DataExchangeFactory dataExchangeFactory, ITypeHandler typeHandler ) : base("value", columnName, columnIndex, clrType, callBackName, dbType, false, nestedResultMapName, nullValue, select, resultClass, dataExchangeFactory, typeHandler) { Contract.Require.That(argumentName, Is.Not.Null & Is.Not.Empty).When("retrieving argument argumentName in ArgumentProperty constructor"); Contract.Require.That(type, Is.Not.Null & Is.Not.Empty).When("retrieving argument type in ArgumentProperty constructor"); Contract.Require.That(resultClass, Is.Not.Null & Is.Not.Empty).When("retrieving argument resultClass in ArgumentProperty constructor"); this.argumentName = argumentName; this.type = type; argumentStrategy = ArgumentStrategyFactory.Get(this); }
/// <summary> /// Register (add) a type handler for a type and dbType /// 根据前两个参数 分两次获取数据 最后把dbType加入字典当中 /// </summary> /// <param name="type">the type</param> /// <param name="dbType">the dbType (optional, if dbType is null the handler will be used for all dbTypes)</param> /// <param name="handler">the handler instance</param> public void Register(Type type, string dbType, ITypeHandler handler) { IDictionary<string, ITypeHandler> map = null; typeHandlerMap.TryGetValue(type, out map); if (map == null) //如果type不存在,则加入当前对象 { map = new Dictionary<string, ITypeHandler>(); typeHandlerMap.Add(type, map) ; } if (dbType==null) { if (logger.IsInfoEnabled) { // notify the user that they are no longer using one of the built-in type handlers ITypeHandler oldTypeHandler = null; map.TryGetValue(NULL, out oldTypeHandler); if (oldTypeHandler != null) { // the replacement will always(?) be a CustomTypeHandler CustomTypeHandler customTypeHandler = handler as CustomTypeHandler; string replacement = string.Empty; if (customTypeHandler != null) { // report the underlying type replacement = customTypeHandler.Callback.ToString(); } else { replacement = handler.ToString(); } // should oldTypeHandler be checked if its a CustomTypeHandler and if so report the Callback property ??? logger.Info("Replacing type handler [" + oldTypeHandler + "] with [" + replacement + "]."); } } map[NULL] = handler;//意味着dbType默认的null类型 对应当前 } else { map.Add(dbType, handler);//最后加入字典当中ITypeHandler处理类对象 } }
/// <summary> /// Initialize a the result property /// for AutoMapper /// </summary> /// <param name="setAccessor">An <see cref="ISetAccessor"/>.</param> /// <param name="typeHandlerFactory"></param> internal void Initialize(TypeHandlerFactory typeHandlerFactory, ISetAccessor setAccessor ) { _setAccessor = setAccessor; _typeHandler = typeHandlerFactory.GetTypeHandler(setAccessor.MemberType); }