HttpProfileBase.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ FXUpdate3074 / FXUpdate3074 / 1.1 / untmp / whidbey / QFE / ndp / fx / src / xsp / System / Web / Profile / HttpProfileBase.cs / 3 / HttpProfileBase.cs

                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

/* 
 * ProfileBase 
 *
 * Copyright (c) 2002 Microsoft Corporation 
 */

namespace System.Web.Profile {
    using System.Security.Principal; 
    using System.Security.Permissions;
    using System.Collections; 
    using System.Collections.Specialized; 
    using System.Web.Configuration;
    using System.Web.Util; 
    using System.Web.Security;
    using System.Web.Compilation;
    using System.Configuration;
    using System.Configuration.Provider; 
    using System.Reflection;
    using System.CodeDom; 
    using System.Web.Hosting; 
    using System.Runtime.Serialization;
    using System.Runtime.Serialization.Formatters.Binary; 
    using System.Security;


    [AspNetHostingPermission(SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)] 
    [AspNetHostingPermission(SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
    public class ProfileBase : SettingsBase { 
        ////////////////////////////////////////////////////////////////////////// 
        //////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////// 
        // Public (instance) functions and properties


        public override object this[string propertyName] { 
            get {
                // 
                if (HttpRuntime.NamedPermissionSet != null && HttpRuntime.ProcessRequestInApplicationTrust) { 
                    HttpRuntime.NamedPermissionSet.PermitOnly();
                } 

                return GetInternal(propertyName);
            }
            set { 
                //
                if (HttpRuntime.NamedPermissionSet != null && HttpRuntime.ProcessRequestInApplicationTrust) { 
                    HttpRuntime.NamedPermissionSet.PermitOnly(); 
                }
 
                SetInternal(propertyName, value);
            }
        }
 
        [SecurityPermission(SecurityAction.Assert, Flags = SecurityPermissionFlag.SerializationFormatter)]
        private object GetInternal(string propertyName) { 
            return base[propertyName]; 
        }
 
        [SecurityPermission(SecurityAction.Assert, Flags = SecurityPermissionFlag.SerializationFormatter)]
        private void SetInternal(string propertyName, object value) {
            if (!_IsAuthenticated) {
                SettingsProperty p = s_Properties[propertyName]; 

                if (p != null) { 
                    bool fAllowAnonymous = (bool)p.Attributes["AllowAnonymous"]; 
                    if (!fAllowAnonymous)
                        throw new ProviderException(SR.GetString(SR.Profile_anonoymous_not_allowed_to_set_property)); 
                }
            }

            base[propertyName] = value; 
        }
 
        public object GetPropertyValue(string propertyName) { return this[propertyName]; } 

        public void SetPropertyValue(string propertyName, object propertyValue) { this[propertyName] = propertyValue; } 

        public ProfileGroupBase GetProfileGroup(string groupName) {
            ProfileGroupBase grp = (ProfileGroupBase)_Groups[groupName];
 
            if (grp == null) {
                Type t = BuildManager.GetProfileType(); 
                if (t == null) 
                    throw new ProviderException(SR.GetString(SR.Profile_group_not_found, groupName));
                t = t.Assembly.GetType("ProfileGroup" + groupName, false); 
                if (t == null)
                    throw new ProviderException(SR.GetString(SR.Profile_group_not_found, groupName));

                grp = (ProfileGroupBase)Activator.CreateInstance(t); 
                grp.Init(this, groupName);
            } 
 
            return grp;
        } 

        public ProfileBase() {
            if (!ProfileManager.Enabled)
                throw new ProviderException(SR.GetString(SR.Profile_not_enabled)); 
            if (!s_Initialized)
                InitializeStatic(); 
        } 

        public void Initialize(string username, bool isAuthenticated) { 
            if (username != null)
                _UserName = username.Trim();
            else
                _UserName = username; 
            //if (string.IsNullOrEmpty(_UserName))
            //    throw new ArgumentException(SR.GetString(SR.Membership_InvalidUserName), "username"); 
            SettingsContext sc = new SettingsContext(); 
            sc.Add("UserName", _UserName);
            sc.Add("IsAuthenticated", isAuthenticated); 
            _IsAuthenticated = isAuthenticated;
            base.Initialize(sc, s_Properties, ProfileManager.Providers);
        }
 
        public override void Save() {
            // 
            if (HttpRuntime.NamedPermissionSet != null && HttpRuntime.ProcessRequestInApplicationTrust) { 
                HttpRuntime.NamedPermissionSet.PermitOnly();
            } 

            SaveWithAssert();
        }
 
        [SecurityPermission(SecurityAction.Assert, Flags = SecurityPermissionFlag.SerializationFormatter)]
        private void SaveWithAssert() { 
            base.Save(); 
            _IsDirty = false;
            _DatesRetrieved = false; 
        }

        public string UserName { get { return _UserName; } }
        public bool IsAnonymous { get { return !_IsAuthenticated; } } 
        public bool IsDirty {
            get { 
                if (_IsDirty) 
                    return true;
                foreach (SettingsPropertyValue pv in PropertyValues) { 
                    if (pv.IsDirty) {
                        _IsDirty = true;
                        return true;
                    } 
                }
                return false; 
            } 
        }
        public DateTime LastActivityDate { 
            get {
                if (!_DatesRetrieved)
                    RetrieveDates();
                return _LastActivityDate.ToLocalTime(); 
            }
        } 
        public DateTime LastUpdatedDate { 
            get {
                if (!_DatesRetrieved) 
                    RetrieveDates();
                return _LastUpdatedDate.ToLocalTime();
            }
        } 

        ////////////////////////////////////////////////////////////////////// 
        ////////////////////////////////////////////////////////////////////// 
        //////////////////////////////////////////////////////////////////////
        // static public Properties and functions 


        static public ProfileBase Create(string username) {
            return Create(username, true); 
        }
 
 
        static public ProfileBase Create(string username, bool isAuthenticated) {
            if (!ProfileManager.Enabled) 
                throw new ProviderException(SR.GetString(SR.Profile_not_enabled));
            InitializeStatic();
            if (s_SingletonInstance != null)
                return s_SingletonInstance; 
            if (s_Properties.Count == 0) {
                lock (s_InitializeLock) { 
                    if (s_SingletonInstance == null) 
                        s_SingletonInstance = new DefaultProfile();
                    return s_SingletonInstance; 
                }
            }
            HttpRuntime.CheckAspNetHostingPermission(AspNetHostingPermissionLevel.Low, SR.Feature_not_supported_at_this_level);
            return CreateMyInstance(username, isAuthenticated); 
        }
 
 
        new static public SettingsPropertyCollection Properties {
            get { 
                InitializeStatic();
                return s_Properties;
            }
        } 

        ////////////////////////////////////////////////////////////////////// 
        ////////////////////////////////////////////////////////////////////// 
        //////////////////////////////////////////////////////////////////////
        // Internal static functions and properties 

        //////////////////////////////////////////////////////////////////////
        //////////////////////////////////////////////////////////////////////
        internal static Type InheritsFromType { 
            get {
                if (!ProfileManager.Enabled) { 
                    return typeof(DefaultProfile); 
                }
                Type t; 
                if (HostingEnvironment.IsHosted)
                    t = BuildManager.GetType(InheritsFromTypeString, true, true);
                else
                    t = GetPropType(InheritsFromTypeString); 

                if (!typeof(ProfileBase).IsAssignableFrom(t)) { 
                    ProfileSection config = RuntimeConfig.GetAppConfig().Profile; 
                    throw new ConfigurationErrorsException(SR.GetString(SR.Wrong_profile_base_type), null, config.ElementInformation.Properties["inherits"].Source, config.ElementInformation.Properties["inherit"].LineNumber);
                } 
                return t;
            }
        }
        internal static string InheritsFromTypeString { 
            get {
                string defaultType = typeof(ProfileBase).ToString(); 
 
                if (!ProfileManager.Enabled)
                    return defaultType; 
                ProfileSection config = RuntimeConfig.GetAppConfig().Profile;
                if (config.Inherits == null)
                    return defaultType;
 
                string inheritsType = config.Inherits.Trim();
                if (inheritsType.Length < 1) 
                    return defaultType; 

                Type t = Type.GetType(inheritsType, false, true); 
                if (t == null)
                    return inheritsType;
                if (!typeof(ProfileBase).IsAssignableFrom(t))
                    throw new ConfigurationErrorsException(SR.GetString(SR.Wrong_profile_base_type), null, config.ElementInformation.Properties["inherits"].Source, config.ElementInformation.Properties["inherit"].LineNumber); 
                return t.AssemblyQualifiedName;
            } 
        } 

        internal static bool InheritsFromCustomType { 
            get {
                if (!ProfileManager.Enabled)
                    return false;
                ProfileSection config = RuntimeConfig.GetAppConfig().Profile; 
                if (config.Inherits == null)
                    return false; 
 
                string inheritsType = config.Inherits.Trim();
 
                if (inheritsType == null || inheritsType.Length < 1)
                    return false;

                Type t = Type.GetType(inheritsType, false, true); 
                if (t == null || t != typeof(ProfileBase))
                    return true; 
                else 
                    return false;
            } 
        }

        //////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////// 
        internal static ProfileBase SingletonInstance { get { return s_SingletonInstance; } }
 
        ////////////////////////////////////////////////////////////////////// 
        //////////////////////////////////////////////////////////////////////
        internal static Hashtable GetPropertiesForCompilation() { 
            if (!ProfileManager.Enabled)
                return null;
            if (s_PropertiesForCompilation != null)
                return s_PropertiesForCompilation; 

            lock (s_InitializeLock) { 
                if (s_PropertiesForCompilation != null) 
                    return s_PropertiesForCompilation;
                Hashtable ht = new Hashtable(); 
                ProfileSection config = RuntimeConfig.GetAppConfig().Profile;
                if (config.PropertySettings == null) {
                    s_PropertiesForCompilation = ht;
                    return s_PropertiesForCompilation; 
                }
                AddProfilePropertySettingsForCompilation(config.PropertySettings, ht, null); 
                foreach (ProfileGroupSettings pgs in config.PropertySettings.GroupSettings) { 
                    AddProfilePropertySettingsForCompilation(pgs.PropertySettings, ht, pgs.Name);
                } 
                s_PropertiesForCompilation = ht;
            }
            return s_PropertiesForCompilation;
        } 

        ////////////////////////////////////////////////////////////////////// 
        ////////////////////////////////////////////////////////////////////// 
        internal static string GetProfileClassName() {
            Hashtable props = GetPropertiesForCompilation(); 
            if (props == null)
                return "System.Web.Profile.DefaultProfile";
            if (props.Count > 0 || InheritsFromCustomType)
                return "ProfileCommon"; 
            else
                return "System.Web.Profile.DefaultProfile"; 
        } 

        ////////////////////////////////////////////////////////////////////// 
        //////////////////////////////////////////////////////////////////////
        private static void AddProfilePropertySettingsForCompilation(ProfilePropertySettingsCollection propertyCollection, Hashtable ht, string groupName) {
            foreach (ProfilePropertySettings pps in propertyCollection) {
                ProfileNameTypeStruct prop = new ProfileNameTypeStruct(); 
                if (groupName != null) {
                    prop.Name = groupName + "." + pps.Name; 
                } 
                else {
                    prop.Name = pps.Name; 
                }
                Type t = pps.TypeInternal;
                if (t == null)
                    t = ResolvePropertyTypeForCommonTypes(pps.Type.ToLower(System.Globalization.CultureInfo.InvariantCulture)); 
                if (t == null)
                    t = BuildManager.GetType(pps.Type, false); 
                if (t == null) { 
                    prop.PropertyCodeRefType = new CodeTypeReference(pps.Type);
                } 
                else {
                    prop.PropertyCodeRefType = new CodeTypeReference(t);
                }
                prop.PropertyType = t; 
                pps.TypeInternal = t;
                prop.IsReadOnly = pps.ReadOnly; 
                prop.LineNumber = pps.ElementInformation.Properties["name"].LineNumber; 
                prop.FileName = pps.ElementInformation.Properties["name"].Source;
                ht.Add(prop.Name, prop); 
            }
        }

        ////////////////////////////////////////////////////////////////////// 
        //////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////// 
        // Private static functions and properties 
        //////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////// 
        static private ProfileBase CreateMyInstance(string username, bool isAuthenticated) {
            Type t;
            if (HostingEnvironment.IsHosted)
                t = BuildManager.GetProfileType(); 
            else
                t = InheritsFromType; 
            ProfileBase hbc = (ProfileBase)Activator.CreateInstance(t); 
            hbc.Initialize(username, isAuthenticated);
            return hbc; 
        }

        //////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////// 
        //////////////////////////////////////////////////////////////////////
        static private void InitializeStatic() { 
            if (!ProfileManager.Enabled || s_Initialized) { 
                if (s_InitializeException != null)
                    throw s_InitializeException; 
                return;
            }
            lock (s_InitializeLock) {
                if (s_Initialized) { 
                    if (s_InitializeException != null)
                        throw s_InitializeException; 
                    return; 
                }
 
                try {
                    ProfileSection config = RuntimeConfig.GetAppConfig().Profile;
                    bool fAnonEnabled = (HostingEnvironment.IsHosted ? AnonymousIdentificationModule.Enabled : true);
                    Type baseType = ProfileBase.InheritsFromType; 
                    bool hasLowTrust = HttpRuntime.HasAspNetHostingPermission(AspNetHostingPermissionLevel.Low);
 
                    s_Properties = new SettingsPropertyCollection(); 

                    ////////////////////////////////////////////////////////////////////// 
                    // Step 1: Add Properties from the base class (if not ProfileBase)
                    if (baseType != typeof(ProfileBase)) {
                        //////////////////////////////////////////////////////////////////////
                        // Step 2: Construct a hashtable containing a list of all the property-names in the ProfileBase type 
                        PropertyInfo[] baseProps = typeof(ProfileBase).GetProperties();
                        NameValueCollection baseProperties = new NameValueCollection(baseProps.Length); 
                        foreach (PropertyInfo baseProp in baseProps) 
                            baseProperties.Add(baseProp.Name, String.Empty);
 
                        //////////////////////////////////////////////////////////////////////
                        // Step 3: For each property in the derived class, add it to the s_Properties class.
                        PropertyInfo[] props = baseType.GetProperties();
                        foreach (PropertyInfo prop in props) { 
                            if (baseProperties[prop.Name] == null) { //not in the base class
 
                                ProfileProvider prov = hasLowTrust ? ProfileManager.Provider : null; 
                                bool readOnly = false;
                                SettingsSerializeAs serializeAs = SettingsSerializeAs.ProviderSpecific; 
                                string defaultValue = String.Empty;
                                bool allowAnonymous = false;
                                string customData = null;
 
                                //////////////////////////////////////////////////////////////////////
                                // Step 4: For the property, get the attributes 
                                Attribute[] attribs = Attribute.GetCustomAttributes(prop, true); 

                                foreach (Attribute attrib in attribs) { 
                                    if (attrib is SettingsSerializeAsAttribute) {
                                        serializeAs = ((SettingsSerializeAsAttribute)attrib).SerializeAs;
                                    }
                                    else if (attrib is SettingsAllowAnonymousAttribute) { 
                                        allowAnonymous = ((SettingsAllowAnonymousAttribute)attrib).Allow;
                                        if (!fAnonEnabled && allowAnonymous) 
                                            throw new ConfigurationErrorsException(SR.GetString(SR.Annoymous_id_module_not_enabled, prop.Name), config.ElementInformation.Properties["inherits"].Source, config.ElementInformation.Properties["inherits"].LineNumber); 
                                    }
                                    else if (attrib is System.ComponentModel.ReadOnlyAttribute) { 
                                        readOnly = ((System.ComponentModel.ReadOnlyAttribute)attrib).IsReadOnly;
                                    }
                                    else if (attrib is DefaultSettingValueAttribute) {
                                        defaultValue = ((DefaultSettingValueAttribute)attrib).Value; 
                                    }
                                    else if (attrib is CustomProviderDataAttribute) { 
                                        customData = ((CustomProviderDataAttribute)attrib).CustomProviderData; 
                                    }
                                    else if (hasLowTrust && attrib is ProfileProviderAttribute) { 
                                        prov = ProfileManager.Providers[((ProfileProviderAttribute)attrib).ProviderName];
                                        if (prov == null)
                                            throw new ConfigurationErrorsException(SR.GetString(SR.Profile_provider_not_found, ((ProfileProviderAttribute)attrib).ProviderName), config.ElementInformation.Properties["inherits"].Source, config.ElementInformation.Properties["inherits"].LineNumber);
                                    } 
                                }
                                ////////////////////////////////////////////////////////////////////// 
                                // Step 5: Add the property to the s_Properties 
                                SettingsAttributeDictionary settings = new SettingsAttributeDictionary();
                                settings.Add("AllowAnonymous", allowAnonymous); 
                                if (!string.IsNullOrEmpty(customData))
                                    settings.Add("CustomProviderData", customData);
                                SettingsProperty sp = new SettingsProperty(prop.Name, prop.PropertyType, prov, readOnly, defaultValue, serializeAs, settings, false, true);
                                s_Properties.Add(sp); 
                            }
                        } 
                    } 

                    ////////////////////////////////////////////////////////////////////// 
                    //////////////////////////////////////////////////////////////////////
                    // Step 6: Add all properties from config
                    if (config.PropertySettings != null) {
                        AddPropertySettingsFromConfig(baseType, fAnonEnabled, hasLowTrust, config.PropertySettings, null); 
                        foreach (ProfileGroupSettings pgs in config.PropertySettings.GroupSettings) {
                            AddPropertySettingsFromConfig(baseType, fAnonEnabled, hasLowTrust, pgs.PropertySettings, pgs.Name); 
                        } 
                    }
 
                }
                catch (Exception e) {
                    if (s_InitializeException == null)
                        s_InitializeException = e; 
                }
                // If there are no properties, create an empty collection. 
                if (s_Properties == null) 
                    s_Properties = new SettingsPropertyCollection();
                // Make the properties collection read-only 
                s_Properties.SetReadOnly();
                s_Initialized = true;
            }
 
            // Throw an exception if there was an exception during initialization
            if (s_InitializeException != null) 
                throw s_InitializeException; 
        }
 
        private static void AddPropertySettingsFromConfig(Type baseType, bool fAnonEnabled, bool hasLowTrust, ProfilePropertySettingsCollection settingsCollection, string groupName) {
            foreach (ProfilePropertySettings pps in settingsCollection) {
                string name = (groupName != null) ? (groupName + "." + pps.Name) : pps.Name;
                if (baseType != typeof(ProfileBase) && s_Properties[name] != null) 
                    throw new ConfigurationErrorsException(SR.GetString(SR.Profile_property_already_added), null, pps.ElementInformation.Properties["name"].Source, pps.ElementInformation.Properties["name"].LineNumber);
 
                try { 
                    if (pps.TypeInternal == null) {
                        pps.TypeInternal = ResolvePropertyType(pps.Type); 
                    }
                }
                catch (Exception e) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Profile_could_not_create_type, e.Message), e, pps.ElementInformation.Properties["type"].Source, pps.ElementInformation.Properties["type"].LineNumber); 
                }
                if (!fAnonEnabled) { 
                    bool fAllowAnonymous = pps.AllowAnonymous; 
                    if (fAllowAnonymous)
                        throw new ConfigurationErrorsException(SR.GetString(SR.Annoymous_id_module_not_enabled, pps.Name), pps.ElementInformation.Properties["allowAnonymous"].Source, pps.ElementInformation.Properties["allowAnonymous"].LineNumber); 
                }
                if (pps.SerializeAs == SerializationMode.Binary && !pps.TypeInternal.IsSerializable) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Property_not_serializable, pps.Name), pps.ElementInformation.Properties["serializeAs"].Source, pps.ElementInformation.Properties["serializeAs"].LineNumber);
                } 
                if (hasLowTrust) {
                    SetProviderForProperty(pps); 
                } 
                else {
                    pps.ProviderInternal = null; 
                }
                SettingsAttributeDictionary settings = new SettingsAttributeDictionary();
                settings.Add("AllowAnonymous", pps.AllowAnonymous);
                if (!string.IsNullOrEmpty(pps.CustomProviderData)) 
                    settings.Add("CustomProviderData", pps.CustomProviderData);
                SettingsProperty sp = new SettingsProperty(name, pps.TypeInternal, pps.ProviderInternal, pps.ReadOnly, pps.DefaultValue, (SettingsSerializeAs)pps.SerializeAs, settings, false, true); 
                s_Properties.Add(sp); 
            }
        } 

        //////////////////////////////////////////////////////////////////////
        //////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////// 
        static private void SetProviderForProperty(ProfilePropertySettings pps) {
            if (pps.Provider == null || pps.Provider.Length < 1) { 
                pps.ProviderInternal = ProfileManager.Provider; // Use default provider 
            }
            else { 
                pps.ProviderInternal = ProfileManager.Providers[pps.Provider]; // Use specified provider
            }

            // Provider not found? 
            if (pps.ProviderInternal == null)
                throw new ConfigurationErrorsException(SR.GetString(SR.Profile_provider_not_found, pps.Provider), pps.ElementInformation.Properties["provider"].Source, pps.ElementInformation.Properties["provider"].LineNumber); 
        } 

 
        //////////////////////////////////////////////////////////////////////
        //////////////////////////////////////////////////////////////////////
        //////////////////////////////////////////////////////////////////////
        static private Type ResolvePropertyTypeForCommonTypes(string typeName) { 
            switch (typeName) {
                case "string": 
                    return typeof(string); 

                case "byte": 
                case "int8":
                    return typeof(byte);

                case "boolean": 
                case "bool":
                    return typeof(bool); 
 
                case "char":
                    return typeof(char); 

                case "int":
                case "integer":
                case "int32": 
                    return typeof(int);
 
                case "date": 
                case "datetime":
                    return typeof(DateTime); 

                case "decimal":
                    return typeof(decimal);
 
                case "double":
                case "float64": 
                    return typeof(System.Double); 

                case "float": 
                case "float32":
                    return typeof(float);

                case "long": 
                case "int64":
                    return typeof(long); 
 
                case "short":
                case "int16": 
                    return typeof(System.Int16);

                case "single":
                    return typeof(Single); 

                case "uint16": 
                case "ushort": 
                    return typeof(UInt16);
 
                case "uint32":
                case "uint":
                    return typeof(uint);
 
                case "ulong":
                case "uint64": 
                    return typeof(ulong); 

                case "object": 
                    return typeof(object);

                default:
                    return null; 
            }
        } 
        static private Type ResolvePropertyType(string typeName) { 
            Type t = ResolvePropertyTypeForCommonTypes(typeName.ToLower(System.Globalization.CultureInfo.InvariantCulture));
            if (t != null) 
                return t;

            if (HostingEnvironment.IsHosted)
                return BuildManager.GetType(typeName, true, true); 
            else
                return GetPropType(typeName); 
        } 

        static private Type GetPropType(string typeName) { 
            Exception ex = null;
            try {
                return Type.GetType(typeName, true, true);
            } 
            catch (Exception e) {
                ex = e; 
            } 

            try { 
                CompilationSection config = RuntimeConfig.GetAppConfig().Compilation;
                if (config != null) {
                    AssemblyCollection ac = config.Assemblies;
                    if (ac != null) { 
                        foreach (Assembly a in ac) {
                            Type t = a.GetType(typeName, false, true); 
                            if (t != null) 
                                return t;
                        } 
                    }
                }
            }
            catch { } 

            throw ex; 
        } 

        ///////////////////////////////////////////////////////////////////////////// 
        /////////////////////////////////////////////////////////////////////////////
        // Instance data
        private Hashtable _Groups = new Hashtable();
        private bool _IsAuthenticated = false; 
        private string _UserName = null;
        private bool _IsDirty = false; 
        private DateTime _LastActivityDate; 
        private DateTime _LastUpdatedDate;
        private bool _DatesRetrieved; 

        private void RetrieveDates() {
            if (_DatesRetrieved || ProfileManager.Provider == null)
                return; 
            int totalRecords;
            ProfileInfoCollection coll = ProfileManager.Provider.FindProfilesByUserName(ProfileAuthenticationOption.All, _UserName, 0, 1, out totalRecords); 
            foreach (ProfileInfo p in coll) { 
                _LastActivityDate = p.LastActivityDate.ToUniversalTime();
                _LastUpdatedDate = p.LastUpdatedDate.ToUniversalTime(); 
                _DatesRetrieved = true;
                return;
            }
        } 

        ///////////////////////////////////////////////////////////////////////////// 
        ///////////////////////////////////////////////////////////////////////////// 
        // Static data
        private static SettingsPropertyCollection s_Properties = null; 
        private static object s_InitializeLock = new Object();
        private static Exception s_InitializeException = null;
        private static bool s_Initialized = false;
        private static ProfileBase s_SingletonInstance = null; 
        private static Hashtable s_PropertiesForCompilation = null;
    } 
 
    //////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////// 
    //////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////
    internal class ProfileNameTypeStruct {
        internal string Name; 
        internal CodeTypeReference PropertyCodeRefType;
        internal Type PropertyType; 
        internal bool IsReadOnly; 
        internal int LineNumber;
        internal string FileName; 
    }
}


// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

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