C#

Quote:

You tell 'em I'm comin' and Hell is comin' with me, you hear?

Console.Write("Enter element value " + nums[i] + ": ");

Console.Write("Enter element value " + i + ": ");

int[] nums = new int[5];

for (int i = 0; i < 5; i++)
    {
    do
        {
        Console.Write("Enter element value " + i + ": ");
        string input = Console.ReadLine();
        if (int.TryParse(input, out nums[i]))
            {
            break;
            }
        Console.WriteLine(input + " is not a number!");
        } while (true);
    }

public static class StopWatch
{
    public static TimeSpan MeasureAction(Action _action)
    {
        Stopwatch watch = Stopwatch.StartNew();
        _action();
        watch.Stop();
        return watch.Elapsed;
    }
    
    public static IMeasuredExecution<T> MeasureFunction<T>(Func<T> _function)
    {
        Stopwatch watch = Stopwatch.StartNew();
        T result = _function();
        watch.Stop();
        return new MeasuredExecution<T>(watch.Elapsed, result);
    }
    
    public static IDisposableMeasuredExecution<T> MeasureFunctionDisposable<T>(Func<T> _function) where T : IDisposable
    {
        Stopwatch watch = Stopwatch.StartNew();
        T result = _function();
        watch.Stop();
        return new DisposableMeasuredExecution<T>(watch.Elapsed, result);
    }
}

public interface IMeasuredExecution<T> : IDisposable
{
    TimeSpan Duration { get; }
    T Result { get; }
}

internal class MeasuredExecution<T> : IMeasuredExecution<T>
{
    public MeasuredExecution(TimeSpan _duration, T _result)
    {
        Duration = _duration;
        Result = _result;
    }

    public TimeSpan Duration { get; }
    public T Result { get; }
    
    public void Dispose()
    {
        var value = Result as IDisposable;
        if (value != null) value.Dispose();
    }
}

Richard Deeming wrote:

add the type parameter to the method instead of the class, and use a different function name

// Type parameter on the method - the compiler infers the type:
StopWatch.MeasureFunction(() => 42);
StopWatch.MeasureFunctionDisposable(CreateSomeDisposableThing);

// Type parameter on the class - you must specify the type:
StopWatch<int>.MeasureFunction(() => 42);

// Type parameter on the class and the method - you must specify the type for the class, but it's not used by the method:
StopWatch<object>.MeasureFunctionDisposable(CreateSomeDisposableThing);

string abc = "<Broker Code=\"" + strbrokercode + "\" IsAllowEstimate=\"" + IsAllowEstimate + "\" ReviseDate=\"" + ReviseDate + "\" BrokerEarnings=\"" + BrokerEarnings + "\" BrokerName=\""+ BrokerName + "\"></Broker>";

string abc = @"<Broker Code=""" + strbrokercode + """ IsAllowEstimate=""" + IsAllowEstimate + """ ReviseDate=""" + ReviseDate + """ BrokerEarnings=""" + BrokerEarnings + """ BrokerName="""+ BrokerName + """></Broker>";

string abc = $"<Broker Code=\"{strbrokercode}\" IsAllowEstimate=\"{IsAllowEstimate}\" ReviseDate=\"{ReviseDate}\" BrokerEarnings=\"{BrokerEarnings}\" BrokerName=\"{BrokerName}\"></Broker>";

string abc = @"<Broker Code=""" + strbrokercode + """ IsAllowEstimate=""" + IsAllowEstimate + """ ReviseDate=""" + ReviseDate + """ BrokerEarnings=""" + BrokerEarnings + """ BrokerName="""+ BrokerName + """></Broker>";

string abc = new System.Xml.Linq.XElement("Broker",
    new System.Xml.Linq.XAttribute("Code", strbrokercode),
    new System.Xml.Linq.XAttribute("IsAllowEstimate", IsAllowEstimate),
    new System.Xml.Linq.XAttribute("ReviseDate", ReviseDate),
    new System.Xml.Linq.XAttribute("BrokerEarnings", BrokerEarnings),
    new System.Xml.Linq.XAttribute("BrokerName", BrokerName)
).ToString();

Mou_kol wrote:

i am seeing many extra back slash has been added to string variable

string strbrokercode="ML";
            string IsAllowEstimate="true";
            string ReviseDate="true";
            string BrokerEarnings="true";
            string BrokerName="true";

            StringBuilder sb = new StringBuilder();

            string abc = "<Broker Code=" + '"' + strbrokercode + '"' + " IsAllowEstimate=" + '"' + IsAllowEstimate + '"' + " ReviseDate=" + '"' + ReviseDate + '"' + " BrokerEarnings=" + '"' + BrokerEarnings + '"' + " BrokerName=" + '"' + BrokerName + '"' + "></Broker>";
            sb.Append(abc);

"<Broker Code=\"ML\" IsAllowEstimate=\"true\" ReviseDate=\"true\" BrokerEarnings=\"true\" BrokerName=\"true\"></Broker>"

using (SqlConnection connection = new SqlConnection("..."))
using (SqlCommand command = new SqlCommand("...", connection))
{
    ...
    using (SqlDataReader reader = command.ExecuteReader())
    {
        ...
    }
}

{
    SqlConnection connection = new SqlConnection("...");
    try
    {
        {
            SqlCommand command = new SqlCommand("...", connection);
            try
            {
                ...
                {
                    SqlDataReader reader = command.ExecuteReader();
                    try
                    {
                        ...
                    }
                    finally
                    {
                        if (reader != null)
                            ((IDisposable)reader).Dispose();
                    }
                }
            }
            finally
            {
                if (command != null)
                    ((IDisposable)command).Dispose();
            }
        }
    }
    finally
    {
        if (connection != null)
            ((IDisposable)connection).Dispose();
    }
}

MSBassSinger wrote:

1 - Capture of runtime data for troubleshooting.

MSBassSinger wrote:

3 - You have full control over the order and operations of releasing resources.

MSBassSinger wrote:

the hope that under the covers, MS got the "using" statement right.

Quote:

There's nothing stopping you from putting a try..catch block either inside or outside of your using block. You can still add any extra data to the exception as required.

Quote:

Disposable objects should be responsible for cleaning up their own resources. It shouldn't be up to the caller to know that they need to clean up a child collection before calling Dispose.

MSBassSinger wrote:

No need for the nested try-finally blocks.

SqlConnection connection = new SqlConnection("...");
SqlCommand command = new SqlCommand("...", connection);
try
{
   ...
}
finally
{
    if (command != null) ((IDisposable)command).Dispose();
    if (connection != null) ((IDisposable)connection).Dispose();
}

SqlConnection connection = null;
SqlCommand command = null;
try
{
    connection = new SqlConnection("...");
    command = new SqlCommand("...", connection);
    ...
}
finally
{
    if (command != null) ((IDisposable)command).Dispose();
    if (connection != null) ((IDisposable)connection).Dispose();
}