C#

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();
}

Quote:

Without them, you can easily introduce bugs where resources don't get cleaned up.

Quote:

A using block should be used where appropriate

Quote:

I'm going to concerned with just two things. Any exceptions thrown by the Command and the data returned.

SqlCommand cmd = new SqlCommand(sql, con);
try
   {
   ...
   }
finally
   {
   if (cmd != null) cmd.Dispose();
   }
cmd.ExecuteNonQuery();  // Perfectly valid, cmd is in scope.

using (SqlCommand cmd = new SqlCommand(sql, con))
   {
   ...
   }
cmd.ExecuteNonQuery();  // Compiler error, cmd is not in scope.

Quote:

And ... it makes the scope of the variable very, very obvious which a try...finally block doesn't

SqlCommand cmd = null;

Quote:

using is cleaner, clearer, and easier to use.