public static void Main()
{
Type type = typeof(BlackBoxInteger);
BindingFlags flags = BindingFlags.Instance | BindingFlags.NonPublic;
ConstructorInfo constructor = type.GetConstructor(flags, null, new Type[] { typeof(int) }, null);
BlackBoxInteger instance = (BlackBoxInteger)constructor.Invoke(new object[] { 0 });
FieldInfo innerField = type.GetField("innerValue", flags);
string[] inputArgs = Console.ReadLine()
.Split("_")
.ToArray();
while (inputArgs[0]?.ToLower() != "end")
{
string methodName = inputArgs[0];
int number = int.Parse(inputArgs[1]);
MethodInfo method = type.GetMethod(methodName, flags);
method.Invoke(instance, new object[] { number });
Console.WriteLine(innerField.GetValue(instance));
inputArgs = Console.ReadLine()
.Split("_")
.ToArray();
}
}
public static void Main()
{
Type blackBoxClass = typeof(BlackBoxInteger);
BlackBoxInteger box = (BlackBoxInteger)Activator.CreateInstance(blackBoxClass, true);
while (true)
{
string input = Console.ReadLine();
if (input == "END")
{
break;
}
else
{
string command = input.Split('_')[0];
int number = int.Parse(input.Split('_')[1]);
blackBoxClass.GetMethod(command, BindingFlags.Instance |
BindingFlags.NonPublic)
.Invoke(box, new object[] { number });
int result = (int)blackBoxClass.GetField("innerValue", BindingFlags.Instance |
BindingFlags.NonPublic).GetValue(box);
Console.WriteLine(result);
}
}
Console.ReadLine();
}
public static void Main()
{
var type = typeof(BlackBoxInteger);
//ConstructorInfo constructor = type.GetConstructor(new Type[] { typeof(int) });
BlackBoxInteger instance = (BlackBoxInteger)Activator.CreateInstance(type, true);
string input = Console.ReadLine();
while (input != "END")
{
string[] tokens = input.Split("_");
string command = tokens[0];
int data = int.Parse(tokens[1]);
var method = type.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance).First(m => m.Name == command);
method.Invoke(instance, new object[] { data });
var fieldInfo = type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance).First(f => f.Name == "innerValue").GetValue(instance);
Console.WriteLine(fieldInfo);
input = Console.ReadLine();
}
}
public static void Main()
{
var constructors = typeof(BlackBoxInteger)
.GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance);
BlackBoxInteger blackBoxInteger = (BlackBoxInteger)constructors[0].Invoke(new object[] { 0 });
while (true)
{
string[] input = Console.ReadLine().Split('_');
string methodName = input[0];
if (methodName == "END")
{
break;
}
int value = int.Parse(input[1]);
MethodInfo method = blackBoxInteger
.GetType()
.GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance);
method.Invoke(blackBoxInteger, new object[] { value });
FieldInfo innerValueField = blackBoxInteger
.GetType()
.GetField("innerValue", BindingFlags.NonPublic | BindingFlags.Instance);
Console.WriteLine(innerValueField.GetValue(blackBoxInteger));
}
}
public static void Main()
{
Type blackBoxType = typeof(BlackBoxInteger);
ConstructorInfo[] constructors = blackBoxType.GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance);
BlackBoxInteger blackBox = (BlackBoxInteger)constructors[1].Invoke(new object[] { });
FieldInfo innerVal = blackBoxType.GetField("innerValue", BindingFlags.NonPublic | BindingFlags.Instance);
MethodInfo[] methods = blackBoxType.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance);
while (true)
{
string[] inputArgs = Console.ReadLine().Split(new[] { '_' }, StringSplitOptions.RemoveEmptyEntries);
string command = inputArgs[0];
if (command == "END")
{
break;
}
int numberToOperateWith = int.Parse(inputArgs[1]);
methods.Where(x => x.Name == command)
.FirstOrDefault()
.Invoke(blackBox, new object[] { numberToOperateWith });
Console.WriteLine(innerVal.GetValue(blackBox));
}
}
public static void Main()
{
Type classInfo = typeof(BlackBoxInteger);
BlackBoxInteger instance = (BlackBoxInteger)Activator.CreateInstance(classInfo, true);
MethodInfo[] methods = classInfo.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance);
string input = Console.ReadLine();
while (input != "END")
{
string[] commandLine = input.Split("_");
string command = commandLine[0];
int value = int.Parse(commandLine[1]);
MethodInfo method = methods.Where(x => x.Name == command).First();
method.Invoke(instance, new object [] { value });
var innerValue = classInfo.GetFields(BindingFlags.NonPublic | BindingFlags.Instance).Where(x => x.Name == "innerValue").First();
Console.WriteLine(innerValue.GetValue(instance));
input = Console.ReadLine();
}
}
public static void Main()
{
Type typeOfBlackBoxInteger = typeof(BlackBoxInteger);
ConstructorInfo blackBoxIntegerConstructor = typeOfBlackBoxInteger.GetConstructor
(BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[] { typeof(int) }, null);
BlackBoxInteger blackBoxInteger = (BlackBoxInteger)blackBoxIntegerConstructor.Invoke(new object[] { 0 });
string input;
while ((input = Console.ReadLine()) != "END")
{
string[] commandSplit = input.Split('_');
string methodName = commandSplit[0];
int methodParameter = int.Parse(commandSplit[1]);
typeOfBlackBoxInteger.GetMethod(methodName, BindingFlags.Instance | BindingFlags.NonPublic)
.Invoke(blackBoxInteger, new object[] { methodParameter });
Console.WriteLine(typeOfBlackBoxInteger.GetField("innerValue", BindingFlags.Instance | BindingFlags.NonPublic)
.GetValue(blackBoxInteger));
}
//Console.WriteLine(typeOfBlackBoxInteger.GetField("innerValue",BindingFlags.Instance | BindingFlags.NonPublic)
// .GetValue(blackBoxInteger));
}
private static void ExecuteCommand(Type type, BlackBoxInteger blackBoxInteger, string command, int number)
{
if (command == "Add")
{
InvokeMethod(type, blackBoxInteger, number, "Add");
}
else if (command == "Subtract")
{
InvokeMethod(type, blackBoxInteger, number, "Subtract");
}
else if (command == "Multiply")
{
InvokeMethod(type, blackBoxInteger, number, "Multiply");
}
else if (command == "Divide")
{
InvokeMethod(type, blackBoxInteger, number, "Divide");
}
else if (command == "LeftShift")
{
InvokeMethod(type, blackBoxInteger, number, "LeftShift");
}
else if (command == "RightShift")
{
InvokeMethod(type, blackBoxInteger, number, "RightShift");
}
}
private static void PrintResult(Type classType, BlackBoxInteger classInstance)
{
FieldInfo field = classType.GetField("innerValue", BindingFlags.NonPublic | BindingFlags.Instance);
field.GetValue(classInstance);
Console.WriteLine(field.GetValue(classInstance));
}
private static void InvokeMethod(Type type, BlackBoxInteger blackBoxInteger, int number, string methodName)
{
MethodInfo method = type.GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance);
method.Invoke(blackBoxInteger, new object[] { number });
FieldInfo field = type.GetField("innerValue", BindingFlags.Instance | BindingFlags.NonPublic);
Console.WriteLine(field.GetValue(blackBoxInteger));
}
public static void Print(MethodInfo[] methods, BlackBoxInteger instance, Type type, int value, string methodName)
{
var AddMethod = methods.FirstOrDefault(m => m.Name == methodName);
AddMethod.Invoke(instance, new object[] { value });
var field = type.GetField("innerValue", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(instance);
Console.WriteLine(field);
}
private static void ProcessCommand(BlackBoxInteger blackBox, string methodName, int value)
{
MethodInfo method = typeof(BlackBoxInteger).GetMethod(methodName, BindingFlags.Instance | BindingFlags.NonPublic);
method.Invoke(blackBox, new object[] { value });
FieldInfo field = typeof(BlackBoxInteger).GetField("innerValue", BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic);
int result = (int)field.GetValue(blackBox);
Console.WriteLine(result);
}
private static void InvokeMethodAndPrintValue(Type blackBoxType, BlackBoxInteger blackBox, string methodName, int methodArg)
{
MethodInfo method = blackBoxType.GetMethod(methodName,
BindingFlags.Instance | BindingFlags.NonPublic);
method.Invoke(blackBox, new object[] { methodArg });
FieldInfo innerValue = blackBoxType.GetField("innerValue",
BindingFlags.Instance |
BindingFlags.NonPublic);
Console.WriteLine(innerValue.GetValue(blackBox));
}
private static void Caller(string command, int value, BlackBoxInteger blackBoxInt)
{
var method = blackBoxInt
.GetType()
.GetMethod(command, BindingFlags.Instance | BindingFlags.NonPublic);
method.Invoke(blackBoxInt, new object[] { value });
var innerValue = blackBoxInt
.GetType()
.GetField("innerValue", BindingFlags.Instance | BindingFlags.NonPublic);
Console.WriteLine(innerValue.GetValue(blackBoxInt));
}
public static void Main()
{
Type type = Type.GetType("P02_BlackBoxInteger.BlackBoxInteger");
BlackBoxInteger blackBoxInteger = (BlackBoxInteger)Activator.CreateInstance(type, true);
string[] commandParams;
while ((commandParams = Console.ReadLine().Split('_'))[0] != "END")
{
string command = commandParams[0];
int number = int.Parse(commandParams[1]);
ExecuteCommand(type, blackBoxInteger, command, number);
}
}
public static void Main()
{
BlackBoxInteger blackBox = (BlackBoxInteger)Activator.CreateInstance(typeof(BlackBoxInteger), true);
var input = Console.ReadLine();
while (!input.Equals("END"))
{
var args = input.Split('_');
var methodName = args[0];
var value = int.Parse(args[1]);
ProcessCommand(blackBox, methodName, value);
input = Console.ReadLine();
}
}
static void ExecuteCommand(BlackBoxInteger instance)
{
string input;
while ((input = Console.ReadLine()) != "END")
{
string[] commandData = input.Split(new char[] { '_' }, StringSplitOptions.RemoveEmptyEntries);
string commandType = commandData[0];
int value = int.Parse(commandData[1]);
MethodInfo currentMethod = null;
switch (commandType)
{
case "Add":
currentMethod = typeof(BlackBoxInteger).GetMethod("Add", BindingFlags.NonPublic | BindingFlags.Instance);
break;
case "Subtract":
currentMethod = typeof(BlackBoxInteger).GetMethod("Subtract", BindingFlags.NonPublic | BindingFlags.Instance);
break;
case "Multiply":
currentMethod = typeof(BlackBoxInteger).GetMethod("Multiply", BindingFlags.NonPublic | BindingFlags.Instance);
break;
case "Divide":
currentMethod = typeof(BlackBoxInteger).GetMethod("Divide", BindingFlags.NonPublic | BindingFlags.Instance);
break;
case "RightShift":
currentMethod = typeof(BlackBoxInteger).GetMethod("RightShift", BindingFlags.NonPublic | BindingFlags.Instance);
break;
case "LeftShift":
currentMethod = typeof(BlackBoxInteger).GetMethod("LeftShift", BindingFlags.NonPublic | BindingFlags.Instance);
break;
}
currentMethod.Invoke(instance, new object[] { value });
Console.WriteLine(typeof(BlackBoxInteger).GetField("innerValue", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(instance));
}
}
public static void Main()
{
Type type = typeof(BlackBoxInteger);
var constructor = type.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[] { typeof(int) }, null);
BlackBoxInteger instance = (BlackBoxInteger)constructor.Invoke(new object[] { 0 });
FieldInfo fieldInfo = type.GetField("innerValue", BindingFlags.NonPublic | BindingFlags.Instance);
string input;
while ((input = Console.ReadLine()) != "END")
{
string[] tokens = input.Split('_', StringSplitOptions.RemoveEmptyEntries);
string name = tokens[0];
int value = int.Parse(tokens[1]);
MethodInfo method = type.GetMethod(name, BindingFlags.NonPublic | BindingFlags.Instance);
method.Invoke(instance, new object[] { value });
Console.WriteLine(fieldInfo.GetValue(instance));
}
}
public static void Main()
{
Type blackBoxType = typeof(BlackBoxInteger);
ConstructorInfo constructor =
blackBoxType.GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance)[0];
BlackBoxInteger blackBox = (BlackBoxInteger)constructor.Invoke(new object[] { 0 });
string input;
while ((input = Console.ReadLine()) != "END")
{
string[] tokens = input.Split("_");
string methodName = tokens[0];
int methodArg = int.Parse(tokens[1]);
InvokeMethodAndPrintValue(blackBoxType, blackBox, methodName, methodArg);
}
}
private static void ProcessCommands(BlackBoxInteger instance, Dictionary <string, MethodInfo> methods)
{
string inputLine;
var innerValueField = instance.GetType()
.GetFields(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public)
.FirstOrDefault();
while ((inputLine = Console.ReadLine()) != "END")
{
var tokens = inputLine.Split("_");
var command = tokens[0];
var argument = int.Parse(tokens[1]);
var currentMethod = methods[command];
currentMethod.Invoke(instance, new object[] { argument });
Console.WriteLine(innerValueField.GetValue(instance));
}
}
public static void Main()
{
Type blackBoxIntegerType = typeof(BlackBoxInteger);
var blackBoxConstructor = blackBoxIntegerType.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[0], null);
BlackBoxInteger blackBoxInteger = (BlackBoxInteger)blackBoxConstructor.Invoke(new object[] { });
var blackBoxMethods = blackBoxIntegerType.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic);
var blackBoxFields = blackBoxIntegerType.GetFields(BindingFlags.Instance | BindingFlags.NonPublic);
var blackBoxInnerValueField = blackBoxFields.FirstOrDefault(f => f.Name == "innerValue");
string input;
while ((input = Console.ReadLine()) != "END")
{
var inputData = input.Split("_");
var command = inputData[0];
var value = int.Parse(inputData[1]);
InvokeMethod(command, value, blackBoxInteger, blackBoxInnerValueField, blackBoxMethods);
}
}
public static void Main()
{
Type classType = typeof(BlackBoxInteger);
BlackBoxInteger instance = (BlackBoxInteger)Activator.CreateInstance(classType, true);
string command;
while ((command = Console.ReadLine()) != "END")
{
var tokens = command.Split('_');
string methodName = tokens[0];
int value = int.Parse(tokens[1]);
classType.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
.Invoke(instance, new object[] { value });
int currentValue = (int)classType.GetField("innerValue", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
.GetValue(instance);
Console.WriteLine(currentValue);
}
}
public static void Main()
{
string methodTokens = Console.ReadLine();
Type type = typeof(BlackBoxInteger);
var constructor = type.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[] { typeof(int) }, null);
BlackBoxInteger classInstance = (BlackBoxInteger)constructor.Invoke(new object[] { 0 });
while (methodTokens != "END")
{
string[] tokens = methodTokens.Split("_");
string name = tokens[0];
int value = int.Parse(tokens[1]);
MethodInfo currentMethod = type.GetMethod(name, BindingFlags.Instance | BindingFlags.NonPublic);
currentMethod.Invoke(classInstance, new object[] { value });
FieldInfo field = type.GetField("innerValue", BindingFlags.NonPublic | BindingFlags.Instance);
Console.WriteLine($"{field.GetValue(classInstance)}");
methodTokens = Console.ReadLine();
}
}
public static void Main()
{
Type classType = Assembly
.GetCallingAssembly()
.GetTypes()
.FirstOrDefault(x => x.Name is nameof(BlackBoxInteger));
BlackBoxInteger instance = (BlackBoxInteger)Activator
.CreateInstance(classType, true);
string inputLine = Console.ReadLine();
while (inputLine != "END")
{
string[] inputArguments = inputLine
.Split(new[] { '_' }, StringSplitOptions.RemoveEmptyEntries);
string methodName = inputArguments[0];
int number = int.Parse(inputArguments[1]);
classType.GetMethod(methodName,
BindingFlags.Instance |
BindingFlags.NonPublic |
BindingFlags.Public)
.Invoke(instance, new object[] { number });
int currentResult = (int)classType.GetField("innerValue",
BindingFlags.Instance |
BindingFlags.NonPublic |
BindingFlags.Public)
.GetValue(instance);
Console.WriteLine(currentResult);
inputLine = Console.ReadLine();
}
}
public static void Main()
{
Type type = typeof(BlackBoxInteger);
ConstructorInfo ctor = type.GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[0], null);
BlackBoxInteger classInstance = (BlackBoxInteger)ctor.Invoke(null);
MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic);
string input;
while ((input = Console.ReadLine()) != "END")
{
var args = input.Split(new[] { "_" }, StringSplitOptions.RemoveEmptyEntries);
string methodName = args[0];
int param = int.Parse(args[1]);
MethodInfo targetMethod = methods.FirstOrDefault(m => m.Name == methodName);
FieldInfo targetField = type.GetField("innerValue");
int index = 0;
for (int i = 0; i < fields.Length; i++)
{
if (fields[i] == targetField)
{
index = i;
}
}
targetMethod.Invoke(classInstance, new object[] { param });
Console.WriteLine(fields[index].GetValue(classInstance));
}
}
public static void Main()
{
string input = string.Empty;
ConstructorInfo blackBoxIntConstructor = (typeof(BlackBoxInteger).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { typeof(int) }, null));
BlackBoxInteger blackBoxInteger = blackBoxIntConstructor.Invoke(new object[] { 0 }) as BlackBoxInteger;
MethodInfo[] blackBoxIntMethods = blackBoxInteger.GetType().GetMethods(BindingFlags.NonPublic | BindingFlags.Instance);
while ((input = Console.ReadLine()) != "END")
{
string[] inputs = input.Split(new char[] { '_' });
FieldInfo[] blackBoxFields = blackBoxInteger.GetType().GetFields();
string methodName = inputs[0];
int parameter = int.Parse(inputs[1]);
MethodInfo methodToInvoke = blackBoxIntMethods.Where(m => m.Name == methodName).First();
methodToInvoke.Invoke(blackBoxInteger, new object[] { parameter });
FieldInfo innerIntField = blackBoxInteger.GetType().GetField("innerValue", BindingFlags.NonPublic | BindingFlags.Instance);
int result = (int)(innerIntField.GetValue(blackBoxInteger));
Console.WriteLine(result);
}
}
public static void Main()
{
Type classType = typeof(BlackBoxInteger);
MethodInfo[] methods = classType.GetMethods(BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);
BlackBoxInteger classInstance = (BlackBoxInteger)Activator.CreateInstance(typeof(BlackBoxInteger), true);
var command = Console.ReadLine();
while (command != "END")
{
string[] commandParts = command.Split("_");
string methodName = commandParts[0];
int number = int.Parse(commandParts[1]);
methods.Where(x => x.Name == methodName).FirstOrDefault()?.Invoke(classInstance, new object[1] {
number
});
PrintResult(classType, classInstance);
command = Console.ReadLine();
}
}
public static void Main()
{
Type classType = typeof(BlackBoxInteger);
BlackBoxInteger blackBox = (BlackBoxInteger)Activator.CreateInstance(classType, true);
string command = Console.ReadLine();
while (!command.Equals("END"))
{
string[] inputCommand = command.Split('_');
string methodName = inputCommand[0];
int passedValue = int.Parse(inputCommand[1]);
MethodInfo currentMethod = classType.GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance);
currentMethod.Invoke(blackBox, new object[] { passedValue });
string innerValue = classType.GetFields(BindingFlags.NonPublic | BindingFlags.Instance).First().GetValue(blackBox).ToString();
Console.WriteLine(innerValue);
command = Console.ReadLine();
}
}
