C#

string selectutilizator = "SELECT * FROM accounts";
            using (SQLiteCommand selcom = new SQLiteCommand(selectutilizator, Conexiune.getConnection()))
            {
                using (SQLiteDataReader read = selcom.ExecuteReader())
                {
                    if (read.HasRows)
                    {
                        Application.Run(new Elev());
                    }
                    else Application.Run(new Intro());
                }
            }

string selectutilizator = "SELECT * FROM accounts";
            bool hasrows=false;
            using (SQLiteCommand selcom = new SQLiteCommand(selectutilizator, Conexiune.getConnection()))
            {
                using (SQLiteDataReader read = selcom.ExecuteReader())
                {
                    if (read.HasRows)
                    {
                        hasrows=true;
                    }
                }
            }
            if (hasrows) Application.Run(new Elev());
            else Application.Run(new Intro());

DPaul1994 wrote:

Yes, you right. Thank you very much!

private void updateIndex()
{
    const string update = "UPDATE questions SET indexrow = @idintrebare WHERE id = @idintrebare";
    using (SQLiteCommand comp = new SQLiteCommand(update, Conexiune.getConnection()))
    {
        comp.CommandType = CommandType.Text;
        comp.Parameters.AddWithValue("@idintrebare", idintrebare);
        comp.ExecuteNonQuery();
    }
}

The ... constructor (which is like an instance method) ...
Because the constructor is an instance member, it is permitted to access both the ... instance field and the ... static field.

Unlike other members, instance constructors are not inherited, and a class has no instance constructors other than those actually declared in the class. If no instance constructor is supplied for a class, then an empty one with no parameters is automatically provided.

If an instance constructor has no constructor initializer, a constructor initializer of the form base() is implicitly provided. Thus, an instance constructor declaration of the form
     C(...) {...}
is exactly equivalent to
     C(...): base() {...}

CRobert456 wrote:

The logic is based on the fact the a base constructor has to be called explicitly, meaning the compiler will not call it automatically

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]

totalsim = (int)read...
totalsimyes = (int)read...

medie_sim = (totalsim / totalsimyes) * 100;
medie_sim = Math.Round(medie_sim, 2);
Console.WriteLine(medie_sim);

1. 15 / 8 = 1.875, but since the variables are integers, only the integer part is used: 15 / 8 = 1
2. You then multiply that result by 100, which (unsurprisingly) gives a final result of 100.
3. You then store that final result in a double, but it's too late - you've already lost the fractional part at step 1.

medie_sim = ((double)totalsim / totalsimyes) * 100;
// or:
// medie_sim = (totalsim / (double)totalsimyes) * 100;