private static void RateRequest(Type item)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (m_SerializerIssuer == null)
{
m_SerializerIssuer = ModelInstanceExpression.ManageIssuer(item, new string[2]
{
"Key",
"Value"
});
}
}
private static void ResetRequest(Type last)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (_InfoIssuer == null)
{
_InfoIssuer = ModelInstanceExpression.InitIssuer(last, last.GetConstructor(new Type[1]
{
typeof(byte[])
}), new string[1]
{
"ToArray"
});
}
}
public override object _0001(TagTestItem config, Type ivk, object template, PrototypeError connection2)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (config._0001() == WatcherComposer.Null)
{
if (!ResolverErrorFilter.PatchReader(ivk))
{
throw StrategyError.PatchComposer(config, "Cannot convert null value to KeyValuePair.");
}
return(null);
}
object obj = null;
object obj2 = null;
config.SortError();
Type res = ResolverErrorFilter.PatchReader(ivk) ? Nullable.GetUnderlyingType(ivk) : ivk;
ModelInstanceExpression modelInstanceExpression = m_ListenerIssuer.InitReader(res);
ProcTest procTest = connection2._0001()._0001(modelInstanceExpression.SetupIssuer("Key"));
ProcTest procTest2 = connection2._0001()._0001(modelInstanceExpression.SetupIssuer("Value"));
while (config._0001() == WatcherComposer.PropertyName)
{
string a = config._0001().ToString();
if (string.Equals(a, "Key", StringComparison.OrdinalIgnoreCase))
{
config.CallError(procTest, iscaller: false);
obj = connection2.AddComposer(config, procTest._0002());
}
else if (string.Equals(a, "Value", StringComparison.OrdinalIgnoreCase))
{
config.CallError(procTest2, iscaller: false);
obj2 = connection2.AddComposer(config, procTest2._0002());
}
else
{
config.AssetError();
}
config.SortError();
}
return(modelInstanceExpression._0001()(new object[2]
{
obj,
obj2
}));
}
private static ModelInstanceExpression CalculateRequest(Type i)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
Type[] genericArguments = i.GetGenericArguments();
Type type = ((IList <Type>)genericArguments)[0];
Type type2 = ((IList <Type>)genericArguments)[1];
return(ModelInstanceExpression.InitIssuer(i, i.GetConstructor(new Type[2]
{
type,
type2
}), new string[2]
{
"Key",
"Value"
}));
}
public override void _0001(RecordClassDispatcher config, object col, PrototypeError dic)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (col == null)
{
config._0008();
return;
}
ModelInstanceExpression modelInstanceExpression = m_ListenerIssuer.InitReader(col.GetType());
PublisherRequestStrategy publisherRequestStrategy = dic._0001() as PublisherRequestStrategy;
config._0002();
config._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Key") : "Key");
dic.InsertComposer(config, modelInstanceExpression.CancelIssuer(col, "Key"), modelInstanceExpression.SetupIssuer("Key"));
config._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Value") : "Value");
dic.InsertComposer(config, modelInstanceExpression.CancelIssuer(col, "Value"), modelInstanceExpression.SetupIssuer("Value"));
config._0011();
}
private static Type IncludeClass(Type info)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
Attribute[] array = ResolverErrorFilter.ForgotReader(info, null, controlopen: true);
foreach (Attribute attribute in array)
{
Type type = attribute.GetType();
if (string.Equals(type.FullName, "System.ComponentModel.DataAnnotations.MetadataTypeAttribute", StringComparison.Ordinal))
{
if (_RefProperty == null)
{
_RefProperty = ModelInstanceExpression.ManageIssuer(type, new string[1]
{
"MetadataClassType"
});
}
return((Type)_RefProperty.CancelIssuer(attribute, "MetadataClassType"));
}
}
return(null);
}
