Beispiel #1
0
        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="datafile"></param>
        /// <param name="tid"></param>
        /// <param name="startTime"></param>
        /// <param name="endTime"></param>
        /// <param name="time"></param>
        /// <param name="result"></param>
        public static void ReadAllValue <T>(this DataFileSeriserbase datafile, int tid, DateTime startTime, DateTime endTime, DateTime time, HisQueryResult <T> result)
        {
            long  addroffset = 0;
            short len        = 0;
            int   datasize   = 0;

            if (!datafile.IsOpened())
            {
                return;
            }

            var aid = datafile.ReadTagIndex(tid, out addroffset, out len);

            if (!aid.IsEmpty())
            {
                int tagcount = len * 60;
                var tindex   = ReadTimeIndex(datafile, 0, aid.Address, startTime, endTime, time, tagcount);
                var vals     = ReadValueInner <T>(datafile, tindex.Keys.ToList(), 0, aid.Address + tagcount * 2, out datasize);
                var qus      = datafile.ReadBytes(aid.Address + 0 + tagcount * (2 + datasize), tagcount);
                int i        = 0;
                foreach (var vv in tindex)
                {
                    if (qus[vv.Key] < 100)
                    {
                        result.Add(vals[i], vv.Value, qus[vv.Key]);
                    }
                    i++;
                }
            }
        }
Beispiel #2
0
        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="file"></param>
        /// <param name="tid"></param>
        /// <param name="times"></param>
        /// <param name="type"></param>
        /// <param name="startTime"></param>
        /// <param name="result"></param>
        public static void Read <T>(this DataFileSeriserbase datafile, int tid, List <DateTime> times, QueryValueMatchType type, DateTime startTime, HisQueryResult <T> result)
        {
            long  addroffset = 0;
            short len        = 0;
            int   datasize   = 0;

            if (!datafile.IsOpened())
            {
                return;
            }

            var aid = datafile.ReadTagIndex(tid, out addroffset, out len);

            if (!aid.IsEmpty())
            {
                int tagcount = len * 60;
                var qs       = ReadTimeIndex(datafile, 0, aid.Address, startTime, tagcount);

                var vals = ReadValueInner <T>(datafile, qs.Keys.ToList(), 0, aid.Address + tagcount * 2, out datasize);
                var qq   = datafile.ReadBytes(aid.Address + 0 + tagcount * (datasize + 2), tagcount);

                var vv = qs.ToArray();
                //long valaddr = addroffset + tagcount * 2;
                int count = 0;
                foreach (var time1 in times)
                {
                    for (int i = 0; i < vv.Length - 1; i++)
                    {
                        var skey = vv[i];

                        var snext = vv[i + 1];

                        if (time1 == skey.Value.Item1)
                        {
                            result.Add(vals[i], time1, qq[skey.Key]);
                            count++;
                            break;
                        }
                        else if (time1 > skey.Value.Item1 && time1 < snext.Value.Item1)
                        {
                            switch (type)
                            {
                            case QueryValueMatchType.Previous:
                                result.Add(vals[i], time1, qq[skey.Key]);
                                count++;
                                break;

                            case QueryValueMatchType.After:
                                result.Add(vals[i + 1], time1, qq[snext.Key]);
                                count++;
                                break;

                            case QueryValueMatchType.Linear:
                                if (typeof(T) == typeof(bool) || typeof(T) == typeof(string) || typeof(T) == typeof(DateTime))
                                {
                                    var ppval = (time1 - skey.Value.Item1).TotalMilliseconds;
                                    var ffval = (snext.Value.Item1 - time1).TotalMilliseconds;

                                    if (ppval < ffval)
                                    {
                                        result.Add(vals[i], time1, qq[skey.Key]);
                                    }
                                    else
                                    {
                                        result.Add(vals[i + 1], time1, qq[snext.Key]);
                                    }
                                    count++;
                                }
                                else
                                {
                                    if (qq[skey.Key] < 20 && qq[snext.Key] < 20)
                                    {
                                        if (CheckTypeIsPointData(typeof(T)))
                                        {
                                            result.Add(LinerValue(skey.Value.Item1, snext.Value.Item1, time1, vals[i], vals[i + 1]), time1, 0);
                                        }
                                        else
                                        {
                                            var pval1 = (time1 - skey.Value.Item1).TotalMilliseconds;
                                            var tval1 = (snext.Value.Item1 - skey.Value.Item1).TotalMilliseconds;
                                            var sval1 = (double)vals[i];
                                            var sval2 = (double)vals[i + 1];
                                            var val1  = pval1 / tval1 * (sval2 - sval1) + sval1;
                                            result.Add((object)val1, time1, 0);
                                        }
                                    }
                                    else if (qq[skey.Key] < 20)
                                    {
                                        result.Add(vals[i], time1, qq[skey.Key]);
                                    }
                                    else if (qq[snext.Key] < 20)
                                    {
                                        result.Add(vals[i + 1], time1, qq[snext.Key]);
                                    }
                                    else
                                    {
                                        result.Add(default(T), time1, (byte)QualityConst.Null);
                                    }
                                }
                                count++;
                                break;

                            case QueryValueMatchType.Closed:
                                var pval = (time1 - skey.Value.Item1).TotalMilliseconds;
                                var fval = (snext.Value.Item1 - time1).TotalMilliseconds;

                                if (pval < fval)
                                {
                                    result.Add(vals[i], time1, qq[skey.Key]);
                                }
                                else
                                {
                                    result.Add(vals[i + 1], time1, qq[snext.Key]);
                                }
                                count++;
                                break;
                            }

                            break;
                        }
                        else if (time1 == snext.Value.Item1)
                        {
                            result.Add(vals[i + 1], time1, qq[snext.Key]);
                            count++;
                            break;
                        }
                    }
                }
            }
        }
Beispiel #3
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="datafile"></param>
        /// <param name="valIndex"></param>
        /// <param name="offset"></param>
        /// <param name="valueaddr"></param>
        /// <param name="result"></param>
        private static List <object> ReadValueInner <T>(this DataFileSeriserbase datafile, List <int> valIndex, long offset, long valueaddr, out int datasize)
        {
            List <object> re = new List <object>();

            string tname = typeof(T).Name;

            switch (tname)
            {
            case "Boolean":
                foreach (var vv in valIndex)
                {
                    re.Add(Convert.ToBoolean(datafile.ReadByte(offset + valueaddr + vv)));
                }
                datasize = 1;
                break;

            case "Byte":
                foreach (var vv in valIndex)
                {
                    re.Add(datafile.ReadByte(offset + valueaddr + vv));
                }
                datasize = 1;
                break;

            case "Int16":
                foreach (var vv in valIndex)
                {
                    re.Add(datafile.ReadShort(offset + valueaddr + vv * 2));
                }
                datasize = 2;
                break;

            case "UInt16":
                foreach (var vv in valIndex)
                {
                    re.Add((ushort)datafile.ReadShort(offset + valueaddr + vv * 2));
                }
                datasize = 2;
                break;

            case "Int32":
                foreach (var vv in valIndex)
                {
                    re.Add(datafile.ReadInt(offset + valueaddr + vv * 4));
                }
                datasize = 4;
                break;

            case "UInt32":
                foreach (var vv in valIndex)
                {
                    re.Add((uint)datafile.ReadInt(offset + valueaddr + vv * 4));
                }
                datasize = 4;
                break;

            case "Int64":
                foreach (var vv in valIndex)
                {
                    re.Add((long)datafile.ReadLong(offset + valueaddr + vv * 8));
                }
                datasize = 8;
                break;

            case "UInt64":
                foreach (var vv in valIndex)
                {
                    re.Add((ulong)datafile.ReadLong(offset + valueaddr + vv * 8));
                }
                datasize = 8;
                break;

            case "Double":
                foreach (var vv in valIndex)
                {
                    re.Add(datafile.ReadDouble(offset + valueaddr + vv * 8));
                }
                datasize = 8;
                break;

            case "Single":
                foreach (var vv in valIndex)
                {
                    re.Add(datafile.ReadFloat(offset + valueaddr + vv * 4));
                }
                datasize = 4;
                break;

            case "String":
                foreach (var vv in valIndex)
                {
                    var str = Encoding.Unicode.GetString(datafile.ReadBytes(offset + valueaddr + vv * Const.StringSize, Const.StringSize));
                    re.Add(str);
                }
                datasize = Const.StringSize;
                break;

            case "DateTime":
                foreach (var vv in valIndex)
                {
                    re.Add(datafile.ReadDateTime(offset + valueaddr + vv * 8));
                }
                datasize = 8;
                break;

            case "IntPointData":
                foreach (var vv in valIndex)
                {
                    var x = datafile.ReadInt(offset + valueaddr + vv * 8);
                    var y = datafile.ReadInt(offset + valueaddr + vv * 8 + 4);
                    re.Add(new IntPointData()
                    {
                        X = x, Y = y
                    });
                }
                datasize = 8;
                break;

            case "UIntPointData":
                foreach (var vv in valIndex)
                {
                    var x = (uint)datafile.ReadInt(offset + valueaddr + vv * 8);
                    var y = (uint)datafile.ReadInt(offset + valueaddr + vv * 8 + 4);
                    re.Add(new UIntPointData()
                    {
                        X = x, Y = y
                    });
                }
                datasize = 8;
                break;

            case "LongPointData":
                foreach (var vv in valIndex)
                {
                    var x = (long)datafile.ReadLong(offset + valueaddr + vv * 16);
                    var y = (long)datafile.ReadLong(offset + valueaddr + vv * 16 + 8);
                    re.Add(new LongPointData()
                    {
                        X = x, Y = y
                    });
                }
                datasize = 16;
                break;

            case "ULongPointData":
                foreach (var vv in valIndex)
                {
                    var x = (ulong)datafile.ReadLong(offset + valueaddr + vv * 16);
                    var y = (ulong)datafile.ReadLong(offset + valueaddr + vv * 16 + 8);
                    re.Add(new ULongPointData()
                    {
                        X = x, Y = y
                    });
                }
                datasize = 16;
                break;

            case "IntPoint3Data":
                foreach (var vv in valIndex)
                {
                    var x = datafile.ReadInt(offset + valueaddr + vv * 12);
                    var y = datafile.ReadInt(offset + valueaddr + vv * 12 + 4);
                    var z = datafile.ReadInt(offset + valueaddr + vv * 12 + 8);
                    re.Add(new IntPoint3Data()
                    {
                        X = x, Y = y, Z = z
                    });
                }
                datasize = 12;
                break;

            case "UIntPoint3Data":
                foreach (var vv in valIndex)
                {
                    var x = (uint)datafile.ReadInt(offset + valueaddr + vv * 12);
                    var y = (uint)datafile.ReadInt(offset + valueaddr + vv * 12 + 4);
                    var z = (uint)datafile.ReadInt(offset + valueaddr + vv * 12 + 8);
                    re.Add(new UIntPoint3Data()
                    {
                        X = x, Y = y, Z = z
                    });
                }
                datasize = 12;
                break;

            case "LongPoint3Data":
                foreach (var vv in valIndex)
                {
                    var x = (long)datafile.ReadLong(offset + valueaddr + vv * 24);
                    var y = (long)datafile.ReadLong(offset + valueaddr + vv * 24 + 8);
                    var z = (long)datafile.ReadLong(offset + valueaddr + vv * 24 + 168);
                    re.Add(new LongPoint3Data()
                    {
                        X = x, Y = y, Z = z
                    });
                }
                datasize = 24;
                break;

            case "ULongPoint3Data":
                foreach (var vv in valIndex)
                {
                    var x = (ulong)datafile.ReadLong(offset + valueaddr + vv * 24);
                    var y = (ulong)datafile.ReadLong(offset + valueaddr + vv * 24 + 8);
                    var z = (ulong)datafile.ReadLong(offset + valueaddr + vv * 24 + 168);
                    re.Add(new ULongPoint3Data()
                    {
                        X = x, Y = y, Z = z
                    });
                }
                datasize = 24;
                break;

            default:
                datasize = 0;
                break;
            }
            return(re);
        }
Beispiel #4
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="datafile"></param>
        /// <param name="valIndex"></param>
        /// <param name="offset"></param>
        /// <param name="valueaddr"></param>
        /// <param name="result"></param>
        private static List <object> ReadValueInner <T>(this DataFileSeriserbase datafile, List <int> valIndex, long offset, long valueaddr, out int datasize)
        {
            List <object> re = new List <object>();

            if (typeof(T) == typeof(bool))
            {
                foreach (var vv in valIndex)
                {
                    re.Add(Convert.ToBoolean(datafile.ReadByte(offset + valueaddr + vv)));
                }
                datasize = 1;
            }
            else if (typeof(T) == typeof(byte))
            {
                foreach (var vv in valIndex)
                {
                    re.Add(datafile.ReadByte(offset + valueaddr + vv));
                }
                datasize = 1;
            }
            else if (typeof(T) == typeof(short))
            {
                foreach (var vv in valIndex)
                {
                    re.Add(datafile.ReadShort(offset + valueaddr + vv * 2));
                }
                datasize = 2;
            }
            else if (typeof(T) == typeof(ushort))
            {
                foreach (var vv in valIndex)
                {
                    re.Add((ushort)datafile.ReadShort(offset + valueaddr + vv * 2));
                }
                datasize = 2;
            }
            else if (typeof(T) == typeof(int))
            {
                foreach (var vv in valIndex)
                {
                    re.Add(datafile.ReadInt(offset + valueaddr + vv * 4));
                }
                datasize = 4;
            }
            else if (typeof(T) == typeof(uint))
            {
                foreach (var vv in valIndex)
                {
                    re.Add((uint)datafile.ReadInt(offset + valueaddr + vv * 4));
                }
                datasize = 4;
            }
            else if (typeof(T) == typeof(long))
            {
                foreach (var vv in valIndex)
                {
                    re.Add((long)datafile.ReadLong(offset + valueaddr + vv * 8));
                }
                datasize = 8;
            }
            else if (typeof(T) == typeof(ulong))
            {
                foreach (var vv in valIndex)
                {
                    re.Add((ulong)datafile.ReadLong(offset + valueaddr + vv * 8));
                }
                datasize = 8;
            }
            else if (typeof(T) == typeof(double))
            {
                foreach (var vv in valIndex)
                {
                    re.Add(datafile.ReadDouble(offset + valueaddr + vv * 8));
                }
                datasize = 8;
            }
            else if (typeof(T) == typeof(float))
            {
                foreach (var vv in valIndex)
                {
                    re.Add(datafile.ReadFloat(offset + valueaddr + vv * 4));
                }
                datasize = 4;
            }
            else if (typeof(T) == typeof(string))
            {
                foreach (var vv in valIndex)
                {
                    var str = Encoding.Unicode.GetString(datafile.ReadBytes(offset + valueaddr + vv * Const.StringSize, Const.StringSize));
                    re.Add(str);
                }
                datasize = Const.StringSize;
            }
            else if (typeof(T) == typeof(DateTime))
            {
                foreach (var vv in valIndex)
                {
                    re.Add(datafile.ReadDateTime(offset + valueaddr + vv * 8));
                }
                datasize = 8;
            }
            else if (typeof(T) == typeof(IntPointData))
            {
                foreach (var vv in valIndex)
                {
                    var x = datafile.ReadInt(offset + valueaddr + vv * 8);
                    var y = datafile.ReadInt(offset + valueaddr + vv * 8 + 4);
                    re.Add(new IntPointData()
                    {
                        X = x, Y = y
                    });
                }
                datasize = 8;
            }
            else if (typeof(T) == typeof(UIntPointData))
            {
                foreach (var vv in valIndex)
                {
                    var x = (uint)datafile.ReadInt(offset + valueaddr + vv * 8);
                    var y = (uint)datafile.ReadInt(offset + valueaddr + vv * 8 + 4);
                    re.Add(new UIntPointData()
                    {
                        X = x, Y = y
                    });
                }
                datasize = 8;
            }
            else if (typeof(T) == typeof(LongPointData))
            {
                foreach (var vv in valIndex)
                {
                    var x = (long)datafile.ReadLong(offset + valueaddr + vv * 16);
                    var y = (long)datafile.ReadLong(offset + valueaddr + vv * 16 + 8);
                    re.Add(new LongPointData()
                    {
                        X = x, Y = y
                    });
                }
                datasize = 16;
            }
            else if (typeof(T) == typeof(ULongPointData))
            {
                foreach (var vv in valIndex)
                {
                    var x = (ulong)datafile.ReadLong(offset + valueaddr + vv * 16);
                    var y = (ulong)datafile.ReadLong(offset + valueaddr + vv * 16 + 8);
                    re.Add(new ULongPointData()
                    {
                        X = x, Y = y
                    });
                }
                datasize = 16;
            }
            else if (typeof(T) == typeof(IntPoint3Data))
            {
                foreach (var vv in valIndex)
                {
                    var x = datafile.ReadInt(offset + valueaddr + vv * 12);
                    var y = datafile.ReadInt(offset + valueaddr + vv * 12 + 4);
                    var z = datafile.ReadInt(offset + valueaddr + vv * 12 + 8);
                    re.Add(new IntPoint3Data()
                    {
                        X = x, Y = y, Z = z
                    });
                }
                datasize = 12;
            }
            else if (typeof(T) == typeof(UIntPoint3Data))
            {
                foreach (var vv in valIndex)
                {
                    var x = (uint)datafile.ReadInt(offset + valueaddr + vv * 12);
                    var y = (uint)datafile.ReadInt(offset + valueaddr + vv * 12 + 4);
                    var z = (uint)datafile.ReadInt(offset + valueaddr + vv * 12 + 8);
                    re.Add(new UIntPoint3Data()
                    {
                        X = x, Y = y, Z = z
                    });
                }
                datasize = 12;
            }
            else if (typeof(T) == typeof(LongPoint3Data))
            {
                foreach (var vv in valIndex)
                {
                    var x = (long)datafile.ReadLong(offset + valueaddr + vv * 24);
                    var y = (long)datafile.ReadLong(offset + valueaddr + vv * 24 + 8);
                    var z = (long)datafile.ReadLong(offset + valueaddr + vv * 24 + 168);
                    re.Add(new LongPoint3Data()
                    {
                        X = x, Y = y, Z = z
                    });
                }
                datasize = 24;
            }
            else if (typeof(T) == typeof(ULongPoint3Data))
            {
                foreach (var vv in valIndex)
                {
                    var x = (ulong)datafile.ReadLong(offset + valueaddr + vv * 24);
                    var y = (ulong)datafile.ReadLong(offset + valueaddr + vv * 24 + 8);
                    var z = (ulong)datafile.ReadLong(offset + valueaddr + vv * 24 + 168);
                    re.Add(new ULongPoint3Data()
                    {
                        X = x, Y = y, Z = z
                    });
                }
                datasize = 24;
            }
            datasize = 0;
            return(re);
        }