InstanceDescriptor.cs source code in C# .NET

                        Code:
                         / FX-1434 / FX-1434 / 1.0 / untmp / whidbey / REDBITS / ndp / fx / src / CompMod / System / ComponentModel / Design / Serialization / InstanceDescriptor.cs / 1 / InstanceDescriptor.cs
                        
                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.ComponentModel.Design.Serialization { 
 
    using System;
    using System.Collections; 
    using System.Diagnostics;
    using System.Reflection;
    using System.Security.Permissions;
 
    /// 
    ///     EventArgs for the ResolveNameEventHandler.  This event is used 
    ///     by the serialization process to match a name to an object 
    ///     instance.
    ///  
    [HostProtection(SharedState = true)]
    [System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.LinkDemand, Name = "FullTrust")]
    public sealed class InstanceDescriptor {
        private MemberInfo  member; 
        private ICollection arguments;
        private bool isComplete; 
 
        /// 
        ///     Creates a new InstanceDescriptor. 
        /// 
        public InstanceDescriptor(MemberInfo member, ICollection arguments) : this(member, arguments, true) {
        }
 
        /// 
        ///     Creates a new InstanceDescriptor. 
        ///  
        public InstanceDescriptor(MemberInfo member, ICollection arguments, bool isComplete) {
            this.member = member; 
            this.isComplete = isComplete;

            if (arguments == null) {
                this.arguments = new object[0]; 
            }
            else { 
                object[] args = new object[arguments.Count]; 
                arguments.CopyTo(args, 0);
                this.arguments = args; 
            }

            if (member is FieldInfo) {
                FieldInfo fi = (FieldInfo)member; 
                if (!fi.IsStatic) {
                    throw new ArgumentException(SR.GetString(SR.InstanceDescriptorMustBeStatic)); 
                } 
                if (this.arguments.Count != 0) {
                    throw new ArgumentException(SR.GetString(SR.InstanceDescriptorLengthMismatch)); 
                }
            }
            else if (member is ConstructorInfo) {
                ConstructorInfo ci = (ConstructorInfo)member; 
                if (ci.IsStatic) {
                    throw new ArgumentException(SR.GetString(SR.InstanceDescriptorCannotBeStatic)); 
                } 
                if (this.arguments.Count != ci.GetParameters().Length) {
                    throw new ArgumentException(SR.GetString(SR.InstanceDescriptorLengthMismatch)); 
                }
            }
            else if (member is MethodInfo) {
                MethodInfo mi = (MethodInfo)member; 
                if (!mi.IsStatic) {
                    throw new ArgumentException(SR.GetString(SR.InstanceDescriptorMustBeStatic)); 
                } 
                if (this.arguments.Count != mi.GetParameters().Length) {
                    throw new ArgumentException(SR.GetString(SR.InstanceDescriptorLengthMismatch)); 
                }
            }
            else if (member is PropertyInfo) {
                PropertyInfo pi = (PropertyInfo)member; 
                if (!pi.CanRead) {
                    throw new ArgumentException(SR.GetString(SR.InstanceDescriptorMustBeReadable)); 
                } 
                MethodInfo mi = pi.GetGetMethod();
                if (mi != null && !mi.IsStatic) { 
                    throw new ArgumentException(SR.GetString(SR.InstanceDescriptorMustBeStatic));
                }
            }
        } 

        ///  
        ///     The collection of arguments that should be passed to 
        ///     MemberInfo in order to create an instance.
        ///  
        public ICollection Arguments {
            get {
                return arguments;
            } 
        }
 
        ///  
        ///     Determines if the contents of this instance descriptor completely identify the instance.
        ///     This will normally be the case, but some objects may be too complex for a single method 
        ///     or constructor to represent.  IsComplete can be used to identify these objects and take
        ///     additional steps to further describe their state.
        /// 
        public bool IsComplete { 
            get {
                return isComplete; 
            } 
        }
 
        /// 
        ///     The MemberInfo object that was passed into the constructor
        ///     of this InstanceDescriptor.
        ///  
        public MemberInfo MemberInfo {
            get { 
                return member; 
            }
        } 

        /// 
        ///     Invokes this instance descriptor, returning the object
        ///     the descriptor describes. 
        /// 
        public object Invoke() { 
            object[] translatedArguments = new object[arguments.Count]; 
            arguments.CopyTo(translatedArguments, 0);
 
            // Instance descriptors can contain other instance
            // descriptors.  Translate them if necessary.
            //
            for(int i = 0; i < translatedArguments.Length; i++) { 
                if (translatedArguments[i] is InstanceDescriptor) {
                    translatedArguments[i] = ((InstanceDescriptor)translatedArguments[i]).Invoke(); 
                } 
            }
 
            if (member is ConstructorInfo) {
                return ((ConstructorInfo)member).Invoke(translatedArguments);
            }
            else if (member is MethodInfo) { 
                return ((MethodInfo)member).Invoke(null, translatedArguments);
            } 
            else if (member is PropertyInfo) { 
                return ((PropertyInfo)member).GetValue(null, translatedArguments);
            } 
            else if (member is FieldInfo) {
                return ((FieldInfo)member).GetValue(null);
            }
            else { 
                Debug.Fail("Unrecognized reflection type in instance descriptor: " + member.GetType().Name);
            } 
 
            return null;
        } 
    }
}
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
InstanceDescriptor.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
