ReferenceConverter.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 / ReferenceConverter.cs / 1 / ReferenceConverter.cs
                        

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

/* 
 */ 
namespace System.ComponentModel {
    using Microsoft.Win32; 
    using System.Collections;
    using System.ComponentModel.Design;
    using System.Diagnostics;
    using System.Globalization; 
    using System.Runtime.InteropServices;
    using System.Runtime.Remoting; 
    using System.Runtime.Serialization.Formatters; 
    using System.Security.Permissions;
 
    /// 
    ///    Provides a type converter to convert object references to and from various
    ///       other representations.
    ///  
    [HostProtection(SharedState = true)]
    public class ReferenceConverter : TypeConverter { 
 
        private static readonly string none = SR.GetString(SR.toStringNone);
        private Type type; 

        /// 
        ///    
        ///       Initializes a new instance of the  class. 
        ///    
        ///  
        public ReferenceConverter(Type type) { 
            this.type = type;
        } 

        /// 
        /// 
        ///    Gets a value indicating whether this converter can convert an object in the 
        ///       given source type to a reference object using the specified context.
        ///  
        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) { 
            if (sourceType == typeof(string) && context != null) {
                return true; 
            }
            return base.CanConvertFrom(context, sourceType);
        }
 
        /// 
        ///  
        ///    Converts the given object to the reference type. 
        /// 
        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) { 

            if (value is string) {
                string text = ((string)value).Trim();
 
                if (!String.Equals(text, none) && context != null) {
 
                    // Try the reference service first. 
                    //
                    IReferenceService refSvc = (IReferenceService)context.GetService(typeof(IReferenceService)); 
                    if (refSvc != null) {
                        object obj = refSvc.GetReference(text);
                        if (obj != null) {
                            return obj; 
                        }
                    } 
 
                    // Now try IContainer
                    // 
                    IContainer cont = context.Container;
                    if (cont != null) {
                        object obj = cont.Components[text];
                        if (obj != null) { 
                            return obj;
                        } 
                    } 
                }
                return null; 

            }
            return base.ConvertFrom(context, culture, value);
        } 

        ///  
        ///  
        ///    Converts the given value object to the reference type
        ///       using the specified context and arguments. 
        /// 
        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) { 
                    // Try the reference service first.
                    //
                    if (context != null) {
                        IReferenceService refSvc = (IReferenceService)context.GetService(typeof(IReferenceService)); 
                        if (refSvc != null) {
                            string name = refSvc.GetName(value); 
                            if (name != null) { 
                                return name;
                            } 
                        }
                    }

                    // Now see if this is an IComponent. 
                    //
                    if (!Marshal.IsComObject(value) && value is IComponent) { 
                        IComponent comp = (IComponent)value; 
                        ISite site = comp.Site;
                        if (site != null) { 
                            string name = site.Name;
                            if (name != null) {
                                return name;
                            } 
                        }
                    } 
 
                    // Couldn't find it.
                    return String.Empty; 
                }
                return none;
            }
 
            return base.ConvertTo(context, culture, value, destinationType);
        } 
 
        /// 
        ///  
        ///    Gets a collection of standard values for the reference data type.
        /// 
        public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) {
 
            object[] components = null;
 
            if (context != null) { 
                ArrayList list = new ArrayList();
                list.Add(null); 

                // Try the reference service first.
                //
                IReferenceService refSvc = (IReferenceService)context.GetService(typeof(IReferenceService)); 
                if (refSvc != null) {
                    object[] objs = refSvc.GetReferences(type); 
                    int count = objs.Length; 

                    for (int i = 0; i < count; i++) { 
                        if (IsValueAllowed(context, objs[i]))
                            list.Add(objs[i]);
                    }
                } 
                else {
 
                    // Now try IContainer. 
                    //
                    IContainer cont = context.Container; 
                    if (cont != null) {
                        ComponentCollection objs = cont.Components;

                        foreach(IComponent obj in objs) { 
                            if (obj != null && type.IsInstanceOfType(obj) &&
                                IsValueAllowed(context, obj)) { 
                                list.Add(obj); 
                            }
                        } 
                    }
                }

                components = list.ToArray(); 
                Array.Sort(components, 0, components.Length, new ReferenceComparer(this));
            } 
 
            return new StandardValuesCollection(components);
        } 

        /// 
        /// 
        ///    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.
        ///  
        public override bool GetStandardValuesSupported(ITypeDescriptorContext context) { 
            return true;
        } 

        /// 
        ///    Gets a value indicating whether a particular value can be added to
        ///       the standard values collection. 
        /// 
        protected virtual bool IsValueAllowed(ITypeDescriptorContext context, object value) { 
            return true; 
        }
 
        /// 
        ///      IComparer object used for sorting references
        /// 
        private class ReferenceComparer : IComparer { 

            private ReferenceConverter converter; 
 
            public ReferenceComparer(ReferenceConverter converter) {
                this.converter = converter; 
            }

            public int Compare(object item1, object item2) {
 
                String itemName1 = converter.ConvertToString(item1);
                String itemName2 = converter.ConvertToString(item2); 
 
                return string.Compare(itemName1, itemName2, false, CultureInfo.InvariantCulture);
            } 
        }
    }
}

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