Example #1
0
        public void Read(ObjectReader reader)
        {
            var type                  = reader.ReadType().UnderlyingType;
            var methodName            = reader.PrimitiveReader.ReadString();
            var genericArgumentsCount = reader.PrimitiveReader.ReadInt32();
            var genericArguments      = new Type[genericArgumentsCount];

            for (int i = 0; i < genericArgumentsCount; i++)
            {
                genericArguments[i] = reader.ReadType().UnderlyingType;
            }

            var parametersCount = reader.PrimitiveReader.ReadInt32();

            if (genericArgumentsCount > 0)
            {
                var parameters = new TypeOrGenericTypeArgument[parametersCount];
                for (int i = 0; i < parameters.Length; i++)
                {
                    var genericType = reader.PrimitiveReader.ReadBoolean();
                    parameters[i] = genericType ?
                                    new TypeOrGenericTypeArgument(reader.PrimitiveReader.ReadInt32()) :
                                    new TypeOrGenericTypeArgument(reader.ReadType().UnderlyingType);
                }

                UnderlyingMethod = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).SingleOrDefault(m =>
                                                                                                                                                               m.IsGenericMethod &&
                                                                                                                                                               m.GetGenericMethodDefinition().Name == methodName &&
                                                                                                                                                               m.GetGenericArguments().Length == genericArgumentsCount &&
                                                                                                                                                               CompareGenericArguments(m.GetGenericMethodDefinition().GetParameters(), parameters));

                if (UnderlyingMethod != null)
                {
                    UnderlyingMethod = UnderlyingMethod.MakeGenericMethod(genericArguments);
                }
            }
            else
            {
                var types = new Type[parametersCount];
                for (int i = 0; i < types.Length; i++)
                {
                    types[i] = reader.ReadType().UnderlyingType;
                }

                UnderlyingMethod = type.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, types, null);
            }
        }
        public void Read(ObjectReader reader)
        {
            var type = reader.ReadType().UnderlyingType;
            var methodName = reader.PrimitiveReader.ReadString();
            var genericArgumentsCount = reader.PrimitiveReader.ReadInt32();
            var genericArguments = new Type[genericArgumentsCount];
            for(int i = 0; i < genericArgumentsCount; i++)
            {
                genericArguments[i] = reader.ReadType().UnderlyingType;
            }

            var parametersCount = reader.PrimitiveReader.ReadInt32();
            if(genericArgumentsCount > 0)
            {
                var parameters = new TypeOrGenericTypeArgument[parametersCount];
                for(int i = 0; i < parameters.Length; i++)
                {
                    var genericType = reader.PrimitiveReader.ReadBoolean();
                    parameters[i] = genericType ? 
                        new TypeOrGenericTypeArgument(reader.PrimitiveReader.ReadInt32()) :
                        new TypeOrGenericTypeArgument(reader.ReadType().UnderlyingType);
                }

                UnderlyingMethod = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).SingleOrDefault(m => 
                    m.IsGenericMethod && 
                    m.GetGenericMethodDefinition().Name == methodName && 
                    m.GetGenericArguments().Length == genericArgumentsCount && 
                    CompareGenericArguments(m.GetGenericMethodDefinition().GetParameters(), parameters));

                if(UnderlyingMethod != null)
                {
                    UnderlyingMethod = UnderlyingMethod.MakeGenericMethod(genericArguments);
                }
            }
            else
            {
                var types = new Type[parametersCount];
                for(int i = 0; i < types.Length; i++)
                {
                    types[i] = reader.ReadType().UnderlyingType;
                }

                UnderlyingMethod = type.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, types, null);
            }
        }
        private static bool CompareGenericArguments(ParameterInfo[] actual, TypeOrGenericTypeArgument[] expected)
        {
            if(actual.Length != expected.Length)
            {
                return false;
            }

            for(int i = 0; i < actual.Length; i++)
            {
                if(actual[i].ParameterType.IsGenericParameter)
                {
                    if(actual[i].ParameterType.GenericParameterPosition != expected[i].GenericTypeArgumentIndex)
                    {
                        return false;
                    }
                }
                else
                {
                    if(actual[i].ParameterType != expected[i].Type)
                    {
                        return false;
                    }
                }
            }

            return true;
        }