C#

<pre lang="C#">

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Numpy;
using Python.Runtime;
using Keras;
using Keras.Layers;
using Keras.Models;
using Keras.Optimizers;
using Keras.losses;

namespace SQLInjectionDetection
{
    class Program
    {
        static void Main(string[] args)
        {
            // Load CSV file
            var trainData = File.ReadAllLines("tokens.csv")
                .Select(l => l.Split(','))
                .Select(s => new { Token = s[0], Label = int.Parse(s[1]) })
                .ToList();

            // Shuffle trainData
            var random = new Random();
            trainData = trainData.OrderBy(d => random.Next()).ToList();

            // Split trainData into training and validation sets
            var splitIndex = (int)(trainData.Count * 0.8);
            var trainDataSubset = trainData.Take(splitIndex).ToList();
            var testDataSubset = trainData.Skip(splitIndex).ToList();

            // Define vocabulary and tokenize trainData
            var vocabulary = new HashSet<char>(trainDataSubset.SelectMany(d => d.Token).Distinct());
            var tokenToIndex = vocabulary.Select((c, i) => new { Token = c, Index = i }).ToDictionary(t => t.Token, t => t.Index);
            var maxSequenceLength = trainDataSubset.Max(d => d.Token.Length);
            var trainTokenized = Tokenize(trainDataSubset, tokenToIndex, maxSequenceLength);
            var testTokenized = Tokenize(testDataSubset, tokenToIndex, maxSequenceLength);

            // Build RNN model
            using (Py.GIL())
            {
                dynamic keras = Py.Import("keras");
                dynamic np = Py.Import("numpy");
                var input = new Input(shape: 1000);
                var embedding = new Embedding(vocabulary.Count, 32).Apply(input);
                var lstm = new LSTM(32).Apply(embedding);
                var output = new Dense(1, activation: keras.activations.sigmoid).Apply(lstm);
                var model = new Model(inputs: input, outputs: output);
                model.Compile(optimizer: new Adam(), loss: new BinaryCrossentropy(), metrics: new[] { "accuracy" });

                // Train model
                var trainX = trainTokenized.Item1;
                var trainY = trainTokenized.Item2;
                var testX = testTokenized.Item1;
                var testY = testTokenized.Item2;
                model.Fit(trainX, trainY, batchSize: 32, epochs: 10, validationData: (testX, testY));

                // Take user input and make prediction
                Console.Write("Enter user input: ");
                var userInput = Console.ReadLine();
                var inputTokenized = TokenizeInput(userInput, tokenToIndex, maxSequenceLength);
                var prediction = model.Predict(inputTokenized).GetData<float>()[0, 0];
                Console.WriteLine($"Prediction: {(prediction > 0.5 ? "Malicious" : "Safe")} (Score: {prediction:F4})");

                // Evaluate model
                var testMetrics = model.Evaluate(testX, testY);
                Console.WriteLine($"Test loss: {testMetrics[0]:F4}");
                Console.WriteLine($"Test accuracy: {testMetrics[1]:F4}");
            }
        }

        private static (NDarray, NDarray) Tokenize(List<dynamic> data, Dictionary<char, int> tokenToIndex, int maxSequenceLength)
        {
            var numExamples = data.Count;
            var X = np.zeros((numExamples, maxSequenceLength));
            var Y = np.zeros((numExamples, 1));
            for (var i = 0; i < numExamples; i++)
            {
                var tokens = data[i].Token;
                var label = data[i].Label;
                Y[i] = label;
                for (var j = 0; j < tokens.Length; j++)
                {
                    var token = tokens[j];
                    var index = tokenToIndex[token];
                    X[i, j] = index;
                }
            }
            return (X, Y);
        }

    }
}

public async Task SomeFunc()
{
	await Task.Run(() =>
	{
		// Some Sync method calls here like..
		var reader = com.ExecuteReader();
		...
	}

}
 
// Or

public async Task SomeFunc()
{
	// Some Async method calls here like..
	var reader = await com.ExecuteReaderAsync();
	....
}

protected void updateSal_Click(object sender, EventArgs e)
        {
            newTotal.Text = theLinq.Salary.Single(s => s.Salary_Year == DateTime.Now.Year).Total_Salary.ToString();
        }

Protected Sub updateSal_Click(ByVal sender As Object, ByVal e As EventArgs)
    Dim rowsAffected As Integer
    Dim currYear As Integer = Date.Now.Year
        Using con As New SqlConnection("server=.;database=Test;integrated security=true")
     Using cmd As New SqlCommand("UPDATE Salary Set  Total_Salary=@totsal WHERE Salary_Year = @currentYear", con)
           cmd.Parameters.Add("@totsal", SqlDbType.Decimal).Value = newTotal.Text
           cmd.Parameters.Add("@currentYear", SqlDbType.Integer).Value = currYear
           con.Open()
           rowsAffected = cmd.ExecuteNonQuery()
        End Using
       End Using
 End Sub