TypeListConverter.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / DotNET / DotNET / 8.0 / untmp / whidbey / REDBITS / ndp / fx / src / CompMod / System / ComponentModel / TypeListConverter.cs / 1 / TypeListConverter.cs
                        

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

/* 
 */ 
namespace System.ComponentModel {
    using Microsoft.Win32; 
    using System.Collections;
    using System.ComponentModel.Design.Serialization;
    using System.Diagnostics;
    using System.Globalization; 
    using System.Reflection;
    using System.Runtime.InteropServices; 
    using System.Runtime.Remoting; 
    using System.Runtime.Serialization.Formatters;
    using System.Security.Permissions; 

    /// 
    ///    Provides a type
    ///       converter that can be used to populate a list box with available types. 
    /// 
    [HostProtection(SharedState = true)] 
    public abstract class TypeListConverter : TypeConverter { 
        private Type[] types;
        private StandardValuesCollection values; 

        /// 
        /// Initializes a new instance of the  class using
        ///    the type array as the available types. 
        /// 
        protected TypeListConverter(Type[] types) { 
            this.types = types; 
        }
 
        /// 
        /// 
        ///    Gets a value indicating whether this converter
        ///       can convert an object in the given source type to an enumeration object using 
        ///       the specified context.
        ///  
        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) { 
            if (sourceType == typeof(string)) {
                return true; 
            }
            return base.CanConvertFrom(context, sourceType);
        }
 
        /// 
        ///    Gets a value indicating whether this converter can 
        ///       convert an object to the given destination type using the context. 
        /// 
        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) { 
            if (destinationType == typeof(InstanceDescriptor)) {
                return true;
            }
            return base.CanConvertTo(context, destinationType); 
        }
 
        ///  
        /// 
        ///    Converts the specified value object to an enumeration object. 
        /// 
        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) {
            if (value is string) {
                foreach(Type t in types) { 
                    if (value.Equals(t.FullName)) {
                        return t; 
                    } 
                }
            } 

            return base.ConvertFrom(context, culture, value);
        }
 
        /// 
        ///  
        ///    Converts the given value object to the specified destination type. 
        /// 
        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) { 
            if (destinationType == null) {
                throw new ArgumentNullException("destinationType");
            }
 
            if (destinationType == typeof(string)) {
                if (value == null) { 
                    return SR.GetString(SR.toStringNone); 
                }
                else { 
                    return((Type)value).FullName;
                }
            }
            if (destinationType == typeof(InstanceDescriptor) && value is Type) { 
                MethodInfo method = typeof(Type).GetMethod("GetType", new Type[] {typeof(string)});
                if (method != null) { 
                    return new InstanceDescriptor(method, new object[] {((Type)value).AssemblyQualifiedName}); 
                }
            } 

            return base.ConvertTo(context, culture, value, destinationType);
        }
 
        /// 
        ///  
        ///    Gets a collection of standard values for the data type this validator is 
        ///       designed for.
        ///  
        public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) {
            if (values == null) {
                object[] objTypes;
 
                if (types != null) {
                    objTypes = new object[types.Length]; 
                    Array.Copy(types, objTypes, types.Length); 
                }
                else { 
                    objTypes = null;
                }

                values = new StandardValuesCollection(objTypes); 
            }
            return values; 
        } 

        ///  
        /// 
        ///    Gets a value indicating whether the list of standard values returned from
        ///     is an exclusive list. 
        ///  
        public override bool GetStandardValuesExclusive(ITypeDescriptorContext context) {
            return true; 
        } 

        ///  
        /// 
        ///    Gets a value indicating whether this object supports a
        ///       standard set of values that can be picked from a list using the specified
        ///       context. 
        /// 
        public override bool GetStandardValuesSupported(ITypeDescriptorContext context) { 
            return true; 
        }
    } 
}

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