DoubleEqual() public méthode

public DoubleEqual ( IntPtr columnIndex, double value ) : void
columnIndex System.IntPtr
value double
Résultat void
QueryHandle Class Documentation
Exemple #1
0
        private static void AddQueryEqual(QueryHandle queryHandle, string columnName, object value)
        {
            var columnIndex = queryHandle.GetColumnIndex(columnName);

            if (value == null)
            {
                queryHandle.NullEqual(columnIndex);
            }
            else if (value is string)
            {
                queryHandle.StringEqual(columnIndex, (string)value, caseSensitive: true);
            }
            else if (value is bool)
            {
                queryHandle.BoolEqual(columnIndex, (bool)value);
            }
            else if (value is char)
            {
                queryHandle.IntEqual(columnIndex, (int)value);
            }
            else if (value is int)
            {
                queryHandle.IntEqual(columnIndex, (int)value);
            }
            else if (value is long)
            {
                queryHandle.LongEqual(columnIndex, (long)value);
            }
            else if (value is float)
            {
                queryHandle.FloatEqual(columnIndex, (float)value);
            }
            else if (value is double)
            {
                queryHandle.DoubleEqual(columnIndex, (double)value);
            }
            else if (value is DateTimeOffset)
            {
                queryHandle.TimestampTicksEqual(columnIndex, (DateTimeOffset)value);
            }
            else if (value is byte[])
            {
                var buffer = (byte[])value;
                if (buffer.Length == 0)
                {
                    // see RealmObject.SetByteArrayValue
                    queryHandle.BinaryEqual(columnIndex, (IntPtr)0x1, IntPtr.Zero);
                    return;
                }

                unsafe
                {
                    fixed(byte *bufferPtr = (byte[])value)
                    {
                        queryHandle.BinaryEqual(columnIndex, (IntPtr)bufferPtr, (IntPtr)buffer.LongCount());
                    }
                }
            }
            else if (value is RealmObject)
            {
                queryHandle.ObjectEqual(columnIndex, ((RealmObject)value).ObjectHandle);
            }
            else
            {
                throw new NotImplementedException();
            }
        }
Exemple #2
0
        private static void AddQueryEqual(QueryHandle queryHandle, string columnName, object value)
        {
            var columnIndex = queryHandle.GetColumnIndex(columnName);

            switch (value)
            {
            case null:
                queryHandle.NullEqual(columnIndex);
                break;

            case string stringValue:
                queryHandle.StringEqual(columnIndex, stringValue, caseSensitive: true);
                break;

            case bool boolValue:
                queryHandle.BoolEqual(columnIndex, boolValue);
                break;

            case byte byteValue:
                queryHandle.IntEqual(columnIndex, byteValue);
                break;

            case short shortValue:
                queryHandle.IntEqual(columnIndex, shortValue);
                break;

            case char charValue:
                queryHandle.IntEqual(columnIndex, charValue);
                break;

            case int intValue:
                queryHandle.IntEqual(columnIndex, intValue);
                break;

            case long longValue:
                queryHandle.LongEqual(columnIndex, longValue);
                break;

            case float floatValue:
                queryHandle.FloatEqual(columnIndex, floatValue);
                break;

            case double doubleValue:
                queryHandle.DoubleEqual(columnIndex, doubleValue);
                break;

            case DateTimeOffset date:
                queryHandle.TimestampTicksEqual(columnIndex, date);
                break;

            case byte[] buffer:
                if (buffer.Length == 0)
                {
                    // see RealmObject.SetByteArrayValue
                    queryHandle.BinaryEqual(columnIndex, (IntPtr)0x1, IntPtr.Zero);
                    return;
                }

                unsafe
                {
                    fixed(byte *bufferPtr = (byte[])value)
                    {
                        queryHandle.BinaryEqual(columnIndex, (IntPtr)bufferPtr, (IntPtr)buffer.LongCount());
                    }
                }
                break;

            case RealmObject obj:
                queryHandle.ObjectEqual(columnIndex, obj.ObjectHandle);
                break;

            case RealmInteger <byte> byteValue:
                queryHandle.IntEqual(columnIndex, byteValue);
                break;

            case RealmInteger <short> shortValue:
                queryHandle.IntEqual(columnIndex, shortValue);
                break;

            case RealmInteger <int> intValue:
                queryHandle.IntEqual(columnIndex, intValue);
                break;

            case RealmInteger <long> longValue:
                queryHandle.LongEqual(columnIndex, longValue);
                break;

            default:
                throw new NotImplementedException();
            }
        }