private void ResolveClass(RecordClassDispatcher task, IDynamicMetaObjectProvider connection, ProducerProperty role, ProductInstanceExpression last2, InitializerTest result3, ProductInstanceExpression reg4)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ManageBroadcaster(task, role, connection);
wrapperProperty.Add(connection);
SortBroadcaster(task, connection, role, last2, result3, reg4);
int lengthpred = task._0002();
for (int i = 0; i < role._0001().Count; i++)
{
ProductInstanceExpression productInstanceExpression = role._0001()[i];
if (productInstanceExpression._0004())
{
try
{
if (CollectBroadcaster(task, connection, role, last2, productInstanceExpression, out ProcTest _0007, out object _0008))
{
productInstanceExpression.DefineClient(task);
InvokeBroadcaster(task, _0008, _0007, productInstanceExpression, role, last2);
}
}
catch (Exception ident)
{
if (!CheckBroadcaster(connection, role, productInstanceExpression._0001(), null, task._0001(), ident))
{
throw;
}
EnableClass(task, lengthpred);
}
}
}
foreach (string item in connection.ResolveIssuer())
{
if (role.CancelClient(connection, item, out object _0004))
{
try
{
ProcTest procTest = DeleteBroadcaster(_0004);
if (FillClass(_0004) && CustomizeBroadcaster(task, _0004, null, procTest, role, last2))
{
string task2 = (role._0001() != null) ? role._0001()(item) : item;
task._0002(task2);
InvokeBroadcaster(task, _0004, procTest, null, role, last2);
}
}
catch (Exception ident2)
{
if (!CheckBroadcaster(connection, role, item, null, task._0001(), ident2))
{
throw;
}
EnableClass(task, lengthpred);
}
}
}
task._0011();
wrapperProperty.RemoveAt(wrapperProperty.Count - 1);
InitBroadcaster(task, role, connection);
}
public override void _0001(RecordClassDispatcher item, object cfg, PrototypeError filter)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (cfg == null)
{
item._0008();
return;
}
DataTable obj = (DataTable)cfg;
PublisherRequestStrategy publisherRequestStrategy = filter._0001() as PublisherRequestStrategy;
item._0003();
foreach (DataRow row in obj.Rows)
{
item._0002();
foreach (DataColumn column in row.Table.Columns)
{
object obj2 = row[column];
if (filter._0001() != (ApplicationState)1 || (obj2 != null && obj2 != DBNull.Value))
{
item._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient(column.ColumnName) : column.ColumnName);
filter.FlushComposer(item, obj2);
}
}
item._0011();
}
item._000F();
}
public override void _0011()
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
m_ComposerIssuer._0011();
errorIssuer._0011();
base._0011();
}
private void DefineBroadcaster(RecordClassDispatcher task, object visitor, PrototypeFilterResolver proc, ProductInstanceExpression cust2, InitializerTest first3, ProductInstanceExpression v4)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ManageBroadcaster(task, proc, visitor);
wrapperProperty.Add(visitor);
SortBroadcaster(task, visitor, proc, cust2, first3, v4);
int lengthpred = task._0002();
for (int i = 0; i < proc._0001().Count; i++)
{
ProductInstanceExpression productInstanceExpression = proc._0001()[i];
try
{
if (CollectBroadcaster(task, visitor, proc, cust2, productInstanceExpression, out ProcTest _0007, out object _0008))
{
productInstanceExpression.DefineClient(task);
InvokeBroadcaster(task, _0008, _0007, productInstanceExpression, proc, cust2);
}
}
catch (Exception ident)
{
if (!CheckBroadcaster(visitor, proc, productInstanceExpression._0001(), null, task._0001(), ident))
{
throw;
}
EnableClass(task, lengthpred);
}
}
IEnumerable <KeyValuePair <object, object> > enumerable = proc._0001()?.Invoke(visitor);
if (enumerable != null)
{
foreach (KeyValuePair <object, object> item in enumerable)
{
ProcTest temp = TestBroadcaster(item.Key);
ProcTest procTest = DeleteBroadcaster(item.Value);
string text = AddClass(task, item.Key, temp, out bool _);
text = ((proc._0001() != null) ? proc._0001()(text) : text);
if (CountBroadcaster(item.Value, null, procTest, proc, cust2))
{
task._0002(text);
QueryBroadcaster(task, item.Value);
}
else if (CustomizeBroadcaster(task, item.Value, null, procTest, proc, cust2))
{
task._0002(text);
InvokeBroadcaster(task, item.Value, procTest, null, proc, cust2);
}
}
}
task._0011();
wrapperProperty.RemoveAt(wrapperProperty.Count - 1);
InitBroadcaster(task, proc, visitor);
}
public override void _0001(RecordClassDispatcher setup, BroadcasterError[] cfg)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
setup._0002();
for (int i = 0; i < _StubIssuer.Count; i++)
{
_StubIssuer[i]._0001(setup, cfg);
}
setup._0011();
}
private void CompareClass(RecordClassDispatcher instance, IDictionary attr, ParamClientBridge c, ProductInstanceExpression param2, InitializerTest caller3, ProductInstanceExpression ivk4)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ProcessComposer processComposer = attr as ProcessComposer;
object obj = (processComposer != null) ? processComposer._0001() : attr;
ManageBroadcaster(instance, c, obj);
wrapperProperty.Add(obj);
SortBroadcaster(instance, obj, c, param2, caller3, ivk4);
if (((InitializerTest)c)._0001() == null)
{
c._0001(baseProperty.listenerError._0001(c._0004() ?? typeof(object)));
}
if (c._0003() == null)
{
c._0002(baseProperty.listenerError._0001(c._0001() ?? typeof(object)));
}
int lengthpred = instance._0002();
foreach (DictionaryEntry item in attr)
{
string text = AddClass(instance, item.Key, c._0003(), out bool last);
text = ((c._0001() != null) ? c._0001()(text) : text);
try
{
object value = item.Value;
ProcTest procTest = ((InitializerTest)c)._0002() ?? DeleteBroadcaster(value);
if (CountBroadcaster(value, null, procTest, c, param2))
{
instance._0001(text, last);
QueryBroadcaster(instance, value);
}
else if (CustomizeBroadcaster(instance, value, null, procTest, c, param2))
{
instance._0001(text, last);
InvokeBroadcaster(instance, value, procTest, null, c, param2);
}
}
catch (Exception ident)
{
if (!CheckBroadcaster(obj, c, text, null, instance._0001(), ident))
{
throw;
}
EnableClass(instance, lengthpred);
}
}
instance._0011();
wrapperProperty.RemoveAt(wrapperProperty.Count - 1);
InitBroadcaster(instance, c, obj);
}
private void ListRequest(RecordClassDispatcher i, Regex reg, PrototypeError tag)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
PublisherRequestStrategy publisherRequestStrategy = tag._0001() as PublisherRequestStrategy;
i._0002();
i._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Pattern") : "Pattern");
i._0004(reg.ToString());
i._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Options") : "Options");
tag.FlushComposer(i, reg.Options);
i._0011();
}
private void VerifyClass(RecordClassDispatcher value, IEnumerable second, MessageTest state, ProductInstanceExpression reference2, InitializerTest v3, ProductInstanceExpression init4)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ManagerErrorFilter managerErrorFilter = second as ManagerErrorFilter;
object obj = (managerErrorFilter != null) ? managerErrorFilter._0001() : second;
ManageBroadcaster(value, state, obj);
wrapperProperty.Add(obj);
bool flag = ValidateClass(value, obj, state, reference2, v3, init4);
value._0003();
int lengthpred = value._0002();
int num = 0;
foreach (object item in second)
{
try
{
ProcTest procTest = ((InitializerTest)state)._0002() ?? DeleteBroadcaster(item);
if (CountBroadcaster(item, null, procTest, state, reference2))
{
QueryBroadcaster(value, item);
}
else if (CustomizeBroadcaster(value, item, null, procTest, state, reference2))
{
InvokeBroadcaster(value, item, procTest, null, state, reference2);
}
}
catch (Exception ident)
{
if (!CheckBroadcaster(obj, state, num, null, value._0001(), ident))
{
throw;
}
EnableClass(value, lengthpred);
}
finally
{
num++;
}
}
value._000F();
if (flag)
{
value._0011();
}
wrapperProperty.RemoveAt(wrapperProperty.Count - 1);
InitBroadcaster(value, state, obj);
}
private void QueryBroadcaster(RecordClassDispatcher var1, object cust)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
string text = CancelBroadcaster(var1, cust);
if (containerProperty != null && containerProperty._0001() >= TraceLevel.Info)
{
containerProperty._0001(TraceLevel.Info, QueueError.ComputeError(null, var1._0002(), "Writing object reference to Id '{0}' for {1}.".SelectReader(CultureInfo.InvariantCulture, text, cust.GetType())), null);
}
var1._0002();
var1._0001("$ref", injectcust: false);
var1._0004(text);
var1._0011();
}
private void PatchClass(RecordClassDispatcher i, Array result, MessageTest tag, ProductInstanceExpression connection2, InitializerTest ord3, ProductInstanceExpression asset4)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ManageBroadcaster(i, tag, result);
wrapperProperty.Add(result);
bool num = ValidateClass(i, result, tag, connection2, ord3, asset4);
FindClass(i, result, tag, connection2, i._0002(), ObserverIteratorMapping.CheckProperty <int>());
if (num)
{
i._0011();
}
wrapperProperty.RemoveAt(wrapperProperty.Count - 1);
InitBroadcaster(i, tag, result);
}
private void ConcatBroadcaster(RecordClassDispatcher def, object selection, ProccesorClassSpec third, ProductInstanceExpression item2, InitializerTest setup3, ProductInstanceExpression attr4)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (third._0001() == (SettingsSerializeAs)40 && RunClass((SparklineAxisMinMaxValues)1, third, item2, setup3, attr4))
{
def._0002();
WriteBroadcaster(def, ((ProcTest)third)._0003());
def._0001("$value", injectcust: false);
RecordClassDispatcher.ComputeTest(def, third._0001(), selection);
def._0011();
}
else
{
RecordClassDispatcher.ComputeTest(def, third._0001(), selection);
}
}
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();
}
public override void _0001(RecordClassDispatcher res, object connection, PrototypeError third)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (connection == null)
{
res._0008();
return;
}
DataSet obj = (DataSet)connection;
PublisherRequestStrategy publisherRequestStrategy = third._0001() as PublisherRequestStrategy;
FieldReaderMapper fieldReaderMapper = new FieldReaderMapper();
res._0002();
foreach (DataTable table in obj.Tables)
{
res._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient(table.TableName) : table.TableName);
fieldReaderMapper._0001(res, table, third);
}
res._0011();
}
public override void _0001(RecordClassDispatcher v, object ivk, PrototypeError util)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (ivk == null)
{
v._0008();
return;
}
PublisherRequestStrategy publisherRequestStrategy = util._0001() as PublisherRequestStrategy;
Type res = m_PrototypeIssuer.InitReader(ivk.GetType());
UtilsClientBridge utilsClientBridge = m_ParameterIssuer.InitReader(res);
int num = (int)utilsClientBridge._ParserIssuer.ConnectIssuer(new object[1]
{
ivk
});
FactoryDicCandidate factoryDicCandidate = utilsClientBridge.m_StatusIssuer.Single((FactoryDicCandidate P_0) => P_0.pageIssuer == num);
v._0002();
v._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Case") : "Case");
v._0004(factoryDicCandidate._HelperIssuer);
if (factoryDicCandidate.exceptionIssuer != null && factoryDicCandidate.exceptionIssuer.Length != 0)
{
object[] obj = (object[])factoryDicCandidate.attributeIssuer.ConnectIssuer(new object[1]
{
ivk
});
v._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Fields") : "Fields");
v._0003();
object[] array = obj;
foreach (object reg in array)
{
util.FlushComposer(v, reg);
}
v._000F();
}
v._0011();
}
public override void _0001(RecordClassDispatcher v, object col, PrototypeError role)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (col == null)
{
v._0008();
return;
}
RateRequest(col.GetType());
PublisherRequestStrategy publisherRequestStrategy = role._0001() as PublisherRequestStrategy;
string init = (string)m_SerializerIssuer.CancelIssuer(col, "Key");
object obj = m_SerializerIssuer.CancelIssuer(col, "Value");
Type type = obj?.GetType();
v._0002();
v._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Key") : "Key");
v._0004(init);
v._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Type") : "Type");
v._0004(type?.FullName);
v._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Value") : "Value");
if (type != null)
{
if (InterceptorInstanceExpression.ExcludeBroadcaster(obj, type, out string _0004))
{
v._0004(_0004);
}
else
{
v._0001(obj);
}
}
else
{
v._0008();
}
v._0011();
}
public override void _0001(RecordClassDispatcher i, object visitor, PrototypeError third)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (visitor == null)
{
i._0008();
return;
}
CreatorIssuer creatorIssuer = CountRequest(visitor);
XmlNamespaceManager xmlNamespaceManager = new XmlNamespaceManager(new NameTable());
AssetRequest(creatorIssuer, xmlNamespaceManager);
if (!_0004())
{
i._0002();
}
InitRequest(i, creatorIssuer, xmlNamespaceManager, !_0004());
if (!_0004())
{
i._0011();
}
}
private void OrderClass(RecordClassDispatcher first, ISerializable visitor, CollectionProperty dic, ProductInstanceExpression selection2, InitializerTest cust3, ProductInstanceExpression asset4)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (!ConfigProperty._0002())
{
string asset5 = "Type '{0}' implements ISerializable but cannot be serialized using the ISerializable interface because the current application is not fully trusted and ISerializable can expose secure data." + Environment.NewLine + "To fix this error either change the environment to be fully trusted, change the application to not deserialize the type, add JsonObjectAttribute to the type or change the JsonSerializer setting ContractResolver to use a new DefaultContractResolver with IgnoreSerializableInterface set to true." + Environment.NewLine;
asset5 = asset5.ListReader(CultureInfo.InvariantCulture, visitor.GetType());
throw StrategyError.ValidateComposer(null, first._0001(), asset5, null);
}
ManageBroadcaster(first, dic, visitor);
wrapperProperty.Add(visitor);
SortBroadcaster(first, visitor, dic, selection2, cust3, asset4);
SerializationInfo serializationInfo = new SerializationInfo(((ProcTest)dic)._0002(), new FormatterConverter());
visitor.GetObjectData(serializationInfo, baseProperty.roleError);
SerializationInfoEnumerator enumerator = serializationInfo.GetEnumerator();
while (enumerator.MoveNext())
{
SerializationEntry current = enumerator.Current;
ProcTest procTest = DeleteBroadcaster(current.Value);
if (CountBroadcaster(current.Value, null, procTest, dic, selection2))
{
first._0002(current.Name);
QueryBroadcaster(first, current.Value);
}
else if (CustomizeBroadcaster(first, current.Value, null, procTest, dic, selection2))
{
first._0002(current.Name);
InvokeBroadcaster(first, current.Value, procTest, null, dic, selection2);
}
}
first._0011();
wrapperProperty.RemoveAt(wrapperProperty.Count - 1);
InitBroadcaster(first, dic, visitor);
}
private void InitRequest(RecordClassDispatcher first, CreatorIssuer second, XmlNamespaceManager template, bool isresult2)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
switch (second._0001())
{
case XmlNodeType.Document:
case XmlNodeType.DocumentFragment:
ExcludeRequest(first, second, template, isresult2);
break;
case XmlNodeType.Element:
if (CancelRequest(second) && DefineRequest(second) && second._0001().Count > 0)
{
ExcludeRequest(first, second, template, hasattr2: false);
break;
}
template.PushScope();
foreach (CreatorIssuer item in second._0002())
{
if (item._0003() == "http://www.w3.org/2000/xmlns/")
{
string prefix = (item._0001() != "xmlns") ? XmlConvert.DecodeName(item._0001()) : string.Empty;
string text = item._0002();
if (text == null)
{
throw new StrategyError("Namespace attribute must have a value.");
}
template.AddNamespace(prefix, text);
}
}
if (isresult2)
{
first._0002(QueryRequest(second, template));
}
if (!ResolveIterator(second._0002()) && second._0001().Count == 1 && second._0001()[0]._0001() == XmlNodeType.Text)
{
first._0004(second._0001()[0]._0002());
}
else if (second._0001().Count == 0 && second._0002().Count == 0)
{
if (((InfoRequestStrategy)second)._0001())
{
first._0008();
}
else
{
first._0004(string.Empty);
}
}
else
{
first._0002();
for (int i = 0; i < second._0002().Count; i++)
{
InitRequest(first, second._0002()[i], template, isresult2: true);
}
ExcludeRequest(first, second, template, hasattr2: true);
first._0011();
}
template.PopScope();
break;
case XmlNodeType.Comment:
if (isresult2)
{
first._0005(second._0002());
}
break;
case XmlNodeType.Attribute:
case XmlNodeType.Text:
case XmlNodeType.CDATA:
case XmlNodeType.ProcessingInstruction:
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
if ((!(second._0003() == "http://www.w3.org/2000/xmlns/") || !(second._0002() == "http://james.newtonking.com/projects/json")) && (!(second._0003() == "http://james.newtonking.com/projects/json") || !(second._0001() == "Array")))
{
if (isresult2)
{
first._0002(QueryRequest(second, template));
}
first._0004(second._0002());
}
break;
case XmlNodeType.XmlDeclaration:
{
DicEventConsumer dicEventConsumer = (DicEventConsumer)second;
first._0002(QueryRequest(second, template));
first._0002();
if (!SetterTest.StartReader(dicEventConsumer._0004()))
{
first._0002("@version");
first._0004(dicEventConsumer._0004());
}
if (!SetterTest.StartReader(dicEventConsumer._0005()))
{
first._0002("@encoding");
first._0004(dicEventConsumer._0005());
}
if (!SetterTest.StartReader(dicEventConsumer._0006()))
{
first._0002("@standalone");
first._0004(dicEventConsumer._0006());
}
first._0011();
break;
}
case XmlNodeType.DocumentType:
{
IndexerIssuer indexerIssuer = (IndexerIssuer)second;
first._0002(QueryRequest(second, template));
first._0002();
if (!SetterTest.StartReader(indexerIssuer._0004()))
{
first._0002("@name");
first._0004(indexerIssuer._0004());
}
if (!SetterTest.StartReader(indexerIssuer._0006()))
{
first._0002("@public");
first._0004(indexerIssuer._0006());
}
if (!SetterTest.StartReader(indexerIssuer._0005()))
{
first._0002("@system");
first._0004(indexerIssuer._0005());
}
if (!SetterTest.StartReader(indexerIssuer._0007()))
{
first._0002("@internalSubset");
first._0004(indexerIssuer._0007());
}
first._0011();
break;
}
default:
throw new StrategyError("Unexpected XmlNodeType when serializing nodes: " + second._0001());
}
}