public ClassPropertyAssignment(ClassProperty property, Expression rhs) { ClassProperty = property; RightHandExpression = rhs; ExpressionType = ExpressionType.ClassPropertyAssignment; HasVar = ClassProperty.HasVar || rhs.HasVar; expressionID = ClassProperty.ExpressionID + "=" + RightHandExpression.ExpressionID; }
public ObjectPropertyAtom(IObjectInstance objectInstance, ClassProperty classProperty, bool hasChildObject) : base(objectInstance, classProperty) { _hasChildObject = hasChildObject; if (ClassProperty.CanRead) { // When the property is out of date, update it from the wrapped object. _depProperty = new Dependent(delegate { object value = ClassProperty.GetObjectValue(ObjectInstance.WrappedObject); if (_hasChildObject) { IObjectInstance oldChild = _child; object oldValue = oldChild == null ? null : oldChild.WrappedObject; _child = null; IObjectInstance wrapper; if (value == null) wrapper = null; else if (value == oldValue) { wrapper = oldChild; _child = wrapper; } else { if (WrapObject(value, out wrapper)) _child = wrapper; } ClassProperty.SetUserOutput(ObjectInstance, wrapper); if (oldChild != _child && oldChild != null) { ObjectInstance.Tree.RemoveKey(oldValue); oldChild.Dispose(); } } else { ClassProperty.SetUserOutput(ObjectInstance, value); } }); } }
/// <summary> /// /// </summary> /// <param name="classProperty"></param> /// <returns></returns> public static Func <TEntity, TResult> GetFunc(ClassProperty classProperty) { var func = (Func <TEntity, TResult>)null; if (cache.TryGetValue(classProperty.GetHashCode(), out func) == false) { if (classProperty != null) { var typeOfEntity = typeof(TEntity); var entity = Expression.Parameter(typeOfEntity, "entity"); var body = Expression.Convert(Expression.Call(entity, classProperty.PropertyInfo.GetMethod), typeof(TResult)); func = Expression .Lambda <Func <TEntity, TResult> >(body, entity) .Compile(); } cache.TryAdd(classProperty.GetHashCode(), func); } return(func); }
public void InsertT <T>(T InValue) where T : Base { Assert.IsFalse(SQLite3DbHandle.Zero == handle); ClassProperty property = InValue.ClassPropertyInfos; stringBuilder.Remove(0, stringBuilder.Length); stringBuilder.Append("INSERT INTO ") .Append(property.ClassName) .Append(" VALUES("); int length = property.Infos.Length; for (int i = 0; i < length; i++) { stringBuilder.Append("\"").Append(property.Infos[i].GetValue(InValue, null)).Append("\", "); } stringBuilder.Remove(stringBuilder.Length - 2, 2); stringBuilder.Append(")"); Exec(stringBuilder.ToString()); }
public long?Get(object input, ClassProperty property) { var value = Convert.ToInt64(input); if (value > 0) { return(value); } else { if (property.PropertyInfo.PropertyType.IsNullable()) { return(null); } else { return(default(long)); } } }
public void CreateTable <T>() where T : Base { Assert.IsFalse(SQLite3DbHandle.Zero == handle); ClassProperty classProperty = Base.GetPropertyInfos(typeof(T)); stringBuilder.Remove(0, stringBuilder.Length); stringBuilder.Append("CREATE TABLE ") .Append(classProperty.ClassName) .Append("("); int length = classProperty.Infos.Length; for (int i = 0; i < length; ++i) { stringBuilder.Append(classProperty.Infos[i].Name); Type type = classProperty.Infos[i].PropertyType; if (type == typeof(int) || type == typeof(long)) { stringBuilder.Append(" INTEGER, "); } else if (type == typeof(float) || type == typeof(double)) { stringBuilder.Append(" REAL, "); } else if (type == typeof(string)) { stringBuilder.Append(" TEXT, "); } else { stringBuilder.Append(" BLOB, "); } } stringBuilder.Remove(stringBuilder.Length - 2, 2); stringBuilder.Append(")"); Exec(stringBuilder.ToString()); }
public ReadOnlyClassProperty(ClassProperty property) { this.property = property; propertyType = new ReadOnlyTypeReference(property.Type); if (property.EmptyAccessors != null) { getAccessor = new ReadOnlyClassAccessor(property.EmptyAccessors.GetAccessorVisibility); setAccessor = new ReadOnlyClassAccessor(property.EmptyAccessors.SetAccessorVisibility); } else { if (property.GetAccessor != null) { getAccessor = new ReadOnlyClassAccessor(property.GetAccessor); } if (property.SetAccessor != null) { setAccessor = new ReadOnlyClassAccessor(property.SetAccessor); } } }
public void Read_class_properties() { var val = new NullableModel { Value = 12 }; var model = new ClassProperty { Nullable = val }; var result = Read(model); result.Should().HaveCount(2); result[0].Attributes.Should().HaveCount(1); result[0].Attributes.ElementAt(0).Should().BeAssignableTo <RequiredAttribute>(); result[0].Value.Should().Be(val); result[0].Path.Should().BeEquivalentTo(new[] { "nullable" }); result[1].Attributes.Should().HaveCount(1); result[1].Attributes.ElementAt(0).Should().BeAssignableTo <RequiredAttribute>(); result[1].Value.Should().Be(12); result[1].Path.Should().BeEquivalentTo(new[] { "nullable", "value" }); }
/// <summary> /// /// </summary> /// <param name="classProperty"></param> /// <returns></returns> public static Action <TEntity, object> GetFunc(ClassProperty classProperty) { var func = (Action <TEntity, object>)null; if (cache.TryGetValue(classProperty.GetHashCode(), out func) == false) { if (classProperty != null) { var entity = Expression.Parameter(typeof(TEntity), "entity"); var value = Expression.Parameter(typeof(object), "value"); var converted = Expression.Convert(value, classProperty.PropertyInfo.PropertyType); var body = (Expression)Expression.Call(entity, classProperty.PropertyInfo.SetMethod, converted); func = Expression .Lambda <Action <TEntity, object> >(body, entity, value) .Compile(); } cache.TryAdd(classProperty.GetHashCode(), func); } return(func); }
public override IQueryElement VisitWhere_value([NotNull] QueryGrammarParser.Where_valueContext context) { if (context.literal() != null) { IQueryElement literal = Visit(context.literal()); return(literal); } else if (context.NAME() != null) { ClassProperty property = new ClassProperty(); property.Name = context.NAME().GetText(); if (context.child_value() != null) { IQueryElement propertyChild = Visit(context.child_value()); property.Add(propertyChild); } return(property); } return(null); }
private PropertyDeclaration VisitClassProperty(ClassProperty property) { Ust body = VisitPropertyValue(property.Value); IdToken name = null; if (property.Key is Identifier identifier) { name = VisitIdentifier(identifier); } else { if (property.Key is Literal literal) { name = new IdToken(literal.StringValue ?? literal.Raw, GetTextSpan(literal)); } else { Logger.LogDebug($"Not implemented type of property key {property.Key.GetType()}"); // TODO } } return(new PropertyDeclaration(null, name, body, GetTextSpan(property))); }
private void DumpAutoProperty(ClassProperty property) { textWriter.Write(" {"); if ((property.Access & PropertyAccess.Read) != PropertyAccess.None) { if (property.ReaderScope != property.Scope) { textWriter.Write(" {0}", property.ReaderScope.ToString().ToLower()); } textWriter.Write(" read;"); } if ((property.Access & PropertyAccess.Write) != PropertyAccess.None) { if (property.WriterScope != property.Scope) { textWriter.Write(" {0}", property.WriterScope.ToString().ToLower()); } textWriter.Write(" write;"); } textWriter.WriteLine(" }"); }
public static Action <TEntity, object> GetFunc(ClassProperty property) { var func = (Action <TEntity, object>)null; // Try get from cache if (m_cache.TryGetValue(property.GetHashCode(), out func) == false) { // Parameters var entity = Expression.Parameter(typeof(TEntity), "entity"); var value = Expression.Parameter(typeof(object), "value"); // Set the body var converted = Expression.Convert(value, property.PropertyInfo.PropertyType); var body = (Expression)Expression.Call(entity, property.PropertyInfo.SetMethod, converted); // Set the function value func = Expression .Lambda <Action <TEntity, object> >(body, entity, value) .Compile(); } // return the function return(func); }
/// <summary> /// /// </summary> /// <param name="commandParameterExpression"></param> /// <param name="paramProperty"></param> /// <param name="dbField"></param> /// <param name="valueType"></param> /// <param name="valueExpression"></param> /// <returns></returns> public static Expression GetPlainTypeToDbParametersForEnumCompiledFunction(Expression commandParameterExpression, ClassProperty paramProperty, DbField dbField, Type valueType, Expression valueExpression) { // DbType var dbType = IsPostgreSqlUserDefined(dbField) ? default : paramProperty.GetDbType() ?? valueType.GetDbType() ?? (dbField != null ? new ClientTypeToDbTypeResolver().Resolve(dbField.Type) : null) ?? (DbType?)Converter.EnumDefaultDatabaseType; // DbCommandExtension.CreateParameter var methodInfo = GetDbCommandCreateParameterMethod(); return(Expression.Call(methodInfo, new Expression[] { commandParameterExpression, Expression.Constant(paramProperty.GetMappedName()), ConvertExpressionToTypeExpression(valueExpression, StaticType.Object), ConvertExpressionToNullableExpression(Expression.Constant(dbType), StaticType.DbType) })); }
public int Set(int input, ClassProperty property) { return(input); }
public static void Run(TestHelper helper) { TextWriter output = helper.Output; output.Write("testing default values... "); output.Flush(); { var v = new Base(); TestHelper.Assert(!v.BoolFalse); TestHelper.Assert(v.BoolTrue); TestHelper.Assert(v.B == 1); TestHelper.Assert(v.S == 2); TestHelper.Assert(v.I == 3); TestHelper.Assert(v.L == 4); TestHelper.Assert(v.F == 5.1F); TestHelper.Assert(v.D == 6.2); TestHelper.Assert(v.Str.Equals("foo \\ \"bar\n \r\n\t\u000b\f\u0007\b? \u0007 \u0007")); TestHelper.Assert(v.NoDefault == null); TestHelper.Assert(v.ZeroI == 0); TestHelper.Assert(v.ZeroL == 0); TestHelper.Assert(v.ZeroF == 0); TestHelper.Assert(v.ZeroDotF == 0); TestHelper.Assert(v.ZeroD == 0); TestHelper.Assert(v.ZeroDotD == 0); } { var v = new Derived(); TestHelper.Assert(!v.BoolFalse); TestHelper.Assert(v.BoolTrue); TestHelper.Assert(v.B == 1); TestHelper.Assert(v.S == 2); TestHelper.Assert(v.I == 3); TestHelper.Assert(v.L == 4); TestHelper.Assert(v.F == 5.1F); TestHelper.Assert(v.D == 6.2); TestHelper.Assert(v.Str.Equals("foo \\ \"bar\n \r\n\t\u000b\f\u0007\b? \u0007 \u0007")); TestHelper.Assert(v.C1 == Color.red); TestHelper.Assert(v.C2 == Color.green); TestHelper.Assert(v.C3 == Color.blue); TestHelper.Assert(v.Nc1 == Nested.Color.red); TestHelper.Assert(v.Nc2 == Nested.Color.green); TestHelper.Assert(v.Nc3 == Nested.Color.blue); TestHelper.Assert(v.NoDefault == null); TestHelper.Assert(v.ZeroI == 0); TestHelper.Assert(v.ZeroL == 0); TestHelper.Assert(v.ZeroF == 0); TestHelper.Assert(v.ZeroDotF == 0); TestHelper.Assert(v.ZeroD == 0); TestHelper.Assert(v.ZeroDotD == 0); } { var v = new BaseEx(); TestHelper.Assert(!v.BoolFalse); TestHelper.Assert(v.BoolTrue); TestHelper.Assert(v.B == 1); TestHelper.Assert(v.S == 2); TestHelper.Assert(v.I == 3); TestHelper.Assert(v.L == 4); TestHelper.Assert(v.F == 5.1F); TestHelper.Assert(v.D == 6.2); TestHelper.Assert(v.Str == "foo \\ \"bar\n \r\n\t\u000b\f\u0007\b? \u0007 \u0007"); TestHelper.Assert(v.NoDefault == null); TestHelper.Assert(v.ZeroI == 0); TestHelper.Assert(v.ZeroL == 0); TestHelper.Assert(v.ZeroF == 0); TestHelper.Assert(v.ZeroDotF == 0); TestHelper.Assert(v.ZeroD == 0); TestHelper.Assert(v.ZeroDotD == 0); } { var v = new DerivedEx(); TestHelper.Assert(!v.BoolFalse); TestHelper.Assert(v.BoolTrue); TestHelper.Assert(v.B == 1); TestHelper.Assert(v.S == 2); TestHelper.Assert(v.I == 3); TestHelper.Assert(v.L == 4); TestHelper.Assert(v.F == 5.1F); TestHelper.Assert(v.D == 6.2); TestHelper.Assert(v.Str == "foo \\ \"bar\n \r\n\t\u000b\f\u0007\b? \u0007 \u0007"); TestHelper.Assert(v.NoDefault == null); TestHelper.Assert(v.C1 == Color.red); TestHelper.Assert(v.C2 == Color.green); TestHelper.Assert(v.C3 == Color.blue); TestHelper.Assert(v.Nc1 == Nested.Color.red); TestHelper.Assert(v.Nc2 == Nested.Color.green); TestHelper.Assert(v.Nc3 == Nested.Color.blue); TestHelper.Assert(v.ZeroI == 0); TestHelper.Assert(v.ZeroL == 0); TestHelper.Assert(v.ZeroF == 0); TestHelper.Assert(v.ZeroDotF == 0); TestHelper.Assert(v.ZeroD == 0); TestHelper.Assert(v.ZeroDotD == 0); } { var v = new ClassProperty(); TestHelper.Assert(!v.BoolFalse); TestHelper.Assert(v.BoolTrue); TestHelper.Assert(v.B == 1); TestHelper.Assert(v.S == 2); TestHelper.Assert(v.I == 3); TestHelper.Assert(v.L == 4); TestHelper.Assert(v.F == 5.1F); TestHelper.Assert(v.D == 6.2); TestHelper.Assert(v.Str.Equals("foo bar")); TestHelper.Assert(v.NoDefault == null); TestHelper.Assert(v.ZeroI == 0); TestHelper.Assert(v.ZeroL == 0); TestHelper.Assert(v.ZeroF == 0); TestHelper.Assert(v.ZeroDotF == 0); TestHelper.Assert(v.ZeroD == 0); TestHelper.Assert(v.ZeroDotD == 0); } { var v = new ExceptionProperty(); TestHelper.Assert(!v.BoolFalse); TestHelper.Assert(v.BoolTrue); TestHelper.Assert(v.B == 1); TestHelper.Assert(v.S == 2); TestHelper.Assert(v.I == 3); TestHelper.Assert(v.L == 4); TestHelper.Assert(v.F == 5.1F); TestHelper.Assert(v.D == 6.2); TestHelper.Assert(v.Str.Equals("foo bar")); TestHelper.Assert(v.NoDefault == null); TestHelper.Assert(v.ZeroI == 0); TestHelper.Assert(v.ZeroL == 0); TestHelper.Assert(v.ZeroF == 0); TestHelper.Assert(v.ZeroDotF == 0); TestHelper.Assert(v.ZeroD == 0); TestHelper.Assert(v.ZeroDotD == 0); } output.WriteLine("ok"); }
public decimal?Set(long?input, ClassProperty property) { return(Convert.ToDecimal(input)); }
public string Get(int?input, ClassProperty property) { return(input > 0 ? Convert.ToString(input) : null); }
private void AddClassProperty(CodeElements codeElements, ref List <ClassProperty> classProperties) { foreach (CodeElement2 codeElement in codeElements) { if (codeElement.Kind == vsCMElement.vsCMElementProperty) { ClassProperty classProperty = new ClassProperty(); CodeProperty2 property = codeElement as CodeProperty2; classProperty.Name = property.Name; //获取属性类型 var propertyType = property.Type; switch (propertyType.TypeKind) { case vsCMTypeRef.vsCMTypeRefString: classProperty.PropertyType = "string"; break; case vsCMTypeRef.vsCMTypeRefInt: classProperty.PropertyType = "int"; break; case vsCMTypeRef.vsCMTypeRefLong: classProperty.PropertyType = "long"; break; case vsCMTypeRef.vsCMTypeRefByte: classProperty.PropertyType = "byte"; break; case vsCMTypeRef.vsCMTypeRefChar: classProperty.PropertyType = "char"; break; case vsCMTypeRef.vsCMTypeRefShort: classProperty.PropertyType = "short"; break; case vsCMTypeRef.vsCMTypeRefBool: classProperty.PropertyType = "bool"; break; case vsCMTypeRef.vsCMTypeRefDecimal: classProperty.PropertyType = "decimal"; break; case vsCMTypeRef.vsCMTypeRefFloat: classProperty.PropertyType = "float"; break; case vsCMTypeRef.vsCMTypeRefDouble: classProperty.PropertyType = "double"; break; default: classProperty.PropertyType = propertyType.AsFullName; break; } classProperties.Add(classProperty); } } }
/// <summary> /// 构造Entity数据 /// </summary> private void InitModelData() { ThreadHelper.ThrowIfNotOnUIThread(); var dataSource = entityModelBindingSource.List; fileModel.Name = textBox3.Text; fileModel.AngularEntityName = fileModel.Name.ToLower(); fileModel.TableName = textBox1.Text; fileModel.Description = textBox4.Text; fileModel.ClassPropertys = new List <ClassProperty>(); fileModel.FirstLowerName = FirstCharToLower(fileModel.Name); fileModel.HasDetail = chkHasDetail.Checked; fileModel.DetailEntityName = txtDetail.Text; fileModel.HasParent = chkHasParent.Checked; fileModel.ParentEntityName = txtParent.Text; enumEntities = new List <EnumEntity>(); foreach (EntityModel model in dataSource) { var item = DeepCopy(model); var property = new ClassProperty { CnName = item.Describe, IsNull = item.IsNull, Name = item.ColName, Lenght = item.DateType == "string" ? Convert.ToInt32(item.Length) : 0, PropertyType = item.DateType, FirstLowerName = FirstCharToLower(item.ColName), IsCreateOrEdit = item.IsCreateOrEdit, IsFilter = item.IsFilter, IsRequired = item.IsRequired, IsShowInList = item.IsShowInList, ClassAttributes = new List <ClassProperty.ClassAttribute>() }; fileModel.ClassPropertys.Add(property); if (item.DateType == "string") { if (!string.IsNullOrEmpty(item.Length)) { property.ClassAttributes.Add(new ClassProperty.ClassAttribute { NameValue = $"[MaxLength({item.Length})]" }); } else { throw new Exception("字符串类型必须指定长度"); } if (!item.IsNull) { property.ClassAttributes.Add(new ClassProperty.ClassAttribute { NameValue = "[Required]" }); } } else { if (item.DateType == "decimal") { if (!string.IsNullOrEmpty(item.Length)) { property.ClassAttributes.Add(new ClassProperty.ClassAttribute { NameValue = $"[Column(TypeName = \"decimal({item.Length})\")]" }); } } if (item.DateType == "enum") { property.PropertyType = item.EnumName; var enumEntity = new EnumEntity { EnumName = item.EnumName, EnumDes = item.Describe, NameSpace = fileModel.Namespace + fileModel.DirName, Values = new List <EnumValue>() }; enumEntities.Add(enumEntity); var values = item.EnumValue.Split(','); foreach (var value in values) { if (value.Contains(":")) { var names = value.Split(':'); enumEntity.Values.Add(new Models.TemplateModels.EnumValue { EnumValueName = names[0], Value = Convert.ToInt32(names[1]) }); } else { enumEntity.Values.Add(new Models.TemplateModels.EnumValue { EnumValueName = value }); } } } if (item.IsNull) { property.PropertyType += "?"; } } } fileModel.Parameters = string.Join(", ", fileModel.ClassPropertys.OrderBy(o => o.PropertyType).Select(s => $"{s.PropertyType} {s.FirstLowerName}")); fileModel.MethodParameters = string.Join(", ", fileModel.ClassPropertys.OrderBy(o => o.PropertyType).Select(s => s.FirstLowerName)); fileModel.CreateParameters = string.Join(", ", fileModel.ClassPropertys.OrderBy(o => o.PropertyType).Select(s => $"dto.{s.Name}")); }
public bool Compare(ClassProperty other, bool verbose) { var result = SomeString == other.SomeString; result &= SomeInt == other.SomeInt; if (verbose) { Console.WriteLine(" SomeString:"); Console.WriteLine(" Me: {0}, Them: {1}", SomeString, other.SomeString); Console.WriteLine(" SomeInt:"); Console.WriteLine(" Me: {0}, Them: {1}", SomeInt, other.SomeInt); } return result; }
public Guid Get(string input, ClassProperty property) { Guid.TryParse(input, out Guid output); return(output); }
public string Set(Guid input, ClassProperty property) { return(input.ToString()); }
public WithHandlerEnum?Get(decimal?input, ClassProperty property) => throw new NotImplementedException();
private static void EmitDataReaderToDataEntityMapping <TEntity>(ILGenerator ilGenerator, int ordinal, ClassProperty property, FieldDefinition fieldDefinition) where TEntity : class { // Get the property type var isNullable = fieldDefinition == null || fieldDefinition?.IsNullable == true; var underlyingType = Nullable.GetUnderlyingType(property.PropertyInfo.PropertyType); var propertyType = underlyingType ?? property.PropertyInfo.PropertyType; // Variables for ending this property emitting var endLabel = ilGenerator.DefineLabel(); // Load the data DataReader instance from argument 0 ilGenerator.Emit(OpCodes.Ldarg, 0); // Load the value base on the ordinal ilGenerator.Emit(OpCodes.Ldc_I4, ordinal); ilGenerator.Emit(OpCodes.Callvirt, typeof(DbDataReader).GetTypeInfo().GetMethod("get_Item", new[] { typeof(int) })); ilGenerator.Emit(OpCodes.Stloc, 1); // Check if nullable in the actual definition if (isNullable == true) { // Load the resulted Value and DBNull.Value for comparisson ilGenerator.Emit(OpCodes.Ldloc, 1); ilGenerator.Emit(OpCodes.Ldsfld, typeof(DBNull).GetTypeInfo().GetField("Value")); ilGenerator.Emit(OpCodes.Ceq); ilGenerator.Emit(OpCodes.Brtrue_S, endLabel); } // Load the DataEntity instance ilGenerator.Emit(OpCodes.Ldloc, 0); ilGenerator.Emit(OpCodes.Ldloc, 1); // Switch which method of Convert are going to used if (propertyType != typeof(byte[])) { // Get the proper convert method var convertMethod = typeof(Convert).GetTypeInfo().GetMethod($"To{propertyType.Name}", new[] { typeof(object) }) ?? typeof(Convert).GetTypeInfo().GetMethod($"ToString", new[] { typeof(object) }); // Convert the value ilGenerator.Emit(OpCodes.Call, convertMethod); // Parse if it is Guid var parseMethod = (MethodInfo)null; // Switch to the correct parser method if (propertyType == typeof(Guid) || propertyType == typeof(DateTimeOffset) || propertyType == typeof(TimeSpan)) { parseMethod = propertyType.GetTypeInfo().GetMethod("Parse", new[] { typeof(string) }); } // Do the parse if set if (parseMethod != null) { ilGenerator.Emit(OpCodes.Call, parseMethod); } } // Check for nullable based on the underlying type if (underlyingType != null) { // Get the type of Nullable<T> object var nullableType = typeof(Nullable <>).MakeGenericType(propertyType); // Create a new instance of Nullable<T> object ilGenerator.Emit(OpCodes.Newobj, nullableType.GetTypeInfo().GetConstructor(new[] { propertyType })); } // Call the (Property.Set) or (Property = Value) ilGenerator.Emit(OpCodes.Call, property.PropertyInfo.GetSetMethod()); // End label for DBNull.Value checking ilGenerator.MarkLabel(endLabel); }
public object Set(long?input, ClassProperty property) { return(input); }
public NormalTableInsideInlineTable() { this.InlineL2 = new ClassProperty(); }
public CallbackTuple(IVisualElement element, IClassMethod <TProp> vmMethod) { this.element = element; this.vmMethod = vmMethod; vmProperty = null; }
public int?Set(string input, ClassProperty property) { return(Convert.ToInt32(input)); }
/// <summary> /// Create Parameter, the process will handle value conversion and type conversion. /// </summary> /// <param name="command">The command object to be used.</param> /// <param name="name">Entity property's name.</param> /// <param name="value">Entity property's value, maybe null.</param> /// <param name="classProperty"> /// The entity's class property information. <br /> /// If the parameter is a dictionary, it will be null, otherwise it will not be null. /// </param> /// <param name="dbField"> /// Used to get the actual field type information of the database to determine whether automatic type conversion is required. <br /> /// When the tableName is assigned, it will be based on the database field information obtained by the tableName, so this parameter will be null in most cases. /// </param> /// <param name="parameterDirection">The direction of the parameter.</param> /// <param name="fallbackType">Used when none of the above parameters can determine the value of Parameter.DbType.</param> /// <returns>An instance of the newly created parameter object.</returns> private static IDbDataParameter CreateParameter(IDbCommand command, string name, object value, ClassProperty classProperty, DbField dbField, ParameterDirection?parameterDirection, Type fallbackType) { /* * In some cases, the value type and the classProperty type will be inconsistent, Therefore, the type gives priority to value. * ex: in RepoDb.MySql.IntegrationTests.TestMySqlConnectionForQueryForMySqlMapAttribute * entity AttributeTable.Id = int * database completetable.Id = bigint(20) AUTO_INCREMENT * value id in connection.Query<AttributeTable>(id) is from connection.Insert<AttributeTable>(table) = ulong */ var valueType = (value?.GetType() ?? classProperty?.PropertyInfo.PropertyType).GetUnderlyingType(); /* * Try to get the propertyHandler, the order of the source of resolve is classProperty and valueType. * If the propertyHandler exists, the value and DbType are re-determined by the propertyHandler. */ var propertyHandler = classProperty?.GetPropertyHandler() ?? (valueType == null ? null : PropertyHandlerCache.Get <object>(valueType)); if (propertyHandler != null) { var propertyHandlerSetMethod = propertyHandler.GetType().GetMethod("Set"); value = propertyHandlerSetMethod.Invoke(propertyHandler, new[] { value, classProperty }); valueType = propertyHandlerSetMethod.ReturnType.GetUnderlyingType(); } /* * When the database field information exists and the field type definition is found to be different from the valueType, * if automatic type conversion is activated at this time, it will be processed. */ if (valueType != null && dbField != null && IsAutomaticConversion(dbField)) { var dbFieldType = dbField.Type.GetUnderlyingType(); if (dbFieldType != valueType) { if (value != null) { value = AutomaticConvert(value, valueType, dbFieldType); } valueType = dbFieldType; } } /* * Set DbType as much as possible, to avoid parameter misjudgment when Value is null. * order: * 1. attribute level, TypeMapAttribute define on class's property * 2. property level, assigned by TypeMapper.Add(entityType, property, dbType, ...) * 3. type level, use TypeMapCache, assigned by TypeMapper.Add(type, dbType, ...), not included Primitive mapping. * 4. type level, primitive mapping, included special type. ex: byte[] ...etc. * 5. if isEnum, use Converter.EnumDefaultDatabaseType. */ // if classProperty exists, try get dbType from attribute level or property level, // The reason for not using classProperty.GetDbType() is to avoid getting the type level mapping. var dbType = classProperty?.GetDbType(); if (dbType == null && (valueType ??= dbField?.Type.GetUnderlyingType() ?? fallbackType) != null) { dbType = valueType.GetDbType() ?? // type level, use TypeMapCache clientTypeToDbTypeResolver.Resolve(valueType) ?? // type level, primitive mapping (dbField?.Type != null ? clientTypeToDbTypeResolver.Resolve(dbField?.Type) : null); // fallback to the database type } if (dbType == null && valueType.IsEnum) { dbType = Converter.EnumDefaultDatabaseType; // use Converter.EnumDefaultDatabaseType } /* * Return the parameter */ return(command.CreateParameter(name, value, dbType, parameterDirection)); }
public decimal?Set(WithHandlerEnum?input, ClassProperty property) => input switch {
public InlineTableWithDisallowedNormalTable() { this.Disallowed = new ClassProperty(); }
public string Set(TargetModel input, ClassProperty property) { return(input?.Value); }
public CallbackTuple(IVisualElement element, ClassProperty <TProp> vmProperty) { this.element = element; this.vmProperty = vmProperty; vmMethod = null; }