Exemplo n.º 1
0
        private static T ParseXml <T>(string xml) where T : new()
        {
            var reader = new SimpleXmlReader(XmlReader.Create(new StringReader(xml), xmlReaderSettings));

            return(Deserialize <T> .From(reader));
        }
Exemplo n.º 2
0
 internal void RegisterCustomType(Type type, Serialize serializer, Deserialize deserializer)
 {
     if (type == null || serializer == null || deserializer == null) return;
     _customSerializer.Add(type, serializer);
     _customDeserializer.Add(type, deserializer);
     // reset property cache
     Instance.ResetPropertyCache();
 }
Exemplo n.º 3
0
        /// <summary>
        /// Fetches location info by city name from related remote api
        /// </summary>
        /// <param name="cityName">City Name</param>
        /// <returns>LocationModel</returns>
        internal static LocationModel FetchLocationInfo(string cityName)
        {
            cityName = RemoveDiacritics(cityName.ToLower());
            LocationModel locationModel  = null;
            var           currrentTSHour = Convert.ToInt64((Math.Floor((decimal)(DateTime.Now.ToEpoch()) / 3600) * 3600));

            if (!methodRequests.ContainsKey(currrentTSHour)) // eger guncel saat dict icinde yoksa ekleme ve onceki saatle islem yapma bolumu
            {
                methodRequests[currrentTSHour] = new ConcurrentDictionary <string, LocationModel>();
            }

            if (methodRequests[currrentTSHour].ContainsKey(cityName))
            {
                return(methodRequests[currrentTSHour].Where(r => r.Key == cityName).Select(r => r.Value).FirstOrDefault());
            }

            Stopwatch sw = Stopwatch.StartNew();

            try
            {
                using (var httpClient = new HttpClient())
                {
                    using (var response = httpClient.GetAsync(_LocationWSURL.Replace("[LOCATION]", cityName ?? "istanbul")).Result)
                    {
                        using (var content = response.Content)
                        {
                            //get the json result from location api
                            var result = content.ReadAsStringAsync().Result;
                            locationModel = Deserialize.FromJson(result).FirstOrDefault();
                            sw.Stop();
                            if (locationModel != null)
                            {
                                //TO DO : consider same spelled different places..
                                //This is more simple to check if the record is available or not then if record not available save etc..
                                var res = DBlite.ExecuteSQL($"INSERT OR IGNORE INTO Location (CityName, Latitude, Longitude, QueryElapsedMilliseconds) VALUES (@CityName, @Latitude, @Longitude, @QueryElapsedMilliseconds);",
                                                            new ArrayList {
                                    new SQLiteParameter("@CityName", cityName),
                                    new SQLiteParameter("@Latitude", locationModel.Lat),
                                    new SQLiteParameter("@Longitude", locationModel.Lon),
                                    new SQLiteParameter("@QueryElapsedMilliseconds", sw.ElapsedMilliseconds)
                                });
                                if (res == -1)
                                {
                                    Log.Error("Location table insert error");
                                }
                                else
                                {
                                    var dt = DBlite.GetData($"SELECT Id, Latitude, Longitude, QueryElapsedMilliseconds FROM Location WHERE CityName = @CityName;",
                                                            new ArrayList {
                                        new SQLiteParameter("@CityName", cityName)
                                    });

                                    if (dt != null && dt.Rows.Count > 0)
                                    {
                                        var dr = dt.Rows[0];
                                        locationModel = new LocationModel
                                        {
                                            CityId   = dr["Id"].Obj2Int32(),
                                            CityName = cityName,
                                            Lat      = dr["Latitude"].Obj2String(),
                                            Lon      = dr["Longitude"].Obj2String(),
                                            QueryElapsedMilliseconds = dr["QueryElapsedMilliseconds"].Obj2Int64(),
                                        };

                                        //max 50 records
                                        if (methodRequests.Count >= 50)
                                        {
                                            methodRequests[currrentTSHour] = new ConcurrentDictionary <string, LocationModel>();
                                        }

                                        //if cityId does not exist
                                        if (!methodRequests[currrentTSHour].ContainsKey(cityName))
                                        {
                                            methodRequests[currrentTSHour].TryAdd(cityName, locationModel);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Error("LocationService : " + ex.ToString());
            }

            return(locationModel);
        }
Exemplo n.º 4
0
        public static AddableArray <T> Deserialize(string str, Deserialize <T> deserialize)
        {
            string type_string     = typeof(T).ConvertToCsharpSource();
            string type_string_xml = type_string.Replace("<", "-").Replace(">", "-");

            T[]        list;
            Equate <T> equate = null;
            int        count  = 0;

            using (XmlReader xmlReader = XmlReader.Create(new StringReader(str)))
            {
                if (!xmlReader.Read() ||
                    !xmlReader.IsStartElement() ||
                    xmlReader.IsEmptyElement ||
                    !xmlReader.Name.Equals("ListArray"))
                {
                    throw new FormatException("Invalid input during ListArray deserialization.");
                }

                bool typeExists   = false;
                bool equateExists = false;
                bool countExists  = false;

                while (xmlReader.MoveToNextAttribute())
                {
                    switch (xmlReader.Name)
                    {
                    case "Type":
                        string typeFromXml = xmlReader.Value;
                        if (!type_string_xml.Equals(typeFromXml))
                        {
                            throw new FormatException("Type mismatch during a ListArray deserialization (ListArray<T>: T does not match the type in the string to deserialize).");
                        }
                        typeExists = true;
                        break;

                    case "Equate":
                        if (string.IsNullOrWhiteSpace(xmlReader.Value))
                        {
                            throw new FormatException("Invalid input during ListArray deserialization (Equate attribute is invalid or missing a value).");
                        }
                        string[] splits = xmlReader.Value.Split(',');
                        if (splits.Length != 3)
                        {
                            throw new FormatException("Invalid input during ListArray deserialization (Equate attribute has an invalid value).");
                        }
                        string methodName            = splits[0];
                        string declaringTypeFullName = splits[1];
                        string assembly = splits[2];
                        throw new NotImplementedException();
                        //equate = Meta.Compile<Equate<T>>(string.Concat(declaringTypeFullName, ".", methodName));
                        equateExists = true;
                        break;

                    case "Count":
                        if (string.IsNullOrWhiteSpace(xmlReader.Value))
                        {
                            throw new FormatException("Invalid input during ListArray deserialization (Count attribute is invalid or missing a value).");
                        }
                        if (!int.TryParse(xmlReader.Value, out count) || count < 0)
                        {
                            throw new FormatException("Invalid input during ListArray deserialization (Count attribute is invalid).");
                        }
                        countExists = true;
                        break;

                    default:
                        continue;
                    }
                }

                if (!equateExists)
                {
                    throw new FormatException("Invalid input during ListArray deserialization (required attribute Equate does not exist).");
                }
                if (!countExists)
                {
                    throw new FormatException("Invalid input during ListArray deserialization (required attribute Count does not exist).");
                }
                if (!typeExists)
                {
                    throw new FormatException("Invalid input during ListArray deserialization (required attribute Type does not exist).");
                }

                xmlReader.MoveToElement();
                list = new T[count];

                for (int i = 0; i < count; i++)
                {
                    while (xmlReader.Name == null || !xmlReader.Name.Equals("Item"))
                    {
                        xmlReader.Read();
                    }
                    if (!xmlReader.IsStartElement() ||
                        xmlReader.IsEmptyElement)
                    {
                        throw new FormatException("Invalid input during ListArray deserialization.");
                    }
                    if (xmlReader.Value == null)
                    {
                        throw new FormatException("Invalid input during ListArray deserialization (missing or invalid contents of Item #" + i + ").");
                    }
                    int  index;
                    bool indexExists = false;
                    while (xmlReader.MoveToNextAttribute())
                    {
                        if (string.IsNullOrWhiteSpace(xmlReader.Name))
                        {
                            throw new FormatException("Invalid input during ListArray deserialization (invalid attribute of Item #" + i + ").");
                        }
                        if (!xmlReader.Name.Equals("Index"))
                        {
                            continue;
                        }
                        if (string.IsNullOrWhiteSpace(xmlReader.Value) ||
                            !int.TryParse(xmlReader.Value, out index) ||
                            index != i)
                        {
                            throw new FormatException("Invalid input during ListArray deserialization (invalid index attribute of Item #" + i + ").");
                        }
                        indexExists = true;
                    }
                    if (!indexExists)
                    {
                        throw new FormatException("Invalid input during ListArray deserialization (missing required Index attribute for Item #" + i + ").");
                    }
                    xmlReader.MoveToElement();
                    string item_string = xmlReader.ReadString().Trim();
                    list[i] = deserialize(item_string);
                    if (i < count - 1 && !xmlReader.ReadToNextSibling("Item"))
                    {
                        throw new FormatException("Invalid input during ListArray deserialization (count attribute and amount of data provided do not match).");
                    }
                }
            }

            return(new AddableArray <T>(list, count, equate));
        }
Exemplo n.º 5
0
        public void FastBinaryReader_Skip_WString_OverflowLength_Throws()
        {
            var data = new byte[]
            {
                0x0a,
                0x00,
                0x00,
                0x09,
                0x02,
                0x00,
                0x27,
                0x49,
                0x39,
                0x54,
                0x36,
                0x75,
                0x29,
                0x53,
                0x43,
                0x56,
                0x3d,
                0x21,
                0x74,
                0x56,
                0x46,
                0x39,
                0x22,
                0x7a,
                0x58,
                0x34,
                0x70,
                0x2d,
                0x70,
                0x69,
                0x5b,
                0x27,
                0x23,
                0x40,
                0x32,
                0x60,
                0x2c,
                0x43,
                0x3a,
                0x3f,
                0x6c,
                0x36,
                0x55,
                0x38,
                0x7a,
                0x54,
                0x12,
                0x03,
                0x00,

                0xff, // count -1
                0xff,
                0xff,
                0xff,
                0xff,

                0x3c,
                0x00,
            };

            var input  = new InputBuffer(data);
            var reader = new FastBinaryReader <InputBuffer>(input);

            Assert.Throws <OverflowException>(() => Deserialize <BondedAlias> .From(reader));

            data = new byte[]
            {
                0x0a,
                0x00,
                0x00,
                0x09,
                0x02,
                0x00,
                0x27,
                0x49,
                0x39,
                0x54,
                0x36,
                0x75,
                0x29,
                0x53,
                0x43,
                0x56,
                0x3d,
                0x21,
                0x74,
                0x56,
                0x46,
                0x39,
                0x22,
                0x7a,
                0x58,
                0x34,
                0x70,
                0x2d,
                0x70,
                0x69,
                0x5b,
                0x27,
                0x23,
                0x40,
                0x32,
                0x60,
                0x2c,
                0x43,
                0x3a,
                0x3f,
                0x6c,
                0x36,
                0x55,
                0x38,
                0x7a,
                0x54,
                0x12,
                0x03,
                0x00,

                0x80, // count (5 byte) = int.MaxValue / 2 + 1
                0x80,
                0x80,
                0x80,
                0x04,

                0x3c,
                0x00,
            };

            input  = new InputBuffer(data);
            reader = new FastBinaryReader <InputBuffer>(input);
            Assert.Throws <OverflowException>(() => Deserialize <BondedAlias> .From(reader));
        }
Exemplo n.º 6
0
        internal static object Deserialize(ObjectReader stream, Deserialize <ObjectReader> info)
        {
            object value = info(stream);

            return(value);
        }
Exemplo n.º 7
0
 public static void RegisterCustomType(Type type, Serialize serializer, Deserialize deserializer)
 {
     Manager.RegisterCustomType(type, serializer, deserializer);
 }
Exemplo n.º 8
0
        public static T DeserializeJson <T>(Stream stream)
        {
            var reader = new SimpleJsonReader(stream);

            return(Deserialize <T> .From(reader));
        }
Exemplo n.º 9
0
 public void should_deserialize_mail_address()
 {
     Deserialize.FormUrlEncoded <OutOfTheBoxTypes>("[email protected]")
     .MailAddress.ShouldEqual(new MailAddress("*****@*****.**"));
 }
Exemplo n.º 10
0
 public void should_deserialize_byte_array()
 {
     Deserialize.FormUrlEncoded <OutOfTheBoxTypes>("ByteArray=b2ggaGFp")
     .ByteArray.ShouldEqual(ASCIIEncoding.ASCII.GetBytes("oh hai"));
 }
Exemplo n.º 11
0
 public void should_deserialize_version()
 {
     Deserialize.FormUrlEncoded <OutOfTheBoxTypes>("Version=1.2.3.4")
     .Version.ShouldEqual(Version.Parse("1.2.3.4"));
 }
Exemplo n.º 12
0
 public void should_deserialize_ip_address()
 {
     Deserialize.FormUrlEncoded <OutOfTheBoxTypes>("IPAddress=192.168.1.1")
     .IPAddress.ShouldEqual(IPAddress.Parse("192.168.1.1"));
 }
Exemplo n.º 13
0
 public void should_exclude_types_when()
 {
     Deserialize.Json <IDictionary <string, ComplexType> >(
         "{ \"item\": { \"Property\": \"hai\" } }",
         x => x.ExcludeTypesWhen((t, o) => t.Name == "ComplexType")).ShouldTotal(0);
 }
Exemplo n.º 14
0
 /// <summary>
 /// Register a custom serializer/deserializer by the type and type code specified.
 /// </summary>
 /// <param name="typeCode">
 /// The type code.
 /// </param>
 /// <param name="type">
 /// The type.
 /// </param>
 /// <param name="serialize">
 /// The serialize delegate.
 /// </param>
 /// <param name="deserialize">
 /// The deserialize delegate.
 /// </param>
 /// <returns>
 /// <c>true</c> if the serializer and deserialize delegate has been registered successfully, otherwise <c>false</c>.
 /// </returns>
 public static bool Register(int typeCode, Type type, Serialize serialize, Deserialize deserialize)
 {
     return Register(typeCode, type, serialize) && Decoder.Register(typeCode, type, deserialize);
 }
Exemplo n.º 15
0
        /// <summary>
        /// 数据接收
        /// </summary>
        /// <param name="data"></param>
        public override void DataReceive(string data)
        {
            try
            {
                if (string.IsNullOrEmpty(data))
                {
                    return;
                }
                HJ212Model  model = Deserialize.DeserializeBase(data);
                CommandType type  = Util.GetCommandType((MiddleCode)model.CN);
                switch (type)
                {
                case CommandType.Notice:
                    NoticeResponse(model);
                    break;

                case CommandType.Request:
                    CommandResult res = RequestResponse(model);
                    if (res != CommandResult.Ready)
                    {
                        return;
                    }
                    break;

                case CommandType.Upload:
                    RequestResponse(model, CommandResult.Forbidden);
                    return;

                case CommandType.Other:
                    return;

                case CommandType.None:
                    RequestResponse(model, CommandResult.Forbidden);
                    return;

                default:
                    RequestResponse(model, CommandResult.Forbidden);
                    return;
                }
                switch ((MiddleCode)model.CN)
                {
                case MiddleCode.SetTimeOutReSendTimes:
                    SetTimeOutReSendTimes(model);
                    break;

                case MiddleCode.GetSceneDeviceTime:
                    UploadSceneDeviceTime(model);
                    break;

                case MiddleCode.SetSceneDeviceTime:
                    SetSceneDeviceTime(model);
                    break;

                case MiddleCode.GetRtdDataInterval:
                    UploadRtdDataInterval(model);
                    break;

                case MiddleCode.SetRtdDataInterval:
                    SetRtdDataInterval(model);
                    break;

                case MiddleCode.GetMinuteDataInterval:
                    UploadMinuteDataInterval(model);
                    break;

                case MiddleCode.SetMinuteDataInterval:
                    SetMinuteDataInterval(model);
                    break;

                case MiddleCode.SetSceneDevicePassword:
                    SetSceneDevicePassword(model);
                    break;

                case MiddleCode.GetRtdData:
                    GetRtdData(model);
                    break;

                case MiddleCode.StopRtdData:
                    StopRtdData(model);
                    break;

                case MiddleCode.GetDeviceRunState:
                    GetDeviceRunState(model);
                    break;

                case MiddleCode.StopDeviceRunState:
                    StopDeviceRunState(model);
                    break;

                case MiddleCode.GetDayData:
                    UploadDayData(model);
                    break;

                case MiddleCode.GetDeviceRunTimeDayData:
                    UploadDeviceRunTimeDayData(model);
                    break;

                case MiddleCode.GetMinuteData:
                    UploadMinuteData(model);
                    break;

                case MiddleCode.GetHourData:
                    UploadHourData(model);
                    break;

                case MiddleCode.RangeCalibration:
                    RangeCalibration(model);
                    break;

                case MiddleCode.GetCycleData:
                    UploadCycleData(model);
                    break;

                case MiddleCode.TakeSampleImmediately:
                    TakeSampleImmediately(model);
                    break;

                case MiddleCode.StartClear:
                    StartClear(model);
                    break;

                case MiddleCode.CompareSample:
                    CompareSample(model);
                    break;

                case MiddleCode.LeaveSuperstandardSample:
                    UploadSuperstandardSample(model);
                    break;

                case MiddleCode.SetSampleTimeInterval:
                    SetSampleTimeInterval(model);
                    break;

                case MiddleCode.GetSampleTimeInterval:
                    UploadSampleTimeInterval(model);
                    break;

                case MiddleCode.GetSampleTime:
                    UploadSampleTime(model);
                    break;

                case MiddleCode.GetSceneDeviceUUID:
                    UploadSceneDeviceUUID(model);
                    break;

                case MiddleCode.GetSceneDeviceInfo:
                    UploadSceneDeviceInfo(model);
                    break;

                case MiddleCode.SetSceneDeviceParam:
                    SetSceneDeviceParam(model);
                    break;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Exemplo n.º 16
0
 public void should_filter_types()
 {
     Deserialize.Json <IDictionary <string, ComplexType> >(
         "{ \"item\": { \"Property\": \"hai\" } }",
         x => x.ExcludeType <ComplexType>()).ShouldTotal(0);
 }
Exemplo n.º 17
0
        static void Main(string[] args)
        {
            if (args.Length < 3)
            {
                Console.WriteLine("Usage:\nBond.CompatibilityTest json|compact|compact2|fast|simple|simple2|schema input_file output_file [json|compact|fast|simple|simple2]");
                return;
            }

            var fromProtocol = args[0];
            var toProtocol   = fromProtocol;
            var inputFile    = args[1];
            var outputFile   = args[2];

            if (args.Length == 4)
            {
                toProtocol = args[3];
            }

            using (var inputStream = new FileStream(inputFile, FileMode.Open, FileAccess.Read))
            {
                var input = new InputStream(inputStream);
                using (var outputStream = new FileStream(outputFile, FileMode.Create))
                {
                    var output = new OutputStream(outputStream);
                    if (fromProtocol == "json")
                    {
                        var reader     = new SimpleJsonReader(inputStream);
                        var writer     = new SimpleJsonWriter(outputStream);
                        var transcoder = new Transcoder <SimpleJsonReader, SimpleJsonWriter>(Schema <Compat> .RuntimeSchema);
                        transcoder.Transcode(reader, writer);
                        writer.Flush();
                    }
                    else if (fromProtocol == "compact")
                    {
                        var reader = new CompactBinaryReader <InputStream>(input);
                        Write(reader, output, toProtocol);
                    }
                    else if (fromProtocol == "compact2")
                    {
                        var reader = new CompactBinaryReader <InputStream>(input, 2);
                        Write(reader, output, toProtocol);
                    }
                    else if (fromProtocol == "fast")
                    {
                        var reader = new FastBinaryReader <InputStream>(input, 2);
                        Write(reader, output, toProtocol);
                    }
                    else if (fromProtocol == "simple")
                    {
                        var reader = new SimpleBinaryReader <InputStream>(input);
                        Write(reader, output, toProtocol);
                    }
                    else if (fromProtocol == "simple2")
                    {
                        var reader = new SimpleBinaryReader <InputStream>(input, 2);
                        Write(reader, output, toProtocol);
                    }
                    else if (fromProtocol == "schema")
                    {
                        SchemaDef schema;

                        var c = (char)inputStream.ReadByte();
                        inputStream.Seek(0, SeekOrigin.Begin);

                        if (c == '{')
                        {
                            var reader = new SimpleJsonReader(inputStream);
                            schema = Deserialize <SchemaDef> .From(reader);
                        }
                        else
                        {
                            schema = Unmarshal <SchemaDef> .From(input);
                        }

                        if (!Comparer.Equal(schema, Schema <Compat> .RuntimeSchema.SchemaDef))
                        {
                            Console.WriteLine("SchemaDef is different");
                        }
                        var writer = new CompactBinaryWriter <OutputStream>(output);
                        Marshal.To(writer, Schema <Compat> .RuntimeSchema.SchemaDef);
                        output.Flush();
                    }
                    else
                    {
                        Console.WriteLine("Unsupported input protocol {0}", fromProtocol);
                    }
                }
            }
        }
Exemplo n.º 18
0
 public static T DeserializeTagged <T>(IClonableTaggedProtocolReader reader)
 {
     return(Deserialize <T> .From(reader));
 }
Exemplo n.º 19
0
        static void Main()
        {
            var circle = new Circle
            {
                Type   = Type.Circle,
                Radius = 3.14
            };

            var rectangle = new Rectangle
            {
                Type   = Type.Rectangle,
                Width  = 10,
                Height = 5.5
            };

            var src = new Polymorphic
            {
                Shapes =
                {
                    new Bonded <Circle>(circle),
                    new Bonded <Rectangle>(rectangle)
                }
            };

            var output = new OutputBuffer();
            var writer = new CompactBinaryWriter <OutputBuffer>(output);

            Serialize.To(writer, src);

            var input  = new InputBuffer(output.Data);
            var reader = new CompactBinaryReader <InputBuffer>(input);

            var dst = Deserialize <Polymorphic> .From(reader);

            var deserializers = new Dictionary <Type, Deserializer <CompactBinaryReader <InputBuffer> > >
            {
                { Type.Circle, new Deserializer <CompactBinaryReader <InputBuffer> >(typeof(Circle)) },
                { Type.Rectangle, new Deserializer <CompactBinaryReader <InputBuffer> >(typeof(Rectangle)) }
            };

            foreach (var item in dst.Shapes)
            {
                // Deserialize item as Shape and extract object type
                var type = item.Deserialize().Type;

                // Select one of the precreated deserializers based on the item type
                var shape = deserializers[type].Deserialize(item);

                if (shape.GetType() == typeof(Circle))
                {
                    ThrowIfFalse(Comparer.Equal(circle, shape as Circle));
                }

                if (shape.GetType() == typeof(Rectangle))
                {
                    ThrowIfFalse(Comparer.Equal(rectangle, shape as Rectangle));
                }

                // Alternatively the generic method IBonded<T>.Deserialize<U> can be used
                if (type == Type.Circle)
                {
                    var c = item.Deserialize <Circle>();
                    ThrowIfFalse(Comparer.Equal(circle, c));
                }

                if (type == Type.Rectangle)
                {
                    var r = item.Deserialize <Rectangle>();
                    ThrowIfFalse(Comparer.Equal(rectangle, r));
                }
            }
        }
Exemplo n.º 20
0
        public async void ExportToExcel(ProgressBar progressBar)
        {
            // Display the ProgressBar control.
            progressBar.Visible = true;
            // Set Minimum to 1 to represent the first file being copied.
            progressBar.Minimum = 1;

            // Set the initial value of the ProgressBar.
            progressBar.Value = 1;
            // Set the Step property to a value of 1 to represent each file being copied.
            progressBar.Step = 1;


            object Nothing = System.Reflection.Missing.Value;
            var    app     = new Microsoft.Office.Interop.Excel.Application();

            app.Visible = false;
            Microsoft.Office.Interop.Excel.Workbook  workBook  = app.Workbooks.Add(Nothing);
            Microsoft.Office.Interop.Excel.Worksheet worksheet = (Microsoft.Office.Interop.Excel.Worksheet)workBook.Sheets[1];
            worksheet.Name          = "Employee Exported";
            worksheet.StandardWidth = 20;

            // Show save file dialog
            SaveFileDialog saveFileDialog = new SaveFileDialog();

            saveFileDialog.Filter = "Excel Files|*.xlsx";

            if (saveFileDialog.ShowDialog() == DialogResult.OK)
            {
                // storing header part in Excel
                Employee employee = new Employee();

                worksheet.Cells[1, 1] = "Id";
                worksheet.Cells[1, 2] = "Name";
                worksheet.Cells[1, 3] = "Email";
                worksheet.Cells[1, 4] = "Gender";
                worksheet.Cells[1, 5] = "Status";

                var response = await EmployeeHelper.ListPage();

                PaginationEmployee paginationInfo = Deserialize.DeserializeEmployeePagination(response);

                int total = paginationInfo.Total;
                int pages = paginationInfo.Pages;
                int page  = paginationInfo.Page;
                int limit = paginationInfo.Limit;

                IList <Employee> employeeList = new List <Employee>();

                int countPage = pages;

                // Set Maximum to the total number of files to copy.
                progressBar.Maximum = total;

                int cellCount = 1;

                for (int i = 1; i <= pages; i++)
                {
                    var responseList = await ListAll(i);

                    employeeList = Deserialize.DeserializeEmployeSearch(responseList);

                    for (int j = 0; j < employeeList.Count; j++)
                    {
                        cellCount++;

                        worksheet.Cells[cellCount, 1] = employeeList[j].Id;
                        worksheet.Cells[cellCount, 2] = employeeList[j].Name;
                        worksheet.Cells[cellCount, 3] = employeeList[j].Email;
                        worksheet.Cells[cellCount, 4] = employeeList[j].Gender;
                        worksheet.Cells[cellCount, 5] = employeeList[j].Status;

                        progressBar.PerformStep();
                    }
                }

                progressBar.Visible = false;

                worksheet.SaveAs(saveFileDialog.FileName, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Microsoft.Office.Interop.Excel.XlSaveAsAccessMode.xlNoChange, Type.Missing, Type.Missing, Type.Missing);
                workBook.Close(false, Type.Missing, Type.Missing);
                app.Quit();
            }
        }
        internal static object Deserialize(JsonUstring stream, Deserialize <JsonUstring> info)
        {
            object value = info(stream);

            return(value);
        }
Exemplo n.º 22
0
 public static T Init <T>()
 {
     return(Deserialize <T> .From(new RandomReader(random)));
 }
Exemplo n.º 23
0
#pragma warning disable CS0618 // Type or member is obsolete; this does not involve any form of user input. Any possible threats presented here already exist in the object being copied
        public static object CopyByBinarySerialization(this object obj) => Deserialize <object> .Binary(Serialize.Binary(obj));
Exemplo n.º 24
0
        public void Rate()
        {
            Logger.Log("Starting rate.");
            Logger.Log("Loading policy.");

            // load policy - open file policy.json
            var policyJson = Reader.ReadFromJson("policy.json");
            var policy     = Deserialize.To <Policy>(policyJson);

            switch (policy.Type)
            {
            case PolicyType.Auto:
                Logger.Log("Rating AUTO policy...");
                Logger.Log("Validating policy.");
                if (string.IsNullOrEmpty(policy.Make))
                {
                    Logger.Log("Auto policy must specify Make");
                    return;
                }
                if (policy.Make == "BMW")
                {
                    if (policy.Deductible < 500)
                    {
                        Rating = 1000m;
                    }
                    Rating = 900m;
                }
                break;

            case PolicyType.Land:
                Logger.Log("Rating LAND policy...");
                Logger.Log("Validating policy.");
                if (policy.BondAmount == 0 || policy.Valuation == 0)
                {
                    Logger.Log("Land policy must specify Bond Amount and Valuation.");
                    return;
                }
                if (policy.BondAmount < 0.8m * policy.Valuation)
                {
                    Logger.Log("Insufficient bond amount.");
                    return;
                }
                Rating = policy.BondAmount * 0.05m;
                break;

            case PolicyType.Life:
                Logger.Log("Rating LIFE policy...");
                Logger.Log("Validating policy.");
                if (policy.DateOfBirth == DateTime.MinValue)
                {
                    Logger.Log("Life policy must include Date of Birth.");
                    return;
                }
                if (policy.DateOfBirth < DateTime.Today.AddYears(-100))
                {
                    Logger.Log("Centenarians are not eligible for coverage.");
                    return;
                }
                if (policy.Amount == 0)
                {
                    Logger.Log("Life policy must include an Amount.");
                    return;
                }
                var age = DateTime.Today.Year - policy.DateOfBirth.Year;
                if ((policy.DateOfBirth.Month == DateTime.Today.Month &&
                     DateTime.Today.Day < policy.DateOfBirth.Day) ||
                    DateTime.Today.Month < policy.DateOfBirth.Month)
                {
                    age--;
                }
                var baseRate = policy.Amount * age / 200;
                if (policy.IsSmoker)
                {
                    Rating = baseRate * 2;
                    break;
                }
                Rating = baseRate;
                break;

            default:
                Logger.Log("Unknown policy type");
                break;
            }

            Logger.Log("Rating completed.");
        }
Exemplo n.º 25
0
 public async static Task <object> CopyByBinarySerializationAsync(this object obj) => await Task.Run(() => Deserialize <object> .Binary(Serialize.Binary(obj)));
Exemplo n.º 26
0
 /// <summary>
 /// Register custom type handlers for your own types not natively handled by fastJSON
 /// </summary>
 /// <param name="type"></param>
 /// <param name="serializer"></param>
 /// <param name="deserializer"></param>
 public static void RegisterCustomType(Type type, Serialize serializer, Deserialize deserializer)
 {
     Reflection.Instance.RegisterCustomType(type, serializer, deserializer);
 }
Exemplo n.º 27
0
 public EventStoreAdapter(GetEventStoreConnection getEventStoreConnection, Serialize serialize, Deserialize deserialize)
 {
     _getEventStoreConnection = getEventStoreConnection;
     _createEventData         = (se, ct) => Defaults.CreateEventData(se, serialize, ct);
     _resolveStreamEvent      = (re, ct) => Defaults.ResolveStreamEvent(re, deserialize, ct);
 }
Exemplo n.º 28
0
 /// <summary>
 /// Initializes a new instance of the <see cref="DecoderInfo"/> class.
 /// </summary>
 /// <param name="type">
 /// The type.
 /// </param>
 /// <param name="deserialize">
 /// The deserialize.
 /// </param>
 internal DecoderInfo(Type type, Deserialize deserialize)
 {
     this.Type = type;
     this.Deserialize = deserialize;
 }
Exemplo n.º 29
0
 public static ISerializedRW <A> lambda <A>(
     Serialize <A> serialize, Deserialize <DeserializeInfo <A> > deserialize
     ) => new Lambda <A>(serialize, deserialize);
Exemplo n.º 30
0
        /// <summary>
        /// Register a custom deserializer by the type and type code specified.
        /// </summary>
        /// <param name="typeCode">
        /// The type code.
        /// </param>
        /// <param name="type">
        /// The type.
        /// </param>
        /// <param name="deserialize">
        /// The deserialize delegate.
        /// </param>
        /// <returns>
        /// <c>true</c> if the deserialize delegate has been registered successfully, otherwise <c>false</c>.
        /// </returns>
        /// <exception cref="ArgumentNullException">
        /// If <paramref name="type"/> is null.
        /// </exception>
        /// <exception cref="ArgumentNullException">
        /// If <paramref name="deserialize"/> is null.
        /// </exception>
        /// <exception cref="ArgumentException">
        /// If <paramref name="typeCode"/> is not in the valid range.
        /// </exception>
        public static bool Register(int typeCode, Type type, Deserialize deserialize)
        {
            if (type == null)
            {
                throw new ArgumentNullException("type");
            }

            if (deserialize == null)
            {
                throw new ArgumentNullException("deserialize");
            }

            Encoder.Register(typeCode, type);
            var internalTypeCode = Encoder.ToInternalTypeCode(typeCode);
            return DecoderInfos.TryAdd((Tags)internalTypeCode, new DecoderInfo(type, deserialize));
        }
Exemplo n.º 31
0
 public Lambda(Serialize <A> serialize, Deserialize <DeserializeInfo <A> > deserialize)
 {
     _serialize   = serialize;
     _deserialize = deserialize;
 }
Exemplo n.º 32
0
 internal void RegisterCustomType(Type type, Serialize serializer, Deserialize deserializer)
 {
     if (type != null && serializer != null && deserializer != null)
     {
         _customSerializer.Add(type, serializer);
         _customDeserializer.Add(type, deserializer);
         // reset property cache
         Reflection.Instance.ResetPropertyCache();
     }
 }
Exemplo n.º 33
0
        /// <summary>
        /// Deserializes an <see cref="IPipFingerprintEntryData"/> of the appropriate concrete type (or null if the type is unknown).
        /// <see cref="PipFingerprintEntry"/> is a tagged polymorphic container (see <see cref="Kind"/>),
        /// and this operation unwraps it. The returned instance contains all relevant data for the entry.
        /// </summary>
        public IPipFingerprintEntryData Deserialize(CacheQueryData cacheQueryData = null)
        {
            if (Kind == PipFingerprintEntryKind.Unknown)
            {
                return(null);
            }

            if (m_deserializedEntryData != null)
            {
                return(m_deserializedEntryData);
            }

            try
            {
                InputBuffer buffer = new InputBuffer(DataBlob);
                CompactBinaryReader <InputBuffer> reader = new CompactBinaryReader <InputBuffer>(buffer);
                IPipFingerprintEntryData          deserialized;

                switch (Kind)
                {
                case PipFingerprintEntryKind.DescriptorV1:
                    deserialized = Deserialize <PipCacheDescriptor> .From(reader);

                    break;

                case PipFingerprintEntryKind.DescriptorV2:
                    deserialized = Deserialize <PipCacheDescriptorV2Metadata> .From(reader);

                    break;

                case PipFingerprintEntryKind.GraphDescriptor:
                    deserialized = Deserialize <PipGraphCacheDescriptor> .From(reader);

                    break;

                case PipFingerprintEntryKind.FileDownload:
                    deserialized = Deserialize <FileDownloadDescriptor> .From(reader);

                    break;

                case PipFingerprintEntryKind.PackageDownload:
                    deserialized = Deserialize <PackageDownloadDescriptor> .From(reader);

                    break;

                case PipFingerprintEntryKind.GraphInputDescriptor:
                    deserialized = Deserialize <PipGraphInputDescriptor> .From(reader);

                    break;

                default:
                    throw Contract.AssertFailure("Unhandled PipFingerprintEntryKind");
                }

                Interlocked.CompareExchange(ref m_deserializedEntryData, deserialized, comparand: null);
                return(Volatile.Read(ref m_deserializedEntryData));
            }
            catch (Exception exception)
            {
                if (IsCorrupted)
                {
                    OutputBuffer valueBuffer = new OutputBuffer(1024);
                    CompactBinaryWriter <OutputBuffer> writer = new CompactBinaryWriter <OutputBuffer>(valueBuffer);
                    Serialize.To(writer, this);

                    // Include in the log the hash of this instance so that we can trace it in the cache log, and obtain the file in the CAS.
                    ContentHash valueHash = ContentHashingUtilities.HashBytes(
                        valueBuffer.Data.Array,
                        valueBuffer.Data.Offset,
                        valueBuffer.Data.Count);

                    const string Unspecified     = "<Unspecified>";
                    string       actualEntryBlob = Unspecified;
                    string       actualEntryHash = Unspecified;

                    if (cacheQueryData != null && cacheQueryData.ContentCache != null)
                    {
                        var maybeActualContent = cacheQueryData.ContentCache.TryLoadContent(
                            cacheQueryData.MetadataHash,
                            failOnNonSeekableStream: true,
                            byteLimit: 20 * 1024 * 1024).Result;

                        if (maybeActualContent.Succeeded && maybeActualContent.Result != null)
                        {
                            actualEntryBlob = ToByteArrayString(maybeActualContent.Result);
                            actualEntryHash = ContentHashingUtilities.HashBytes(maybeActualContent.Result).ToString();
                        }
                    }

                    Logger.Log.DeserializingCorruptedPipFingerprintEntry(
                        Events.StaticContext,
                        kind: Kind.ToString(),
                        weakFingerprint: cacheQueryData?.WeakContentFingerprint.ToString() ?? Unspecified,
                        pathSetHash: cacheQueryData?.PathSetHash.ToString() ?? Unspecified,
                        strongFingerprint: cacheQueryData?.StrongContentFingerprint.ToString() ?? Unspecified,
                        expectedHash: cacheQueryData?.MetadataHash.ToString() ?? Unspecified, // expected metadata hash
                        hash: valueHash.ToString(),                                           // re-computed hash
                        blob: ToDataBlobString(),                                             // blob of data carried by pip fingerprint entry
                        actualHash: actualEntryHash,                                          // actual pip fingerprint entry hash
                        actualEntryBlob: actualEntryBlob);                                    // actual pip fingerprint entry blob

                    throw new BuildXLException("Deserializing corrupted pip fingerprint entry", exception, ExceptionRootCause.CorruptedCache);
                }

                // We don't expect this to happen so rethrow the exception.
                throw;
            }
        }