Esempio n. 1
0
        private static void AddStreamType <T>()
        {
            var        type   = typeof(T);
            MethodInfo reader = null;
            MethodInfo writer = null;
            MethodInfo skiper = null;

            foreach (var method in typeof(BinStreamExtensions).GetMethods())
            {
                var attrib = method.GetCustomAttribute <BinStreamExtensionAttribute>(false);
                if (attrib == null || attrib.Type != type)
                {
                    continue;
                }

                switch (attrib.Kind)
                {
                case StreamExtensionKind.Read: reader = method; break;

                case StreamExtensionKind.Write: writer = method; break;

                case StreamExtensionKind.Skip: skiper = method; break;
                }
            }

            var description = new BinTypeDescription(type, type.Name);
            var version     = new BinTypeVersion(0, 0);
            var process     = BinTypeProcess.CreateStreamProcess(writer, reader, skiper);

            AddTypeImpl(description, version, process);
        }
Esempio n. 2
0
        private static void AddType(Type type)
        {
            string     name   = null;
            MethodInfo reader = null;
            MethodInfo writer = null;

            foreach (var method in typeof(BinTypeExtensions).GetMethods())
            {
                var attrib = method.GetCustomAttribute <BinTypeExtensionAttribute>(false);
                if (attrib == null || attrib.Type != type)
                {
                    continue;
                }

                name = attrib.Name;
                switch (attrib.Kind)
                {
                case TypeExtensionKind.Read: reader = method; break;

                case TypeExtensionKind.Write: writer = method; break;
                }
            }

            var description = new BinTypeDescription(type, name);
            var version     = new BinTypeVersion(0, 0);
            var process     = BinTypeProcess.Create(writer, reader);

            AddTypeImpl(description, version, process);
        }
        public ArraySerializerTypeInfo(BinTypeDescription description, BinTypeVersion version, BinTypeProcess process)
            : base(description, version, process)
        {
            if (description.Type != typeof(Array))
            {
                throw new ArgumentException("Type must be an array.");
            }

            if (!string.Equals(description.TypeId, SerializerTypes.ArrayToken, StringComparison.Ordinal))
            {
                throw new ArgumentException("TypeId must be an array.");
            }
        }
Esempio n. 4
0
        public SerializerTypeInfo(BinTypeDescription description, BinTypeVersion version, BinTypeProcess process)
        {
            // Check
            if (description == null)
            {
                throw new ArgumentNullException("description");
            }
            if (version == null)
            {
                throw new ArgumentNullException("version");
            }

            // Set
            Type   = description.Type;
            TypeId = description.TypeId;

            Version             = version.Version;
            MinSupportedVersion = version.MinSipportedVersion;

            if (process != null)
            {
                StreamWriter = process.StreamWriter;
                StreamReader = process.StreamReader;
                StreamSkiper = process.StreamSkiper;

                _typeWriter = process.TypeWriter;
                _typeReader = process.TypeReader;
            }
        }
Esempio n. 5
0
 public static void AddType(BinTypeDescription description, BinTypeVersion version, BinTypeProcess process)
 {
     Locker.EnterWriteLock();
     try
     {
         AddTypeImpl(description, version, process);
     }
     finally
     {
         Locker.ExitWriteLock();
     }
 }
Esempio n. 6
0
        private static void AddTypeImpl(BinTypeDescription description, BinTypeVersion version, BinTypeProcess process)
        {
            if (TypesById.ContainsKey(description.TypeId))
            {
                throw new InvalidOperationException(string.Format("TypeInfo with this id already exist {0} by type {1}.", description.TypeId, description.Type));
            }

            if (TypesByType.ContainsKey(description.Type))
            {
                throw new InvalidOperationException(string.Format("TypeInfo with this Type already exist {0} by id {1}.", description.Type, description.TypeId));
            }

            if (description.Type.IsArray)
            {
                throw new ArgumentException("Can't register array.");
            }

            if (process != null && !process.IsValid(description.Type))
            {
                throw new ArgumentException("Process is not valid");
            }

            SerializerTypeInfo typeInfo;

            if (description.Type == typeof(Array))
            {
                typeInfo = new ArraySerializerTypeInfo(description, version, process);
            }
            else if (description.Type.IsGenericType)
            {
                typeInfo = new GenericSerializerTypeInfo(description, version, process);
            }
            else
            {
                typeInfo = new SerializerTypeInfo(description, version, process);
            }

            TypesById.Add(description.TypeId, typeInfo);
            TypesByType.Add(description.Type, typeInfo);
        }
Esempio n. 7
0
        public GenericSerializerTypeInfo(BinTypeDescription description, BinTypeVersion version, BinTypeProcess process)
            : base(description, version, process)
        {
            if (!Type.IsGenericType)
            {
                throw new ArgumentException("Type must be generic.");
            }

            if (!Type.IsGenericTypeDefinition)
            {
                throw new ArgumentException("Generic type must be opened.");
            }

            if (IsGenericTypeId(TypeId))
            {
                throw new ArgumentException("Type id must be declared as non generic");
            }
        }