private void _console_LineWrittenEvent(object sender, LineWrittenEventArgs e)
{
switch (e.Level.ToString())
{
case "Default":
_logger.Debug(e.Value);
break;
case "Information":
_logger.Info(e.Value);
break;
case "Warning":
_logger.Warn(e.Value);
break;
case "Error":
_logger.Error(e.Value);
break;
default:
_logger.Error(string.Format("Unknown output level: {0}", e.Level));
_logger.Info(e.Value);
break;
}
Trace.WriteLine(e.Value, e.Level.ToString());
}
public ActionResult CreateVerse(VerseModel v)
{
logger.Info("Entering VerseController.CreateVerse() with " + v);
if (ModelState.IsValid)
{
VerseBusinessService bs = new VerseBusinessService();
bool result = bs.CreateVerse(v);
string message;
if (result)
{
message = "Verse successfully inserted";
}
else
{
message = "Verse insertion failed.";
}
logger.Info("Exiting VerseController.CreateVerse() with " + message);
return(View("Index"));
}
else
{
return(View());
}
}
public bool CreateVerse(VerseModel v)
{
logger.Info("Entering VerseBusinessService.CreateVerse() with " + v);
VerseDataService ds = new VerseDataService();
bool result = ds.Create(v);
logger.Info("Exiting VerseBusinessService.CreateVerse() with " + result);
return(result);
}
static void Main(string[] args)
{
const int num = 500000; //50W
const string msg = "test";
var watch = new Stopwatch();
watch.Start();
for (var i = 0; i < num; i++)
{
MyLogger.Debug(msg);
}
var t1 = watch.ElapsedMilliseconds;
Console.WriteLine($"t1: {t1}");
for (var i = 0; i < num; i++)
{
MyLogger.Info(i.ToString());
}
var t2 = watch.ElapsedMilliseconds;
Console.WriteLine($"t2 - t1: {t2 - t1}");
Console.Read();
}
// No matter what service method is called, it's funneled through here.
public void Intercept(IInvocation call)
{
MyLogger.Info("Starting call: " + call.Method.Name);
// Actually invoke whatever method was originally called
call.Proceed();
MyLogger.Info("Finished call: " + call.Method.Name);
}
public string MyLog()
{
var loger = new MyLogger("Info");
var ex = new Exception("eeeee");
loger.Info("MyLog", ex);
return(loger.ToString());
}
private async void BtnStartClick(object sender, EventArgs e)
{
try
{
LoadRequestParameters();
LockControls();
if (CheckSavePath() && CheckConnection())
{
var programParameters = LoadProgramParameters();
var requestParameters = LoadRequestParameters();
var result = await DownloadDataAsync(programParameters, requestParameters);
_progress.Report(new KeyValuePair <string, string>("INFO", result));
}
UnlockControls();
_logger.Info("Done");
}
catch (Exception ex)
{
_logger.Info("BtnStartClick_Exception");
_logger.Info(ex.ToString());
}
}
//method which accesses the SearchService utility and dependent on the value received will sets the
//model values to the coresponding values.
public ActionResult Search(VerseModel model)
{
logger = new MyLogger();
SearchService service = new SearchService();
if (service.Authenticate(model))
{
logger.Info("The given credentials returned a verse which exists in the database: " + model.Testament + "|" + model.Book + "|" + model.Chapter + "|" + model.Verse + "|" + model.VerseText);
model = service.changeValues(model);
return(View("~/Views/Search/Search.cshtml", model));
}
else
{
logger.Info("The given credentials did not exist in the database.");
model.SearchStatus = 2;
return(View("~/Views/Search/Search.cshtml", model));
}
}
public bool Create(VerseModel verse)
{
logger.Info("Entering VerseDataService.Create() with " + verse);
bool success = false;
string queryString = "INSERT INTO dbo.verses (TESTAMENT, BOOK, CHAPTER, VERSE, TEXT) VALUES (@TESTAMENT, @BOOK, @CHAPTER, @VERSE, @TEXT)";
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand command = new SqlCommand(queryString, connection);
command.Parameters.Add("@TESTAMENT", System.Data.SqlDbType.VarChar, 40).Value = verse.Testament;
command.Parameters.Add("@BOOK", System.Data.SqlDbType.VarChar, 40).Value = verse.Book;
command.Parameters.Add("@CHAPTER", System.Data.SqlDbType.VarChar, 40).Value = verse.Chapter;
command.Parameters.Add("@VERSE", System.Data.SqlDbType.VarChar, 40).Value = verse.Verse;
command.Parameters.Add("@TEXT", System.Data.SqlDbType.VarChar, 1000).Value = verse.Text;
try
{
connection.Open();
SqlDataReader reader = command.ExecuteReader();
if (reader.RecordsAffected > 0)
{
success = true;
}
reader.Close();
connection.Close();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
logger.Info("Exiting VerseDataService.Create() with " + success);
return(success);
}
static void Main(string[] args)
{
MyLogger logger = new MyLogger();
logger.Info("\n-----Task2-----IndexOutOfRangeException\n\n", Operation.LoggingToConsole);
int n = 7;
try
{
ExceptionSituations.InstantiateArray(n, 100);
}
catch (System.IndexOutOfRangeException e)
{
logger.Error(e.Message, Operation.LoggingToConsole);
}
catch (System.Exception e)
{
logger.Error(e.Message, Operation.LoggingToFile);
logger.ReadFromLogFile();
}
}
public ActionResult Login(UserModel model)
{
logger.Info("Entering LoginController.Login()");
try
{
if (ModelState.IsValid)
{
SecurityService sservice = new SecurityService();
bool results = sservice.Authenticate(model);
if (results)
{
logger.Info("Parameters are: " + new JavaScriptSerializer().Serialize(model));
logger.Info("Exit LoginControlle.DoLogin() with login passing");
Session["user"] = model;
return(View("LoginPassed", model));
}
else
{
logger.Info("Parameters are: " + new JavaScriptSerializer().Serialize(model));
logger.Info("Exit LoginController.DoLogin() with login failing");
Session.Clear();
return(View("LoginFailed"));
}
}
else
{
return(View(model));
}
}
catch (Exception e)
{
logger.Error("Exception LoginController.DoLogin()" + e.Message);
return(Content("Exception in login" + e.Message));
}
}
public void OnActionExecuted(ActionExecutedContext filterContext)
{
logger.Info($"We are using the CustomActionAttribute for {filterContext.ActionDescriptor.ControllerDescriptor.ControllerName} for method {filterContext.ActionDescriptor.ActionName} and within OnActionExecuted.");
}
public void DoWork()
{
// TODO: Add implementation logic
logger.Info("doing some worky worky stuff");
}
public SendResponse Send()
{
string responseMessage = null;
var stopWatch = new Stopwatch();
stopWatch.Start();
lock (_syncRoot)
{
Point[] points = null;
var retryCount = 0;
try
{
while (_queue.Count + _failQueue.Count > 0)
{
if (_queue.Count > 0)
{
var pts = new List <Point>();
retryCount = 0;
while (_queue.Count > 0)
{
pts.AddRange(_queue.Dequeue());
}
points = pts.ToArray();
}
else
{
var meta = _failQueue.Dequeue();
retryCount = meta.Item1;
points = meta.Item2;
}
var client = _client.Value;
if (client != null)
{
_myLogger.Debug("Sending:" + Environment.NewLine + GetPointsString(points));
var response = client.WriteAsync(points).Result;
_myLogger.Info("Response: " + response.StatusCode + " " + response.Body);
_canSucceed = true;
OnSendBusinessEvent(new SendCompleteEventArgs(_senderConfiguration, string.Format("Sending {0} points to server.", points.Length), points.Length, SendCompleteEventArgs.OutputLevel.Information));
}
else
{
responseMessage = "There is no client configured for sending data to the database, or the client has invalid settings.";
OnSendBusinessEvent(new SendCompleteEventArgs(_senderConfiguration, responseMessage, points.Length, SendCompleteEventArgs.OutputLevel.Error));
}
}
}
catch (Exception exception)
{
if (points != null)
{
var sb = new StringBuilder();
sb.AppendLine(exception.Message);
sb.AppendLine(GetPointsString(points));
_myLogger.Error(sb.ToString());
}
else
{
_myLogger.Error(exception);
}
if (exception is AggregateException)
{
exception = exception.InnerException;
}
responseMessage = exception.Message;
OnSendBusinessEvent(new SendCompleteEventArgs(_senderConfiguration, exception));
if (points != null)
{
if (!_dropOnFail)
{
var invalidExceptionType = exception.IsExceptionValidForPutBack();
if (invalidExceptionType != null)
{
OnSendBusinessEvent(new SendCompleteEventArgs(_senderConfiguration, String.Format("Dropping {0} since the exception type {1} is not allowed for resend.", points.Length, invalidExceptionType), points.Length, SendCompleteEventArgs.OutputLevel.Warning));
}
else if (!_canSucceed)
{
OnSendBusinessEvent(new SendCompleteEventArgs(_senderConfiguration, String.Format("Dropping {0} points because there have never yet been a successful send.", points.Length), points.Length, SendCompleteEventArgs.OutputLevel.Warning));
}
else if (retryCount > 5)
{
OnSendBusinessEvent(new SendCompleteEventArgs(_senderConfiguration, String.Format("Dropping {0} points after {1} retries.", points.Length, retryCount), points.Length, SendCompleteEventArgs.OutputLevel.Warning));
}
else
{
OnSendBusinessEvent(new SendCompleteEventArgs(_senderConfiguration, String.Format("Putting {0} points back in the queue.", points.Length), points.Length, SendCompleteEventArgs.OutputLevel.Warning));
retryCount++;
_failQueue.Enqueue(new Tuple <int, Point[]>(retryCount, points));
}
}
else
{
OnSendBusinessEvent(new SendCompleteEventArgs(_senderConfiguration, String.Format("Dropping {0} points.", points.Length), points.Length, SendCompleteEventArgs.OutputLevel.Warning));
}
}
}
}
return(new SendResponse(responseMessage, stopWatch.Elapsed.TotalMilliseconds));
}