The Labs \ Source Viewer \ SSCLI \ System.ComponentModel \ ReferenceComparer

  1. //------------------------------------------------------------------------------
  2. // <copyright file="ReferenceConverter.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. /*
  16. */
  17. namespace System.ComponentModel
  18. {
  19.     using Microsoft.Win32;
  20.     using System.Collections;
  21.     using System.ComponentModel.Design;
  22.     using System.Diagnostics;
  23.     using System.Globalization;
  24.     using System.Runtime.InteropServices;
  25.     using System.Runtime.Remoting;
  26.     using System.Runtime.Serialization.Formatters;
  27.     using System.Security.Permissions;
  28.    
  29.     /// <devdoc>
  30.     /// <para>Provides a type converter to convert object references to and from various
  31.     /// other representations.</para>
  32.     /// </devdoc>
  33.     [HostProtection(SharedState = true)]
  34.     public class ReferenceConverter : TypeConverter
  35.     {
  36.        
  37.         private static readonly string none = SR.GetString(SR.toStringNone);
  38.         private Type type;
  39.        
  40.         /// <devdoc>
  41.         /// <para>
  42.         /// Initializes a new instance of the <see cref='System.ComponentModel.ReferenceConverter'/> class.
  43.         /// </para>
  44.         /// </devdoc>
  45.         public ReferenceConverter(Type type)
  46.         {
  47.             this.type = type;
  48.         }
  49.        
  50.         /// <internalonly/>
  51.         /// <devdoc>
  52.         /// <para>Gets a value indicating whether this converter can convert an object in the
  53.         /// given source type to a reference object using the specified context.</para>
  54.         /// </devdoc>
  55.         public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
  56.         {
  57.             if (sourceType == typeof(string) && context != null) {
  58.                 return true;
  59.             }
  60.             return base.CanConvertFrom(context, sourceType);
  61.         }
  62.        
  63.         /// <internalonly/>
  64.         /// <devdoc>
  65.         /// <para>Converts the given object to the reference type.</para>
  66.         /// </devdoc>
  67.         public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
  68.         {
  69.            
  70.             if (value is string) {
  71.                 string text = ((string)value).Trim();
  72.                
  73.                 if (!String.Equals(text, none) && context != null) {
  74.                    
  75.                     // Try the reference service first.
  76.                     //
  77.                     IReferenceService refSvc = (IReferenceService)context.GetService(typeof(IReferenceService));
  78.                     if (refSvc != null) {
  79.                         object obj = refSvc.GetReference(text);
  80.                         if (obj != null) {
  81.                             return obj;
  82.                         }
  83.                     }
  84.                    
  85.                     // Now try IContainer
  86.                     //
  87.                     IContainer cont = context.Container;
  88.                     if (cont != null) {
  89.                         object obj = cont.Components[text];
  90.                         if (obj != null) {
  91.                             return obj;
  92.                         }
  93.                     }
  94.                 }
  95.                 return null;
  96.                
  97.             }
  98.             return base.ConvertFrom(context, culture, value);
  99.         }
  100.        
  101.         /// <internalonly/>
  102.         /// <devdoc>
  103.         /// <para>Converts the given value object to the reference type
  104.         /// using the specified context and arguments.</para>
  105.         /// </devdoc>
  106.         public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
  107.         {
  108.             if (destinationType == null) {
  109.                 throw new ArgumentNullException("destinationType");
  110.             }
  111.            
  112.             if (destinationType == typeof(string)) {
  113.                
  114.                 if (value != null) {
  115.                     // Try the reference service first.
  116.                     //
  117.                     if (context != null) {
  118.                         IReferenceService refSvc = (IReferenceService)context.GetService(typeof(IReferenceService));
  119.                         if (refSvc != null) {
  120.                             string name = refSvc.GetName(value);
  121.                             if (name != null) {
  122.                                 return name;
  123.                             }
  124.                         }
  125.                     }
  126.                    
  127.                     // Now see if this is an IComponent.
  128.                     //
  129.                     if (!Marshal.IsComObject(value) && value is IComponent) {
  130.                         IComponent comp = (IComponent)value;
  131.                         ISite site = comp.Site;
  132.                         if (site != null) {
  133.                             string name = site.Name;
  134.                             if (name != null) {
  135.                                 return name;
  136.                             }
  137.                         }
  138.                     }
  139.                    
  140.                     // Couldn't find it.
  141.                     return String.Empty;
  142.                 }
  143.                 return none;
  144.             }
  145.            
  146.             return base.ConvertTo(context, culture, value, destinationType);
  147.         }
  148.        
  149.         /// <internalonly/>
  150.         /// <devdoc>
  151.         /// <para>Gets a collection of standard values for the reference data type.</para>
  152.         /// </devdoc>
  153.         public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
  154.         {
  155.            
  156.             object[] components = null;
  157.            
  158.             if (context != null) {
  159.                 ArrayList list = new ArrayList();
  160.                 list.Add(null);
  161.                
  162.                 // Try the reference service first.
  163.                 //
  164.                 IReferenceService refSvc = (IReferenceService)context.GetService(typeof(IReferenceService));
  165.                 if (refSvc != null) {
  166.                     object[] objs = refSvc.GetReferences(type);
  167.                     int count = objs.Length;
  168.                    
  169.                     for (int i = 0; i < count; i++) {
  170.                         if (IsValueAllowed(context, objs[i]))
  171.                             list.Add(objs[i]);
  172.                     }
  173.                 }
  174.                 else {
  175.                    
  176.                     // Now try IContainer.
  177.                     //
  178.                     IContainer cont = context.Container;
  179.                     if (cont != null) {
  180.                         ComponentCollection objs = cont.Components;
  181.                        
  182.                         foreach (IComponent obj in objs) {
  183.                             if (obj != null && type.IsInstanceOfType(obj) && IsValueAllowed(context, obj)) {
  184.                                 list.Add(obj);
  185.                             }
  186.                         }
  187.                     }
  188.                 }
  189.                
  190.                 components = list.ToArray();
  191.                 Array.Sort(components, 0, components.Length, new ReferenceComparer(this));
  192.             }
  193.            
  194.             return new StandardValuesCollection(components);
  195.         }
  196.        
  197.         /// <internalonly/>
  198.         /// <devdoc>
  199.         /// <para>Gets a value indicating whether the list of standard values returned from
  200.         /// <see cref='System.ComponentModel.ReferenceConverter.GetStandardValues'/> is an exclusive list. </para>
  201.         /// </devdoc>
  202.         public override bool GetStandardValuesExclusive(ITypeDescriptorContext context)
  203.         {
  204.             return true;
  205.         }
  206.        
  207.         /// <internalonly/>
  208.         /// <devdoc>
  209.         /// <para>Gets a value indicating whether this object supports a standard set of values
  210.         /// that can be picked from a list.</para>
  211.         /// </devdoc>
  212.         public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
  213.         {
  214.             return true;
  215.         }
  216.        
  217.         /// <devdoc>
  218.         /// <para>Gets a value indicating whether a particular value can be added to
  219.         /// the standard values collection.</para>
  220.         /// </devdoc>
  221.         protected virtual bool IsValueAllowed(ITypeDescriptorContext context, object value)
  222.         {
  223.             return true;
  224.         }
  225.        
  226.         /// <devdoc>
  227.         /// IComparer object used for sorting references
  228.         /// </devdoc>
  229.         private class ReferenceComparer : IComparer
  230.         {
  231.            
  232.             private ReferenceConverter converter;
  233.            
  234.             public ReferenceComparer(ReferenceConverter converter)
  235.             {
  236.                 this.converter = converter;
  237.             }
  238.            
  239.             public int Compare(object item1, object item2)
  240.             {
  241.                
  242.                 string itemName1 = converter.ConvertToString(item1);
  243.                 string itemName2 = converter.ConvertToString(item2);
  244.                
  245.                 return string.Compare(itemName1, itemName2, false, CultureInfo.InvariantCulture);
  246.             }
  247.         }
  248.     }
  249. }

Developer Fusion