public override object DeferredLoad(ServiceProviderContext serviceContext, XamlValueConverter <XamlDeferringLoader> deferringLoader, XamlReader deferredContent)
{
if (!MemberAccessPermissionDenied || deferringLoader.IsPublic || !IsDefaultConverter(deferringLoader))
{
try
{
return(_transparentRuntime.DeferredLoad(serviceContext, deferringLoader, deferredContent));
}
catch (XamlException e)
{
// We don't know if MissingMethodException is due to visibility or not.
// So we fall back to the elevated runtime, but we don't set _memberAccessPermissionDenied.
if (e.InnerException is MissingMethodException)
{
EnsureElevatedRuntime();
}
else if (e.InnerException is MethodAccessException)
{
MemberAccessPermissionDenied = true;
}
else
{
throw;
}
}
}
return(_elevatedRuntime.DeferredLoad(serviceContext, deferringLoader, deferredContent));
}
public override object CreateFromValue(ServiceProviderContext serviceContext, XamlValueConverter <TypeConverter> ts, object value, XamlMember property)
{
if (!MemberAccessPermissionDenied || ts.IsPublic || !IsDefaultConverter(ts))
{
try
{
return(_transparentRuntime.CreateFromValue(serviceContext, ts, value, property));
}
// We don't know if MissingMethodException is due to visibility or not.
// So we fall back to the elevated runtime, but we don't set _memberAccessPermissionDenied.
catch (MissingMethodException)
{
EnsureElevatedRuntime();
}
catch (MethodAccessException)
{
MemberAccessPermissionDenied = true;
}
catch (SecurityException)
{
MemberAccessPermissionDenied = true;
}
}
return(_elevatedRuntime.CreateFromValue(serviceContext, ts, value, property));
}
public override object DeferredLoad(ServiceProviderContext serviceContext,
XamlValueConverter <XamlDeferringLoader> deferringLoader,
XamlReader deferredContent)
{
try
{
XamlDeferringLoader converter = GetConverterInstance(deferringLoader);
if (converter == null)
{
throw new XamlObjectWriterException(SR.Get(SRID.DeferringLoaderInstanceNull, deferringLoader));
}
return(converter.Load(deferredContent, serviceContext));
}
catch (Exception e)
{
// Reset the reader in case our caller catches and retries
IXamlIndexingReader indexingReader = deferredContent as IXamlIndexingReader;
if (indexingReader != null && indexingReader.CurrentIndex >= 0)
{
indexingReader.CurrentIndex = -1;
}
if (CriticalExceptions.IsCriticalException(e) || e is XamlException)
{
throw;
}
throw CreateException(SR.Get(SRID.DeferredLoad), e);
}
}
private object CreateObjectWithTypeConverter(ServiceProviderContext serviceContext,
XamlValueConverter <TypeConverter> ts, object value)
{
TypeConverter typeConverter = GetConverterInstance(ts);
object obj;
if (typeConverter != null)
{
//We sometimes ignoreCanConvert for WPFv3 Compatibility (but only if a string is coming in)
if (_ignoreCanConvert && value.GetType() == typeof(string))
{
obj = typeConverter.ConvertFrom(serviceContext, TypeConverterHelper.InvariantEnglishUS, value);
}
else
{
if (typeConverter.CanConvertFrom(value.GetType()))
{
obj = typeConverter.ConvertFrom(serviceContext, TypeConverterHelper.InvariantEnglishUS, value);
}
else
{
//let the value passthrough (to be set as the property value later).
obj = value;
}
}
}
else
{
//let the value passthrough (to be set as the property value later).
obj = value;
}
return(obj);
}
public override object DeferredLoad(ServiceProviderContext serviceContext, XamlValueConverter <XamlDeferringLoader> deferringLoader, XamlReader deferredContent)
{
if ((!this.MemberAccessPermissionDenied || deferringLoader.IsPublic) || !IsDefaultConverter <XamlDeferringLoader>(deferringLoader))
{
try
{
return(this._transparentRuntime.DeferredLoad(serviceContext, deferringLoader, deferredContent));
}
catch (XamlException exception)
{
if (!(exception.InnerException is MissingMethodException))
{
if (!(exception.InnerException is MethodAccessException))
{
throw;
}
this.MemberAccessPermissionDenied = true;
}
else
{
this.EnsureElevatedRuntime();
}
}
catch (SecurityException)
{
this.MemberAccessPermissionDenied = true;
}
}
return(this._elevatedRuntime.DeferredLoad(serviceContext, deferringLoader, deferredContent));
}
public override object DeferredLoad(ServiceProviderContext serviceContext, XamlValueConverter <XamlDeferringLoader> deferringLoader, XamlReader deferredContent)
{
object obj2;
try
{
XamlDeferringLoader converterInstance = this.GetConverterInstance <XamlDeferringLoader>(deferringLoader);
if (converterInstance == null)
{
throw new XamlObjectWriterException(System.Xaml.SR.Get("DeferringLoaderInstanceNull", new object[] { deferringLoader }));
}
obj2 = converterInstance.Load(deferredContent, serviceContext);
}
catch (Exception exception)
{
IXamlIndexingReader reader = deferredContent as IXamlIndexingReader;
if ((reader != null) && (reader.CurrentIndex >= 0))
{
reader.CurrentIndex = -1;
}
if (!CriticalExceptions.IsCriticalException(exception) && !(exception is XamlException))
{
throw this.CreateException(System.Xaml.SR.Get("DeferredLoad"), exception);
}
throw;
}
return(obj2);
}
public Uri BuildRequestTokenUri()
{
int timestamp = UnixTime.ToUnixTime(DateTime.Now);
OAuthParameters parameters = new OAuthParameters();
parameters.ConsumerKey = ConsumerStore.FixedConsumer.Key;
parameters.Nonce = new GuidNonceProvider().GenerateNonce(timestamp);
parameters.SignatureMethod = "HMAC-SHA1";
parameters.Timestamp = timestamp.ToString(CultureInfo.InvariantCulture);
parameters.Version = "1.0";
parameters.Callback = "http://yourownsite.com/";
parameters.Signature = ServiceProviderContext.GetSigningProvider("HMAC-SHA1").ComputeSignature(
SignatureBase.Create("GET", this.RequestTokenBaseUri, parameters),
ConsumerStore.FixedConsumer.Secret,
null);
UriBuilder builder = new UriBuilder(this.RequestTokenBaseUri)
{
Query = parameters.ToQueryStringFormat()
};
return(builder.Uri);
}
public Uri BuildEchoCallUri(params KeyValuePair <string, string>[] pairs)
{
int timestamp = UnixTime.ToUnixTime(DateTime.Now);
OAuthParameters parameters = new OAuthParameters();
parameters.ConsumerKey = ConsumerStore.FixedConsumer.Key;
parameters.Nonce = new GuidNonceProvider().GenerateNonce(timestamp);
parameters.SignatureMethod = "HMAC-SHA1";
parameters.Timestamp = timestamp.ToString(CultureInfo.InvariantCulture);
parameters.Version = "1.0";
parameters.Token = TokenGenerator.FixedAccessToken.Token;
foreach (KeyValuePair <string, string> pair in pairs)
{
parameters.AdditionalParameters.Add(pair.Key, pair.Value);
}
parameters.Signature = ServiceProviderContext.GetSigningProvider("HMAC-SHA1").ComputeSignature(
SignatureBase.Create("GET", this.EchoApiBaseUri, parameters),
ConsumerStore.FixedConsumer.Secret,
TokenGenerator.FixedAccessToken.Secret);
UriBuilder builder = new UriBuilder(this.EchoApiBaseUri)
{
Query = parameters.ToQueryStringFormat()
};
return(builder.Uri);
}
public void Test_SigningProviderLookup()
{
ISigningProvider provider;
provider = ServiceProviderContext.GetSigningProvider("HMAC-SHA1");
Assert.That(provider, Is.TypeOf(typeof(HmacSha1SigningProvider)));
Assert.That(provider.SignatureMethod, Is.EqualTo("HMAC-SHA1"));
}
public override object CreateFromValue(ServiceProviderContext serviceContext, XamlValueConverter <TypeConverter> ts, object value, XamlMember property)
{
if (!(ts == BuiltInValueConverter.String) && !(ts == BuiltInValueConverter.Object))
{
return(this.CreateObjectWithTypeConverter(serviceContext, ts, value));
}
return(value);
}
//CreateFromValue is expected to convert the provided value via any applicable converter (on property or type) or provide the original value if there is no converter
public override object CreateFromValue(
ServiceProviderContext serviceContext,
XamlValueConverter <TypeConverter> ts, object value,
XamlMember property)
{
// check for a few common but special case text reps.
if (ts == BuiltInValueConverter.String || ts == BuiltInValueConverter.Object)
{
return(value);
}
return(CreateObjectWithTypeConverter(serviceContext, ts, value));
}
public override object CreateFromValue(ServiceProviderContext serviceContext, XamlValueConverter <TypeConverter> ts, object value, XamlMember property)
{
if (ts == BuiltInValueConverter.Event)
{
string methodName = value as string;
if (methodName != null)
{
object obj2;
Type type;
EventConverter.GetRootObjectAndDelegateType(serviceContext, out obj2, out type);
return(this.CreateDelegate(type, obj2, methodName));
}
}
return(base.CreateFromValue(serviceContext, ts, value, property));
}
private object CreateObjectWithTypeConverter(ServiceProviderContext serviceContext, XamlValueConverter <TypeConverter> ts, object value)
{
TypeConverter converterInstance = this.GetConverterInstance <TypeConverter>(ts);
if (converterInstance != null)
{
if (this._ignoreCanConvert && (value.GetType() == typeof(string)))
{
return(converterInstance.ConvertFrom(serviceContext, TypeConverterHelper.InvariantEnglishUS, value));
}
if (converterInstance.CanConvertFrom(value.GetType()))
{
return(converterInstance.ConvertFrom(serviceContext, TypeConverterHelper.InvariantEnglishUS, value));
}
return(value);
}
return(value);
}
//CreateFromValue is expected to convert the provided value via any applicable converter (on property or type) or provide the original value if there is no converter
public override object CreateFromValue(
ServiceProviderContext serviceContext,
XamlValueConverter <TypeConverter> ts, object value,
XamlMember property)
{
if (ts == BuiltInValueConverter.Event)
{
string valueString = value as string;
if (valueString != null)
{
object rootObject;
Type delegateType;
EventConverter.GetRootObjectAndDelegateType(serviceContext, out rootObject, out delegateType);
return(CreateDelegate(delegateType, rootObject, valueString));
}
}
return(base.CreateFromValue(serviceContext, ts, value, property));
}
public override object CreateFromValue(ServiceProviderContext serviceContext, XamlValueConverter <TypeConverter> ts, object value, XamlMember property)
{
if ((!this.MemberAccessPermissionDenied || ts.IsPublic) || !IsDefaultConverter <TypeConverter>(ts))
{
try
{
return(this._transparentRuntime.CreateFromValue(serviceContext, ts, value, property));
}
catch (MissingMethodException)
{
this.EnsureElevatedRuntime();
}
catch (MethodAccessException)
{
this.MemberAccessPermissionDenied = true;
}
catch (SecurityException)
{
this.MemberAccessPermissionDenied = true;
}
}
return(this._elevatedRuntime.CreateFromValue(serviceContext, ts, value, property));
}
//CreateFromValue is expected to convert the provided value via any applicable converter (on property or type) or provide the original value if there is no converter
abstract public object CreateFromValue(ServiceProviderContext serviceContext, XamlValueConverter <TypeConverter> ts,
object value, XamlMember property);
abstract public object DeferredLoad(ServiceProviderContext serviceContext,
XamlValueConverter <XamlDeferringLoader> deferringLoader,
XamlReader deferredContent);
private UserDAO()
{
db = new ServiceProviderContext();
}
public void Test_NonexistentSigningProviderLookup()
{
ISigningProvider provider = ServiceProviderContext.GetSigningProvider("MADEUP");
Assert.That(provider, Is.Null);
}
