static FwkGeneratorHelper() { roottemplate = Path.Combine(HelperFunctions.ProgramFilesx86(), @"Fwk Software Factory\5.0\FwkTemplates\tt\"); _TemplateDocument = (TemplateDocument)HelperFunctions.DeserializeFromXml(typeof(TemplateDocument), GetFileTemplate("Templates.xml")); _MappingTypes = (MappingTypes)HelperFunctions.DeserializeFromXml(typeof(MappingTypes), GetFileTemplate("MappingType.xml")); NotSupportTypes_ToIncludeInBackEnd = "xml,timestamp,sql_variant"; NotSupportTypes_ToSearchInStoreProcedure = "xml,timestamp,sql_variant,varbinary,binary,image"; NotSupportTypes_ToInsertStoreProcedure = "xml,timestamp,sql_variant"; _Entity_Envelope_tt = FwkGeneratorHelper.GetFileTemplate("Entity.txt"); _Entity_Property_TemplateBinary_tt = _TemplateDocument.GetTemplate("Property_Binary").Content; _Entity_Property_tt = _TemplateDocument.GetTemplate("Property").Content; _Entity_Member_tt = " private [TYPENAME][NullToken] _[Property_Name];"; UserDefinedTypes = new UserDefinedTypes(); }
static FwkGeneratorHelper() { //roottemplate = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Templates"); //Path.Combine(HelperFunctions.ProgramFilesx86(), @"Allus Global BPO\FwkTemplates\tt\"); roottemplate = Path.Combine(System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Templates"); _TemplateDocument = (TemplateDocument)HelperFunctions.DeserializeFromXml(typeof(TemplateDocument), GetFileTemplate("Templates.xml")); _MappingTypes = (MappingTypes)HelperFunctions.DeserializeFromXml(typeof(MappingTypes), GetFileTemplate("MappingType.xml")); NotSupportTypes_ToIncludeInBackEnd = "xml,timestamp,sql_variant"; NotSupportTypes_ToSearchInStoreProcedure = "xml,timestamp,sql_variant,varbinary,binary,image"; NotSupportTypes_ToInsertStoreProcedure = "xml,timestamp,sql_variant"; _Entity_Envelope_tt = FwkGeneratorHelper.GetFileTemplate("Entity.txt"); _Entity_Property_TemplateBinary_tt = _TemplateDocument.GetTemplate("Property_Binary").Content; _Entity_Property_tt = _TemplateDocument.GetTemplate("Property").Content; _Entity_Member_tt = " private [TYPENAME][NullToken] _[Property_Name];"; }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { reader.MaxDepth = Object3D.MaxJsonDepth; var parentItem = existingValue as IObject3D; var items = new List <IObject3D>(); var jArray = JArray.Load(reader); foreach (var item in jArray) { string typeName = item["TypeName"]?.ToString(); IObject3D childItem; if (string.IsNullOrEmpty(typeName) || typeName == "Object3D" || !MappingTypes.TryGetValue(typeName, out string fullTypeName)) { // Use a normal Object3D type if the TypeName field is missing, invalid or has no mapping entry childItem = item.ToObject <Object3D>(serializer); } else { // If a mapping entry exists, try to find the type for the given entry falling back to Object3D if that fails Type type = Type.GetType(fullTypeName) ?? typeof(Object3D); childItem = (IObject3D)item.ToObject(type, serializer); } childItem.Parent = parentItem; items.Add(childItem); } return(new AscendableSafeList <IObject3D>(items, null)); }
private ObjectMappingData( TSource source, TTarget target, int?enumerableIndex, MappingTypes mappingTypes, IMappingContext mappingContext, IObjectMappingData declaredTypeMappingData, IObjectMappingData parent, bool createMapper) : base(source, target, enumerableIndex, parent, mappingContext) { MappingTypes = mappingTypes; MappingContext = mappingContext; DeclaredTypeMappingData = declaredTypeMappingData; if (parent != null) { Parent = parent; return; } if (createMapper) { _mapper = MapperContext.ObjectMapperFactory.GetOrCreateRoot(this); } }
public override string GetPropertyTypeName(string dbTypeName) { dbTypeName = dbTypeName.ToLower(); var propertyTypes = MappingTypes.Where(it => it.Value.ToString().ToLower() == dbTypeName || it.Key.ToLower() == dbTypeName); if (propertyTypes == null) { return("other"); } else if (dbTypeName == "xml" || dbTypeName == "string" || dbTypeName == "jsonb" || dbTypeName == "json") { return("string"); } else if (dbTypeName == "bpchar") //数据库char datatype 查询出来的时候是 bpchar { return("char"); } if (dbTypeName == "byte[]") { return("byte[]"); } else if (propertyTypes == null || propertyTypes.Count() == 0) { Check.ThrowNotSupportedException(string.Format(" \"{0}\" Type NotSupported, DbBindProvider.GetPropertyTypeName error.", dbTypeName)); return(null); } else if (propertyTypes.First().Value == CSharpDataType.byteArray) { return("byte[]"); } else { return(propertyTypes.First().Value.ToString()); } }
/// <summary> /// Initializes a new instance of the <see cref="MonitoredItemReference"/> struct. /// </summary> /// <param name="index">The index.</param> /// <param name="fieldType">Type of the field.</param> /// <param name="mappingType">Type of the mapping.</param> public MonitoredItemReference(int index, FieldTypes fieldType, MappingTypes mappingType) : this() { this.Index = index; this.FieldType = fieldType; this.MappingType = mappingType; }
public static IObjectMappingData ForRoot <TSource, TTarget>( TSource source, TTarget target, IMappingContext mappingContext) { MappingTypes mappingTypes; if ((target == null) && (typeof(TTarget) == typeof(object))) { // This is a 'create new' mapping where the target type has come // through as 'object'. This happens when you use .ToANew<dynamic>(), // and I can't see how to differentiate that from .ToANew<object>(). // Given that the former is more likely and that people asking for // .ToANew<object>() are doing something weird, default the target // type to ExpandoObject: mappingTypes = MappingTypes.For(source, default(ExpandoObject)); return(Create( source, default(ExpandoObject), null, mappingTypes, mappingContext)); } mappingTypes = MappingTypes.For(source, target); return(Create( source, target, null, mappingTypes, mappingContext)); }
public ChildObjectMapperKey(MappingTypes mappingTypes, IChildMembersSource childMembersSource) : this( mappingTypes, childMembersSource.TargetMemberRegistrationName, childMembersSource.DataSourceIndex) { _childMemberSource = childMembersSource; }
public static DeclaredAndRuntimeTypesKey For <TSource, TTarget>(MappingTypes mappingTypes) { return(new DeclaredAndRuntimeTypesKey( typeof(TSource), typeof(TTarget), mappingTypes.SourceType, mappingTypes.TargetType)); }
public ChildObjectMapperKey( MappingTypes mappingTypes, string targetMemberRegistrationName, int dataSourceIndex) : base(mappingTypes) { _targetMemberRegistrationName = targetMemberRegistrationName; _dataSourceIndex = dataSourceIndex; }
public ObjectMapperKeyBase WithTypes <TNewSource, TNewTarget>() { if (MappingTypes.RuntimeTypesAreTheSame) { return(this); } return(CreateInstance(MappingTypes.WithTypes <TNewSource, TNewTarget>())); }
public QueryProjectorKey( MappingTypes mappingTypes, Type queryProviderType, MapperContext mapperContext) : base(mappingTypes) { QueryProviderType = queryProviderType; _mapperContext = mapperContext; }
/// <returns> /// True if the MappingType is directional (asymmetric; like part-whole); /// False if it is the same in any direction (symmetric; like antonym). /// </returns> public static bool IsAsymmetric(MappingTypes type) { return(type == MappingTypes.kmtEntryAsymmetricPair || type == MappingTypes.kmtEntryOrSenseAsymmetricPair || type == MappingTypes.kmtSenseAsymmetricPair || type == MappingTypes.kmtEntryTree || type == MappingTypes.kmtEntryOrSenseTree || type == MappingTypes.kmtSenseTree || type == MappingTypes.kmtSenseUnidirectional || type == MappingTypes.kmtEntryUnidirectional || type == MappingTypes.kmtEntryOrSenseUnidirectional); }
private static Func <IObjectMappingDataFactoryBridge, TSource, TTarget, int?, object, object, object, object, object> GetPartialTrustMappingDataCreator <TSource, TTarget>( MappingTypes mappingTypes) { var createCallerKey = DeclaredAndRuntimeTypesKey.For <TSource, TTarget>(mappingTypes); var createCallerFunc = GlobalContext.Instance.Cache.GetOrAdd(createCallerKey, k => { var bridgeParameter = Expression.Parameter(typeof(IObjectMappingDataFactoryBridge), "bridge"); var sourceParameter = Parameters.Create(k.DeclaredSourceType, "source"); var targetParameter = Parameters.Create(k.DeclaredTargetType, "target"); var elementIndexParameter = Expression.Parameter(typeof(int?), "i"); var elementKeyParameter = Expression.Parameter(typeof(object), "key"); var mappingTypesParameter = Expression.Parameter(typeof(object), "mappingTypes"); var mappingContextParameter = Expression.Parameter(typeof(object), "mappingContext"); var parentParameter = Expression.Parameter(typeof(object), "parent"); var createMethod = bridgeParameter.Type .GetPublicInstanceMethod("CreateMappingData") .MakeGenericMethod( k.DeclaredSourceType, k.DeclaredTargetType, k.RuntimeSourceType, k.RuntimeTargetType); var createCall = Expression.Call( bridgeParameter, createMethod, sourceParameter, targetParameter, elementIndexParameter, elementKeyParameter, mappingTypesParameter, mappingContextParameter, parentParameter); var createLambda = Expression .Lambda <Func <IObjectMappingDataFactoryBridge, TSource, TTarget, int?, object, object, object, object, object> >( createCall, bridgeParameter, sourceParameter, targetParameter, elementIndexParameter, elementKeyParameter, mappingTypesParameter, mappingContextParameter, parentParameter); return(createLambda.Compile()); }); return(createCallerFunc); }
private static MappingDataCreator <TSource, TTarget> GetMappingDataCreator <TSource, TTarget>( MappingTypes mappingTypes) { var constructorKey = DeclaredAndRuntimeTypesKey.For <TSource, TTarget>(mappingTypes); var constructionFunc = GlobalContext.Instance.Cache.GetOrAdd(constructorKey, k => { var elementIndexParameter = Expression.Parameter(typeof(int?), "i"); var elementKeyParameter = Expression.Parameter(typeof(object), "key"); var mappingTypesParameter = typeof(MappingTypes).GetOrCreateParameter("mappingTypes"); var mappingContextParameter = typeof(IMappingContext).GetOrCreateParameter("mappingContext"); var mappingDataParameter = typeof(IObjectMappingData).GetOrCreateParameter("mappingData"); var dataType = typeof(ObjectMappingData <,>) .MakeGenericType(k.RuntimeSourceType, k.RuntimeTargetType); var sourceParameter = Parameters.Create(k.DeclaredSourceType, "source"); var targetParameter = Parameters.Create(k.DeclaredTargetType, "target"); var targetParameterValue = TypeExtensionsPolyfill.IsValueType(k.RuntimeTargetType) && k.DeclaredTargetType.CanBeNull() ? Expression.Coalesce(targetParameter, k.RuntimeTargetType.ToDefaultExpression()) : (Expression)targetParameter; var constructorCall = Expression.New( dataType.GetPublicInstanceConstructors().First(), sourceParameter.GetConversionTo(k.RuntimeSourceType), targetParameterValue.GetConversionTo(k.RuntimeTargetType), elementIndexParameter, elementKeyParameter, mappingTypesParameter, mappingContextParameter, mappingDataParameter, true.ToConstantExpression()); // <- createMapper var constructionLambda = Expression.Lambda <MappingDataCreator <TSource, TTarget> >( constructorCall, sourceParameter, targetParameter, elementIndexParameter, elementKeyParameter, mappingTypesParameter, mappingContextParameter, mappingDataParameter); return(constructionLambda.Compile()); }); return(constructionFunc); }
public static IObjectMappingData ForElement <TSource, TTarget>( TSource source, TTarget target, int enumerableIndex, IObjectMappingData parent) { var mapperKey = new ElementObjectMapperKey(MappingTypes.For(source, target)); return(Create( source, target, enumerableIndex, mapperKey, parent)); }
object IObjectMappingDataFactoryBridge.ForChild <TSource, TTarget>(object childMembersSource, object parent) { var mapperKey = new ChildObjectMapperKey( MappingTypes.For(default(TSource), default(TTarget)), (IChildMembersSource)childMembersSource); var parentMappingData = (IObjectMappingData)parent; return(Create( default(TSource), default(TTarget), default(int?), mapperKey, parentMappingData)); }
private static ObjectMappingData <TSource, TTarget> ForRootFixedTypes <TSource, TTarget>( TSource source, TTarget target, MappingTypes mappingTypes, IMappingContext mappingContext, bool createMapper = true) { return(new ObjectMappingData <TSource, TTarget>( source, target, null, // <- No enumerable index because we're at the root mappingTypes, mappingContext, parent: null, createMapper: createMapper)); }
private static IObjectMappingData Create <TDeclaredSource, TDeclaredTarget>( TDeclaredSource source, TDeclaredTarget target, int?elementIndex, object elementKey, MappingTypes mappingTypes, IMappingContext mappingContext, IObjectMappingData parent = null) { if (mappingTypes.RuntimeTypesAreTheSame) { return(new ObjectMappingData <TDeclaredSource, TDeclaredTarget>( source, target, elementIndex, elementKey, mappingTypes, mappingContext, parent)); } if (Constants.ReflectionNotPermitted) { var createCaller = GetPartialTrustMappingDataCreator <TDeclaredSource, TDeclaredTarget>(mappingTypes); return((IObjectMappingData)createCaller.Invoke( _bridge, source, target, elementIndex, elementKey, mappingTypes, mappingContext, parent)); } var constructionFunc = GetMappingDataCreator <TDeclaredSource, TDeclaredTarget>(mappingTypes); return(constructionFunc.Invoke( source, target, elementIndex, elementKey, mappingTypes, mappingContext, parent)); }
/// <summary> /// This method returns Data Fields mapping json strings from web.config for given backendID /// </summary> /// <param name="backendID"></param> /// <returns></returns> public MappingTypes GetFiledsMappingJsonString(string backendID) { string callerMethodName = string.Empty; try { //Get Caller Method name from CallerInformation class callerMethodName = CallerInformation.TrackCallerMethodName(); //Object initialization for C calss MappingTypes Objtype = null; string requestFieldsMappingJson = string.Empty; string matrixFieldsMappingJson = string.Empty; //checking is backend is null or empty if (!string.IsNullOrEmpty(backendID)) { switch (backendID.ToLower()) { //based on the backendid reading the corresponding mapping json string from web.config case CoreConstants.Backends.CAR: requestFieldsMappingJson = Convert.ToString(ConfigurationManager.AppSettings["Backend.CAR.RequestFeildsMapping"]); matrixFieldsMappingJson = Convert.ToString(ConfigurationManager.AppSettings["Backend.CAR.MatrixFeildsMapping"]); break; case CoreConstants.Backends.BPMOnline: requestFieldsMappingJson = Convert.ToString(ConfigurationManager.AppSettings["Backend.BPMOnline.RequestFeildsMapping"]); matrixFieldsMappingJson = Convert.ToString(ConfigurationManager.AppSettings["Backend.BPMOnline.MatrixFeildsMapping"]); break; default: break; } //Assign values to MappingTypes class properties Objtype = new MappingTypes() { RequestFieldsMappingJson = requestFieldsMappingJson, MatrixFieldsMappingJson = matrixFieldsMappingJson }; } return(Objtype); } catch (Exception exception) { InsightLogger.Exception(exception.Message, exception, callerMethodName); throw new DataAccessException(exception.Message, exception.InnerException); } }
/// <summary> /// Gets a mapping of predefined values of requested type. /// </summary> /// <param name="type">Required mapping type.</param> /// <returns>Mapping containing possible values and additional information for the requested type.</returns> public static ValueMapping GetMapping(MappingTypes type) { switch (type) { case MappingTypes.STATUS: return(CreateStatusMapping()); case MappingTypes.BFLAG: return(CreateBflagMapping()); case MappingTypes.ATTRIBUTE_DATA_TYPE: return(CreateAttributeDataTypeMapping()); default: return(null); } }
private static IObjectMappingData Create <TDeclaredSource, TDeclaredTarget>( TDeclaredSource source, TDeclaredTarget target, int?enumerableIndex, Func <MappingTypes, IMappingContext, ObjectMapperKeyBase> mapperKeyFactory, IMappingContext mappingContext, IObjectMappingData parent = null) { var mappingTypes = MappingTypes.For(source, target); var mapperKey = mapperKeyFactory.Invoke(mappingTypes, mappingContext); if (mappingTypes.RuntimeTypesAreTheSame) { return(new ObjectMappingData <TDeclaredSource, TDeclaredTarget>( source, target, enumerableIndex, mapperKey, mappingContext, parent)); } if (Constants.ReflectionNotPermitted) { var createCaller = GetPartialTrustMappingDataCreator <TDeclaredSource, TDeclaredTarget>(mappingTypes); return((IObjectMappingData)createCaller.Invoke( _bridge, source, target, enumerableIndex, mapperKey, mappingContext, parent)); } var constructionFunc = GetMappingDataCreator <TDeclaredSource, TDeclaredTarget>(mappingTypes); return(constructionFunc.Invoke( source, target, enumerableIndex, mapperKey, mappingContext, parent)); }
private static ObjectMappingData <TSource, TTarget> ForRootFixedTypes <TSource, TTarget>( TSource source, TTarget target, MappingTypes mappingTypes, IMappingContext mappingContext, bool createMapper = true) { return(new ObjectMappingData <TSource, TTarget>( source, target, default(int?), // <- No element index because we're at the root default(object), // <- No element key because we're at the root mappingTypes, mappingContext, parent: null, createMapper: createMapper)); }
public static ObjectMappingData <TSourceElement, TTargetElement> ForElement <TSourceElement, TTargetElement>( TSourceElement sourceElement, TTargetElement targetElement, int enumerableIndex, IObjectMappingDataUntyped parent) { var mapperKey = new ElementObjectMapperKey(MappingTypes.Fixed <TSourceElement, TTargetElement>()); var mappingDataParent = (IObjectMappingData)parent; return(new ObjectMappingData <TSourceElement, TTargetElement>( sourceElement, targetElement, enumerableIndex, mapperKey, mappingDataParent.MappingContext, mappingDataParent)); }
public ObjectMappingData( TSource source, TTarget target, int?enumerableIndex, MappingTypes mappingTypes, IMappingContext mappingContext, IObjectMappingData parent, bool createMapper = true) : this( source, target, enumerableIndex, mappingTypes, mappingContext, null, parent, createMapper) { }
public override string GetPropertyTypeName(string dbTypeName) { dbTypeName = dbTypeName.ToLower(); var propertyTypes = MappingTypes.Where(it => it.Value.ToString() == dbTypeName || it.Key.ToLower() == dbTypeName); if (dbTypeName == "int32") { return("int"); } else if (dbTypeName == "int64") { return("long"); } else if (dbTypeName == "int16") { return("short"); } else if (propertyTypes == null) { return("other"); } else if (dbTypeName == "xml" || dbTypeName == "string") { return("string"); } if (dbTypeName == "byte[]") { return("byte[]"); } else if (propertyTypes == null || propertyTypes.Count() == 0) { //Check.ThrowNotSupportedException(string.Format(" \"{0}\" Type NotSupported, DbBindProvider.GetPropertyTypeName error.", dbTypeName)); throw new NotSupportedException($"{ dbTypeName } Type NotSupported, DbBindProvider.GetPropertyTypeName error"); } else if (propertyTypes.First().Value == CSharpDataType.byteArray) { return("byte[]"); } else { return(propertyTypes.First().Value.ToString()); } }
public static IObjectMappingData ForChild <TSource, TTarget>( TSource source, TTarget target, int?enumerableIndex, string targetMemberRegistrationName, int dataSourceIndex, IObjectMappingData parent) { var mapperKey = new ChildObjectMapperKey( MappingTypes.For(source, target), targetMemberRegistrationName, dataSourceIndex); return(Create( source, target, enumerableIndex, mapperKey, parent)); }
public ObjectMappingData( TSource source, TTarget target, int?elementIndex, object elementKey, MappingTypes mappingTypes, IMappingContext mappingContext, IObjectMappingData parent, bool createMapper = true) : this( source, target, elementIndex, elementKey, mappingTypes, mappingContext, null, parent, createMapper) { }
private static MappingDataCreator <TSource, TTarget> GetMappingDataCreator <TSource, TTarget>( MappingTypes mappingTypes) { var constructorKey = DeclaredAndRuntimeTypesKey.For <TSource, TTarget>(mappingTypes); // TODO: Local cache var constructionFunc = GlobalContext.Instance.Cache.GetOrAdd(constructorKey, k => { var mapperKeyParameter = Expression.Parameter(typeof(ObjectMapperKeyBase), "mapperKey"); var enumerableIndexParameter = Expression.Parameter(typeof(int?), "i"); var dataType = typeof(ObjectMappingData <,>) .MakeGenericType(k.RuntimeSourceType, k.RuntimeTargetType); var sourceParameter = Parameters.Create(k.DeclaredSourceType, "source"); var targetParameter = Parameters.Create(k.DeclaredTargetType, "target"); var constructorCall = Expression.New( dataType.GetPublicInstanceConstructors().First(), sourceParameter.GetConversionTo(k.RuntimeSourceType), targetParameter.GetConversionTo(k.RuntimeTargetType), enumerableIndexParameter, mapperKeyParameter, Parameters.MappingContext, Parameters.ObjectMappingData); var constructionLambda = Expression.Lambda <MappingDataCreator <TSource, TTarget> >( constructorCall, sourceParameter, targetParameter, enumerableIndexParameter, mapperKeyParameter, Parameters.MappingContext, Parameters.ObjectMappingData); return(constructionLambda.Compile()); }); return(constructionFunc); }
/// <summary> /// Formats the complete value structure from OPC. /// </summary> /// <param name="mappingType">The mapping type.</param> /// <param name="opcValue">The opc value.</param> /// <returns>The formatted value</returns> private string FormatOpcVtq(MappingTypes mappingType, DAVtq opcValue) { // This should never happen at this point. var formattedValue = DisplayInvalidValue; // The mapping type at this point is an OPC mapping type. switch (mappingType) { case MappingTypes.OpcValueType: formattedValue = this.FormatOpcValue(opcValue); break; case MappingTypes.OpcTimestampType: formattedValue = this.FormatOpcTimestamp(opcValue); break; case MappingTypes.OpcQualityType: formattedValue = this.FormatOpcQuality(opcValue); break; } return(formattedValue); }
public static ObjectMappingData <TSource, TTarget> ForChild <TSource, TTarget>( TSource source, TTarget target, int?enumerableIndex, string targetMemberRegistrationName, int dataSourceIndex, IObjectMappingDataUntyped parent) { var mapperKey = new ChildObjectMapperKey( targetMemberRegistrationName, dataSourceIndex, MappingTypes.Fixed <TSource, TTarget>()); var mappingDataParent = (IObjectMappingData)parent; return(new ObjectMappingData <TSource, TTarget>( source, target, enumerableIndex, mapperKey, mappingDataParent.MappingContext, mappingDataParent)); }
protected override ObjectMapperKeyBase CreateInstance(MappingTypes newMappingTypes) { return((_childMemberSource != null) ? new ChildObjectMapperKey(newMappingTypes, _childMemberSource) : new ChildObjectMapperKey(newMappingTypes, _targetMemberRegistrationName, _dataSourceIndex)); }
private static void LoadMappingTypes() { _MappingTypes = new MappingTypes(); _MappingTypes.Add(new MappingType("varchar", "System.String", "System.Data.DbType.String", "string", "[Name] [Type]([Length]) [Direction]")); _MappingTypes.Add(new MappingType("nvarchar", "System.String", "System.Data.DbType.String", "string", "[Name] [Type]([Length]) [Direction]")); _MappingTypes.Add(new MappingType("text", "System.String", "System.Data.DbType.String", "string", "[Name] varchar(8000) [Direction]")); _MappingTypes.Add(new MappingType("ntext", "System.String", "System.Data.DbType.String", "string", "[Name] varchar(8000) [Direction]")); _MappingTypes.Add(new MappingType("uniqueidentifier", "Guid", "System.Data.DbType.String", "string", "[Name] uniqueidentifier")); _MappingTypes.Add(new MappingType("nchar", "System.String", "System.Data.DbType.String", "string", "[Name] nchar([Length]) [Direction]")); _MappingTypes.Add(new MappingType("char", "System.String", "System.Data.DbType.String", "string", "[Name] char([Length]) [Direction]")); _MappingTypes.Add(new MappingType("sysname", "System.String", "System.Data.DbType.String", "string", "[Name] char([Length]) [Direction]")); _MappingTypes.Add(new MappingType("bit", "System.Boolean", "System.Data.DbType.Boolean", "boolean", "[Name] [Type] [Direction]")); _MappingTypes.Add(new MappingType("datetime", "System.DateTime", "System.Data.DbType.DateTime", "dateTime", "[Name] [Type] [Direction]")); _MappingTypes.Add(new MappingType("smalldatetime", "System.DateTime", "System.Data.DbType.DateTime", "dateTime", "[Name] [Type] [Direction]")); _MappingTypes.Add(new MappingType("real", "System.Int32", "System.Data.DbType.Int32", "double", "[Name] [Type] [Direction]")); _MappingTypes.Add(new MappingType("numeric", "System.Int32", "System.Data.DbType.Int32", "decimal", "[Name] [Type]([Precision],[Scale]) [Direction]")); _MappingTypes.Add(new MappingType("bigint", "System.Int32", "System.Data.DbType.Int32", "int", "[Name] [Type] [Direction]")); _MappingTypes.Add(new MappingType("smallint", "System.Int32", "System.Data.DbType.Int32", "int", "[Name] [Type] [Direction]")); _MappingTypes.Add(new MappingType("int", "System.Int32", "System.Data.DbType.Int32", "int", "[Name] [Type] [Direction]")); _MappingTypes.Add(new MappingType("tinyint", "System.Int32", "System.Data.DbType.Int32", "int", "[Name] [Type] [Direction]")); _MappingTypes.Add(new MappingType("decimal", "System.Decimal", "System.Data.DbType.Decimal", "decimal", "[Name] [Type] [Direction]")); _MappingTypes.Add(new MappingType("float", "System.Double", "System.Data.DbType.Double", "float", "[Name] [Type] [Direction]")); _MappingTypes.Add(new MappingType("double", "System.Double", "System.Data.DbType.Double", "dounble", "[Name] [Type] [Direction]")); _MappingTypes.Add(new MappingType("money", "System.Double", "System.Data.DbType.Double", "double", "[Name] [Type] [Direction]")); _MappingTypes.Add(new MappingType("smallmoney", "System.Double", "System.Data.DbType.Double", "double", "[Name] [Type] [Direction]")); _MappingTypes.Add(new MappingType("image", "System.Byte[]", "System.Data.DbType.Binary", "base64Binary", "[Name] [Type]([Length])")); _MappingTypes.Add(new MappingType("binary", "System.Byte[]", "System.Data.DbType.Binary", "base64Binary", "[Name] [Type]([Length])")); _MappingTypes.Add(new MappingType("varbinary", "System.Byte[]", "System.Data.DbType.Binary", "base64Binary", "[Name] [Type]([Length])")); }