public override object ProvideValue(IServiceProvider provider)
{
if (type != null)
{
return(type);
}
if (provider == null)
{
throw new ArgumentNullException();
}
if (typeName == null)
{
throw new ArgumentNullException();
}
IXamlTypeResolver resolver = provider.GetService(typeof(IXamlTypeResolver)) as IXamlTypeResolver;
if (resolver == null)
{
throw new Exception("null resolver");
}
return(resolver.Resolve(typeName));
}
/// <summary>
/// Returns an object that is provided as the value of the target property for this markup extension.
/// </summary>
/// <param name="serviceProvider">A service provider helper that can provide services for the markup extension.</param>
public override object ProvideValue(IServiceProvider serviceProvider)
{
Contract.RequireNotNull(serviceProvider, out IServiceProvider ServiceProvider);
IXamlTypeResolver XamlTypeResolver = (IXamlTypeResolver)ServiceProvider.GetService(typeof(IXamlTypeResolver));
NotNullType Type;
if (Arg1.Length == 0)
{
Type = TypeFromName(XamlTypeResolver, TypeName);
}
else
{
NotNullType GenericDefinitionType = TypeFromName(XamlTypeResolver, TypeName);
NotNullAssembly GenericDefinitionAssembly = GenericDefinitionType.Assembly;
GenericDefinitionType = GenericDefinitionAssembly.GetType(ToFullNameWithArguments(GenericDefinitionType.Name, 1)) !;
NotNullType[] GenericArguments = new NotNullType[] { TypeFromName(XamlTypeResolver, Arg1) };
Type = GenericDefinitionType.MakeGenericType(GenericArguments);
}
return(Type);
}
public override Object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, Object value)
{
IXamlTypeResolver resolver = context.GetService(typeof(IXamlTypeResolver)) as IXamlTypeResolver;
if (value is String)
{
String[] stringArray = ((String)value).Split(',');
List <Type> types = new List <Type>();
for (Int32 i = 0; i < stringArray.Length; i++)
{
// Try to resolve type using XAML resolver.
Type type = resolver.Resolve(stringArray[i].Trim());
// Try to resolve using Type class.
if (type == null)
{
type = Type.GetType(stringArray[i].Trim());
}
if (type == null)
{
throw new InvalidOperationException();
}
else
{
types.Add(type);
}
}
return(types);
}
return(null);
}
/// <summary>
/// Returns an object that should be set on the property where this extension is applied.
/// </summary>
/// <param name="serviceProvider">Object that can provide services for the markup extension.</param>
/// <returns>The object value to set on the property where the markup extension provided
/// value is evaluated.</returns>
/// <exception cref="System.InvalidOperationException">serviceProvider was null, or failed to
/// implement a required service.</exception>
public override object ProvideValue(IServiceProvider serviceProvider)
{
object obj = null;
Type typeToResolve;
if (_dataContextType == null)
{
typeToResolve = typeof(object);
}
else if (_dataContextType is Type)
{
typeToResolve = (Type)_dataContextType;
}
else if (_dataContextType is String)
{
#if !WINDOWS_UWP
// ReSharper disable SuggestUseVarKeywordEvident
IXamlTypeResolver service = serviceProvider.GetService(typeof(IXamlTypeResolver)) as IXamlTypeResolver;
// ReSharper restore SuggestUseVarKeywordEvident
typeToResolve = BindHelper.ResolveTypeByName((string)_dataContextType);
if ((service != null) && (typeToResolve == null))
{
typeToResolve = service.Resolve((string)_dataContextType);
}
#else
typeToResolve = BindHelper.ResolveTypeByName((string)_dataContextType);
#endif
}
else
{
throw new ArgumentNullException("LocateDataContext - DataContextType can be 'Type' or 'String' or empty.");
}
// ReSharper disable SuggestUseVarKeywordEvident
IProvideValueTarget serviceProvideValueTarget = serviceProvider.GetService(typeof(IProvideValueTarget)) as IProvideValueTarget;
// ReSharper restore SuggestUseVarKeywordEvident
if ((serviceProvideValueTarget != null) && (serviceProvideValueTarget.TargetObject != null))
{
// Save targets for case delayed processing
TargetObject = serviceProvideValueTarget.TargetObject;
TargetProperty = serviceProvideValueTarget.TargetProperty;
if (!(serviceProvideValueTarget.TargetObject is DependencyObject))
{
throw new AggregateException("LocateDataContext - Target of the markup extension must be the DependencyObject type.");
}
obj = BindHelper.LocateValidDependencyPropertyByAllTrees(serviceProvideValueTarget.TargetObject as DependencyObject, FrameworkElement.DataContextProperty, MethodName, PropertyName, null, typeToResolve);
if (obj == null)
{
var frameworkElement = TargetObject as FrameworkElement;
if (frameworkElement != null)
{
frameworkElement.Loaded += DelayLocateDataContext;
}
}
}
return(obj);
}
public override object ProvideValue(IServiceProvider serviceProvider)
{
if (this._type == null)
{
if (this._typeName == null)
{
throw new InvalidOperationException(System.Xaml.SR.Get("MarkupExtensionTypeName"));
}
if (serviceProvider == null)
{
throw new ArgumentNullException("serviceProvider");
}
IXamlTypeResolver service = serviceProvider.GetService(typeof(IXamlTypeResolver)) as IXamlTypeResolver;
if (service == null)
{
throw new InvalidOperationException(System.Xaml.SR.Get("MarkupExtensionNoContext", new object[] { base.GetType().Name, "IXamlTypeResolver" }));
}
this._type = service.Resolve(this._typeName);
if (this._type == null)
{
throw new InvalidOperationException(System.Xaml.SR.Get("MarkupExtensionTypeNameBad", new object[] { this._typeName }));
}
}
return(this._type);
}
private NotNullType TypeFromName(IXamlTypeResolver xamlTypeResolver, string name)
{
string AssemblyQualifiedName = Contract.NullSupressed(xamlTypeResolver.Resolve(name).AssemblyQualifiedName);
NotNullType Result = NotNullType.GetType(AssemblyQualifiedName);
return(Result);
}
public override void Setup ()
{
base.Setup ();
var nsManager = new XmlNamespaceManager (new NameTable ());
nsManager.AddNamespace ("local", "clr-namespace:Xamarin.Forms.Xaml.UnitTests;assembly=Xamarin.Forms.Xaml.UnitTests");
nsManager.AddNamespace ("x", "http://schemas.microsoft.com/winfx/2009/xaml");
typeResolver = new Internals.XamlTypeResolver (nsManager, XamlParser.GetElementType, Assembly.GetCallingAssembly ());
}
private void AssertPropertyPathes(string path, IXamlTypeResolver typeResolver, bool positionsCheck, params PathToken[] expectedTokens)
{
var analyzer = new PropertyPathAnalyzer();
var tokens = analyzer.GetPathes(path, typeResolver);
CollectionAssert.AreEqual(expectedTokens.ToList(), tokens, new TestPathComparer(positionsCheck));
}
public override void Setup ()
{
base.Setup ();
var nsManager = new XmlNamespaceManager (new NameTable ());
nsManager.AddNamespace ("local", "clr-namespace:Xamarin.Forms.Xaml.UnitTests;assembly=Xamarin.Forms.Xaml.UnitTests");
nsManager.AddNamespace ("x", "http://schemas.microsoft.com/winfx/2009/xaml");
typeResolver = new Internals.XamlTypeResolver (nsManager, XamlParser.GetElementType, Assembly.GetCallingAssembly ());
}
public override object ProvideValue(IServiceProvider serviceProvider)
{
object obj2;
if (this._member == null)
{
throw new InvalidOperationException(System.Xaml.SR.Get("MarkupExtensionStaticMember"));
}
Type memberType = this.MemberType;
string str = null;
string str2 = null;
if (memberType != null)
{
str = this._member;
str2 = memberType.FullName + "." + this._member;
}
else
{
str2 = this._member;
int index = this._member.IndexOf('.');
if (index < 0)
{
throw new ArgumentException(System.Xaml.SR.Get("MarkupExtensionBadStatic", new object[] { this._member }));
}
string qualifiedTypeName = this._member.Substring(0, index);
if (qualifiedTypeName == string.Empty)
{
throw new ArgumentException(System.Xaml.SR.Get("MarkupExtensionBadStatic", new object[] { this._member }));
}
if (serviceProvider == null)
{
throw new ArgumentNullException("serviceProvider");
}
IXamlTypeResolver service = serviceProvider.GetService(typeof(IXamlTypeResolver)) as IXamlTypeResolver;
if (service == null)
{
throw new ArgumentException(System.Xaml.SR.Get("MarkupExtensionNoContext", new object[] { base.GetType().Name, "IXamlTypeResolver" }));
}
memberType = service.Resolve(qualifiedTypeName);
str = this._member.Substring(index + 1, (this._member.Length - index) - 1);
if (str == string.Empty)
{
throw new ArgumentException(System.Xaml.SR.Get("MarkupExtensionBadStatic", new object[] { this._member }));
}
}
if (memberType.IsEnum)
{
return(Enum.Parse(memberType, str));
}
if (!this.GetFieldOrPropertyValue(memberType, str, out obj2))
{
throw new ArgumentException(System.Xaml.SR.Get("MarkupExtensionBadStatic", new object[] { str2 }));
}
return(obj2);
}
public override void Setup()
{
base.Setup();
DeviceInfo.SetCurrent(mockDeviceInfo = new MockDeviceInfo());
var nsManager = new XmlNamespaceManager(new NameTable());
nsManager.AddNamespace("local", "clr-namespace:Microsoft.Maui.Controls.Xaml.UnitTests;assembly=Microsoft.Maui.Controls.Xaml.UnitTests");
nsManager.AddNamespace("x", "http://schemas.microsoft.com/winfx/2009/xaml");
typeResolver = new Internals.XamlTypeResolver(nsManager, XamlParser.GetElementType, Assembly.GetCallingAssembly());
}
/// <summary>
/// Find all sourceProperties pathes in Path string
/// </summary>
/// <param name="normPath"></param>
/// <returns>List of pathes and its start positions</returns>
private List <PathAppearances> GetSourcePathes(string normPath, IXamlTypeResolver typeResolver)
{
var propertyPathAnalyzer = new PropertyPathAnalyzer();
var pathes = propertyPathAnalyzer.GetPathes(normPath, typeResolver);
var propertiesGroups = pathes.GroupBy(p => p.Id).Select(p => new PathAppearances(p.Key, p.ToList())).ToList();
return(propertiesGroups);
}
public ServiceProviderMock(object TargetObject, object TargetProperty, Dictionary <string, Type> resolvedTypes)
{
provideValueTargetMock = new ProvideValueTargetMock
{
TargetObject = TargetObject,
TargetProperty = TargetProperty
};
xamlTypeResolverMock = new XamlTypeResolverMock(resolvedTypes);
}
public override Boolean CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
{
IXamlTypeResolver resolver = context.GetService(typeof(IXamlTypeResolver)) as IXamlTypeResolver;
if (sourceType == typeof(Type) || context != null)
{
return(true);
}
return(false);
}
public List <PathToken> GetPathes(string normPath, IXamlTypeResolver typeResolver)
{
_typeResolver = typeResolver;
Tracer.TraceDebug(string.Format("Start read {0} ", normPath));
var chunks = GetChunks(normPath);
var pathes = GetPathes(chunks);
return(pathes);
}
public sealed override object ProvideValue(IServiceProvider serviceProvider)
{
try {
this.serviceProvider = serviceProvider;
return(ProvideValueCore());
} finally {
this.serviceProvider = null;
this.targetProvider = null;
this.xamlTypeResolver = null;
}
}
public List <PathToken> GetPathes(string normPath, IXamlTypeResolver typeResolver)
{
_typeResolver = typeResolver;
Debug.WriteLine(string.Format("PropertyPathAnalyzer.GetPathes: start read {0} ", normPath));
var chunks = GetChunks(normPath);
var pathes = GetPathes(chunks);
return(pathes);
}
public override object ProvideValue(IServiceProvider serviceProvider)
{
IXamlTypeResolver xamlTypeResolver = serviceProvider.GetService(typeof(IXamlTypeResolver)) as IXamlTypeResolver;
if (xamlTypeResolver == null)
{
throw new ArgumentException("xamlTypeResolver");
}
Type resolvedType = xamlTypeResolver.Resolve(TypeName);
return(resolvedType);
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
string qualifiedTypeName = value as string;
if ((context != null) && (qualifiedTypeName != null))
{
IXamlTypeResolver service = GetService <IXamlTypeResolver>(context);
if (service != null)
{
return(service.Resolve(qualifiedTypeName));
}
}
return(base.ConvertFrom(context, culture, value));
}
public object ProvideValue(IServiceProvider serviceProvider)
{
IXamlTypeResolver resolver = serviceProvider.GetService(typeof(IXamlTypeResolver)) as IXamlTypeResolver;
if (resolver == null)
{
return(null);
}
var type = resolver.Resolve(Type);
var s = Application.Current.Resources[type.FullName] as Style;
return(s);
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
string text = value as string;
if (context != null && text != null)
{
IXamlTypeResolver xamlTypeResolver = (IXamlTypeResolver)context.GetService(typeof(IXamlTypeResolver));
if (xamlTypeResolver != null)
{
return(xamlTypeResolver.Resolve(text));
}
}
return(base.ConvertFrom(context, culture, value));
}
//Utility helper to get the required information from the parserContext
private Type GetTypeFromContext(ITypeDescriptorContext context, string typeName)
{
// Parser Context must exist to get the namespace info from prefix, if not, we assume it is known command.
if (null != context && typeName != null)
{
IXamlTypeResolver xamlTypeResolver = (IXamlTypeResolver)context.GetService(typeof(IXamlTypeResolver));
if (null != xamlTypeResolver)
{
return(xamlTypeResolver.Resolve(typeName));
}
}
return(null);
}
public override object ProvideValue(IServiceProvider serviceProvider)
{
IXamlTypeResolver typeResolver = (IXamlTypeResolver)serviceProvider.GetService(typeof(IXamlTypeResolver));
int sepindex = TypeName.IndexOf('+');
if (sepindex < 0)
{
return(typeResolver.Resolve(TypeName));
}
else
{
Type outerType = typeResolver.Resolve(TypeName.Substring(0, sepindex));
return(outerType.Assembly.GetType(outerType.FullName + "+" + TypeName.Substring(sepindex + 1)));
}
}
private Type parseType(IServiceProvider serviceProvider)
{
if (this.Type == null)
{
IXamlTypeResolver xamlTypeResolver = serviceProvider.GetService(typeof(IXamlTypeResolver)) as IXamlTypeResolver;
if (xamlTypeResolver != null)
{
return(xamlTypeResolver.Resolve(this.TypeName));
}
}
else
{
return(this.Type);
}
return(typeof(IEnumerable <object>));
}
public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
{
string typeName = value as string;
if (null != context && typeName != null)
{
IXamlTypeResolver xamlTypeResolver = (IXamlTypeResolver)context.GetService(typeof(IXamlTypeResolver));
if (null != xamlTypeResolver)
{
return(xamlTypeResolver.Resolve(typeName));
}
}
return(base.ConvertFrom(context, culture, value));
}
public override void Setup()
{
base.Setup();
var nsManager = new XmlNamespaceManager(new NameTable());
nsManager.AddNamespace("", "http://xamarin.com/schemas/2014/forms");
nsManager.AddNamespace("local", "clr-namespace:Xamarin.Forms.Xaml.UnitTests;assembly=Xamarin.Forms.Xaml.UnitTests");
nsManager.AddNamespace("sys", "clr-namespace:System;assembly=mscorlib");
nsManager.AddNamespace("x", "http://schemas.microsoft.com/winfx/2006/xaml");
typeResolver = new Internals.XamlTypeResolver(nsManager, XamlParser.GetElementType, Assembly.GetCallingAssembly());
serviceProvider = new Internals.XamlServiceProvider(null, null)
{
IXamlTypeResolver = typeResolver,
};
}
public Type Resolve(IServiceProvider p)
{
if (_type == null)
{
if (_typeName == null)
{
throw new InvalidOperationException("MarkupExtension Type requires Type or TypeName to be defined.");
}
IXamlTypeResolver service = p.GetService <IXamlTypeResolver>(true);
_type = service.Resolve(_typeName);
if (_type == null)
{
throw new InvalidOperationException(String.Format("MarkupExtension invalid TypeName '{0}'.", _typeName));
}
}
return(_type);
}
/// <summary>
/// Returns an object that is provided as the value of the target property for this markup extension.
/// </summary>
/// <param name="serviceProvider">A service provider helper that can provide services for the markup extension.</param>
public override object ProvideValue(IServiceProvider serviceProvider)
{
Debug.Assert(serviceProvider != null);
Debug.Assert(TypeName != null);
Debug.Assert((Arg1 == null && Arg2 == null) || (Arg1 != null && Arg2 == null) || (Arg1 != null && Arg2 != null));
IXamlTypeResolver XamlTypeResolver = serviceProvider.GetService(typeof(IXamlTypeResolver)) as IXamlTypeResolver;
System.Type Type = null;
if (Arg1 == null && Arg2 == null)
{
Type = XamlTypeResolver.Resolve(TypeName);
}
else if (Arg1 != null && Arg2 == null)
{
System.Type Arg1Type;
System.Type GenericDefinitionType;
Arg1Type = XamlTypeResolver.Resolve(Arg1);
GenericDefinitionType = XamlTypeResolver.Resolve($"{TypeName}`1");
System.Type[] GenericArguments = new System.Type[] { Arg1Type };
Type = GenericDefinitionType.MakeGenericType(GenericArguments);
}
else if (Arg1 != null && Arg1 != null)
{
System.Type Arg1Type;
System.Type Arg2Type;
System.Type GenericDefinitionType;
Arg1Type = XamlTypeResolver.Resolve(Arg1);
Arg2Type = XamlTypeResolver.Resolve(Arg2);
GenericDefinitionType = XamlTypeResolver.Resolve(TypeName);
Assembly GenericDefinitionAssembly = GenericDefinitionType.Assembly;
GenericDefinitionType = GenericDefinitionAssembly.GetType(ToFullNameWithArguments(GenericDefinitionType.Name, 2));
System.Type[] GenericArguments = new System.Type[] { Arg1Type, Arg2Type };
Type = GenericDefinitionType.MakeGenericType(GenericArguments);
}
return(Type);
}
public void XamlServiceProviderIXamlTypeResolver()
{
tlog.Debug(tag, $"XamlServiceProviderIXamlTypeResolver START");
try
{
IXamlTypeResolver i1 = x1.IXamlTypeResolver;
x1.IXamlTypeResolver = i1;
}
catch (Exception e)
{
Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
Assert.Fail("Caught Exception" + e.ToString());
}
tlog.Debug(tag, $"XamlServiceProviderIXamlTypeResolver END (OK)");
Assert.Pass("XamlServiceProviderIXamlTypeResolver");
}
public override object ProvideValue(IServiceProvider serviceProvider)
{
IProvideValueTarget provideValue = serviceProvider.GetService(typeof(IProvideValueTarget)) as IProvideValueTarget;
if (provideValue != null)
{
var host = provideValue.TargetObject as FrameworkElement;
var prop = provideValue.TargetProperty as DependencyProperty;
}
IXamlTypeResolver xamlTypeResolver = serviceProvider.GetService(typeof(IXamlTypeResolver)) as IXamlTypeResolver;
if (xamlTypeResolver != null)
{
}
double result = 0;
switch (Operation)
{
case Operation.Add:
result = X + Y;
break;
case Operation.Subtract:
result = X - Y;
break;
case Operation.Multiply:
result = X * Y;
break;
case Operation.Divide:
result = X / Y;
break;
default:
throw new ArgumentException("invalid operation");
}
return(result.ToString());
}
/// <summary>
/// Return an object that should be set on the targetObject's targetProperty
/// for this markup extension. TypeExtension resolves a string into a Type
/// and returns it.
/// </summary>
/// <param name="serviceProvider">Object that can provide services for the markup extension.</param>
/// <returns>
/// The object to set on this property.
/// </returns>
public override object ProvideValue(IServiceProvider serviceProvider)
{
// If a type was supplied, no context nor type name are needed
if (_type != null)
{
return(_type);
}
// Validate the initialization
if (_typeName == null)
{
throw new InvalidOperationException(SR.Get(SRID.MarkupExtensionTypeName));
}
// Get the IXamlTypeResolver from the service provider
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
IXamlTypeResolver xamlTypeResolver = serviceProvider.GetService(typeof(IXamlTypeResolver)) as IXamlTypeResolver;
if (xamlTypeResolver == null)
{
throw new InvalidOperationException(SR.Get(SRID.MarkupExtensionNoContext, GetType().Name, "IXamlTypeResolver"));
}
// Get the type
_type = xamlTypeResolver.Resolve(_typeName);
if (_type == null)
{
throw new InvalidOperationException(SR.Get(SRID.MarkupExtensionTypeNameBad, _typeName));
}
return(_type);
// we could cash the result of type as _type, but it might cause some problems, and in theory we shouldn't need to
}
public override object ProvideValue( IServiceProvider serviceProvider )
{
_typeResolver = (IXamlTypeResolver)serviceProvider.GetService( typeof( IXamlTypeResolver ) );
var targetResolver = (IProvideValueTarget)serviceProvider.GetService( typeof( IProvideValueTarget ) );
object targetObject = targetResolver.TargetObject;
object targetProperty = targetResolver.TargetProperty;
if ( ServiceProvider == null )
{
// HACK: The service provider provided by SharedDP objects doesn't seem to work?
ServiceProvider = serviceProvider;
}
if ( targetObject is DependencyObject || targetObject is Binding || targetObject is MultiBinding )
{
return ProvideValue( targetObject, targetProperty );
}
// Required to resolve SharedDP when Binding is used in templates.
return this;
}
