static FormatterCache()
            {
                Type t = typeof(T);

                BssomFormatterAttribute attr = t.GetCustomAttribute <BssomFormatterAttribute>();

                if (attr == null)
                {
                    return;
                }

                Type formatterType = attr.FormatterType;

                if (formatterType.IsGenericType && !formatterType.IsConstructedGenericType)
                {
                    formatterType = formatterType.MakeGenericType(t.GetGenericArguments());
                }

                if (formatterType != t)
                {
                    throw BssomSerializationTypeFormatterException.AttributeFormatterTypeMismatch(formatterType, t);
                }

                if (attr.Arguments == null)
                {
                    Formatter = (IBssomFormatter <T>)Activator.CreateInstance(formatterType);
                }
                else
                {
                    Formatter = (IBssomFormatter <T>)Activator.CreateInstance(formatterType, attr.Arguments);
                }
            }
        //Size IEnumerable
        public static int SizeIEnumerable(ref BssomSizeContext context, IEnumerable value)
        {
            if (value == null)
            {
                return(BssomBinaryPrimitives.NullSize);
            }

            IBssomFormatter <object> formatter = context.Option.FormatterResolver.GetFormatterWithVerify <object>();

            long dataLen = 0;

            foreach (object item in value)
            {
                dataLen += formatter.Size(ref context, item);
            }

            if (value is ICollection coll)
            {
                return(BssomBinaryPrimitives.Array2TypeSize(coll.Count, dataLen));
            }
            else
            {
                return(BssomBinaryPrimitives.Array2TypeSizeWithFixU32Count(dataLen));
            }
        }
Beispiel #3
0
 static FormatterCache()
 {
     if (typeof(T) == typeof(object))
     {
         Formatter = (IBssomFormatter <T>)(IBssomFormatter) ObjectFormatter.Instance;
     }
 }
Beispiel #4
0
 static FormatterCache()
 {
     if (typeof(T) == typeof(string))
     {
         Formatter = (IBssomFormatter <T>)(object) MyStringFormatter.Instance;
     }
 }
            static FormatterCache()
            {
                Type t = typeof(T);

                if (Array1ResolverGetFormatterHelper.TryGetFormatter(t, out IBssomFormatter formatter))
                {
                    Formatter = (IBssomFormatter <T>)formatter;
                    return;
                }

                if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(ArraySegment <>))
                {
                    Formatter = (IBssomFormatter <T>)Activator.CreateInstance(typeof(ArraySegmentFormatter <>).MakeGenericType(t.GetGenericArguments()));
                    return;
                }

                if (TypeIsArray(t, out int rank, out Type elementType))
                {
                    if (rank == 1)
                    {
                        Formatter = (IBssomFormatter <T>)Activator.CreateInstance(typeof(OneDimensionalArrayFormatter <>).MakeGenericType(elementType));
                    }
                    else if (rank == 2)
                    {
                        Formatter = (IBssomFormatter <T>)Activator.CreateInstance(typeof(TwoDimensionalArrayFormatter <>).MakeGenericType(elementType));
                    }
                    else if (rank == 3)
                    {
                        Formatter = (IBssomFormatter <T>)Activator.CreateInstance(typeof(ThreeDimensionalArrayFormatter <>).MakeGenericType(elementType));
                    }
                    else if (rank == 4)
                    {
                        Formatter = (IBssomFormatter <T>)Activator.CreateInstance(typeof(FourDimensionalArrayFormatter <>).MakeGenericType(elementType));
                    }
                    else
                    {
                        throw BssomSerializationTypeFormatterException.UnsupportedType(t);
                    }
                    return;
                }

                if (TypeIsCollection(t,
                                     out ConstructorInfo constructor,
                                     out Type itemType,
                                     out bool isImplGenerIList, out bool IsImplIList, out bool isImplGenerICollec, out bool isImplIReadOnlyList))
                {
                    TypeInfo buildType;
                    if (t.IsInterface)
                    {
                        buildType = ICollectionFormatterTypeBuilder.BuildICollectionInterfaceType(DynamicAssembly, t, itemType);
                    }
                    else
                    {
                        buildType = ICollectionFormatterTypeBuilder.BuildICollectionImplementationType(DynamicAssembly, t, constructor, itemType, isImplGenerIList, IsImplIList, isImplGenerICollec, isImplIReadOnlyList);
                    }

                    Formatter = (IBssomFormatter <T>)Activator.CreateInstance(buildType);
                }
            }
        internal static bool TryGetFormatter(Type t, out IBssomFormatter formatter)
        {
            if (FormatterMap.TryGetValue(t, out formatter))
            {
                return(true);
            }

            return(false);
        }
Beispiel #7
0
            static FormatterCache()
            {
                Type t = typeof(T);

                if (PrimitiveResolverGetFormatterHelper.TryGetFormatter(t, out IBssomFormatter formatter))
                {
                    Formatter = (IBssomFormatter <T>)formatter;
                }
            }
            static FormatterCache()
            {
                Type t = typeof(T);

                if (BssomValueResolverGetFormatterHelper.TryGetFormatter(t, out IBssomFormatter formatter))
                {
                    Formatter = (IBssomFormatter <T>)formatter;
                    return;
                }
            }
 static FormatterCache()
 {
     foreach (IFormatterResolver item in Resolvers)
     {
         IBssomFormatter <T> f = item.GetFormatter <T>();
         if (f != null)
         {
             Formatter = f;
             return;
         }
     }
 }
Beispiel #10
0
            static FormatterCache()
            {
                Type t = typeof(T);

                if (BuildInResolverGetFormatterHelper.TryGetFormatter(t, out IBssomFormatter formatter))
                {
                    Formatter = (IBssomFormatter <T>)formatter;
                    return;
                }

                if (t.IsEnum)
                {
                    Formatter = EnumFormatter <T> .Instance;
                    return;
                }

                if (t.IsGenericType)
                {
                    Type genericType = t.GetGenericTypeDefinition();
                    if (genericType == typeof(Nullable <>))
                    {
                        Formatter = (IBssomFormatter <T>)Activator.CreateInstance(typeof(NullableFormatter <>).MakeGenericType(t.GetGenericArguments()));
                        return;
                    }
                    else if (genericType == typeof(Lazy <>))
                    {
                        Formatter = (IBssomFormatter <T>)Activator.CreateInstance(typeof(LazyFormatter <>).MakeGenericType(t.GetGenericArguments()));
                        return;
                    }
                    else if (genericType == typeof(IGrouping <,>))
                    {
                        Formatter = (IBssomFormatter <T>)Activator.CreateInstance(typeof(InterfaceGroupingFormatter <,>).MakeGenericType(t.GetGenericArguments()));
                        return;
                    }
                    else if (genericType == typeof(ILookup <,>))
                    {
                        Formatter = (IBssomFormatter <T>)Activator.CreateInstance(typeof(InterfaceILookupFormatter <,>).MakeGenericType(t.GetGenericArguments()));
                        return;
                    }
                }

                if (t.IsAnonymousType())
                {
                    Formatter = AnonymousTypeFormatter <T> .Instance;
                    return;
                }
            }
        //Serialize IEnumerable<>
        public static void SerializeGenericIEnumerable <TElement>(ref BssomWriter writer,
                                                                  ref BssomSerializeContext context, IEnumerable <TElement> value)
        {
            if (value == null)
            {
                writer.WriteNull();
                return;
            }

            IBssomFormatter <TElement> formatter = context.Option.FormatterResolver.GetFormatterWithVerify <TElement>();

            writer.WriteArray2Type();
            long pos = writer.FillUInt32FixNumber();

            if (value.TryGetICollectionCount(out int count))
            {
                writer.WriteVariableNumber(count);
                foreach (TElement item in value)
                {
                    context.CancellationToken.ThrowIfCancellationRequested();
                    formatter.Serialize(ref writer, ref context, item);
                }
                writer.WriteBackFixNumber(pos, checked ((int)(writer.Position - pos - BssomBinaryPrimitives.FixUInt32NumberSize)));
            }
            else
            {
                count = 0;
                long posCount = writer.FillUInt32FixNumber();
                foreach (TElement item in value)
                {
                    context.CancellationToken.ThrowIfCancellationRequested();
                    count++;
                    formatter.Serialize(ref writer, ref context, item);
                }
                long cPos = writer.Position;
                writer.BufferWriter.Seek(pos);
                writer.WriteBackFixNumber(checked ((int)(writer.Position - posCount)));
                writer.WriteBackFixNumber(count);
                writer.BufferWriter.Seek(cPos);
            }
        }
        //Serialize IList
        public static void SerializeIList(ref BssomWriter writer, ref BssomSerializeContext context, IList value)
        {
            if (value == null)
            {
                writer.WriteNull();
                return;
            }

            IBssomFormatter <object> formatter = context.Option.FormatterResolver.GetFormatterWithVerify <object>();

            writer.WriteArray2Type();
            long pos = writer.FillUInt32FixNumber();

            writer.WriteVariableNumber(value.Count);
            for (int i = 0; i < value.Count; i++)
            {
                context.CancellationToken.ThrowIfCancellationRequested();
                formatter.Serialize(ref writer, ref context, value[i]);
            }
            writer.WriteBackFixNumber(pos, checked ((int)(writer.Position - pos - BssomBinaryPrimitives.FixUInt32NumberSize)));
        }
            static FormatterCache()
            {
                Type t = typeof(T);

                if (t == typeof(IDictionary))
                {
                    Formatter = (IBssomFormatter <T>)((IBssomFormatter)IDictionaryFormatter.Instance);
                    return;
                }

                if (TypeIsDictionary(t, out ConstructorInfo constructor, out bool typeIsGeneric, out Type genericTypeDefinition, out Type genericKeyType, out Type genericValueType))
                {
                    if (typeIsGeneric && genericKeyType != typeof(object) && !BssMapKeyResolverProvider.TryGetBssMapKeyResolver(genericKeyType, out IBssMapKeyResolver keyConvert))
                    {
                        return;// throw BssomSerializationException.MapKeyTypeError();
                    }

                    TypeInfo buildType;
                    if (typeIsGeneric)
                    {
                        if (t.IsInterface)
                        {
                            buildType = IDictionaryFormatterTypeBuilder.BuildGenericIDictionaryInterfaceType(DynamicAssembly, t, genericTypeDefinition, genericKeyType, genericValueType);
                        }
                        else
                        {
                            buildType = IDictionaryFormatterTypeBuilder.BuildGenericIDictionaryImplementationType(DynamicAssembly, constructor, t, genericKeyType, genericValueType);
                        }
                    }
                    else
                    {
                        //impl IDictionary class/struct
                        buildType = IDictionaryFormatterTypeBuilder.BuildIDictionaryImplementationType(DynamicAssembly, constructor, t);
                    }

                    Formatter = (IBssomFormatter <T>)Activator.CreateInstance(buildType);
                }
            }
        //Size IEnumerable<>
        public static int SizeGenericIEnumerable <TElement>(ref BssomSizeContext context, IEnumerable <TElement> value)
        {
            if (value == null)
            {
                return(BssomBinaryPrimitives.NullSize);
            }

            IBssomFormatter <TElement> formatter = context.Option.FormatterResolver.GetFormatterWithVerify <TElement>();
            long dataLen = 0;

            foreach (TElement item in value)
            {
                dataLen += formatter.Size(ref context, item);
            }

            if (value.TryGetICollectionCount(out int count))
            {
                return(BssomBinaryPrimitives.Array2TypeSize(count, dataLen));
            }
            else
            {
                return(BssomBinaryPrimitives.Array2TypeSizeWithFixU32Count(dataLen));
            }
        }
        //Serialize IList<> / IReadOnlyList<>
        public static void SerializeGenerIList <TElement>(ref BssomWriter writer, ref BssomSerializeContext context,
                                                          IEnumerable <TElement> value)
        {
            if (value == null)
            {
                writer.WriteNull();
            }
            else
            {
                DEBUG.Assert(value is IList <TElement> || value is IReadOnlyList <TElement>);
                IBssomFormatter <TElement> formatter = context.Option.FormatterResolver.GetFormatterWithVerify <TElement>();

                writer.WriteArray2Type();
                long pos = writer.FillUInt32FixNumber();
                if (value is IList <TElement> list)
                {
                    writer.WriteVariableNumber(list.Count);
                    for (int i = 0; i < list.Count; i++)
                    {
                        context.CancellationToken.ThrowIfCancellationRequested();
                        formatter.Serialize(ref writer, ref context, list[i]);
                    }
                }
                else
                {
                    IReadOnlyList <TElement> rels = Unsafe.As <IEnumerable <TElement>, IReadOnlyList <TElement> >(ref value);
                    writer.WriteVariableNumber(rels.Count);
                    for (int i = 0; i < rels.Count; i++)
                    {
                        context.CancellationToken.ThrowIfCancellationRequested();
                        formatter.Serialize(ref writer, ref context, rels[i]);
                    }
                }
                writer.WriteBackFixNumber(pos, checked ((int)(writer.Position - pos - BssomBinaryPrimitives.FixUInt32NumberSize)));
            }
        }
            static FormatterCache()
            {
                Type t = typeof(T);

                Formatter = (IBssomFormatter <T>)Activator.CreateInstance(Array3CodeGenResolverBuilder.Build(DynamicAssembly, new ObjectSerializationInfo(t, false)));
            }