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])"));
}
