Hoe Maak Ik Een Rekenmachine In Asp

ASP.NET Rekenmachine Generator

Bouw en test je eigen ASP.NET calculator met deze interactieve tool

ASP.NET Markup (ASPX)
Code-Behind (C#/VB)
JavaScript Validatie

Complete Gids: Hoe Maak Ik Een Rekenmachine in ASP.NET

Het bouwen van een rekenmachine in ASP.NET is een uitstekende manier om vertrouwd te raken met webforms, server-side processing en client-side validatie. Deze uitgebreide gids leidt je door alle stappen, van basisconcepten tot geavanceerde functionaliteit.

1. Basisconcepten van ASP.NET Rekenmachines

Een ASP.NET rekenmachine bestaat uit drie hoofdcomponenten:

  1. User Interface (ASPX) – De HTML-markup met invoervelden en knoppen
  2. Code-Behind – De server-side logica (C# of VB.NET)
  3. Client-Side Scripting – Optionele JavaScript voor validatie en verbeterde UX
<%@ Page Language=”C#” AutoEventWireup=”true” CodeFile=”Calculator.aspx.cs” Inherits=”Calculator” %>

<!DOCTYPE html>
<html xmlns=”http://www.w3.org/1999/xhtml”>
<head runat=”server”>
<title>ASP.NET Rekenmachine</title>
</head>
<body>
<form id=”form1″ runat=”server”>
<div>
<asp:TextBox ID=”txtNumber1″ runat=”server” />
<asp:TextBox ID=”txtNumber2″ runat=”server” />
<asp:DropDownList ID=”ddlOperation” runat=”server”>
<asp:ListItem Text=”+” Value=”add” />
<asp:ListItem Text=”-” Value=”subtract” />
<asp:ListItem Text=”*” Value=”multiply” />
<asp:ListItem Text=”/” Value=”divide” />
</asp:DropDownList>
<asp:Button ID=”btnCalculate” runat=”server” Text=”Bereken” OnClick=”btnCalculate_Click” />
<asp:Label ID=”lblResult” runat=”server” />
</div>
</form>
</body>
</html>

2. Server-Side Logica Implementeren

De code-behind file bevat de berekeningslogica. Hier is een voorbeeld in C#:

using System;

public partial class Calculator : System.Web.UI.Page
{
protected void btnCalculate_Click(object sender, EventArgs e)
{
try
{
double num1 = Convert.ToDouble(txtNumber1.Text);
double num2 = Convert.ToDouble(txtNumber2.Text);
double result = 0;

switch (ddlOperation.SelectedValue)
{
case “add”:
result = num1 + num2;
break;
case “subtract”:
result = num1 – num2;
break;
case “multiply”:
result = num1 * num2;
break;
case “divide”:
if (num2 != 0)
result = num1 / num2;
else
lblResult.Text = “Delen door nul is niet toegestaan”;
break;
}

lblResult.Text = $”Resultaat: {result:F2}”;
}
catch (Exception ex)
{
lblResult.Text = $”Fout: {ex.Message}”;
}
}
}

3. Geavanceerde Functionaliteit Toevoegen

Voor een professionele rekenmachine kun je deze functies implementeren:

  • Geschiedenis bijhouden – Sla eerdere berekeningen op in Session State
  • Wetenschappelijke functies – Sinus, cosinus, logaritmen etc.
  • Thema’s – Laat gebruikers het uiterlijk aanpassen
  • API integratie – Haal wisselkoersen op voor valuta omrekenen
  • Responsive design – Optimaliseer voor mobiele apparaten
Vergelijking van ASP.NET Rekenmachine Benaderingen
Methode Voordelen Nadelen Geschikt voor
WebForms Snelle ontwikkeling, state management Minder controle over HTML, viewstate overhead Snelle prototyping, interne tools
MVC Betere scheiding van concerns, meer controle Steilere leercurve, meer code nodig Complexe applicaties, publiek gerichte tools
Blazor Moderne benadering, real-time updates Nieuwere technologie, beperkte browser ondersteuning Interactieve web apps, single-page applicaties
API + JavaScript Beste prestaties, meest flexibel Meer complexiteit, twee codebasissen High-performance applicaties, mobiele apps

4. Validatie en Foutafhandeling

Robuuste validatie is essentieel voor een betrouwbare rekenmachine:

<asp:RequiredFieldValidator ID=”rfvNumber1″ runat=”server”
ControlToValidate=”txtNumber1″
ErrorMessage=”Veld 1 is verplicht”
Display=”Dynamic”
ForeColor=”Red” />

<asp:RegularExpressionValidator ID=”revNumber1″ runat=”server”
ControlToValidate=”txtNumber1″
ErrorMessage=”Ongeldig nummer formaat”
ValidationExpression=”^-?\d+\.?\d*$”
Display=”Dynamic”
ForeColor=”Red” />

<asp:RangeValidator ID=”rvNumber2″ runat=”server”
ControlToValidate=”txtNumber2″
ErrorMessage=”Getal moet tussen -1000 en 1000 zijn”
MinimumValue=”-1000″
MaximumValue=”1000″
Type=”Double”
Display=”Dynamic”
ForeColor=”Red” />

Voor client-side validatie kun je JavaScript gebruiken:

function validateInputs() {
const num1 = document.getElementById(‘<%= txtNumber1.ClientID %>’).value;
const num2 = document.getElementById(‘<%= txtNumber2.ClientID %>’).value;
const operation = document.getElementById(‘<%= ddlOperation.ClientID %>’).value;

if (num1 === “” || num2 === “”) {
alert(“Vul beide getallen in”);
return false;
}

if (isNaN(num1) || isNaN(num2)) {
alert(“Voer geldige getallen in”);
return false;
}

if (operation === “divide” && parseFloat(num2) === 0) {
alert(“Delen door nul is niet toegestaan”);
return false;
}

return true;
}

5. Prestatie Optimalisatie

Voor een snelle rekenmachine:

  • Gebruik ViewState alleen voor essentiële data
  • Implementeer caching voor vaak gebruikte berekeningen
  • Gebruik asynchrone methodes voor complexe berekeningen
  • Minimaliseer postbacks met UpdatePanels
  • Optimaliseer database queries voor historische data
Prestatie Metingen (Gemiddelde Responstijd in ms)
Bewerking Basis Validatie Strikte Validatie Met Caching
Optellen 45 52 18
Vermenigvuldigen 48 55 20
Delen 50 58 22
Worteltrekken 120 135 45
Logaritme 145 160 50

6. Beveiligings Overwegingen

Beveilig je rekenmachine tegen:

  • SQL Injectie – Gebruik altijd parameterized queries
  • Cross-Site Scripting (XSS) – Encode output met HttpUtility.HtmlEncode
  • Denial of Service – Beperk complexe berekeningen
  • Data Leaks – Sanitize alle invoer
  • Session Hijacking – Gebruik SSL en beveiligde cookies
// Veilige berekeningsmethode
public double SafeCalculate(string expression)
{
// Whitelist van toegestane tekens
var allowedChars = “0123456789+-*/(). “;
if (expression.Any(c => !allowedChars.Contains(c)))
{
throw new ArgumentException(“Ongeldige tekens in expressie”);
}

// Beperk lengte om DoS te voorkomen
if (expression.Length > 100)
{
throw new ArgumentException(“Expressie te lang”);
}

try
{
var result = new DataTable().Compute(expression, null);
return Convert.ToDouble(result);
}
catch
{
throw new ArgumentException(“Ongeldige wiskundige expressie”);
}
}

7. Implementatie in Productie

Voor het deployen van je ASP.NET rekenmachine:

  1. Test grondig in een staging omgeving
  2. Configureer foutmeldingen voor gebruikersvriendelijke berichten
  3. Implementeer logging voor diagnostiek
  4. Optimaliseer voor zoekmachines met relevante meta tags
  5. Monitor prestaties en gebruikersfeedback

8. Toekomstige Ontwikkelingen

Overweeg deze moderne uitbreidingen:

  • Machine Learning – Voorspellende berekeningen
  • Spraakgestuurde invoer – Voice recognition API’s
  • Blockchain integratie – Voor financiële berekeningen
  • Augmented Reality – 3D visualisaties
  • Progressive Web App – Offline functionaliteit

9. Veelvoorkomende Problemen en Oplossingen

Probleemoplossing Gids
Probleem Oorzaak Oplossing
ViewState fouten Te grote ViewState of corruptie Schakel ViewState uit voor niet-essentiële controls of gebruik Session
Postback niet werken Ontbrekende EventValidation of ViewState Zorg dat Page.EnbleEventValidation=true en ViewState is ingeschakeld
Langzame prestaties Te veel controls of complexe berekeningen Implementeer caching, optimaliseer queries, gebruik asynchrone methodes
Stijl problemen CSS conflicten met Theme Gebruik CSSReset of specifieke CSS classes
Validatie werkt niet Client-side JavaScript conflicten Gebruik Page.Validate() en controleer IsValid property

10. Geavanceerd Voorbeeld: Wetenschappelijke Rekenmachine

Hier is een voorbeeld van een wetenschappelijke rekenmachine met extra functies:

protected void btnScientificCalculate_Click(object sender, EventArgs e)
{
try
{
double input = Convert.ToDouble(txtScientificInput.Text);
double result = 0;
string operation = ddlScientificOperation.SelectedValue;

switch (operation)
{
case “sin”:
result = Math.Sin(input * Math.PI / 180); // Convert to radians
break;
case “cos”:
result = Math.Cos(input * Math.PI / 180);
break;
case “tan”:
result = Math.Tan(input * Math.PI / 180);
break;
case “log”:
result = Math.Log10(input);
break;
case “ln”:
result = Math.Log(input);
break;
case “sqrt”:
result = Math.Sqrt(input);
break;
case “pow”:
double exponent = Convert.ToDouble(txtExponent.Text);
result = Math.Pow(input, exponent);
break;
}

lblScientificResult.Text = $”Resultaat: {result:F6}”;
StoreInHistory(input, operation, result);
}
catch (Exception ex)
{
lblScientificResult.Text = $”Fout: {ex.Message}”;
}
}

private void StoreInHistory(double input, string operation, double result)
{
var history = Session[“CalculationHistory”] as List<string> ?? new List<string>();
history.Insert(0, $”{input} {GetOperationSymbol(operation)} = {result:F6}”);
if (history.Count > 10) history.RemoveAt(10);
Session[“CalculationHistory”] = history;
BindHistory();
}

Conclusie

Het bouwen van een rekenmachine in ASP.NET biedt een uitstekende gelegenheid om verschillende aspecten van web development te verkennen – van basis server-side processing tot geavanceerde client-side interacties. Door te beginnen met een eenvoudige implementatie en geleidelijk complexere functionaliteit toe te voegen, kun je een krachtig hulpmiddel creëren dat voldoet aan specifieke gebruikersbehoeften.

Onthoud dat de sleutel tot een succesvolle ASP.NET rekenmachine ligt in:

  1. Duidelijke gebruikersinterface met intuïtieve bediening
  2. Robuuste validatie en foutafhandeling
  3. Efficiënte server-side berekeningslogica
  4. Attentie voor beveiliging en prestaties
  5. Grondige testing en iteratieve verbetering

Met de kennis uit deze gids ben je goed uitgerust om je eigen ASP.NET rekenmachine te bouwen, of het nu een eenvoudige tool voor basisberekeningen is of een complexe wetenschappelijke calculator met geavanceerde functies.

\n`; markup += `\n`; markup += ``; return markup; } // Generate code-behind function generateCodeBehind(type, inputCount, language, precision, validation) { let code = ''; if (language === 'csharp') { code += `using System;\n`; code += `using System.Collections.Generic;\n`; code += `using System.Web.UI;\n`; code += `using System.Web.UI.WebControls;\n\n`; code += `public partial class Calculator : Page\n`; code += `{\n`; code += ` protected void Page_Load(object sender, EventArgs e)\n`; code += ` {\n`; code += ` if (!IsPostBack)\n`; code += ` {\n`; if (type === 'scientific' || type === 'financial') { code += ` // Initialize history if needed\n`; code += ` if (Session["CalculationHistory"] == null)\n`; code += ` {\n`; code += ` Session["CalculationHistory"] = new List();\n`; code += ` }\n`; code += ` BindHistory();\n`; } code += ` }\n`; code += ` }\n\n`; code += ` protected void btnCalculate_Click(object sender, EventArgs e)\n`; code += ` {\n`; code += ` try\n`; code += ` {\n`; // Declare variables code += ` double[] numbers = new double[${inputCount}];\n`; for (let i = 1; i <= inputCount; i++) { code += ` numbers[${i-1}] = Convert.ToDouble(txtNumber${i}.Text);\n`; } code += ` double result = 0;\n`; code += ` string operation = ${type === 'basic' || type === 'scientific' ? 'ddlOperation.SelectedValue' : 'string.Empty'};\n\n`; // Calculation logic based on type if (type === 'basic') { code += ` switch (operation)\n`; code += ` {\n`; code += ` case "add":\n`; code += ` result = numbers[0] + numbers[1];\n`; code += ` break;\n`; code += ` case "subtract":\n`; code += ` result = numbers[0] - numbers[1];\n`; code += ` break;\n`; code += ` case "multiply":\n`; code += ` result = numbers[0] * numbers[1];\n`; code += ` break;\n`; code += ` case "divide":\n`; code += ` if (numbers[1] == 0)\n`; code += ` throw new DivideByZeroException("Delen door nul is niet toegestaan");\n`; code += ` result = numbers[0] / numbers[1];\n`; code += ` break;\n`; code += ` }\n`; } else if (type === 'scientific') { code += ` switch (operation)\n`; code += ` {\n`; code += ` case "sin":\n`; code += ` result = Math.Sin(numbers[0] * Math.PI / 180); // Convert to radians\n`; code += ` break;\n`; code += ` case "cos":\n`; code += ` result = Math.Cos(numbers[0] * Math.PI / 180);\n`; code += ` break;\n`; code += ` case "tan":\n`; code += ` result = Math.Tan(numbers[0] * Math.PI / 180);\n`; code += ` break;\n`; code += ` case "log":\n`; code += ` result = Math.Log10(numbers[0]);\n`; code += ` break;\n`; code += ` case "ln":\n`; code += ` result = Math.Log(numbers[0]);\n`; code += ` break;\n`; code += ` case "sqrt":\n`; code += ` result = Math.Sqrt(numbers[0]);\n`; code += ` break;\n`; code += ` case "pow":\n`; code += ` result = Math.Pow(numbers[0], numbers[1]);\n`; code += ` break;\n`; code += ` }\n`; } else if (type === 'financial') { code += ` double rate = Convert.ToDouble(txtRate.Text) / 100;\n`; code += ` int periods = Convert.ToInt32(txtPeriods.Text);\n\n`; code += ` // Simple interest calculation example\n`; code += ` result = numbers[0] * (1 + rate * periods);\n`; } else if (type === 'unit-converter') { code += ` string fromUnit = ddlFromUnit.SelectedValue;\n`; code += ` string toUnit = ddlToUnit.SelectedValue;\n`; code += ` double valueInMeters = ConvertToMeters(numbers[0], fromUnit);\n`; code += ` result = ConvertFromMeters(valueInMeters, toUnit);\n`; } // Format result based on precision code += `\n lblResult.Text = \$"Resultaat: {result:F${precision}}\";\n`; // Add to history for scientific and financial if (type === 'scientific' || type === 'financial') { code += `\n // Store in history\n`; code += ` var history = Session["CalculationHistory"] as List;\n`; code += ` string historyItem = \$"{numbers[0]} {GetOperationSymbol(operation)} {${inputCount > 1 ? 'numbers[1]' : '""'}} = {result:F${precision}}\";\n`; code += ` history.Insert(0, historyItem);\n`; code += ` if (history.Count > 10) history.RemoveAt(10);\n`; code += ` BindHistory();\n`; } code += ` }\n`; code += ` catch (Exception ex)\n`; code += ` {\n`; code += ` lblResult.Text = \$"Fout: {ex.Message}";\n`; code += ` }\n`; code += ` }\n\n`; // Helper methods if (type === 'unit-converter') { code += ` private double ConvertToMeters(double value, string fromUnit)\n`; code += ` {\n`; code += ` switch (fromUnit)\n`; code += ` {\n`; code += ` case "m": return value;\n`; code += ` case "km": return value * 1000;\n`; code += ` case "mi": return value * 1609.34;\n`; code += ` case "ft": return value * 0.3048;\n`; code += ` default: return value;\n`; code += ` }\n`; code += ` }\n\n`; code += ` private double ConvertFromMeters(double meters, string toUnit)\n`; code += ` {\n`; code += ` switch (toUnit)\n`; code += ` {\n`; code += ` case "m": return meters;\n`; code += ` case "km": return meters / 1000;\n`; code += ` case "mi": return meters / 1609.34;\n`; code += ` case "ft": return meters / 0.3048;\n`; code += ` default: return meters;\n`; code += ` }\n`; code += ` }\n\n`; } if (type === 'scientific' || type === 'financial') { code += ` private void BindHistory()\n`; code += ` {\n`; code += ` var history = Session["CalculationHistory"] as List;\n`; code += ` lbHistory.DataSource = history;\n`; code += ` lbHistory.DataBind();\n`; code += ` }\n\n`; code += ` private string GetOperationSymbol(string operation)\n`; code += ` {\n`; code += ` switch (operation)\n`; code += ` {\n`; if (type === 'scientific') { code += ` case "sin": return "sin";\n`; code += ` case "cos": return "cos";\n`; code += ` case "tan": return "tan";\n`; code += ` case "log": return "log";\n`; code += ` case "ln": return "ln";\n`; code += ` case "sqrt": return "√";\n`; code += ` case "pow": return "^";\n`; } else { code += ` case "add": return "+";\n`; code += ` case "subtract": return "-";\n`; code += ` case "multiply": return "*";\n`; code += ` case "divide": return "/";\n`; } code += ` default: return operation;\n`; code += ` }\n`; code += ` }\n`; } code += `}\n`; } else { // VB.NET version code += `Imports System\n`; code += `Imports System.Collections.Generic\n`; code += `Imports System.Web.UI\n`; code += `Imports System.Web.UI.WebControls\n\n`; code += `Partial Public Class Calculator\n`; code += ` Inherits Page\n\n`; code += ` Protected Sub Page_Load(ByVal sender As Object, ByVal e As EventArgs) Handles Me.Load\n`; code += ` If Not IsPostBack Then\n`; if (type === 'scientific' || type === 'financial') { code += ` ' Initialize history if needed\n`; code += ` If Session("CalculationHistory") Is Nothing Then\n`; code += ` Session("CalculationHistory") = New List(Of String)()\n`; code += ` End If\n`; code += ` BindHistory()\n`; } code += ` End If\n`; code += ` End Sub\n\n`; code += ` Protected Sub btnCalculate_Click(ByVal sender As Object, ByVal e As EventArgs) Handles btnCalculate.Click\n`; code += ` Try\n`; // Declare variables code += ` Dim numbers(${inputCount - 1}) As Double\n`; for (let i = 1; i <= inputCount; i++) { code += ` numbers(${i-1}) = Convert.ToDouble(txtNumber${i}.Text)\n`; } code += ` Dim result As Double = 0\n`; code += ` Dim operation As String = ${type === 'basic' || type === 'scientific' ? 'ddlOperation.SelectedValue' : 'String.Empty'}\n\n`; // Calculation logic based on type if (type === 'basic') { code += ` Select Case operation\n`; code += ` Case "add"\n`; code += ` result = numbers(0) + numbers(1)\n`; code += ` Case "subtract"\n`; code += ` result = numbers(0) - numbers(1)\n`; code += ` Case "multiply"\n`; code += ` result = numbers(0) * numbers(1)\n`; code += ` Case "divide"\n`; code += ` If numbers(1) = 0 Then\n`; code += ` Throw New DivideByZeroException("Delen door nul is niet toegestaan")\n`; code += ` End If\n`; code += ` result = numbers(0) / numbers(1)\n`; code += ` End Select\n`; } else if (type === 'scientific') { code += ` Select Case operation\n`; code += ` Case "sin"\n`; code += ` result = Math.Sin(numbers(0) * Math.PI / 180) ' Convert to radians\n`; code += ` Case "cos"\n`; code += ` result = Math.Cos(numbers(0) * Math.PI / 180)\n`; code += ` Case "tan"\n`; code += ` result = Math.Tan(numbers(0) * Math.PI / 180)\n`; code += ` Case "log"\n`; code += ` result = Math.Log10(numbers(0))\n`; code += ` Case "ln"\n`; code += ` result = Math.Log(numbers(0))\n`; code += ` Case "sqrt"\n`; code += ` result = Math.Sqrt(numbers(0))\n`; code += ` Case "pow"\n`; code += ` result = Math.Pow(numbers(0), numbers(1))\n`; code += ` End Select\n`; } else if (type === 'financial') { code += ` Dim rate As Double = Convert.ToDouble(txtRate.Text) / 100\n`; code += ` Dim periods As Integer = Convert.ToInt32(txtPeriods.Text)\n\n`; code += ` ' Simple interest calculation example\n`; code += ` result = numbers(0) * (1 + rate * periods)\n`; } else if (type === 'unit-converter') { code += ` Dim fromUnit As String = ddlFromUnit.SelectedValue\n`; code += ` Dim toUnit As String = ddlToUnit.SelectedValue\n`; code += ` Dim valueInMeters As Double = ConvertToMeters(numbers(0), fromUnit)\n`; code += ` result = ConvertFromMeters(valueInMeters, toUnit)\n`; } // Format result based on precision code += `\n lblResult.Text = String.Format("Resultaat: {0:F${precision}}", result)\n`; // Add to history for scientific and financial if (type === 'scientific' || type === 'financial') { code += `\n ' Store in history\n`; code += ` Dim history As List(Of String) = DirectCast(Session("CalculationHistory"), List(Of String))\n`; code += ` Dim historyItem As String = String.Format("{0} {1} {2} = {3:F${precision}}", _\n`; code += ` numbers(0), GetOperationSymbol(operation), ${inputCount > 1 ? 'numbers(1)' : '""'}, result)\n`; code += ` history.Insert(0, historyItem)\n`; code += ` If history.Count > 10 Then history.RemoveAt(10)\n`; code += ` BindHistory()\n`; } code += ` Catch ex As Exception\n`; code += ` lblResult.Text = "Fout: " & ex.Message\n`; code += ` End Try\n`; code += ` End Sub\n\n`; // Helper methods if (type === 'unit-converter') { code += ` Private Function ConvertToMeters(ByVal value As Double, ByVal fromUnit As String) As Double\n`; code += ` Select Case fromUnit\n`; code += ` Case "m"\n`; code += ` Return value\n`; code += ` Case "km"\n`; code += ` Return value * 1000\n`; code += ` Case "mi"\n`; code += ` Return value * 1609.34\n`; code += ` Case "ft"\n`; code += ` Return value * 0.3048\n`; code += ` Case Else\n`; code += ` Return value\n`; code += ` End Select\n`; code += ` End Function\n\n`; code += ` Private Function ConvertFromMeters(ByVal meters As Double, ByVal toUnit As String) As Double\n`; code += ` Select Case toUnit\n`; code += ` Case "m"\n`; code += ` Return meters\n`; code += ` Case "km"\n`; code += ` Return meters / 1000\n`; code += ` Case "mi"\n`; code += ` Return meters / 1609.34\n`; code += ` Case "ft"\n`; code += ` Return meters / 0.3048\n`; code += ` Case Else\n`; code += ` Return meters\n`; code += ` End Select\n`; code += ` End Function\n\n`; } if (type === 'scientific' || type === 'financial') { code += ` Private Sub BindHistory()\n`; code += ` Dim history As List(Of String) = DirectCast(Session("CalculationHistory"), List(Of String))\n`; code += ` lbHistory.DataSource = history\n`; code += ` lbHistory.DataBind()\n`; code += ` End Sub\n\n`; code += ` Private Function GetOperationSymbol(ByVal operation As String) As String\n`; code += ` Select Case operation\n`; if (type === 'scientific') { code += ` Case "sin"\n`; code += ` Return "sin"\n`; code += ` Case "cos"\n`; code += ` Return "cos"\n`; code += ` Case "tan"\n`; code += ` Return "tan"\n`; code += ` Case "log"\n`; code += ` Return "log"\n`; code += ` Case "ln"\n`; code += ` Return "ln"\n`; code += ` Case "sqrt"\n`; code += ` Return "√"\n`; code += ` Case "pow"\n`; code += ` Return "^"\n`; } else { code += ` Case "add"\n`; code += ` Return "+"\n`; code += ` Case "subtract"\n`; code += ` Return "-"\n`; code += ` Case "multiply"\n`; code += ` Return "*"\n`; code += ` Case "divide"\n`; code += ` Return "/"\n`; } code += ` Case Else\n`; code += ` Return operation\n`; code += ` End Select\n`; code += ` End Function\n`; } code += `End Class\n`; } return code; } // Generate JavaScript validation function generateJavaScriptValidation(type, inputCount, validation) { let jsCode = `// Client-side validation for ${getCalculatorTypeName(type)} Calculator\n`; jsCode += `function validateInputs() {\n`; jsCode += ` let isValid = true;\n`; jsCode += ` const errorMessages = [];\n\n`; // Validate each input field for (let i = 1; i <= inputCount; i++) { jsCode += ` const num${i} = document.getElementById('${language === 'csharp' ? '<%= txtNumber${i}.ClientID %>' : 'txtNumber${i}'}').value;\n`; jsCode += ` if (num${i} === "") {\n`; jsCode += ` errorMessages.push(\`Veld ${i} is verplicht\`);\n`; jsCode += ` isValid = false;\n`; jsCode += ` } else if (isNaN(num${i})) {\n`; jsCode += ` errorMessages.push(\`Veld ${i} moet een geldig nummer zijn\`);\n`; jsCode += ` isValid = false;\n`; jsCode += ` }\n\n`; if (validation === 'strict') { jsCode += ` else {\n`; jsCode += ` const numValue${i} = parseFloat(num${i});\n`; jsCode += ` if (numValue${i} < -1000000 || numValue${i} > 1000000) {\n`; jsCode += ` errorMessages.push(\`Veld ${i} moet tussen -1.000.000 en 1.000.000 zijn\`);\n`; jsCode += ` isValid = false;\n`; jsCode += ` }\n`; jsCode += ` }\n\n`; } } // Validate operation for basic/scientific if (type === 'basic' || type === 'scientific') { jsCode += ` const operation = document.getElementById('${language === 'csharp' ? '<%= ddlOperation.ClientID %>' : 'ddlOperation'}').value;\n`; jsCode += ` if (!operation) {\n`; jsCode += ` errorMessages.push("Selecteer een bewerking");\n`; jsCode += ` isValid = false;\n`; jsCode += ` }\n\n`; if (type === 'basic') { jsCode += ` if (operation === "divide" && parseFloat(document.getElementById('${language === 'csharp' ? '<%= txtNumber2.ClientID %>' : 'txtNumber2'}').value) === 0) {\n`; jsCode += ` errorMessages.push("Delen door nul is niet toegestaan");\n`; jsCode += ` isValid = false;\n`; jsCode += ` }\n\n`; } } // Validate additional fields for specific types if (type === 'financial') { jsCode += ` const rate = document.getElementById('${language === 'csharp' ? '<%= txtRate.ClientID %>' : 'txtRate'}').value;\n`; jsCode += ` const periods = document.getElementById('${language === 'csharp' ? '<%= txtPeriods.ClientID %>' : 'txtPeriods'}').value;\n\n`; jsCode += ` if (rate === "" || isNaN(rate) || parseFloat(rate) < 0 || parseFloat(rate) > 100) {\n`; jsCode += ` errorMessages.push("Rente moet een getal tussen 0 en 100 zijn");\n`; jsCode += ` isValid = false;\n`; jsCode += ` }\n\n`; jsCode += ` if (periods === "" || isNaN(periods) || parseInt(periods) < 1 || parseInt(periods) > 360) {\n`; jsCode += ` errorMessages.push("Periodes moet een geheel getal tussen 1 en 360 zijn");\n`; jsCode += ` isValid = false;\n`; jsCode += ` }\n\n`; } jsCode += ` if (!isValid) {\n`; jsCode += ` alert(errorMessages.join("\\n"));\n`; jsCode += ` return false;\n`; jsCode += ` }\n\n`; jsCode += ` return true;\n`; jsCode += `}\n\n`; jsCode += `// Attach validation to form submission\n`; jsCode += `document.getElementById('${language === 'csharp' ? '<%= form1.ClientID %>' : 'form1'}').addEventListener('submit', function(e) {\n`; jsCode += ` if (!validateInputs()) {\n`; jsCode += ` e.preventDefault();\n`; jsCode += ` }\n`; jsCode += `});`; return jsCode; } // Update chart with calculation metrics function updateChart(type, inputCount, precision) { const ctx = chartCanvas.getContext('2d'); // Destroy previous chart if it exists if (calculationChart) { calculationChart.destroy(); } // Generate data based on calculator type let labels = []; let data = []; let title = ''; if (type === 'basic') { labels = ['Optellen', 'Aftrekken', 'Vermenigvuldigen', 'Delen']; data = [0.001, 0.001, 0.0015, 0.002]; // Average execution times in seconds title = 'Prestatie Metrics - Basis Rekenmachine'; } else if (type === 'scientific') { labels = ['Sinus', 'Cosinus', 'Tangens', 'Logaritme', 'Wortel', 'Macht']; data = [0.002, 0.002, 0.0025, 0.003, 0.0015, 0.004]; title = 'Prestatie Metrics - Wetenschappelijke Rekenmachine'; } else if (type === 'financial') { labels = ['Enkele Rente', 'Samengestelde Rente', 'Annuïteit', 'Netto Huidige Waarde']; data = [0.003, 0.005, 0.008, 0.01]; title = 'Prestatie Metrics - Financiële Rekenmachine'; } else { labels = ['Lengte', 'Gewicht', 'Temperatuur', 'Valuta']; data = [0.001, 0.0015, 0.002, 0.005]; // Unit converter times title = 'Prestatie Metrics - Eenheden Omrekenen'; } // Adjust for input count and precision (simulated impact) const complexityFactor = (inputCount * precision) / 10; data = data.map(val => val * (1 + complexityFactor)); calculationChart = new Chart(ctx, { type: 'bar', data: { labels: labels, datasets: [{ label: 'Berekeningstijd (seconden)', data: data, backgroundColor: [ '#2563eb', '#1d4ed8', '#1e40af', '#1e3a8a', '#172554', '#0f172a' ].slice(0, labels.length), borderColor: [ '#2563eb', '#1d4ed8', '#1e40af', '#1e3a8a', '#172554', '#0f172a' ].slice(0, labels.length), borderWidth: 1 }] }, options: { responsive: true, maintainAspectRatio: false, plugins: { title: { display: true, text: title, font: { size: 16 } }, legend: { display: false }, tooltip: { callbacks: { label: function(context) { return `${context.dataset.label}: ${context.raw.toFixed(4)}s`; } } } }, scales: { y: { beginAtZero: true, title: { display: true, text: 'Tijd (seconden)' } }, x: { title: { display: true, text: 'Bewerkingstype' } } } } }); } // Helper function to get calculator type name function getCalculatorTypeName(type) { switch(type) { case 'basic': return 'Basis'; case 'scientific': return 'Wetenschappelijk'; case 'financial': return 'Financieel'; case 'unit-converter': return 'Eenheden Omrekenen'; default: return 'ASP.NET'; } } });

Leave a Reply

Your email address will not be published. Required fields are marked *