/// <summary>Download file.</summary>
/// <param name="uri">The URI.</param>
/// <param name="fileName">The filename output.</param>
public static void Download(Uri uri, string fileName)
{
try
{
using (WebClient _client = new WebClient())
{
_client.Headers.Add("User-Agent", "Mozilla/4.0 (compatible; MSIE 8.0)");
_client.Proxy = null;
_client.DownloadProgressChanged += Client_DownloadProgressChanged;
_client.DownloadFileCompleted += Client_DownloadFileCompleted;
// _client.DownloadFileAsync(uri, fileName);
object _syncObject = new object();
lock (_syncObject)
{
_client.DownloadFileAsync(uri, fileName, _syncObject);
while (_client.IsBusy)
{
}
// This would block the thread until download completes
Monitor.Wait(_syncObject);
}
}
}
catch (Exception e)
{
ExceptionsManager.WriteException(e.Message);
}
}
private static void Client_DownloadProgressChanged(object sender, DownloadProgressChangedEventArgs e)
{
try
{
long _bytesReceived = e.BytesReceived;
long _totalBytes = e.TotalBytesToReceive;
Bytes _received = new Bytes(_bytesReceived)
{
Abbreviated = true
};
Bytes _total = new Bytes(_totalBytes)
{
Abbreviated = true
};
if (_totalBytes == -1)
{
// _total = "?";
}
ConsoleManager.WriteOutput("(" + e.ProgressPercentage.ToString("0") + "%) " + _received + " / " + _total);
}
catch (Exception ex)
{
ExceptionsManager.WriteException(ex.Message);
}
}
/// <summary>Creates a console command instance.</summary>
/// <param name="command">The console command.</param>
public static void CreateCommandInstance(string command)
{
try
{
ConsoleCommand _command = new ConsoleCommand(command);
string _result = InvokeCommandMethod(_command);
WriteOutput(_result);
}
catch (Exception e)
{
ExceptionsManager.WriteException(e.Message);
}
}
/// <summary>Invokes the command method.</summary>
/// <param name="command">The console command.</param>
/// <returns>The <see cref="string" />.</returns>
private static string InvokeCommandMethod(ConsoleCommand command)
{
Console.Write(Environment.NewLine);
// Validate the class name and command name:
// Validate the command name:
if (!_commandLibraries.ContainsKey(command.LibraryClassName))
{
ExceptionsManager.CommandNotRecognized(command);
return(string.Empty);
}
var methodDictionary = _commandLibraries[command.LibraryClassName];
if (!methodDictionary.ContainsKey(command.Name))
{
ExceptionsManager.CommandNotRecognized(command);
return(string.Empty);
}
// Make sure the correct number of required arguments are provided:
var methodParameterValueList = new List <object>();
IEnumerable <ParameterInfo> paramInfoList = methodDictionary[command.Name].ToList();
// Validate proper # of required arguments provided. Some may be optional:
var requiredParams = paramInfoList.Where(p => p.IsOptional == false);
var optionalParams = paramInfoList.Where(p => p.IsOptional);
int requiredCount = requiredParams.Count();
int optionalCount = optionalParams.Count();
int providedCount = command.Arguments.Count();
if (requiredCount > providedCount)
{
ExceptionsManager.WriteException(string.Format("Missing required argument. {0} required, {1} optional, {2} provided", requiredCount, optionalCount, providedCount));
Console.Write(Environment.NewLine);
return(string.Empty);
}
// Make sure all arguments are coerced to the proper type, and that there is a
// value for every method parameter. The InvokeMember method fails if the number
// of arguments provided does not match the number of parameters in the
// method signature, even if some are optional:
if (paramInfoList.Any())
{
// Populate the list with default values:
methodParameterValueList.AddRange(paramInfoList.Select(param => param.DefaultValue));
// Now walk through all the arguments passed from the console and assign
// accordingly. Any optional arguments not provided have already been set to
// the default specified by the method signature:
for (var i = 0; i < command.Arguments.Count(); i++)
{
ParameterInfo _parameterInfo = paramInfoList.ElementAt(i);
Type _parameterType = _parameterInfo.ParameterType;
try
{
// Coming from the Console, all of our arguments are passed in as
// strings. Coerce to the type to match the method parameter:
object value = CoerceArgument(_parameterType, command.Arguments.ElementAt(i));
methodParameterValueList.RemoveAt(i);
methodParameterValueList.Insert(i, value);
}
catch (ArgumentException)
{
string argumentName = _parameterInfo.Name;
string argumentTypeName = _parameterType.Name;
string message = string.Format(string.Empty + "The value passed for argument '{0}' cannot be parsed to type '{1}'", argumentName, argumentTypeName);
throw new ArgumentException(message);
}
}
}
// Set up to invoke the method using reflection:
Assembly current = typeof(Program).Assembly;
// Need the full Namespace for this:
Type _commandLibraryClass = current.GetType(CommandNamespace + "." + command.LibraryClassName);
object[] inputArgs = null;
if (methodParameterValueList.Count > 0)
{
inputArgs = methodParameterValueList.ToArray();
}
Type typeInfo = _commandLibraryClass;
// This will throw if the number of arguments provided does not match the number
// required by the method signature, even if some are optional:
try
{
object result = typeInfo.InvokeMember(command.Name, BindingFlags.InvokeMethod | BindingFlags.Static | BindingFlags.Public, null, null, inputArgs);
return(result.ToString());
}
catch (TargetInvocationException e)
{
throw e.InnerException;
}
}