Wie übergeben Parameter an TypeConverter abgeleitete Klasse

Question

Ich würde gerne einige Parameter an Klasse von TypeConverter abgeleitet übergeben. Sag mir bitte, wie kann ich das machen? Zum Beispiel, ich habe diese Klasse:

public class DDlExample 
{ 
     [TypeConverter(typeof(ExClassConverter))] 
     public int Bounds { get; set; } 
} 

class ExClassConverter : TypeConverter 
{ 
    public int FirstParam{get;set;} 
... 
} 

Ich möchte Wert firstParam wie dies passieren:

public class DDlExample 
{ 
     [TypeConverter(typeof(ExClassConverter), ***FirstParam=2***)] 
     public int Bounds { get; set; } 
} 

Ist es möglich?

Es scheint, diese Aufgabe hat keine Entscheidung. Ich werde versuchen, ein Problem zu wiederholen. Ich habe eine Klasse von TypeConverter abgeleitet und ich verwende es auf verschiedene Eigenschaften, um verschiedene Werte Dropdown-Liste anzuzeigen. Wie kann ich definieren, welche Eigenschaften aus ExClassConverter : TypeConverter Dropdown-Liste mit entsprechenden Werten füllen?

[AttributeUsage(AttributeTargets.Property,AllowMultiple=true,Inherited=true)] 
public class ParamDesc:Attribute 
{ 
    public ParamDesc(int PD) { DictID = PD; } 
    public int DictID { get; set; } 
} 

public class DDlExample 
{ 
    [ParamDesc(1)] 
    [TypeConverter(typeof(ExClassConverter))] 
    public int Bounds { get; set; } 

    [ParamDes(2)] 
    [TypeConverter(typeof(ExClassConverter))] 
    public int Rounds { get; set; } 
} 

class ExClassConverter : TypeConverter 
{ 

private List<string> LSValues1 = new List<string>(new string[] {"first","second","third"}); 
private List<string> LSValues2 = new List<string>(new string[] {"apple","melon","grapes"}); 

public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) 
{ 
    if (sourceType == typeof(string)) 
     return true; 
    return base.CanConvertFrom(context, sourceType); 

} 

public override bool CanConvertTo(ITypeDescriptorContext context, Type sourceType) 
{    
    if (sourceType == typeof(int)) 
      return (sourceType == typeof(int)?true:false); 
    return base.CanConvertTo(context, sourceType); 
} 

public override object ConvertTo(ITypeDescriptorContext context, 
    CultureInfo culture, object value, Type destType) 
{ 
     if (value is int) 
     {   
      return LSValues1[(int)value]; 
     } 
     return base.ConvertTo(context, culture, value, destType); 
} 
public override object ConvertFrom(ITypeDescriptorContext context, 
CultureInfo culture, object value) 
{ 
    if (value is string) 
    { 
     return LSValues1.IndexOf(value.ToString()); 
    } 
    return base.ConvertFrom(context, culture, value); 

} 

public override bool GetStandardValuesSupported(ITypeDescriptorContext context) 
{ 
    return true; 
} 

public override bool GetStandardValuesExclusive(ITypeDescriptorContext context) 
{ 
    return true; 
} 

public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) 
{ 
    StandardValuesCollection svc = new StandardValuesCollection(LSValues1); 
    return svc; 
} 
} 

Answer 1

Ich habe die Aufgabe gelöst. Früher habe ich ITypeDescriptorContext context bei Methoden ConvertTo und ConvertFrom:

if (context != null) 
{ 
    AttributeCollection ua = context.PropertyDescriptor.Attributes;      
    ParamDesc cca = (ParamDesc)ua[typeof(ParamDesc)];  
    if (cca != null) 
     System.Console.WriteLine("Attribute value is " + cca.DictID.ToString()); 
} 

Answer 2

Alte Frage, aber ...

Der Vollständigkeit halber wird eine Lösung für das, was OP zu sein scheint das Problem ist: nur der Name der Eigenschaft überprüft die Art Konverter wird dagegen aufgerufen. Beispiel:

Diese Lösung vermeidet, dass das zusätzliche Attribut von OP auf die Eigenschaft angewendet werden muss.