示例#1
0
        public void CustomSerializerWorksWithTVPs()
        {
            DbSerializationRule.Serialize <EncodedInt>(new EncodedTypeSerializer());

            var e = new EncodedInt()
            {
                Encoded = "Two"
            };
            var o = new TestWithSerializedObject()
            {
                Encoded = e
            };
            var data = new List <TestWithSerializedObject>()
            {
                o
            };

            try
            {
                Connection().ExecuteSql("CREATE TYPE TestTableWithEncodedInt AS TABLE (Encoded int)");

                using (var c = Connection().OpenWithTransaction())
                {
                    c.ExecuteSql("CREATE PROC TestEncoded(@Encoded [TestTableWithEncodedInt] READONLY) AS SELECT * FROM @Encoded");
                    var e2 = c.Query <TestWithSerializedObject>("TestEncoded", new { Encoded = data }).First();
                    Assert.AreEqual(e.Encoded, e2.Encoded.Encoded);
                }
            }
            finally
            {
                Connection().ExecuteSql("DROP TYPE TestTableWithEncodedInt");
            }
        }
示例#2
0
        public void CustomSerializerWorksWithOtherTypes()
        {
            DbSerializationRule.Serialize <EncodedInt>("Encoded", new EncodedIntSerializer());

            using (var c = Connection().OpenWithTransaction())
            {
                var e = new EncodedInt()
                {
                    Encoded = "Two"
                };

                c.ExecuteSql("CREATE PROC TestEncoded(@Encoded int) AS SELECT Encoded=@Encoded");
                var e2 = c.Query <EncodedInt>("TestEncoded", e).First();
                Assert.AreEqual(e.Encoded, e2.Encoded);
            }
        }
示例#3
0
        public void CustomSerializerWorksWithXmlFields()
        {
            var customSerializer = new CustomXmlSerializer();

            DbSerializationRule.Serialize <EncodedInt>(customSerializer);

            var e = new EncodedInt()
            {
                Encoded = "Two"
            };

            using (var c = Connection().OpenWithTransaction())
            {
                c.ExecuteSql("CREATE PROC TestEncodedXml(@Encoded [Xml]) AS SELECT Encoded=@Encoded");
                var e2 = c.Query <TestWithSerializedObject>("TestEncodedXml", new { Encoded = e }).First();
                Assert.AreEqual(e.Encoded, e2.Encoded.Encoded);
            }

            Assert.IsTrue(customSerializer.DidSerialize);
            Assert.IsTrue(customSerializer.DidDeserialize);
        }
		public void CustomSerializerWorksWithTVPs()
		{
			DbSerializationRule.Serialize<EncodedInt>(new EncodedTypeSerializer());

			var e = new EncodedInt() { Encoded = "Two" };
			var o = new TestWithSerializedObject() { Encoded = e };
			var data = new List<TestWithSerializedObject>() { o };

			try
			{
				Connection().ExecuteSql("CREATE TYPE TestTableWithEncodedInt AS TABLE (Encoded int)");

				using (var c = Connection().OpenWithTransaction())
				{
					c.ExecuteSql("CREATE PROC TestEncoded(@Encoded [TestTableWithEncodedInt] READONLY) AS SELECT * FROM @Encoded");
					var e2 = c.Query<TestWithSerializedObject>("TestEncoded", new { Encoded = data }).First();
					Assert.AreEqual(e.Encoded, e2.Encoded.Encoded);
				}
			}
			finally
			{
				Connection().ExecuteSql("DROP TYPE TestTableWithEncodedInt");
			}
		}
        public void CustomSerializerWorksWithOtherTypes()
        {
            DbSerializationRule.Serialize<EncodedInt>("Encoded", new EncodedIntSerializer());

            using (var c = Connection().OpenWithTransaction())
            {
                var e = new EncodedInt() { Encoded = "Two" };

                c.ExecuteSql("CREATE PROC TestEncoded(@Encoded int) AS SELECT Encoded=@Encoded");
                var e2 = c.Query<EncodedInt>("TestEncoded", e).First();
                Assert.AreEqual(e.Encoded, e2.Encoded);
            }
        }
示例#6
0
            public bool Read(BinaryReader br)
            {
                u8 prefix = br.ReadByte();

                if (prefix != PREFIX_SIZE)
                {
                    return(false);
                }

                EncodedInt encSize = new EncodedInt();

                encSize.Read(br);

                u32 size_expected = encSize.Value;
                u32 size_read     = 0;

                bool reading_items = false;

                prefix = br.ReadByte();
                size_read++;

                switch (prefix)
                {
                case PREFIX_ITEM_ID:
                    reading_items = true;
                    break;

                case PREFIX_CLIENT_KEY:
                    break;

                default:
                    return(false);
                }

                if (reading_items)
                {
                    EncodedInt encId = new EncodedInt();
                    encId.Read(br);
                    item_id    = encId.Value;
                    size_read += encId.Length();

                    if (size_read == size_expected)
                    {
                        return(true);
                    }

                    prefix = br.ReadByte();
                    size_read++;

                    if (prefix != PREFIX_ITEM_NAME)
                    {
                        return(false);
                    }
                }

                EncodedInt encName = new EncodedInt();

                encName.Read(br);

                name       = DecodeString(br, encName.Value);
                size_read += encName.Value + encName.Length();

                if (size_read == size_expected)
                {
                    return(true);
                }

                prefix = br.ReadByte();
                size_read++;

                if (reading_items)
                {
                    if (prefix != PREFIX_ITEM_VALUE)
                    {
                        return(false);
                    }
                }
                else if (prefix != PREFIX_CLIENT_VAL)
                {
                    return(false);
                }

                EncodedInt encValue = new EncodedInt();

                encValue.Read(br);
                value = DecodeString(br, encValue.Value);

                size_read += encValue.Value + encValue.Length();;

                if (size_read != size_expected)
                {
                    return(false);
                }

                return(true);
            }
示例#7
0
            public bool Write(BinaryWriter bw)
            {
                byte[] name_encoded  = EncodeString(name);
                byte[] value_encoded = EncodeString(value);

                EncodedInt encName  = new EncodedInt((u32)name_encoded.Length);
                EncodedInt encValue = new EncodedInt((u32)value_encoded.Length);

                u32 total_size = 0;

                EncodedInt encItem = null;

                if (item_id != 0)
                {
                    encItem     = new EncodedInt(item_id);
                    total_size += 1 + encItem.Length();
                }

                if (encName.Value > 0)
                {
                    total_size += 1 + encName.Length() + encName.Value;
                }

                if (encValue.Value > 0)
                {
                    total_size += 1 + encValue.Length() + encValue.Value;
                }

                // write total size
                EncodedInt encTotal = new EncodedInt(total_size);

                bw.Write(PREFIX_SIZE);
                encTotal.Write(bw);

                if (encItem != null)
                {
                    // write item_id
                    bw.Write(PREFIX_ITEM_ID);
                    encItem.Write(bw);

                    // write name
                    if (encName.Value > 0)
                    {
                        bw.Write(PREFIX_ITEM_NAME);
                        encName.Write(bw);
                        bw.Write(name_encoded, 0, name_encoded.Length);
                    }

                    // write value
                    if (encValue.Value > 0)
                    {
                        bw.Write(PREFIX_ITEM_VALUE);
                        encValue.Write(bw);
                        bw.Write(value_encoded, 0, value_encoded.Length);
                    }
                }
                else
                {
                    // write name
                    if (encName.Value > 0)
                    {
                        bw.Write(PREFIX_CLIENT_KEY);
                        encName.Write(bw);
                        bw.Write(name_encoded, 0, name_encoded.Length);
                    }

                    // write value
                    if (encValue.Value > 0)
                    {
                        bw.Write(PREFIX_CLIENT_VAL);
                        encValue.Write(bw);
                        bw.Write(value_encoded, 0, value_encoded.Length);
                    }
                }

                return(true);
            }