From f31948368a866668c124b6849fde92272f8cdf3e Mon Sep 17 00:00:00 2001 From: yfakariya Date: Tue, 2 May 2017 23:36:09 +0900 Subject: [PATCH 1/4] Change version. --- build/Version.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build/Version.txt b/build/Version.txt index d1df9128d..1a7ab5633 100644 --- a/build/Version.txt +++ b/build/Version.txt @@ -1 +1 @@ -0.9.0-beta2 \ No newline at end of file +0.9.0-rc1 \ No newline at end of file From ef95185be552d4494218d72eeec8495a7990ed94 Mon Sep 17 00:00:00 2001 From: yfakariya Date: Sun, 30 Apr 2017 20:44:27 +0900 Subject: [PATCH 2/4] Fix typo --- samples/Samples/Sample07_ConstructorBasedDeserialization.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/samples/Samples/Sample07_ConstructorBasedDeserialization.cs b/samples/Samples/Sample07_ConstructorBasedDeserialization.cs index 8f5aa841f..c18891670 100644 --- a/samples/Samples/Sample07_ConstructorBasedDeserialization.cs +++ b/samples/Samples/Sample07_ConstructorBasedDeserialization.cs @@ -40,7 +40,7 @@ public void DoConstructorBasedDeserialization() { // As of 0.8, constructor based deserialization is relaxed. // 1. If the type have a constructor with MessagePackDeserializationConstructorAttribute, then it will be used for deserialization. - // 2. Else, ff the type have a default public constructor then it will be used for deserialization. + // 2. Else, if the type have a default public constructor then it will be used for deserialization. // 3. Otherwise, most parameterful constructor will be used. var serializerForSimpleRecord = MessagePackSerializer.Get(); From cbd4add6a4351ec0548083df07a7da22dae6de47 Mon Sep 17 00:00:00 2001 From: yfakariya Date: Sun, 30 Apr 2017 20:45:20 +0900 Subject: [PATCH 3/4] Fix wrong code generation for constructor based deserialization. #233 This commit fixes wrong code generation due to strange name calculation bug. --- CHANGES.txt | 5 ++ .../SerializerBuilder`2.Object.cs | 14 +--- ...deDomBasedAutoMessagePackSerializerTest.cs | 25 ++++++ ...deDomBasedAutoMessagePackSerializerTest.cs | 81 ++++++++++++++++++- ...FieldBasedAutoMessagePackSerializerTest.cs | 25 ++++++ ...ationBasedAutoMessagePackSerializerTest.cs | 25 ++++++ ...ctionBasedAutoMessagePackSerializerTest.cs | 25 ++++++ .../AutoMessagePackSerializerTest.Types.cs | 20 +++++ .../AutoMessagePackSerializerTest.Types.tt | 20 +++++ .../AutoMessagePackSerializerTest.ttinclude | 25 ++++++ ...FieldBasedAutoMessagePackSerializerTest.cs | 25 ++++++ ...ationBasedAutoMessagePackSerializerTest.cs | 25 ++++++ ...ctionBasedAutoMessagePackSerializerTest.cs | 25 ++++++ 13 files changed, 326 insertions(+), 14 deletions(-) diff --git a/CHANGES.txt b/CHANGES.txt index 533c0e271..9d0c73f67 100644 --- a/CHANGES.txt +++ b/CHANGES.txt @@ -640,3 +640,8 @@ Release 0.9.0 beta2 2017/2/12 * Fix null items of complex type in List or Dictionary will not be deserialized as null. Issue #211. (from 0.8.1) * Fix types which implement IPackable and IUnpackable but do not have any members cannot be serialized. Issue #202 * Fix Windows Native build error. Issue #206. + +Release 0.9.0 RC1 T.B.D. + + BUG FIXES + * Fix constructor deserialization fails if the constructor parameters order is not lexical. Issue #233 diff --git a/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Object.cs b/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Object.cs index 309adf1ac..38f3c14de 100644 --- a/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Object.cs +++ b/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Object.cs @@ -845,12 +845,6 @@ private TConstruct EmitObjectUnpackFromCore( TContext context, SerializationTarg #endif // FEATURE_TAP ; - int constructorParameterIndex = 0; - var fieldNames = - targetInfo.IsConstructorDeserialization - ? targetInfo.DeserializationConstructor.GetParameters().Select( p => p.Name ).ToArray() - : targetInfo.Members.Where( m => m.MemberName != null ).Select( m => m.MemberName ).ToArray(); - for ( int i = 0; i < targetInfo.Members.Count; i++ ) { var count = i; @@ -881,6 +875,8 @@ private TConstruct EmitObjectUnpackFromCore( TContext context, SerializationTarg } else { + var name = targetInfo.Members[ count ].MemberName; + Contract.Assert( !String.IsNullOrEmpty( name ), targetInfo.Members[ count ] + "@" + i + " does not have member name."); var unpackedItem = context.DefineUnpackedItemParameterInSetValueMethods( targetInfo.Members[ count ].Member.GetMemberValueType() ); Func storeValueStatementEmitter; @@ -892,7 +888,7 @@ private TConstruct EmitObjectUnpackFromCore( TContext context, SerializationTarg context, context.UnpackingContextInSetValueMethods, Metadata._DynamicUnpackingContext.Set, - this.MakeStringLiteral( context, fieldNames[ count ] ), + this.MakeStringLiteral( context, name ), targetInfo.Members[ count ].Member.GetMemberValueType().GetIsValueType() ? this.EmitBoxExpression( context, @@ -903,11 +899,9 @@ targetInfo.Members[ count ].Member.GetMemberValueType().GetIsValueType() } else if ( targetInfo.IsConstructorDeserialization || this.TargetType.GetIsValueType() ) { - var name = fieldNames[ constructorParameterIndex ]; storeValueStatementEmitter = () => this.EmitSetField( context, context.UnpackingContextInSetValueMethods, unpackingContext.Type, name, unpackedItem ); - constructorParameterIndex++; } else { @@ -1013,7 +1007,7 @@ private UnpackingContextInfo EmitObjectUnpackingContextInitialization( TContext { var constructorParameters = targetInfo.DeserializationConstructor.GetParameters(); var contextFields = - constructorParameters.Select( p => new KeyValuePair( p.Name, p.ParameterType ) ).ToArray(); + constructorParameters.Select( ( p, i ) => new KeyValuePair( targetInfo.GetCorrespondingMemberName( i ) ?? ( "__OrphanParameter" + i.ToString( CultureInfo.InvariantCulture ) ), p.ParameterType ) ).ToArray(); var constructorArguments = new List( constructorParameters.Length ); var mappableConstructorArguments = new HashSet(); var initializationStatements = diff --git a/test/MsgPack.UnitTest.CodeDom/Serialization/ArrayCodeDomBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest.CodeDom/Serialization/ArrayCodeDomBasedAutoMessagePackSerializerTest.cs index 1efd4071e..190c48b3b 100644 --- a/test/MsgPack.UnitTest.CodeDom/Serialization/ArrayCodeDomBasedAutoMessagePackSerializerTest.cs +++ b/test/MsgPack.UnitTest.CodeDom/Serialization/ArrayCodeDomBasedAutoMessagePackSerializerTest.cs @@ -3855,6 +3855,31 @@ public void TestOptionalConstructorString_Success() } } + // Issue233 + [Test] + public void TestConstructorDeserializationWithParametersNotInLexicalOrder() + { + var endpoints = + new EndpointList( + "Test String One", + new Dictionary + { + { "ConfigService", new [] { "ur1", "ur2" } }, + { "TestService", new [] { "ur1", "ur2" } } + }, + "Test String Two" + ); + + var context = new SerializationContext(); + var ser = context.GetSerializer(); + var bytes = ser.PackSingleObject( endpoints ); + var endpointsDeser = ser.UnpackSingleObject( bytes ); + + Assert.That( endpointsDeser.StringOne, Is.EqualTo( endpoints.StringOne ) ); + Assert.That( endpointsDeser.StringTwo, Is.EqualTo( endpoints.StringTwo ) ); + Assert.That( endpointsDeser.Endpoints, Is.EqualTo( endpoints.Endpoints ) ); + } + [Test] public void TestCollection_Success() { diff --git a/test/MsgPack.UnitTest.CodeDom/Serialization/MapCodeDomBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest.CodeDom/Serialization/MapCodeDomBasedAutoMessagePackSerializerTest.cs index c015ee34b..b0a450c2d 100644 --- a/test/MsgPack.UnitTest.CodeDom/Serialization/MapCodeDomBasedAutoMessagePackSerializerTest.cs +++ b/test/MsgPack.UnitTest.CodeDom/Serialization/MapCodeDomBasedAutoMessagePackSerializerTest.cs @@ -3932,6 +3932,31 @@ public void TestOptionalConstructorString_Success() } } + // Issue233 + [Test] + public void TestConstructorDeserializationWithParametersNotInLexicalOrder() + { + var endpoints = + new EndpointList( + "Test String One", + new Dictionary + { + { "ConfigService", new [] { "ur1", "ur2" } }, + { "TestService", new [] { "ur1", "ur2" } } + }, + "Test String Two" + ); + + var context = new SerializationContext(); + var ser = context.GetSerializer(); + var bytes = ser.PackSingleObject( endpoints ); + var endpointsDeser = ser.UnpackSingleObject( bytes ); + + Assert.That( endpointsDeser.StringOne, Is.EqualTo( endpoints.StringOne ) ); + Assert.That( endpointsDeser.StringTwo, Is.EqualTo( endpoints.StringTwo ) ); + Assert.That( endpointsDeser.Endpoints, Is.EqualTo( endpoints.Endpoints ) ); + } + [Test] public void TestCollection_Success() { @@ -21081,25 +21106,73 @@ public void TestUriFieldArrayNull() } [Test] - public void TestVersionField() + public void TestVersionConstructorMajorMinor() + { + this.TestCoreWithAutoVerify( new Version( 1, 2 ), GetSerializationContext() ); + } + + [Test] + public void TestVersionConstructorMajorMinorArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Version( 1, 2 ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestVersionConstructorMajorMinorNull() + { + this.TestCoreWithAutoVerify( default( Version ), GetSerializationContext() ); + } + + [Test] + public void TestVersionConstructorMajorMinorArrayNull() + { + this.TestCoreWithAutoVerify( default( Version[] ), GetSerializationContext() ); + } + + [Test] + public void TestVersionConstructorMajorMinorBuild() + { + this.TestCoreWithAutoVerify( new Version( 1, 2, 3 ), GetSerializationContext() ); + } + + [Test] + public void TestVersionConstructorMajorMinorBuildArray() + { + this.TestCoreWithAutoVerify( Enumerable.Repeat( new Version( 1, 2, 3 ), 2 ).ToArray(), GetSerializationContext() ); + } + + [Test] + public void TestVersionConstructorMajorMinorBuildNull() + { + this.TestCoreWithAutoVerify( default( Version ), GetSerializationContext() ); + } + + [Test] + public void TestVersionConstructorMajorMinorBuildArrayNull() + { + this.TestCoreWithAutoVerify( default( Version[] ), GetSerializationContext() ); + } + + [Test] + public void TestFullVersionConstructor() { this.TestCoreWithAutoVerify( new Version( 1, 2, 3, 4 ), GetSerializationContext() ); } [Test] - public void TestVersionFieldArray() + public void TestFullVersionConstructorArray() { this.TestCoreWithAutoVerify( Enumerable.Repeat( new Version( 1, 2, 3, 4 ), 2 ).ToArray(), GetSerializationContext() ); } [Test] - public void TestVersionFieldNull() + public void TestFullVersionConstructorNull() { this.TestCoreWithAutoVerify( default( Version ), GetSerializationContext() ); } [Test] - public void TestVersionFieldArrayNull() + public void TestFullVersionConstructorArrayNull() { this.TestCoreWithAutoVerify( default( Version[] ), GetSerializationContext() ); } diff --git a/test/MsgPack.UnitTest/Serialization/ArrayFieldBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest/Serialization/ArrayFieldBasedAutoMessagePackSerializerTest.cs index 233271147..10c2024a3 100644 --- a/test/MsgPack.UnitTest/Serialization/ArrayFieldBasedAutoMessagePackSerializerTest.cs +++ b/test/MsgPack.UnitTest/Serialization/ArrayFieldBasedAutoMessagePackSerializerTest.cs @@ -3855,6 +3855,31 @@ public void TestOptionalConstructorString_Success() } } + // Issue233 + [Test] + public void TestConstructorDeserializationWithParametersNotInLexicalOrder() + { + var endpoints = + new EndpointList( + "Test String One", + new Dictionary + { + { "ConfigService", new [] { "ur1", "ur2" } }, + { "TestService", new [] { "ur1", "ur2" } } + }, + "Test String Two" + ); + + var context = new SerializationContext(); + var ser = context.GetSerializer(); + var bytes = ser.PackSingleObject( endpoints ); + var endpointsDeser = ser.UnpackSingleObject( bytes ); + + Assert.That( endpointsDeser.StringOne, Is.EqualTo( endpoints.StringOne ) ); + Assert.That( endpointsDeser.StringTwo, Is.EqualTo( endpoints.StringTwo ) ); + Assert.That( endpointsDeser.Endpoints, Is.EqualTo( endpoints.Endpoints ) ); + } + [Test] public void TestCollection_Success() { diff --git a/test/MsgPack.UnitTest/Serialization/ArrayGenerationBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest/Serialization/ArrayGenerationBasedAutoMessagePackSerializerTest.cs index 83568e2e1..60198666c 100644 --- a/test/MsgPack.UnitTest/Serialization/ArrayGenerationBasedAutoMessagePackSerializerTest.cs +++ b/test/MsgPack.UnitTest/Serialization/ArrayGenerationBasedAutoMessagePackSerializerTest.cs @@ -908,6 +908,31 @@ public void TestNonZeroBoundMultidimensionalArray() #endif // !SILVERLIGHT + // Issue233 + [Test] + public void TestConstructorDeserializationWithParametersNotInLexicalOrder() + { + var endpoints = + new EndpointList( + "Test String One", + new Dictionary + { + { "ConfigService", new [] { "ur1", "ur2" } }, + { "TestService", new [] { "ur1", "ur2" } } + }, + "Test String Two" + ); + + var context = new SerializationContext(); + var ser = context.GetSerializer(); + var bytes = ser.PackSingleObject( endpoints ); + var endpointsDeser = ser.UnpackSingleObject( bytes ); + + Assert.That( endpointsDeser.StringOne, Is.EqualTo( endpoints.StringOne ) ); + Assert.That( endpointsDeser.StringTwo, Is.EqualTo( endpoints.StringTwo ) ); + Assert.That( endpointsDeser.Endpoints, Is.EqualTo( endpoints.Endpoints ) ); + } + [Test] public void TestCollection_Success() { diff --git a/test/MsgPack.UnitTest/Serialization/ArrayReflectionBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest/Serialization/ArrayReflectionBasedAutoMessagePackSerializerTest.cs index d5a33e51c..780aabd51 100644 --- a/test/MsgPack.UnitTest/Serialization/ArrayReflectionBasedAutoMessagePackSerializerTest.cs +++ b/test/MsgPack.UnitTest/Serialization/ArrayReflectionBasedAutoMessagePackSerializerTest.cs @@ -3855,6 +3855,31 @@ public void TestOptionalConstructorString_Success() } } + // Issue233 + [Test] + public void TestConstructorDeserializationWithParametersNotInLexicalOrder() + { + var endpoints = + new EndpointList( + "Test String One", + new Dictionary + { + { "ConfigService", new [] { "ur1", "ur2" } }, + { "TestService", new [] { "ur1", "ur2" } } + }, + "Test String Two" + ); + + var context = new SerializationContext(); + var ser = context.GetSerializer(); + var bytes = ser.PackSingleObject( endpoints ); + var endpointsDeser = ser.UnpackSingleObject( bytes ); + + Assert.That( endpointsDeser.StringOne, Is.EqualTo( endpoints.StringOne ) ); + Assert.That( endpointsDeser.StringTwo, Is.EqualTo( endpoints.StringTwo ) ); + Assert.That( endpointsDeser.Endpoints, Is.EqualTo( endpoints.Endpoints ) ); + } + [Test] public void TestCollection_Success() { diff --git a/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.Types.cs b/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.Types.cs index 8dfe00979..d46e402f2 100644 --- a/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.Types.cs +++ b/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.Types.cs @@ -14713,6 +14713,26 @@ public string GetValue() } #endregion -- Empty interfaces -- + + #region -- Issue 233 (constructor based deserialization when the parameters are not in lexicol order) -- + + public class EndpointList + { + public string StringOne { get; } + + public Dictionary Endpoints { get; } + + public string StringTwo { get; } + + public EndpointList( string stringOne, Dictionary endpoints, string stringTwo ) + { + StringOne = stringOne; + Endpoints = endpoints; + StringTwo = stringTwo; + } + } + + #endregion -- Issue 233 (constructor based deserialization when the parameters are not in lexicol order) -- } // Issue #108 diff --git a/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.Types.tt b/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.Types.tt index 4f4c13e78..7effbf099 100644 --- a/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.Types.tt +++ b/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.Types.tt @@ -2449,6 +2449,26 @@ if ( isAsync ) #> #endregion -- Empty interfaces -- + + #region -- Issue 233 (constructor based deserialization when the parameters are not in lexicol order) -- + + public class EndpointList + { + public string StringOne { get; } + + public Dictionary Endpoints { get; } + + public string StringTwo { get; } + + public EndpointList( string stringOne, Dictionary endpoints, string stringTwo ) + { + StringOne = stringOne; + Endpoints = endpoints; + StringTwo = stringTwo; + } + } + + #endregion -- Issue 233 (constructor based deserialization when the parameters are not in lexicol order) -- } // Issue #108 diff --git a/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.ttinclude b/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.ttinclude index 476499e76..5d3ed35d1 100644 --- a/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.ttinclude +++ b/test/MsgPack.UnitTest/Serialization/AutoMessagePackSerializerTest.ttinclude @@ -2069,6 +2069,31 @@ namespace MsgPack.Serialization } #> + // Issue233 + [Test] + public void TestConstructorDeserializationWithParametersNotInLexicalOrder() + { + var endpoints = + new EndpointList( + "Test String One", + new Dictionary + { + { "ConfigService", new [] { "ur1", "ur2" } }, + { "TestService", new [] { "ur1", "ur2" } } + }, + "Test String Two" + ); + + var context = new SerializationContext(); + var ser = context.GetSerializer(); + var bytes = ser.PackSingleObject( endpoints ); + var endpointsDeser = ser.UnpackSingleObject( bytes ); + + Assert.That( endpointsDeser.StringOne, Is.EqualTo( endpoints.StringOne ) ); + Assert.That( endpointsDeser.StringTwo, Is.EqualTo( endpoints.StringTwo ) ); + Assert.That( endpointsDeser.Endpoints, Is.EqualTo( endpoints.Endpoints ) ); + } + [Test] public void TestCollection_Success() { diff --git a/test/MsgPack.UnitTest/Serialization/MapFieldBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest/Serialization/MapFieldBasedAutoMessagePackSerializerTest.cs index 763d9caa1..548b9015d 100644 --- a/test/MsgPack.UnitTest/Serialization/MapFieldBasedAutoMessagePackSerializerTest.cs +++ b/test/MsgPack.UnitTest/Serialization/MapFieldBasedAutoMessagePackSerializerTest.cs @@ -3932,6 +3932,31 @@ public void TestOptionalConstructorString_Success() } } + // Issue233 + [Test] + public void TestConstructorDeserializationWithParametersNotInLexicalOrder() + { + var endpoints = + new EndpointList( + "Test String One", + new Dictionary + { + { "ConfigService", new [] { "ur1", "ur2" } }, + { "TestService", new [] { "ur1", "ur2" } } + }, + "Test String Two" + ); + + var context = new SerializationContext(); + var ser = context.GetSerializer(); + var bytes = ser.PackSingleObject( endpoints ); + var endpointsDeser = ser.UnpackSingleObject( bytes ); + + Assert.That( endpointsDeser.StringOne, Is.EqualTo( endpoints.StringOne ) ); + Assert.That( endpointsDeser.StringTwo, Is.EqualTo( endpoints.StringTwo ) ); + Assert.That( endpointsDeser.Endpoints, Is.EqualTo( endpoints.Endpoints ) ); + } + [Test] public void TestCollection_Success() { diff --git a/test/MsgPack.UnitTest/Serialization/MapGenerationBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest/Serialization/MapGenerationBasedAutoMessagePackSerializerTest.cs index 7a51418b8..8bcdc61b5 100644 --- a/test/MsgPack.UnitTest/Serialization/MapGenerationBasedAutoMessagePackSerializerTest.cs +++ b/test/MsgPack.UnitTest/Serialization/MapGenerationBasedAutoMessagePackSerializerTest.cs @@ -908,6 +908,31 @@ public void TestNonZeroBoundMultidimensionalArray() #endif // !SILVERLIGHT + // Issue233 + [Test] + public void TestConstructorDeserializationWithParametersNotInLexicalOrder() + { + var endpoints = + new EndpointList( + "Test String One", + new Dictionary + { + { "ConfigService", new [] { "ur1", "ur2" } }, + { "TestService", new [] { "ur1", "ur2" } } + }, + "Test String Two" + ); + + var context = new SerializationContext(); + var ser = context.GetSerializer(); + var bytes = ser.PackSingleObject( endpoints ); + var endpointsDeser = ser.UnpackSingleObject( bytes ); + + Assert.That( endpointsDeser.StringOne, Is.EqualTo( endpoints.StringOne ) ); + Assert.That( endpointsDeser.StringTwo, Is.EqualTo( endpoints.StringTwo ) ); + Assert.That( endpointsDeser.Endpoints, Is.EqualTo( endpoints.Endpoints ) ); + } + [Test] public void TestCollection_Success() { diff --git a/test/MsgPack.UnitTest/Serialization/MapReflectionBasedAutoMessagePackSerializerTest.cs b/test/MsgPack.UnitTest/Serialization/MapReflectionBasedAutoMessagePackSerializerTest.cs index eb378255b..f97485c3e 100644 --- a/test/MsgPack.UnitTest/Serialization/MapReflectionBasedAutoMessagePackSerializerTest.cs +++ b/test/MsgPack.UnitTest/Serialization/MapReflectionBasedAutoMessagePackSerializerTest.cs @@ -3932,6 +3932,31 @@ public void TestOptionalConstructorString_Success() } } + // Issue233 + [Test] + public void TestConstructorDeserializationWithParametersNotInLexicalOrder() + { + var endpoints = + new EndpointList( + "Test String One", + new Dictionary + { + { "ConfigService", new [] { "ur1", "ur2" } }, + { "TestService", new [] { "ur1", "ur2" } } + }, + "Test String Two" + ); + + var context = new SerializationContext(); + var ser = context.GetSerializer(); + var bytes = ser.PackSingleObject( endpoints ); + var endpointsDeser = ser.UnpackSingleObject( bytes ); + + Assert.That( endpointsDeser.StringOne, Is.EqualTo( endpoints.StringOne ) ); + Assert.That( endpointsDeser.StringTwo, Is.EqualTo( endpoints.StringTwo ) ); + Assert.That( endpointsDeser.Endpoints, Is.EqualTo( endpoints.Endpoints ) ); + } + [Test] public void TestCollection_Success() { From b627c2bf4e1ac5a9fb597985aeee8e0d5f0c9051 Mon Sep 17 00:00:00 2001 From: yfakariya Date: Sun, 30 Apr 2017 23:07:31 +0900 Subject: [PATCH 4/4] Remove unused DynamicUnpackingContext --- .../DynamicUnpackingContext.cs | 70 -------------- .../SerializerBuilder`2.Object.cs | 93 +++---------------- .../SerializerBuilder`2.Tuple.cs | 44 +++------ .../Metadata/_DynamicUnpackingContext.cs | 38 -------- 4 files changed, 22 insertions(+), 223 deletions(-) delete mode 100644 src/MsgPack/Serialization/AbstractSerializers/DynamicUnpackingContext.cs delete mode 100644 src/MsgPack/Serialization/Metadata/_DynamicUnpackingContext.cs diff --git a/src/MsgPack/Serialization/AbstractSerializers/DynamicUnpackingContext.cs b/src/MsgPack/Serialization/AbstractSerializers/DynamicUnpackingContext.cs deleted file mode 100644 index cb1d6197e..000000000 --- a/src/MsgPack/Serialization/AbstractSerializers/DynamicUnpackingContext.cs +++ /dev/null @@ -1,70 +0,0 @@ -#region -- License Terms -- -// -// MessagePack for CLI -// -// Copyright (C) 2015 FUJIWARA, Yusuke -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#endregion -- License Terms -- - -using System; -using System.Collections.Generic; -using System.Linq; -using System.Reflection; -#if FEATURE_TAP -using System.Threading; -#endif // FEATURE_TAP - -namespace MsgPack.Serialization.AbstractSerializers -{ - internal class DynamicUnpackingContext - { - private readonly Dictionary _bag; - - public object Get( string key ) - { - object result; - this._bag.TryGetValue( key, out result ); - return result; - } - - public void Set( string key, object value ) - { - this._bag[ key ] = value; - } - -#if FEATURE_TAP - - public CancellationToken CancellationToken - { - get; - private set; - } - -#endif // FEATURE_TAP - - public DynamicUnpackingContext( int capacity ) - { - this._bag = new Dictionary( capacity ); - } - -#if FEATURE_TAP - public DynamicUnpackingContext( int capacity, CancellationToken cancellationToken ) - :this( capacity ) - { - this.CancellationToken = cancellationToken; - } -#endif // FEATURE_TAP - } -} \ No newline at end of file diff --git a/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Object.cs b/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Object.cs index 38f3c14de..05392bdd4 100644 --- a/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Object.cs +++ b/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Object.cs @@ -880,24 +880,7 @@ private TConstruct EmitObjectUnpackFromCore( TContext context, SerializationTarg var unpackedItem = context.DefineUnpackedItemParameterInSetValueMethods( targetInfo.Members[ count ].Member.GetMemberValueType() ); Func storeValueStatementEmitter; - if ( unpackingContext.VariableType.TryGetRuntimeType() == typeof( DynamicUnpackingContext ) ) - { - storeValueStatementEmitter = - () => - this.EmitInvokeVoidMethod( - context, - context.UnpackingContextInSetValueMethods, - Metadata._DynamicUnpackingContext.Set, - this.MakeStringLiteral( context, name ), - targetInfo.Members[ count ].Member.GetMemberValueType().GetIsValueType() - ? this.EmitBoxExpression( - context, - unpackedItem.ContextType, - unpackedItem - ) : unpackedItem - ); - } - else if ( targetInfo.IsConstructorDeserialization || this.TargetType.GetIsValueType() ) + if ( targetInfo.IsConstructorDeserialization || this.TargetType.GetIsValueType() ) { storeValueStatementEmitter = () => @@ -1142,39 +1125,7 @@ IEnumerable argumentInitializers unpackingContext.Statements.AddRange( argumentInitializers ); unpackingContext.Statements.Add( - unpackingContext.VariableType.TryGetRuntimeType() == typeof( DynamicUnpackingContext ) - ? this.EmitSequentialStatements( - context, - TypeDefinition.VoidType, - new[] - { - this.EmitStoreVariableStatement( - context, - unpackingContext.Variable, - this.EmitCreateNewObjectExpression( - context, - unpackingContext.Variable, - unpackingContext.Constructor, - this.MakeInt32Literal( context, constructorArguments.Count ) - ) - ) - }.Concat( - constructorArguments.Select( ( a, i ) => - this.EmitInvokeVoidMethod( - context, - unpackingContext.Variable, - Metadata._DynamicUnpackingContext.Set, - this.MakeStringLiteral( context, contextFields[ i ].Key ), - a.ContextType.ResolveRuntimeType().GetIsValueType() - ? this.EmitBoxExpression( - context, - a.ContextType, - a - ) : a - ) - ) - ) - ) : this.EmitStoreVariableStatement( + this.EmitStoreVariableStatement( context, unpackingContext.Variable, this.EmitCreateNewObjectExpression( @@ -1218,26 +1169,15 @@ private IEnumerable EmitCreateObjectFromContextCore( context, result, member, - unpackingContext.VariableType.TryGetRuntimeType() == typeof( DynamicUnpackingContext ) - ? this.EmitUnboxAnyExpression( - context, - field.Value, - this.EmitInvokeMethodExpression( - context, - context.UnpackingContextInCreateObjectFromContext, - Metadata._DynamicUnpackingContext.Get, - this.MakeStringLiteral( context, field.Key ) - ) - ) - : this.EmitGetFieldExpression( - context, - context.UnpackingContextInCreateObjectFromContext, - new FieldDefinition( - unpackingContext.Type, - field.Key, - field.Value - ) + this.EmitGetFieldExpression( + context, + context.UnpackingContextInCreateObjectFromContext, + new FieldDefinition( + unpackingContext.Type, + field.Key, + field.Value ) + ) ); } @@ -1517,18 +1457,7 @@ private IEnumerable EmitInvokeDeserializationConstructorStatementsCo constructor, fields.Select( f => - unpackingContext.ContextType.TryGetRuntimeType() == typeof( DynamicUnpackingContext ) - ? this.EmitUnboxAnyExpression( - context, - f.Value, - this.EmitInvokeMethodExpression( - context, - unpackingContext, - Metadata._DynamicUnpackingContext.Get, - this.MakeStringLiteral( context, f.Key ) - ) - ) - : this.EmitGetFieldExpression( context, unpackingContext, new FieldDefinition( unpackingContext.ContextType, f.Key, f.Value ) ) + this.EmitGetFieldExpression( context, unpackingContext, new FieldDefinition( unpackingContext.ContextType, f.Key, f.Value ) ) ).ToArray() ) ); diff --git a/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Tuple.cs b/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Tuple.cs index 8ba8187f2..30244bb07 100644 --- a/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Tuple.cs +++ b/src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`2.Tuple.cs @@ -350,18 +350,8 @@ private IEnumerable BuildTupleUnpackFromCore( TContext context, ILis setUnpackValueOfMethodName, false, // isStatic TypeDefinition.VoidType, - () => unpackingContext.VariableType.TryGetRuntimeType() == typeof( DynamicUnpackingContext ) - ? this.EmitInvokeVoidMethod( - context, - context.UnpackingContextInSetValueMethods, - Metadata._DynamicUnpackingContext.Set, - this.MakeStringLiteral( context, propertyName ), - this.EmitBoxExpression( - context, - itemTypes[ index ], - unpackedItem - ) - ) : this.EmitSetField( + () => + this.EmitSetField( context, context.UnpackingContextInSetValueMethods, unpackingContext.VariableType, @@ -383,25 +373,15 @@ private IEnumerable BuildTupleUnpackFromCore( TContext context, ILis var gets = Enumerable.Range( nest * 7, Math.Min( itemTypes.Count - nest * 7, 7 ) ) .Select( i => - unpackingContext.VariableType.TryGetRuntimeType() == typeof( DynamicUnpackingContext ) - ? this.EmitUnboxAnyExpression( - context, - itemTypes[ i ], - this.EmitInvokeMethodExpression( - context, - context.UnpackingContextInCreateObjectFromContext, - Metadata._DynamicUnpackingContext.Get, - this.MakeStringLiteral( context, SerializationTarget.GetTupleItemNameFromIndex( i ) ) - ) - ) : this.EmitGetFieldExpression( - context, - context.UnpackingContextInCreateObjectFromContext, - new FieldDefinition( - unpackingContext.VariableType, - SerializationTarget.GetTupleItemNameFromIndex( i ), - itemTypes[ i ] - ) + this.EmitGetFieldExpression( + context, + context.UnpackingContextInCreateObjectFromContext, + new FieldDefinition( + unpackingContext.VariableType, + SerializationTarget.GetTupleItemNameFromIndex( i ), + itemTypes[ i ] ) + ) ); if ( currentTuple != null ) { @@ -499,9 +479,7 @@ out constructor context, unpackingContext.Variable, unpackingContext.Constructor, - unpackingContext.VariableType.TryGetRuntimeType() == typeof( DynamicUnpackingContext ) - ? new[] { this.MakeInt32Literal( context, itemTypes.Count ) } - : itemTypes.Select( t => this.MakeDefaultLiteral( context, t ) ).ToArray() + itemTypes.Select( t => this.MakeDefaultLiteral( context, t ) ).ToArray() ) ) ); diff --git a/src/MsgPack/Serialization/Metadata/_DynamicUnpackingContext.cs b/src/MsgPack/Serialization/Metadata/_DynamicUnpackingContext.cs deleted file mode 100644 index 43b51979a..000000000 --- a/src/MsgPack/Serialization/Metadata/_DynamicUnpackingContext.cs +++ /dev/null @@ -1,38 +0,0 @@ -#region -- License Terms -- -// -// MessagePack for CLI -// -// Copyright (C) 2015 FUJIWARA, Yusuke -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#endregion -- License Terms -- - -using System; -using System.Reflection; - -using MsgPack.Serialization.AbstractSerializers; - -// ReSharper disable InconsistentNaming - -namespace MsgPack.Serialization.Metadata -{ - internal static class _DynamicUnpackingContext - { - public static MethodInfo Get = - FromExpression.ToMethod( ( DynamicUnpackingContext @this, string key ) => @this.Get( key ) ); - - public static MethodInfo Set = - FromExpression.ToMethod( ( DynamicUnpackingContext @this, string key, object value ) => @this.Set( key, value ) ); - } -}