C#

Midnight Ahri wrote:

I tried a lot of example and still not working.

Midnight Ahri wrote:

at least tell me what is wrong in my code.

Richard MacCutchan wrote:

So you want us to guess a) what your code is doing, and b) what errors occur.

After calling OpenAsync, State must return Connecting until the returned Task is completed. Then, if the connection was successful, State must return Open. If the connection fails, State must return Closed.

this.cnn.OpenASync();

if (this.cnn.State == ConnectionState.Connecting)
{
    //cnn is busy connecting
}

if (this.cnn.State == ConnectionState.Closed)
{
    //cnn failed to open
}

static async Task<ConnectionState> Method(SqlConnection cnn)
        {
            await cnn.OpenAsync();
            return cnn.State;
        }

private void SQLClientLoader_Load(object sender, EventArgs e)
        {
            do
            {
                this.cnn = new SqlConnection(this.par.Constr);

                try
                {
                    ConnectionState cst = Method(cnn).Result;

                    if (cst == ConnectionState.Open)
                    {
                        this.par.sqSuccess = true;
                    }
                    else
                    {

                    }
                }
                catch (Exception ex)
                {
                    this.par.sqSuccess = false;

                    this.par.Exception = ex.Message;
                }
                finally
                {

                }
            } while ((bool)this.par.sqSuccess != true);
        }

private void SQLClientLoader_Load(object sender, EventArgs e)
        {
            this.GetSQLState();
        }

async private System.Threading.Tasks.Task<ConnectionState> GetStateAsync()
        {
            do
            {
                this.cts = new CancellationTokenSource();
                this.cnn = new SqlConnection(this.par.Constr);

                try
                {
                    await Task.Delay(2500);

                    await this.cnn.OpenAsync(cts.Token);
                }
                catch (Exception ex)
                {
                    cts.Cancel(false);

                    this.cnn.Dispose();
                    this.cts.Dispose();
                }
            } while (this.cnn.State != ConnectionState.Open);

            return this.cnn.State;
        }

async private void GetSQLState()
        {
            

            if (await GetStateAsync() == ConnectionState.Open)
            {
                this.Close();
            }

            await Task.Delay(2500);
        }

WaseemAmin wrote:

if the user is a common person

public class H2G2
{
  private const int Answer = 42;
  public H2G2()
  {
    Console.WriteLine("The answer to Life, the Universe, Everything is {0}", Answer);
  }
}

public class TaxCalc
{
  private readonly double taxRate;
  public TaxCalc(double taxRate)
  {
    this.taxRate = taxRate;
  }

  public void Calculate(double value)
  {
    double total = value * taxRate; // Note that taxRate cannot change now that it has been set.
      // this means you can't do something like this --taxRate;
    Console.WriteLine("The total is {0}", total);
  }
}

Pete O'Hanlon wrote:

There's a subtle difference between readonly and const which it sort of emulates. If you like, you can think of readonly as a runtime constant as opposed to const which is a compile time constant.

eng.iris wrote:

when delay button clicked i move the current record to another datatabbe and after 2 min i restore it back to the original datatable

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