public T Get <T>(int index)
{
return(TypeConverters.ConvertBoxed <T>(this[index]));
}
public bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
{
return(TypeConverters.CanConvertFrom <TextDecorationCollection>(sourceType));
}
public object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
return(TypeConverters.ConvertFrom <TextDecorationCollection>(this, value));
}
public virtual void InitTypeConverters()
{
bool useComplex = BaseTypeSequence.Contains(typeof(Complex));
bool useBigInt = BaseTypeSequence.Contains(typeof(BigInteger));
//->string
Type T = typeof(string);
foreach (Type t in BaseTypeSequence)
{
if (t != T)
{
TypeConverters.Add(t, T, ConvertAnyToString);
}
}
//->Complex
if (useComplex)
{
TypeConverters.Add(typeof(sbyte), typeof(Complex), ConvertAnyToComplex);
TypeConverters.Add(typeof(byte), typeof(Complex), ConvertAnyToComplex);
TypeConverters.Add(typeof(Int16), typeof(Complex), ConvertAnyToComplex);
TypeConverters.Add(typeof(UInt16), typeof(Complex), ConvertAnyToComplex);
TypeConverters.Add(typeof(Int32), typeof(Complex), ConvertAnyToComplex);
TypeConverters.Add(typeof(UInt32), typeof(Complex), ConvertAnyToComplex);
TypeConverters.Add(typeof(Int64), typeof(Complex), ConvertAnyToComplex);
TypeConverters.Add(typeof(UInt64), typeof(Complex), ConvertAnyToComplex);
TypeConverters.Add(typeof(Single), typeof(Complex), ConvertAnyToComplex);
if (useBigInt)
{
TypeConverters.Add(typeof(BigInteger), typeof(Complex), ConvertBigIntToComplex);
}
}
//->BigInteger
if (useBigInt)
{
TypeConverters.Add(typeof(sbyte), typeof(BigInteger), ConvertAnyIntToBigInteger);
TypeConverters.Add(typeof(byte), typeof(BigInteger), ConvertAnyIntToBigInteger);
TypeConverters.Add(typeof(Int16), typeof(BigInteger), ConvertAnyIntToBigInteger);
TypeConverters.Add(typeof(UInt16), typeof(BigInteger), ConvertAnyIntToBigInteger);
TypeConverters.Add(typeof(Int32), typeof(BigInteger), ConvertAnyIntToBigInteger);
TypeConverters.Add(typeof(UInt32), typeof(BigInteger), ConvertAnyIntToBigInteger);
TypeConverters.Add(typeof(Int64), typeof(BigInteger), ConvertAnyIntToBigInteger);
TypeConverters.Add(typeof(UInt64), typeof(BigInteger), ConvertAnyIntToBigInteger);
}
//->Double
TypeConverters.Add(typeof(sbyte), typeof(double), value => (double)(sbyte)value);
TypeConverters.Add(typeof(byte), typeof(double), value => (double)(byte)value);
TypeConverters.Add(typeof(Int16), typeof(double), value => (double)(Int16)value);
TypeConverters.Add(typeof(UInt16), typeof(double), value => (double)(UInt16)value);
TypeConverters.Add(typeof(Int32), typeof(double), value => (double)(Int32)value);
TypeConverters.Add(typeof(UInt32), typeof(double), value => (double)(UInt32)value);
TypeConverters.Add(typeof(Int64), typeof(double), value => (double)(Int64)value);
TypeConverters.Add(typeof(UInt64), typeof(double), value => (double)(UInt64)value);
TypeConverters.Add(typeof(Single), typeof(double), value => (double)(Single)value);
if (useBigInt)
{
TypeConverters.Add(typeof(BigInteger), typeof(double), value => ((BigInteger)value).ToDouble(null));
}
//->Single
TypeConverters.Add(typeof(sbyte), typeof(Single), value => (Single)(sbyte)value);
TypeConverters.Add(typeof(byte), typeof(Single), value => (Single)(byte)value);
TypeConverters.Add(typeof(Int16), typeof(Single), value => (Single)(Int16)value);
TypeConverters.Add(typeof(UInt16), typeof(Single), value => (Single)(UInt16)value);
TypeConverters.Add(typeof(Int32), typeof(Single), value => (Single)(Int32)value);
TypeConverters.Add(typeof(UInt32), typeof(Single), value => (Single)(UInt32)value);
TypeConverters.Add(typeof(Int64), typeof(Single), value => (Single)(Int64)value);
TypeConverters.Add(typeof(UInt64), typeof(Single), value => (Single)(UInt64)value);
if (useBigInt)
{
TypeConverters.Add(typeof(BigInteger), typeof(Single), value => (Single)((BigInteger)value).ToDouble(null));
}
//->UInt64
TypeConverters.Add(typeof(sbyte), typeof(UInt64), value => (UInt64)(sbyte)value);
TypeConverters.Add(typeof(byte), typeof(UInt64), value => (UInt64)(byte)value);
TypeConverters.Add(typeof(Int16), typeof(UInt64), value => (UInt64)(Int16)value);
TypeConverters.Add(typeof(UInt16), typeof(UInt64), value => (UInt64)(UInt16)value);
TypeConverters.Add(typeof(Int32), typeof(UInt64), value => (UInt64)(Int32)value);
TypeConverters.Add(typeof(UInt32), typeof(UInt64), value => (UInt64)(UInt32)value);
TypeConverters.Add(typeof(Int64), typeof(UInt64), value => (UInt64)(Int64)value);
//->Int64
TypeConverters.Add(typeof(sbyte), typeof(Int64), value => (Int64)(sbyte)value);
TypeConverters.Add(typeof(byte), typeof(Int64), value => (Int64)(byte)value);
TypeConverters.Add(typeof(Int16), typeof(Int64), value => (Int64)(Int16)value);
TypeConverters.Add(typeof(UInt16), typeof(Int64), value => (Int64)(UInt16)value);
TypeConverters.Add(typeof(Int32), typeof(Int64), value => (Int64)(Int32)value);
TypeConverters.Add(typeof(UInt32), typeof(Int64), value => (Int64)(UInt32)value);
//->UInt32
TypeConverters.Add(typeof(sbyte), typeof(UInt32), value => (UInt32)(sbyte)value);
TypeConverters.Add(typeof(byte), typeof(UInt32), value => (UInt32)(byte)value);
TypeConverters.Add(typeof(Int16), typeof(UInt32), value => (UInt32)(Int16)value);
TypeConverters.Add(typeof(UInt16), typeof(UInt32), value => (UInt32)(UInt16)value);
TypeConverters.Add(typeof(Int32), typeof(UInt32), value => (UInt32)(Int32)value);
//->Int32
TypeConverters.Add(typeof(sbyte), typeof(Int32), value => (Int32)(sbyte)value);
TypeConverters.Add(typeof(byte), typeof(Int32), value => (Int32)(byte)value);
TypeConverters.Add(typeof(Int16), typeof(Int32), value => (Int32)(Int16)value);
TypeConverters.Add(typeof(UInt16), typeof(Int32), value => (Int32)(UInt16)value);
//->UInt16
TypeConverters.Add(typeof(sbyte), typeof(UInt16), value => (UInt16)(sbyte)value);
TypeConverters.Add(typeof(byte), typeof(UInt16), value => (UInt16)(byte)value);
TypeConverters.Add(typeof(Int16), typeof(UInt16), value => (UInt16)(Int16)value);
//->Int16
TypeConverters.Add(typeof(sbyte), typeof(Int16), value => (Int16)(sbyte)value);
TypeConverters.Add(typeof(byte), typeof(Int16), value => (Int16)(byte)value);
//->byte
TypeConverters.Add(typeof(sbyte), typeof(byte), value => (byte)(sbyte)value);
}
public static void RegisterTypeConverters(params IConvertType[] converters)
{
TypeConverters.AddRange(converters);
}
/// <summary>
/// Convert value into instance of type conversionType
/// </summary>
/// <param name="values">the values to convert</param>
/// <param name="conversionType">The type to convert to</param>
/// <returns></returns>
private bool CanChangeType(object[] values, Type conversionType)
{
return(TypeConverters.Any(typeConverter => typeConverter.CanConvert(values, conversionType)));
}
public override bool CanConvertTo(ITypeDescriptorContext typeDescriptorContext, Type destinationType)
{
return(TypeConverters.CanConvertTo <double>(destinationType));
}
/// <summary>
/// Remove instance of type converter from list of type converters.
/// </summary>
/// <param name="typeConverter">The type converter instance to remove.</param>
/// <returns></returns>
public SettingsLoader RemoveTypeConverter(ITypeConverter typeConverter)
{
TypeConverters.Remove(typeConverter);
return(this);
}
/// <summary>
/// Add type converter instance to front of list of type converters.
/// </summary>
/// <param name="typeConverter"></param>
/// <returns></returns>
public SettingsLoader AddTypeConverter(ITypeConverter typeConverter)
{
// Insert at top of list.
TypeConverters.Insert(0, typeConverter);
return(this);
}
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
{
TypeConverters.TryParseDouble(value.ToString(), out double result, double.Parse(parameter.ToString()));
return(result / 100);
}
public bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
{
return(TypeConverters.CanConvertFrom <bool?>(sourceType) ||
(sourceType == typeof(bool)));
}
public async Task InvokeMethodAsync_CanInvokeRawMethodWithResponse_HttpServerReturnsNonSuccessResponse()
{
var client = new MockClient();
var data = new Response()
{
Name = "Look, I was invoked!"
};
var invokeResponse = new InvokeResponse();
invokeResponse.Data = TypeConverters.ToAny(data);
var response =
client.Call <InvokeResponse>()
.SetResponse(invokeResponse)
.AddHeader("dapr-status-header", "200")
.Build();
var trailers = new Metadata();
const string grpcErrorInfoReason = "Insufficient permissions";
const int grpcErrorInfoDetailHttpCode = 500;
const string grpcErrorInfoDetailHttpErrorMsg = "no permissions";
int grpcStatusCode = Convert.ToInt32(StatusCode.PermissionDenied);
const string grpcStatusMessage = "Bad permissions";
var details = new Google.Rpc.Status
{
Code = grpcStatusCode,
Message = grpcStatusMessage,
};
var errorInfo = new Google.Rpc.ErrorInfo
{
Reason = grpcErrorInfoReason,
Domain = "dapr.io",
};
errorInfo.Metadata.Add("http.code", grpcErrorInfoDetailHttpCode.ToString());
errorInfo.Metadata.Add("http.error_message", grpcErrorInfoDetailHttpErrorMsg);
details.Details.Add(Google.Protobuf.WellKnownTypes.Any.Pack(errorInfo));
var entry = new Metadata.Entry("grpc-status-details-bin", Google.Protobuf.MessageExtensions.ToByteArray(details));
trailers.Add(entry);
const string rpcExceptionMessage = "No access to app";
const StatusCode rpcStatusCode = StatusCode.PermissionDenied;
const string rpcStatusDetail = "Insufficient permissions";
var rpcException = new RpcException(new Status(rpcStatusCode, rpcStatusDetail), trailers, rpcExceptionMessage);
// Setup the mock client to throw an Rpc Exception with the expected details info
client.Mock
.Setup(m => m.InvokeServiceAsync(It.IsAny <Autogen.Grpc.v1.InvokeServiceRequest>(), It.IsAny <CallOptions>()))
.Throws(rpcException);
try
{
var body = new Request()
{
RequestParameter = "Hello "
};
var bytes = JsonSerializer.SerializeToUtf8Bytes(body);
await client.DaprClient.InvokeMethodRawAsync("test", "testMethod", bytes);
Assert.False(true);
}
catch (InvocationException ex)
{
ex.Message.Should().Be("Exception while invoking testMethod on appId:test");
ex.InnerException.Message.Should().Be(rpcExceptionMessage);
ex.Response.GrpcStatusInfo.Should().BeNull();
Encoding.UTF8.GetString(ex.Response.Body).Should().Be(grpcErrorInfoDetailHttpErrorMsg);
ex.Response.HttpStatusCode.Should().Be(grpcErrorInfoDetailHttpCode);
}
}
public object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
return(TypeConverters.ConvertFrom <FontStretch>(this, value));
}
public bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
{
return(TypeConverters.CanConvertFrom <FontStretch>(sourceType));
}
public override bool CanConvertFrom (ITypeDescriptorContext context, Type sourceType)
{
return TypeConverters.CanConvertFrom<Duration>(sourceType);
}
public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
{
return(TypeConverters.CanConvertFrom <PropertyPath>(sourceType));
}
