2 // Copyright (C) 2010 Novell Inc. http://novell.com
4 // Permission is hereby granted, free of charge, to any person obtaining
5 // a copy of this software and associated documentation files (the
6 // "Software"), to deal in the Software without restriction, including
7 // without limitation the rights to use, copy, modify, merge, publish,
8 // distribute, sublicense, and/or sell copies of the Software, and to
9 // permit persons to whom the Software is furnished to do so, subject to
10 // the following conditions:
12 // The above copyright notice and this permission notice shall be
13 // included in all copies or substantial portions of the Software.
15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
19 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
20 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
21 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 using System.Collections;
25 using System.Collections.Generic;
26 using System.ComponentModel;
28 using System.Reflection;
29 using System.Windows.Markup;
30 using System.Xaml.Schema;
31 using System.Xml.Serialization;
35 public class XamlType : IEquatable<XamlType>
37 public XamlType (Type underlyingType, XamlSchemaContext schemaContext)
38 : this (underlyingType, schemaContext, null)
42 // static readonly Type [] predefined_types = {
43 // typeof (XData), typeof (Uri), typeof (TimeSpan), typeof (PropertyDefinition), typeof (MemberDefinition), typeof (Reference)
46 public XamlType (Type underlyingType, XamlSchemaContext schemaContext, XamlTypeInvoker invoker)
47 : this (schemaContext, invoker)
49 if (underlyingType == null)
50 throw new ArgumentNullException ("underlyingType");
51 type = underlyingType;
52 underlying_type = type;
55 if (XamlLanguage.InitializingTypes) {
56 // These are special. Only XamlLanguage members are with shorthand name.
57 if (type == typeof (PropertyDefinition))
59 else if (type == typeof (MemberDefinition))
62 Name = GetXamlName (type);
63 PreferredXamlNamespace = XamlLanguage.Xaml2006Namespace;
64 } else if ((xt = XamlLanguage.AllTypes.FirstOrDefault (t => t.UnderlyingType == type)) != null) {
66 PreferredXamlNamespace = XamlLanguage.Xaml2006Namespace;
68 Name = GetXamlName (type);
69 PreferredXamlNamespace = schemaContext.GetXamlNamespace (type.Namespace) ?? String.Format ("clr-namespace:{0};assembly={1}", type.Namespace, type.Assembly.GetName ().Name);
71 if (type.IsGenericType) {
72 TypeArguments = new List<XamlType> ();
73 foreach (var gta in type.GetGenericArguments ())
74 TypeArguments.Add (schemaContext.GetXamlType (gta));
78 public XamlType (string unknownTypeNamespace, string unknownTypeName, IList<XamlType> typeArguments, XamlSchemaContext schemaContext)
79 : this (schemaContext, null)
81 if (unknownTypeNamespace == null)
82 throw new ArgumentNullException ("unknownTypeNamespace");
83 if (unknownTypeName == null)
84 throw new ArgumentNullException ("unknownTypeName");
85 if (schemaContext == null)
86 throw new ArgumentNullException ("schemaContext");
88 type = typeof (object);
89 Name = unknownTypeName;
90 PreferredXamlNamespace = unknownTypeNamespace;
91 TypeArguments = typeArguments != null && typeArguments.Count == 0 ? null : typeArguments;
92 // explicit_ns = unknownTypeNamespace;
95 protected XamlType (string typeName, IList<XamlType> typeArguments, XamlSchemaContext schemaContext)
96 : this (String.Empty, typeName, typeArguments, schemaContext)
100 XamlType (XamlSchemaContext schemaContext, XamlTypeInvoker invoker)
102 if (schemaContext == null)
103 throw new ArgumentNullException ("schemaContext");
104 SchemaContext = schemaContext;
105 this.invoker = invoker ?? new XamlTypeInvoker (this);
108 Type type, underlying_type;
110 // string explicit_ns;
112 // populated properties
114 XamlTypeInvoker invoker;
116 internal EventHandler<XamlSetMarkupExtensionEventArgs> SetMarkupExtensionHandler {
117 get { return LookupSetMarkupExtensionHandler (); }
120 internal EventHandler<XamlSetTypeConverterEventArgs> SetTypeConverterHandler {
121 get { return LookupSetTypeConverterHandler (); }
124 public IList<XamlType> AllowedContentTypes {
125 get { return LookupAllowedContentTypes (); }
128 public XamlType BaseType {
129 get { return LookupBaseType (); }
132 public bool ConstructionRequiresArguments {
133 get { return LookupConstructionRequiresArguments (); }
136 public XamlMember ContentProperty {
137 get { return LookupContentProperty (); }
140 public IList<XamlType> ContentWrappers {
141 get { return LookupContentWrappers (); }
144 public XamlValueConverter<XamlDeferringLoader> DeferringLoader {
145 get { return LookupDeferringLoader (); }
148 public XamlTypeInvoker Invoker {
149 get { return LookupInvoker (); }
152 public bool IsAmbient {
153 get { return LookupIsAmbient (); }
156 public bool IsArray {
157 get { return LookupCollectionKind () == XamlCollectionKind.Array; }
160 // it somehow treats array as not a collection...
161 public bool IsCollection {
162 get { return LookupCollectionKind () == XamlCollectionKind.Collection; }
165 public bool IsConstructible {
166 get { return LookupIsConstructible (); }
169 public bool IsDictionary {
170 get { return LookupCollectionKind () == XamlCollectionKind.Dictionary; }
173 public bool IsGeneric {
174 get { return type.IsGenericType; }
177 public bool IsMarkupExtension {
178 get { return LookupIsMarkupExtension (); }
180 public bool IsNameScope {
181 get { return LookupIsNameScope (); }
183 public bool IsNameValid {
184 get { return XamlLanguage.IsValidXamlName (Name); }
187 public bool IsNullable {
188 get { return LookupIsNullable (); }
191 public bool IsPublic {
192 get { return LookupIsPublic (); }
195 public bool IsUnknown {
196 get { return LookupIsUnknown (); }
199 public bool IsUsableDuringInitialization {
200 get { return LookupUsableDuringInitialization (); }
203 public bool IsWhitespaceSignificantCollection {
204 get { return LookupIsWhitespaceSignificantCollection (); }
207 public bool IsXData {
208 get { return LookupIsXData (); }
211 public XamlType ItemType {
212 get { return LookupItemType (); }
215 public XamlType KeyType {
216 get { return LookupKeyType (); }
219 public XamlType MarkupExtensionReturnType {
220 get { return LookupMarkupExtensionReturnType (); }
223 public string Name { get; private set; }
225 public string PreferredXamlNamespace { get; private set; }
227 public XamlSchemaContext SchemaContext { get; private set; }
229 public bool TrimSurroundingWhitespace {
230 get { return LookupTrimSurroundingWhitespace (); }
233 public IList<XamlType> TypeArguments { get; private set; }
235 public XamlValueConverter<TypeConverter> TypeConverter {
236 get { return LookupTypeConverter (); }
239 public Type UnderlyingType {
240 get { return LookupUnderlyingType (); }
243 public XamlValueConverter<ValueSerializer> ValueSerializer {
244 get { return LookupValueSerializer (); }
247 internal string GetInternalXmlName ()
249 if (IsMarkupExtension && Name.EndsWith ("Extension", StringComparison.Ordinal))
250 return Name.Substring (0, Name.Length - 9);
251 var stn = XamlLanguage.SpecialNames.FirstOrDefault (s => s.Type == this);
252 return stn != null ? stn.Name : Name;
255 public static bool operator == (XamlType left, XamlType right)
257 return IsNull (left) ? IsNull (right) : left.Equals (right);
260 static bool IsNull (XamlType a)
262 return Object.ReferenceEquals (a, null);
265 public static bool operator != (XamlType left, XamlType right)
267 return !(left == right);
270 public bool Equals (XamlType other)
272 // It does not compare XamlSchemaContext.
273 return !IsNull (other) &&
274 UnderlyingType == other.UnderlyingType &&
275 Name == other.Name &&
276 PreferredXamlNamespace == other.PreferredXamlNamespace && TypeArguments.ListEquals (other.TypeArguments);
279 public override bool Equals (object obj)
281 var a = obj as XamlType;
285 public override int GetHashCode ()
287 if (UnderlyingType != null)
288 return UnderlyingType.GetHashCode ();
289 int x = Name.GetHashCode () << 7 + PreferredXamlNamespace.GetHashCode ();
290 if (TypeArguments != null)
291 foreach (var t in TypeArguments)
292 x = t.GetHashCode () + x << 5;
296 public override string ToString ()
298 return new XamlTypeName (this).ToString ();
299 //return String.IsNullOrEmpty (PreferredXamlNamespace) ? Name : String.Concat ("{", PreferredXamlNamespace, "}", Name);
302 public virtual bool CanAssignTo (XamlType xamlType)
304 if (this.UnderlyingType == null)
305 return xamlType == XamlLanguage.Object;
306 var ut = xamlType.UnderlyingType ?? typeof (object);
307 return ut.IsAssignableFrom (UnderlyingType);
310 public XamlMember GetAliasedProperty (XamlDirective directive)
312 return LookupAliasedProperty (directive);
315 public ICollection<XamlMember> GetAllAttachableMembers ()
317 return new List<XamlMember> (LookupAllAttachableMembers ());
320 public ICollection<XamlMember> GetAllMembers ()
322 return new List<XamlMember> (LookupAllMembers ());
325 public XamlMember GetAttachableMember (string name)
327 return LookupAttachableMember (name);
330 public XamlMember GetMember (string name)
332 return LookupMember (name, true);
335 public IList<XamlType> GetPositionalParameters (int parameterCount)
337 return LookupPositionalParameters (parameterCount);
340 public virtual IList<string> GetXamlNamespaces ()
342 throw new NotImplementedException ();
343 /* this does not work like documented!
344 if (explicit_ns != null)
345 return new string [] {explicit_ns};
346 var l = SchemaContext.GetAllXamlNamespaces ();
348 return new List<string> (l);
349 return new string [] {String.Empty};
355 protected virtual XamlMember LookupAliasedProperty (XamlDirective directive)
357 if (directive == XamlLanguage.Key) {
358 var a = this.GetCustomAttribute<DictionaryKeyPropertyAttribute> ();
359 return a != null ? GetMember (a.Name) : null;
361 if (directive == XamlLanguage.Name) {
362 var a = this.GetCustomAttribute<RuntimeNamePropertyAttribute> ();
363 return a != null ? GetMember (a.Name) : null;
365 if (directive == XamlLanguage.Uid) {
366 var a = this.GetCustomAttribute<UidPropertyAttribute> ();
367 return a != null ? GetMember (a.Name) : null;
369 if (directive == XamlLanguage.Lang) {
370 var a = this.GetCustomAttribute<XmlLangPropertyAttribute> ();
371 return a != null ? GetMember (a.Name) : null;
376 protected virtual IEnumerable<XamlMember> LookupAllAttachableMembers ()
378 if (UnderlyingType == null)
379 return BaseType != null ? BaseType.GetAllAttachableMembers () : empty_array;
380 if (all_attachable_members_cache == null) {
381 all_attachable_members_cache = new List<XamlMember> (DoLookupAllAttachableMembers ());
382 all_attachable_members_cache.Sort (TypeExtensionMethods.CompareMembers);
384 return all_attachable_members_cache;
387 IEnumerable<XamlMember> DoLookupAllAttachableMembers ()
389 // based on http://msdn.microsoft.com/en-us/library/ff184560.aspx
390 var bf = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static;
392 var gl = new Dictionary<string,MethodInfo> ();
393 var sl = new Dictionary<string,MethodInfo> ();
394 var al = new Dictionary<string,MethodInfo> ();
395 //var rl = new Dictionary<string,MethodInfo> ();
396 var nl = new List<string> ();
397 foreach (var mi in UnderlyingType.GetMethods (bf)) {
399 if (mi.Name.StartsWith ("Get", StringComparison.Ordinal)) {
400 if (mi.ReturnType == typeof (void))
402 var args = mi.GetParameters ();
403 if (args.Length != 1)
405 name = mi.Name.Substring (3);
407 } else if (mi.Name.StartsWith ("Set", StringComparison.Ordinal)) {
408 // looks like the return type is *ignored*
409 //if (mi.ReturnType != typeof (void))
411 var args = mi.GetParameters ();
412 if (args.Length != 2)
414 name = mi.Name.Substring (3);
416 } else if (mi.Name.EndsWith ("Handler", StringComparison.Ordinal)) {
417 var args = mi.GetParameters ();
418 if (args.Length != 2)
420 if (mi.Name.StartsWith ("Add", StringComparison.Ordinal)) {
421 name = mi.Name.Substring (3, mi.Name.Length - 3 - 7);
423 }/* else if (mi.Name.StartsWith ("Remove", StringComparison.Ordinal)) {
424 name = mi.Name.Substring (6, mi.Name.Length - 6 - 7);
428 if (name != null && !nl.Contains (name))
432 foreach (var name in nl) {
434 var g = gl.TryGetValue (name, out m) ? m : null;
435 var s = sl.TryGetValue (name, out m) ? m : null;
436 if (g != null || s != null)
437 yield return new XamlMember (name, g, s, SchemaContext);
438 var a = al.TryGetValue (name, out m) ? m : null;
439 //var r = rl.TryGetValue (name, out m) ? m : null;
441 yield return new XamlMember (name, a, SchemaContext);
445 static readonly XamlMember [] empty_array = new XamlMember [0];
447 protected virtual IEnumerable<XamlMember> LookupAllMembers ()
449 if (UnderlyingType == null)
450 return BaseType != null ? BaseType.GetAllMembers () : empty_array;
451 if (all_members_cache == null) {
452 all_members_cache = new List<XamlMember> (DoLookupAllMembers ());
453 all_members_cache.Sort (TypeExtensionMethods.CompareMembers);
455 return all_members_cache;
458 List<XamlMember> all_members_cache;
459 List<XamlMember> all_attachable_members_cache;
461 IEnumerable<XamlMember> DoLookupAllMembers ()
463 // This is a hack that is likely required due to internal implementation difference in System.Uri. Our Uri has two readonly collection properties
464 if (this == XamlLanguage.Uri)
467 var bf = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
469 foreach (var pi in UnderlyingType.GetProperties (bf)) {
470 if (pi.Name.Contains ('.')) // exclude explicit interface implementations.
472 if (pi.CanRead && (pi.CanWrite || IsCollectionType (pi.PropertyType) || typeof (IXmlSerializable).IsAssignableFrom (pi.PropertyType)) && pi.GetIndexParameters ().Length == 0)
473 yield return new XamlMember (pi, SchemaContext);
475 foreach (var ei in UnderlyingType.GetEvents (bf))
476 yield return new XamlMember (ei, SchemaContext);
479 static bool IsPublicAccessor (MethodInfo mi)
481 return mi != null && mi.IsPublic;
484 bool IsCollectionType (Type type)
488 var xt = SchemaContext.GetXamlType (type);
489 return xt.LookupCollectionKind () != XamlCollectionKind.None;
492 protected virtual IList<XamlType> LookupAllowedContentTypes ()
494 // the actual implementation is very different from what is documented :(
498 var l = new List<XamlType> ();
499 if (ContentWrappers != null)
500 l.AddRange (ContentWrappers);
501 if (ContentProperty != null)
502 l.Add (ContentProperty.Type);
503 if (ItemType != null)
505 return l.Count > 0 ? l : null;
509 protected virtual XamlMember LookupAttachableMember (string name)
511 return GetAllAttachableMembers ().FirstOrDefault (m => m.Name == name);
514 protected virtual XamlType LookupBaseType ()
516 if (base_type == null) {
517 if (UnderlyingType == null)
518 base_type = SchemaContext.GetXamlType (typeof (object));
520 base_type = type.BaseType == null || type.BaseType == typeof (object) ? null : SchemaContext.GetXamlType (type.BaseType);
525 // This implementation is not verified. (No place to use.)
526 protected internal virtual XamlCollectionKind LookupCollectionKind ()
528 if (UnderlyingType == null)
529 return BaseType != null ? BaseType.LookupCollectionKind () : XamlCollectionKind.None;
531 return XamlCollectionKind.Array;
533 if (type.ImplementsAnyInterfacesOf (typeof (IDictionary), typeof (IDictionary<,>)))
534 return XamlCollectionKind.Dictionary;
536 if (type.ImplementsAnyInterfacesOf (typeof (IList), typeof (ICollection<>)))
537 return XamlCollectionKind.Collection;
539 return XamlCollectionKind.None;
542 protected virtual bool LookupConstructionRequiresArguments ()
544 if (UnderlyingType == null)
547 // not sure if it is required, but MemberDefinition return true while they are abstract and it makes no sense.
548 if (UnderlyingType.IsAbstract)
551 // FIXME: probably some primitive types are treated as special.
552 switch (Type.GetTypeCode (UnderlyingType)) {
553 case TypeCode.String:
555 case TypeCode.Object:
556 if (UnderlyingType == typeof (TimeSpan))
563 return UnderlyingType.GetConstructor (BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, Type.EmptyTypes, null) == null;
566 protected virtual XamlMember LookupContentProperty ()
568 var a = this.GetCustomAttribute<ContentPropertyAttribute> ();
569 return a != null && a.Name != null ? GetMember (a.Name) : null;
572 protected virtual IList<XamlType> LookupContentWrappers ()
574 if (GetCustomAttributeProvider () == null)
577 var arr = GetCustomAttributeProvider ().GetCustomAttributes (typeof (ContentWrapperAttribute), false);
578 if (arr == null || arr.Length == 0)
580 var l = new XamlType [arr.Length];
581 for (int i = 0; i < l.Length; i++)
582 l [i] = SchemaContext.GetXamlType (((ContentWrapperAttribute) arr [i]).ContentWrapper);
586 internal ICustomAttributeProvider GetCustomAttributeProvider ()
588 return LookupCustomAttributeProvider ();
591 protected internal virtual ICustomAttributeProvider LookupCustomAttributeProvider ()
593 return UnderlyingType;
596 protected virtual XamlValueConverter<XamlDeferringLoader> LookupDeferringLoader ()
598 throw new NotImplementedException ();
601 protected virtual XamlTypeInvoker LookupInvoker ()
606 protected virtual bool LookupIsAmbient ()
608 return this.GetCustomAttribute<AmbientAttribute> () != null;
611 // It is documented as if it were to reflect spec. section 5.2,
612 // but the actual behavior shows it is *totally* wrong.
613 // Here I have implemented this based on the nunit test results. sigh.
614 protected virtual bool LookupIsConstructible ()
616 if (UnderlyingType == null)
618 if (IsMarkupExtension)
620 if (UnderlyingType.IsAbstract)
627 protected virtual bool LookupIsMarkupExtension ()
629 return typeof (MarkupExtension).IsAssignableFrom (UnderlyingType);
632 protected virtual bool LookupIsNameScope ()
634 return typeof (INameScope).IsAssignableFrom (UnderlyingType);
637 protected virtual bool LookupIsNullable ()
639 return !type.IsValueType || type.IsGenericType && type.GetGenericTypeDefinition () == typeof (Nullable<>);
642 protected virtual bool LookupIsPublic ()
644 return underlying_type == null || underlying_type.IsPublic || underlying_type.IsNestedPublic;
647 protected virtual bool LookupIsUnknown ()
649 return UnderlyingType == null;
652 protected virtual bool LookupIsWhitespaceSignificantCollection ()
654 // probably for unknown types, it should preserve whitespaces.
655 return IsUnknown || this.GetCustomAttribute<WhitespaceSignificantCollectionAttribute> () != null;
658 protected virtual bool LookupIsXData ()
660 return CanAssignTo (SchemaContext.GetXamlType (typeof (IXmlSerializable)));
663 protected virtual XamlType LookupItemType ()
666 return new XamlType (type.GetElementType (), SchemaContext);
669 return new XamlType (typeof (object), SchemaContext);
670 return new XamlType (type.GetGenericArguments () [1], SchemaContext);
675 return new XamlType (typeof (object), SchemaContext);
676 return new XamlType (type.GetGenericArguments () [0], SchemaContext);
679 protected virtual XamlType LookupKeyType ()
684 return new XamlType (typeof (object), SchemaContext);
685 return new XamlType (type.GetGenericArguments () [0], SchemaContext);
688 protected virtual XamlType LookupMarkupExtensionReturnType ()
690 var a = this.GetCustomAttribute<MarkupExtensionReturnTypeAttribute> ();
691 return a != null ? new XamlType (a.ReturnType, SchemaContext) : null;
694 protected virtual XamlMember LookupMember (string name, bool skipReadOnlyCheck)
696 // FIXME: verify if this does not filter out events.
697 return GetAllMembers ().FirstOrDefault (m => m.Name == name && (skipReadOnlyCheck || !m.IsReadOnly || m.Type.IsCollection || m.Type.IsDictionary || m.Type.IsArray));
700 protected virtual IList<XamlType> LookupPositionalParameters (int parameterCount)
702 if (UnderlyingType == null/* || !IsMarkupExtension*/) // see nunit tests...
705 // check if there is applicable ConstructorArgumentAttribute.
706 // If there is, then return its type.
707 if (parameterCount == 1) {
708 foreach (var xm in GetAllMembers ()) {
709 var ca = xm.GetCustomAttributeProvider ().GetCustomAttribute<ConstructorArgumentAttribute> (false);
711 return new XamlType [] {xm.Type};
715 var methods = (from m in UnderlyingType.GetConstructors (BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance) where m.GetParameters ().Length == parameterCount select m).ToArray ();
716 if (methods.Length == 1)
717 return (from p in methods [0].GetParameters () select SchemaContext.GetXamlType (p.ParameterType)).ToArray ();
719 if (SchemaContext.SupportMarkupExtensionsWithDuplicateArity)
720 throw new NotSupportedException ("The default LookupPositionalParameters implementation does not allow duplicate arity of markup extensions");
724 BindingFlags flags_get_static = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static;
726 protected virtual EventHandler<XamlSetMarkupExtensionEventArgs> LookupSetMarkupExtensionHandler ()
728 var a = this.GetCustomAttribute<XamlSetMarkupExtensionAttribute> ();
731 var mi = type.GetMethod (a.XamlSetMarkupExtensionHandler, flags_get_static);
733 throw new ArgumentException ("Binding to XamlSetMarkupExtensionHandler failed");
734 return (EventHandler<XamlSetMarkupExtensionEventArgs>) Delegate.CreateDelegate (typeof (EventHandler<XamlSetMarkupExtensionEventArgs>), mi);
737 protected virtual EventHandler<XamlSetTypeConverterEventArgs> LookupSetTypeConverterHandler ()
739 var a = this.GetCustomAttribute<XamlSetTypeConverterAttribute> ();
742 var mi = type.GetMethod (a.XamlSetTypeConverterHandler, flags_get_static);
744 throw new ArgumentException ("Binding to XamlSetTypeConverterHandler failed");
745 return (EventHandler<XamlSetTypeConverterEventArgs>) Delegate.CreateDelegate (typeof (EventHandler<XamlSetTypeConverterEventArgs>), mi);
748 protected virtual bool LookupTrimSurroundingWhitespace ()
750 return this.GetCustomAttribute<TrimSurroundingWhitespaceAttribute> () != null;
753 protected virtual XamlValueConverter<TypeConverter> LookupTypeConverter ()
755 var t = UnderlyingType;
759 // equivalent to TypeExtension.
760 // FIXME: not sure if it should be specially handled here.
761 if (t == typeof (Type))
762 t = typeof (TypeExtension);
764 var a = GetCustomAttributeProvider ();
765 var ca = a != null ? a.GetCustomAttribute<TypeConverterAttribute> (false) : null;
767 return SchemaContext.GetValueConverter<TypeConverter> (Type.GetType (ca.ConverterTypeName), this);
769 if (t == typeof (object)) // This is a special case. ConverterType is null.
770 return SchemaContext.GetValueConverter<TypeConverter> (null, this);
772 // It's still not decent to check CollectionConverter.
773 var tct = t.GetTypeConverter ().GetType ();
774 if (tct != typeof (TypeConverter) && tct != typeof (CollectionConverter) && tct != typeof (ReferenceConverter))
775 return SchemaContext.GetValueConverter<TypeConverter> (tct, this);
779 protected virtual Type LookupUnderlyingType ()
781 return underlying_type;
784 protected virtual bool LookupUsableDuringInitialization ()
786 var a = this.GetCustomAttribute<UsableDuringInitializationAttribute> ();
787 return a != null && a.Usable;
790 static XamlValueConverter<ValueSerializer> string_value_serializer;
792 protected virtual XamlValueConverter<ValueSerializer> LookupValueSerializer ()
794 return LookupValueSerializer (this, GetCustomAttributeProvider ());
797 internal static XamlValueConverter<ValueSerializer> LookupValueSerializer (XamlType targetType, ICustomAttributeProvider provider)
799 if (provider == null)
802 var a = provider.GetCustomAttribute<ValueSerializerAttribute> (true);
804 return new XamlValueConverter<ValueSerializer> (a.ValueSerializerType ?? Type.GetType (a.ValueSerializerTypeName), targetType);
806 if (targetType.BaseType != null) {
807 var ret = targetType.BaseType.LookupValueSerializer ();
812 if (targetType.UnderlyingType == typeof (string)) {
813 if (string_value_serializer == null)
814 string_value_serializer = new XamlValueConverter<ValueSerializer> (typeof (StringValueSerializer), targetType);
815 return string_value_serializer;
821 static string GetXamlName (Type type)
824 if (!type.IsNestedPublic && !type.IsNestedAssembly && !type.IsNestedPrivate)
827 n = GetXamlName (type.DeclaringType) + "+" + type.Name;
828 if (type.IsGenericType && !type.ContainsGenericParameters) // the latter condition is to filter out "nested non-generic type within generic type".
829 return n.Substring (0, n.IndexOf ('`'));