C#

Question: 1
Suppose using controls in Visual Studio you have developed the layout for a calculator in design mode as shown
below, and given names of button Add, Subtract, Multiply and divide as Plusbtn, Subbtn, Mulbtn and Divbtn
respectively. Names for TextBox labeled First Number, Second Number and Result are textBox1, textBox2 and
textBox3 respectively. If a number is entered in TextBox1 and TextBox2, clicking the buttons should produce result
of respective operation in TextBox3. Complete the code

DataTable loDataTable = new DataTable();
DataColumn loDataColumn = new DataColumn("Eval", typeof(double), expression);
loDataTable.Columns.Add(loDataColumn);
loDataTable.Rows.Add(0);
return (UInt32)(double)(loDataTable.Rows[0]["Eval"]);

public static bool parseDifficultExpression(string difficultExpression, out UInt32 parsedValue)
{
    try
    {
        string[] usingList = new string[] { "System",
                                            "System.Text",
                                            "System.Diagnostics" };
        string methodAsString = "    returnValue = " + difficultExpression + ";";
        string notUsed = "";
        parsedValue = (UInt32)Utilities.executeMethodAsString(usingList, methodAsString, notUsed, typeof(UInt32));
        return true;
    }
    catch (Exception)
    {
        parsedValue = 0xFFFFFFFF;
        return false;
    }
}

public static object executeMethodAsString(string[] usingList, string methodAsString, object args, Type returnType)
{
    string[] importList = new string[] { "System.dll" };
    string namespaceName = "myNameSpace";
    string className = "myClass";
    string methodName = "myMethod";

    //Create method
    CodeMemberMethod pMethod = new CodeMemberMethod();
    pMethod.Name = methodName;
    pMethod.Attributes = MemberAttributes.Public;
    pMethod.Parameters.Add(new CodeParameterDeclarationExpression(args.GetType(), "args"));
    pMethod.ReturnType = new CodeTypeReference(typeof(UInt32));
    string completeMethod =
        returnType + " returnValue = new " + returnType + "();" + "\r\n" +
        "try {"                                                 + "\r\n" +
            methodAsString                                      + "\r\n" +
        "} catch {"                                             + "\r\n" +
        "    returnValue = new " + returnType + "();"           + "\r\n" +
        "}"                                                     + "\r\n" +
        "return returnValue;";
    pMethod.Statements.Add(new CodeSnippetExpression(completeMethod));

//    Here you can look at what the assembled method looks like
//    Console.WriteLine(completeMethod);

    CodeTypeDeclaration pClass = new CodeTypeDeclaration(className);
    pClass.Attributes = MemberAttributes.Public;
    pClass.Members.Add(pMethod);
    CodeNamespace pNamespace = new CodeNamespace(namespaceName);
    pNamespace.Types.Add(pClass);
    for (int i = 0; i < usingList.Length; i++)
    {
        pNamespace.Imports.Add(new CodeNamespaceImport(usingList[i]));
    }

    CodeCompileUnit pUnit = new CodeCompileUnit();
    pUnit.Namespaces.Add(pNamespace);
    CompilerParameters pParams = new CompilerParameters(importList);
    pParams.GenerateInMemory = true;
    CompilerResults pResults = (new CSharpCodeProvider()).CreateCompiler().CompileAssemblyFromDom(pParams, pUnit);

    if ((pResults.Errors != null) && (0 < pResults.Errors.Count))
    {
        foreach (CompilerError pError in pResults.Errors)
        {
            Debug.WriteLine(pError.ToString());
        }
        return null;
    }
    else
    {
        object typeInstance = pResults.CompiledAssembly.CreateInstance(namespaceName + "." + className);
        MethodInfo methodInfo = typeInstance.GetType().GetMethod(methodName);
        return methodInfo.Invoke(typeInstance, new object[] { args });
    }
}

CompilerResults pResults = (new CSharpCodeProvider()).CreateCompiler().CompileAssemblyFromDom(pParams, pUnit);

public async Task<bool> WasItemPurchased(string productId)  
{  
var billing = CrossInAppBilling.Current;  
var result = false;  
try  
{  
var connected = await billing.ConnectAsync(ItemType.InAppPurchase);  
  
if (!connected)  
{  
//Couldn't connect  
return false;  
}  
  
//check purchases  
var verify = new InAppBillingVerify();  
var purchases = await billing.GetPurchasesAsync(ItemType.InAppPurchase, verify);  
  
//check for null just incase  
if (purchases?.Any(p => p.ProductId == productId) ?? false)  
{  
//Purchase restored  
Preferences.Set(productId, true);  
return true;  
}  
else  
{  
//no purchases found  
//Toast.MakeText(this, GetString(Resource.String.Options_RestoreUnavailable), ToastLength.Long);  
return false;  
}  
}  
catch (InAppBillingPurchaseException purchaseEx)  
{  
var message = string.Empty;  
switch (purchaseEx.PurchaseError)  
{  
case PurchaseError.AppStoreUnavailable:  
RestorePurchasesStatusMessage = GetString(Resource.String.Options_PaidFunctions_ErrorAppStoreUnavailable);  
break;  
case PurchaseError.BillingUnavailable:  
RestorePurchasesStatusMessage = GetString(Resource.String.Options_PaidFunctions_ErrorBillingUnavailable);  
break;  
case PurchaseError.PaymentInvalid:  
RestorePurchasesStatusMessage = GetString(Resource.String.Options_PaidFunctions_ErrorPaymentInvalid);  
break;  
case PurchaseError.PaymentNotAllowed:  
RestorePurchasesStatusMessage = GetString(Resource.String.Options_PaidFunctions_ErrorPaymentNotAllowed);  
break;  
case PurchaseError.AlreadyOwned:  
RestorePurchasesStatusMessage = GetString(Resource.String.Options_PaidFunctions_ErrorAlreadyOwned);  
Preferences.Set(productId, true);  
result = true;  
break;  
}  
  
//Decide if it is an error we care about  
if (string.IsNullOrWhiteSpace(message))  
return false;  
  
//Display message to user  
//Toast.MakeText(this, message, ToastLength.Long);  
}  
catch (Exception exception)  
{  
Crashes.TrackError(exception);  
//Something has gone wrong  
RestorePurchasesStatusMessage = GetString(Resource.String.Options_PaidFunctions_ErrorAppStoreUnavailable);  
//Toast.MakeText(this, GetString(Resource.String.Options_PaidFunctions_ErrorAppStoreUnavailable), ToastLength.Long);  
}  
finally  
{  
await billing.DisconnectAsync();  
}  
  
return result;  
}  
  
public async Task<bool> PurchaseItem(string productId, string payload)  
{  
var billing = CrossInAppBilling.Current;  
try  
{  
var connected = await billing.ConnectAsync(ItemType.InAppPurchase);  
if (!connected)  
{  
//we are offline or can't connect, don't try to purchase  
return false;  
}  
  
//check purchases  
var verify = new InAppBillingVerify();  
var purchase = await billing.PurchaseAsync(productId, ItemType.InAppPurchase, payload, verify);  
  
//possibility that a null came through.  
if (purchase == null)  
{  
//did not purchase  
}  
else if (purchase.State == PurchaseState.Purchased)  
{  
//purchased!  
Preferences.Set(productId, true);  
}  
}  
catch (InAppBillingPurchaseException purchaseEx)  
{  
var message = string.Empty;  
switch (purchaseEx.PurchaseError)  
{  
case PurchaseError.AppStoreUnavailable:  
message = GetString(Resource.String.Options_PaidFunctions_ErrorAppStoreUnavailable);  
break;  
case PurchaseError.BillingUnavailable:  
message = GetString(Resource.String.Options_PaidFunctions_ErrorBillingUnavailable);  
break;  
case PurchaseError.PaymentInvalid:  
message = GetString(Resource.String.Options_PaidFunctions_ErrorPaymentInvalid);  
break;  
case PurchaseError.PaymentNotAllowed:  
message = GetString(Resource.String.Options_PaidFunctions_ErrorPaymentNotAllowed);  
break;  
case PurchaseError.AlreadyOwned:  
message = GetString(Resource.String.Options_PaidFunctions_ErrorAlreadyOwned);  
Preferences.Set(productId, true);  
EnableOrDisableProFeatures();  
break;  
}  
  
//Decide if it is an error we care about  
if (string.IsNullOrWhiteSpace(message))  
return false;  
  
//Display message to user  
DisplayToast(message, ToastLength.Long);  
  
}  
catch (Exception exception)  
{  
Crashes.TrackError(exception);  
//Something else has gone wrong, log it  
//Debug("Issue connecting: " + ex);  
DisplayToast(GetString(Resource.String.Options_PaidFunctions_ErrorAppStoreUnavailable), ToastLength.Long);  
  
}  
finally  
{  
await billing.DisconnectAsync();  
}  
return false;  
}  
  
private async Task RestorePurchases()  
{  
var currentConnectivity = Connectivity.NetworkAccess;  
var restorePurchasesResults = new List<bool>();  
if (currentConnectivity == NetworkAccess.Internet)  
{  
restorePurchasesResults.Add(await WasItemPurchased(GetString(Resource.String.Options_PaidFunctions_PurchaseTemplatesAndMoreButtons)));  
restorePurchasesResults.Add(await WasItemPurchased(GetString(Resource.String.Options_PaidFunctions_PurchaseCustomResources)));  
restorePurchasesResults.Add(await WasItemPurchased(GetString(Resource.String.Options_PaidFunctions_PurchaseDisplayWebpageAfterVote)));  
if (restorePurchasesResults.Contains(true))  
{  
DisplayToast(GetString(Resource.String.Options_PaidFunctions_PurchasesRestored), ToastLength.Long);  
  
EnableOrDisableProFeatures();  
}  
else  
{  
if (string.IsNullOrEmpty(RestorePurchasesStatusMessage))  
RestorePurchasesStatusMessage = GetString(Resource.String.Options_PaidFunctions_PurchasesNotFound);  
DisplayToast(RestorePurchasesStatusMessage, ToastLength.Long);  
  
}  
}  
else  
{  
DisplayToast(GetString(Resource.String.Options_InternetUnavailable), ToastLength.Long);  
  
}  
}  
  
private async Task<string> GetProductPrice(string productId)  
{  
var billing = CrossInAppBilling.Current;  
try  
{  
  
var connected = await billing.ConnectAsync(ItemType.InAppPurchase);  
  
if (!connected)  
{  
//Couldn't connect  
return string.Empty;  
}  
  
//check purchases  
var item = await billing.GetProductInfoAsync(ItemType.InAppPurchase, productId);  
  
if (item != null)  
return item.ToList()[0].LocalizedPrice;  
}  
catch (InAppBillingPurchaseException purchaseEx)  
{  
var message = string.Empty;  
switch (purchaseEx.PurchaseError)  
{  
case PurchaseError.AppStoreUnavailable:  
message = GetString(Resource.String.Options_PaidFunctions_ErrorAppStoreUnavailable);  
break;  
case PurchaseError.BillingUnavailable:  
message = GetString(Resource.String.Options_PaidFunctions_ErrorBillingUnavailable);  
break;  
case PurchaseError.PaymentInvalid:  
message = GetString(Resource.String.Options_PaidFunctions_ErrorPaymentInvalid);  
break;  
case PurchaseError.PaymentNotAllowed:  
message = GetString(Resource.String.Options_PaidFunctions_ErrorPaymentNotAllowed);  
break;  
}  
  
//Decide if it is an error we care about  
if (string.IsNullOrWhiteSpace(message))  
return string.Empty;  
  
//Display message to user  
DisplayToast(message, ToastLength.Long);  
  
}  
catch (Exception exception)  
{  
Crashes.TrackError(exception);  
//Something has gone wrong  
}  
finally  
{  
await billing.DisconnectAsync();  
}  
return string.Empty;  
}