FormatterServices.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / FXUpdate3074 / FXUpdate3074 / 1.1 / untmp / whidbey / QFE / ndp / clr / src / BCL / System / Runtime / Serialization / FormatterServices.cs / 4 / FormatterServices.cs
                        

                        
                            // ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
/*============================================================
** 
** Class: FormatterServices 
**
** 
** Purpose: Provides some static methods to aid with the implementation
**          of a Formatter for Serialization.
**
** 
============================================================*/
namespace System.Runtime.Serialization { 
 
    using System;
    using System.Reflection; 
    using System.Reflection.Cache;
    using System.Collections;
    using System.Collections.Generic;
    using System.Security; 
    using System.Security.Permissions;
    using System.Runtime.Serialization.Formatters; 
    using System.Runtime.Remoting; 
    using System.Runtime.CompilerServices;
    using System.Threading; 
    using System.IO;
    using System.Text;
    using System.Globalization;
 
[System.Runtime.InteropServices.ComVisible(true)]
    public sealed class FormatterServices { 
        internal static Dictionary m_MemberInfoTable = new Dictionary(32); 

        private static Object s_FormatterServicesSyncObject = null; 

        private static Object formatterServicesSyncObject
        {
            get 
            {
                if (s_FormatterServicesSyncObject == null) 
                { 
                    Object o = new Object();
                    Interlocked.CompareExchange(ref s_FormatterServicesSyncObject, o, null); 
                }
                return s_FormatterServicesSyncObject;
            }
        } 

        private FormatterServices() { 
            throw new NotSupportedException(); 
        }
 
        private static MemberInfo[] GetSerializableMembers(RuntimeType type) {
            // get the list of all fields
            FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
            int countProper = 0; 
            for (int i = 0;  i < fields.Length; i++) {
                if ((fields[i].Attributes & FieldAttributes.NotSerialized) == FieldAttributes.NotSerialized) 
                    continue; 
                countProper++;
            } 
            if (countProper != fields.Length) {
                FieldInfo[] properFields = new FieldInfo[countProper];
                countProper = 0;
                for (int i = 0;  i < fields.Length; i++) { 
                    if ((fields[i].Attributes & FieldAttributes.NotSerialized) == FieldAttributes.NotSerialized)
                        continue; 
                    properFields[countProper] = fields[i]; 
                    countProper++;
                } 
                return properFields;
            }
            else
                return fields; 
        }
 
        private static bool CheckSerializable(RuntimeType type) { 
            if (type.IsSerializable) {
                return true; 
            }
            return false;
        }
 
        private static MemberInfo[] InternalGetSerializableMembers(RuntimeType type) {
            ArrayList allMembers=null; 
            MemberInfo[] typeMembers; 
            FieldInfo [] typeFields;
            RuntimeType parentType; 

            BCLDebug.Assert(type!=null, "[GetAllSerializableMembers]type!=null");

            //< 

            if (type.IsInterface) { 
                return new MemberInfo[0]; 
            }
 
            if (!(CheckSerializable(type))) {
                    throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_NonSerType"), type.FullName, type.Module.Assembly.FullName));
            }
 
            //Get all of the serializable members in the class to be serialized.
            typeMembers = GetSerializableMembers(type); 
 
            //If this class doesn't extend directly from object, walk its hierarchy and
            //get all of the private and assembly-access fields (e.g. all fields that aren't 
            //virtual) and include them in the list of things to be serialized.
            parentType = (RuntimeType)(type.BaseType);
            if (parentType!=null && parentType!=typeof(Object)) {
                Type[] parentTypes = null; 
                int parentTypeCount = 0;
                bool classNamesUnique = GetParentTypes(parentType, out parentTypes, out parentTypeCount); 
                if (parentTypeCount > 0){ 
                    allMembers = new ArrayList();
                    for (int i = 0; i < parentTypeCount;i++){ 
                        parentType = (RuntimeType)parentTypes[i];
                        if (!CheckSerializable(parentType)) {
                                throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_NonSerType"), parentType.FullName, parentType.Module.Assembly.FullName));
                        } 

                        typeFields = parentType.GetFields(BindingFlags.NonPublic | BindingFlags.Instance); 
                        String typeName = classNamesUnique ? parentType.Name : parentType.FullName; 
                        foreach (FieldInfo field in typeFields) {
                            // Family and Assembly fields will be gathered by the type itself. 
                            if (!field.IsNotSerialized) {
                                allMembers.Add(new SerializationFieldInfo((RuntimeFieldInfo)field, typeName));
                            }
                        } 
                    }
                    //If we actually found any new MemberInfo's, we need to create a new MemberInfo array and 
                    //copy all of the members which we've found so far into that. 
                    if (allMembers!=null && allMembers.Count>0) {
                        MemberInfo[] membersTemp = new MemberInfo[allMembers.Count + typeMembers.Length]; 
                        Array.Copy(typeMembers, membersTemp, typeMembers.Length);
                        allMembers.CopyTo(membersTemp, typeMembers.Length);
                        typeMembers = membersTemp;
                    } 
                }
            } 
            return typeMembers; 
        }
 
        static bool GetParentTypes(Type parentType, out Type[] parentTypes, out int parentTypeCount){
            //Check if there are any dup class names. Then we need to include as part of
            //typeName to prefix the Field names in SerializationFieldInfo
            /*out*/ parentTypes = null; 
            /*out*/ parentTypeCount = 0;
            bool unique = true; 
            for(Type t1 = parentType;t1 != typeof(object); t1 = t1.BaseType){ 
                if (t1.IsInterface) continue;
                string t1Name = t1.Name; 
                for(int i=0;unique && i

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK