C #-use XML files to record operation logs

You can use databases, text files, and XML files to record application operation logs. Here I will introduce how to use XML files to record operation logs.
I think using XML to record operation logs has the following advantages:
1. You can delete historical operation logs without occupying the database space.
2. datatable can read XML files, and datatable can also be saved as XML files conveniently.
3. Easy to view logs. You can directly open the XML file, read the datatable, and view the logs through the program.

The following describes how to use an XML file to record operation logs in vs2005:
1. Create a dataset: joblogdataset. XSD
The following fields are available: tracelevel (log type), user (user), datetime (Operation Time), Module (module), function (function), and message (Message.
If you do not need to add more, tracelevel (Log Type) indicates info, warning, error, trance, and off.
Joblogdataset.jpg(7.55 KB)

2. Create the log type the code: run the code! ">

General browsing copy code Print Code

2. /// <Summary>
3. /// Log Type
4. /// </Summary>
5. Public Enum logtype
6. {
7. /// <Summary>
8. /// Information
9. /// </Summary>
10. Info,
11. /// <Summary>
12. /// Warning
13. /// </Summary>
14. Warning,
15. /// <Summary>
16. /// Error
17. /// </Summary>
18. Error,
19. /// <Summary>
20. /// Tracking
21. /// </Summary>
22. Trace,
23. /// <Summary>
24. /// No logs
25. /// </Summary>
26. Off
27. }

 
/// <Summary>
/// Log Type
/// </Summary>
Public Enum logtype
{
/// <Summary>
/// Information
/// </Summary>
Info,
/// <Summary>
/// Warning
/// </Summary>
Warning,
/// <Summary>
/// Error
/// </Summary>
Error,
/// <Summary>
/// Tracking
/// </Summary>
Trace,
/// <Summary>
/// No logs
/// </Summary>
Off
}

2. Log writing method the code: General browse copy code Print Code

2. /// <Summary>
3. /// Write logs
4. /// </Summary>
5. /// <Param name = "tracelevel"> Log Type (Info, warning, error, trance, off) </param>
6. /// <Param name = "user"> User </param>
7. /// <Param name = "module"> module </param>
8. /// <Param name = "function"> function </param>
9. /// <Param name = "message"> message </param>
10. Public static void writelog (logtype, string user, string module, string function, string message)
11. {
12. Try
13. {
14. // Do not record logs whose type is logtype. Off
15. If (logtype = logtype. Off)
16. Return;
18. Joblogdataset. joblogdatatable T = new joblogdataset. joblogdatatable ();
20. // One log file (. xml file) every day, the log file name is called: joblog yyyy-MM-dd.xml
21. String joblogfile = appdomain. currentdomain. basedirectory + "joblog" +
22. Datetime. Today. tostring ("yyyy-mm-dd") + ". xml ";
23. If (! File. exists (joblogfile ))
24. T. writexml (joblogfile );
26. // Read logs from the. xml file
27. T. readxml (joblogfile );
29. // Add a log
30. Joblogdataset. joblogrow r = T. newjoblogrow ();
31. R. tracelevel = logtype. tostring ();
32. R. User = user;
33. R. datetime = datetime. now;
34. R. module = module;
35. R. Function = function;
36. R. Message = message;
37. T. addjoblogrow (R );
39. // Save the log to the XML file
40. T. writexml (joblogfile );
41. }
42. Catch (exception)
43. {}
44. }

 
/// <Summary>
/// Write logs
/// </Summary>
/// <Param name = "tracelevel"> Log Type (Info, warning, error, trance, off) </param>
/// <Param name = "user"> User </param>
/// <Param name = "module"> module </param>
/// <Param name = "function"> function </param>
/// <Param name = "message"> message </param>
Public static void writelog (logtype, string user, string module, string function, string message)
{
Try
{
// Do not record logs whose type is logtype. Off
If (logtype = logtype. Off)
Return;

Joblogdataset. joblogdatatable T = new joblogdataset. joblogdatatable ();

// One log file (. xml file) every day, the log file name is called: joblog yyyy-MM-dd.xml
String joblogfile = appdomain. currentdomain. basedirectory + "joblog" +
Datetime. Today. tostring ("yyyy-mm-dd") + ". xml ";
If (! File. exists (joblogfile ))
T. writexml (joblogfile );

// Read logs from the. xml file
T. readxml (joblogfile );

// Add a log
Joblogdataset. joblogrow r = T. newjoblogrow ();
R. tracelevel = logtype. tostring ();
R. User = user;
R. datetime = datetime. now;
R. module = module;
R. Function = function;
R. Message = message;
T. addjoblogrow (R );

// Save the log to the XML file
T. writexml (joblogfile );
}
Catch (exception)
{}
}

3. Log reading method the code: General browse copy code Print Code

1. /// <Summary>
2. /// Read logs
3. /// </Summary>
4. /// <Returns> return the able for reading logs </returns>
5. Public static joblogdataset. joblogdatatable readlog ()
6. {
7. Joblogdataset. joblogdatatable = new joblogdataset. joblogdatatable ();
8. Try
9. {
10. // Obtain all log files joblog *. XML from the application folder
11. String [] joblogfiles = directory. getfiles (
12. Appdomain. currentdomain. basedirectory, "joblog *. xml", searchoption. topdirectoryonly );
14. // Read each log record to the log able
15. Foreach (string joblogfile in joblogfiles)
16. {
17. If (file. exists (joblogfile ))
18. {
19. // Read all log files to the temporary able
20. Joblogdataset. joblogdatatable T = new joblogdataset. joblogdatatable ();
21. T. readxml (joblogfile );
22. // Import log records to the primary log datatable
23. Foreach (joblogdataset. joblogrow R in T)
24. Joblogdatatable. importrow (R );
25. }
26. }
27. // Return the read log datatable
28. Return joblogdatatable;
29. }
30. Catch (exception)
31. {
32. Return joblogdatatable;
33. }
34. }

/// <Summary>
/// Read logs
/// </Summary>
/// <Returns> return the able for reading logs </returns>
Public static joblogdataset. joblogdatatable readlog ()
{
Joblogdataset. joblogdatatable = new joblogdataset. joblogdatatable ();
Try
{
// Obtain all log files joblog *. XML from the application folder
String [] joblogfiles = directory. getfiles (
Appdomain. currentdomain. basedirectory, "joblog *. xml", searchoption. topdirectoryonly );

// Read each log record to the log able
Foreach (string joblogfile in joblogfiles)
{
If (file. exists (joblogfile ))
{
// Read all log files to the temporary able
Joblogdataset. joblogdatatable T = new joblogdataset. joblogdatatable ();
T. readxml (joblogfile );
// Import log records to the primary log datatable
Foreach (joblogdataset. joblogrow R in T)
Joblogdatatable. importrow (R );
}
}
// Return the read log datatable
Return joblogdatatable;
}
Catch (exception)
{
Return joblogdatatable;
}
}

4. directly call the writelog method where logs need to be written.