C#

_Q12_ wrote:

give me a tutorial from which i can learn by myself how to do it, please.

using System.Net.Security;
using System.Security.Principal;
...
	// the value for enum SecurityProtocolType.Tls12 is 3072, hence:
	ServicePointManager.SecurityProtocol=(SecurityProtocolType)3072;
	// now use your regular web code e.g.
	using (WebClient wc=new WebClient()) {
		// ...
	}

//initialize WEBPAGE
//Special wepage Reading  [using System.Net;]
ServicePointManager.Expect100Continue = true;
ServicePointManager.DefaultConnectionLimit = 9999;
//in .NET 4.0, TLS 1.2 is not supported, but if you have .NET 4.5 (or above) installed on the system
//then you still can opt in for TLS 1.2 even if your application framework doesn’t support it.
//The only problem is that SecurityProtocolType in .NET 4.0 doesn’t have an entry for TLS1.2,
//so we’d have to use a numerical representation of this enum value:
ServicePointManager.SecurityProtocol = (SecurityProtocolType)3072;
//instead of: ServicePointManager.SecurityProtocol = SecurityProtocolType.Ssl3 | SecurityProtocolType.Tls;

_Q12_ wrote:

Tell me please how to use it in this little thing i want

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