more comments

Author: kerryjiang

src/SciSharp.MySQL.Replication/ChecksumType.cs

@@ -4,9 +4,19 @@
 
 namespace SciSharp.MySQL.Replication
 {
+    /// <summary>
+    /// Defines the types of checksums used in MySQL replication events.
+    /// </summary>
     public enum ChecksumType : int
     {
+        /// <summary>
+        /// No checksum is used.
+        /// </summary>
         NONE = 0,
+        
+        /// <summary>
+        /// CRC32 checksum algorithm is used.
+        /// </summary>
         CRC32 = 4
     }
 }

src/SciSharp.MySQL.Replication/DefaultCharset.cs

@@ -3,10 +3,19 @@
 
 namespace SciSharp.MySQL.Replication
 {
+    /// <summary>
+    /// Represents charset information for MySQL replication.
+    /// </summary>
     public class DefaultCharset
     {
+        /// <summary>
+        /// Gets or sets the default collation ID for the charset.
+        /// </summary>
         public int DefaultCharsetCollation { get; set; }
 
+        /// <summary>
+        /// Gets or sets a dictionary mapping charset IDs to their corresponding collation IDs.
+        /// </summary>
         public Dictionary<int, int> CharsetCollations { get; set; }
     }
 }

src/SciSharp.MySQL.Replication/Events/CellValue.cs

@@ -7,10 +7,20 @@
 
 namespace SciSharp.MySQL.Replication
 {
+    /// <summary>
+    /// Represents a value of a cell in a row, containing both old and new values.
+    /// Used in replication events to track changes between states of a row.
+    /// </summary>
     public class CellValue
     {
+        /// <summary>
+        /// Gets or sets the old value of the cell.
+        /// </summary>
         public object OldValue { get; set; }
 
+        /// <summary>
+        /// Gets or sets the new value of the cell.
+        /// </summary>
         public object NewValue { get; set; }
     }
 }

src/SciSharp.MySQL.Replication/Events/DefaultEventFactory.cs

@@ -3,10 +3,18 @@
 
 namespace SciSharp.MySQL.Replication
 {
-
+    /// <summary>
+    /// Default implementation of the log event factory that creates events of a specified type.
+    /// </summary>
+    /// <typeparam name="TEventType">The type of log event to create.</typeparam>
     class DefaultEventFactory<TEventType> : ILogEventFactory
         where TEventType : LogEvent, new()
     {
+        /// <summary>
+        /// Creates a new instance of a log event.
+        /// </summary>
+        /// <param name="context">The context information for creating the event.</param>
+        /// <returns>A new instance of the specified log event type.</returns>
         public LogEvent Create(object context)
         {
             return new TEventType();

src/SciSharp.MySQL.Replication/Events/DeleteRowsEvent.cs

@@ -7,6 +7,10 @@
 
 namespace SciSharp.MySQL.Replication
 {
+    /// <summary>
+    /// Represents a MySQL binary log event that contains rows deleted from a table.
+    /// This event is generated for a delete operation on a row in a MySQL table.
+    /// </summary>
     public sealed class DeleteRowsEvent :  RowsEvent
     {
         public DeleteRowsEvent()

src/SciSharp.MySQL.Replication/Events/EmptyPayloadEvent.cs

@@ -3,8 +3,17 @@
 
 namespace SciSharp.MySQL.Replication
 {
+    /// <summary>
+    /// Represents a log event with an empty payload.
+    /// This is used for events that don't contain any additional data beyond their headers.
+    /// </summary>
     public sealed class EmptyPayloadEvent : LogEvent
     {
+        /// <summary>
+        /// Decodes the body of the empty payload event, which contains no data.
+        /// </summary>
+        /// <param name="reader">The sequence reader containing the binary data.</param>
+        /// <param name="context">The context for decoding.</param>
         protected internal override void DecodeBody(ref SequenceReader<byte> reader, object context)
         {
 

src/SciSharp.MySQL.Replication/Events/ErrorEvent.cs

@@ -5,11 +5,32 @@
 
 namespace SciSharp.MySQL.Replication
 {
+    /// <summary>
+    /// Represents an error event in the MySQL binary log.
+    /// Contains information about errors that occurred during the replication process.
+    /// </summary>
     public sealed class ErrorEvent : LogEvent
     {
+        /// <summary>
+        /// Gets the error code associated with this error event.
+        /// </summary>
         public short ErrorCode { get; private set; }
+        
+        /// <summary>
+        /// Gets the SQL state code, a standard error code consisting of five characters.
+        /// </summary>
         public string SqlState { get; private set; }
+        
+        /// <summary>
+        /// Gets the human-readable error message.
+        /// </summary>
         public String ErrorMessage { get; private set; }
+        
+        /// <summary>
+        /// Decodes the body of the error event from the binary log.
+        /// </summary>
+        /// <param name="reader">The sequence reader containing the binary data.</param>
+        /// <param name="context">The context for decoding.</param>
         protected internal override void DecodeBody(ref SequenceReader<byte> reader, object context)
         {
             reader.TryReadLittleEndian(out short errorCode);
@@ -28,6 +49,10 @@ protected internal override void DecodeBody(ref SequenceReader<byte> reader, obj
             ErrorMessage = reader.Sequence.Slice(reader.Consumed).GetString(Encoding.UTF8);
         }
 
+        /// <summary>
+        /// Returns a string representation of the error event.
+        /// </summary>
+        /// <returns>A string containing the event type, SQL state, and error message.</returns>
         public override string ToString()
         {
             return $"{EventType.ToString()}\r\nSqlState: {SqlState}\r\nErrorMessage: {ErrorMessage}";

src/SciSharp.MySQL.Replication/Events/NotImplementedEvent.cs

@@ -3,8 +3,19 @@
 
 namespace SciSharp.MySQL.Replication
 {
+    /// <summary>
+    /// Represents a placeholder for log event types that have not been implemented yet.
+    /// This event is used when the system encounters an event type that it recognizes
+    /// but doesn't have specific handling logic for.
+    /// </summary>
     public sealed class NotImplementedEvent : LogEvent
     {
+        /// <summary>
+        /// Decodes the body of the not implemented event. This implementation is intentionally
+        /// empty as the event doesn't process any content.
+        /// </summary>
+        /// <param name="reader">The sequence reader containing the binary data.</param>
+        /// <param name="context">The context for decoding.</param>
         protected internal override void DecodeBody(ref SequenceReader<byte> reader, object context)
         {
 

src/SciSharp.MySQL.Replication/Events/RowEventFlags.cs

@@ -7,12 +7,31 @@
 
 namespace SciSharp.MySQL.Replication
 {
+    /// <summary>
+    /// Specifies flags that provide additional information about rows events in MySQL replication.
+    /// These flags describe configuration settings and state information for row operations.
+    /// </summary>
     [Flags]
     public enum RowsEventFlags : byte
     {
+        /// <summary>
+        /// Indicates the end of a statement.
+        /// </summary>
         EndOfStatement = 0x01,
+
+        /// <summary>
+        /// Indicates that foreign key checks are disabled.
+        /// </summary>
         NoForeignKeyChecks = 0x02,
+        
+        /// <summary>
+        /// Indicates that unique key checks are disabled.
+        /// </summary>
         NoUniqueKeyChecks = 0x04,
+        
+        /// <summary>
+        /// Indicates that row has a columns bitmap.
+        /// </summary>
         RowHasAColumns = 0x08    
     }
 }

src/SciSharp.MySQL.Replication/Events/UpdateRowsEvent.cs

@@ -6,22 +6,52 @@
 
 namespace SciSharp.MySQL.Replication
 {
+    /// <summary>
+    /// Represents a MySQL binary log event that contains rows updated in a table.
+    /// This event is generated for an update operation on rows in a MySQL table and
+    /// contains both the before and after values of the affected rows.
+    /// </summary>
     public sealed class UpdateRowsEvent :  RowsEvent
     {
+        /// <summary>
+        /// Gets the bitmap indicating which columns are included in the before-update image.
+        /// </summary>
         public BitArray IncludedColumnsBeforeUpdate { get; private set; }
 
+        /// <summary>
+        /// Reads the included columns bitmaps from the binary representation.
+        /// For update events, this includes both the before and after update column bitmaps.
+        /// </summary>
+        /// <param name="reader">The sequence reader containing the binary data.</param>
         protected override void ReadIncludedColumns(ref SequenceReader<byte> reader)
         {
             var columnCount = (int)reader.ReadLengthEncodedInteger();
             IncludedColumnsBeforeUpdate = reader.ReadBitArray(columnCount);
             IncludedColumns = reader.ReadBitArray(columnCount);
         }
 
+        /// <summary>
+        /// Reads the row data from the binary representation, including both
+        /// before and after values for updated rows.
+        /// </summary>
+        /// <param name="reader">The sequence reader containing the binary data.</param>
+        /// <param name="includedColumns">The bitmap of columns present in the row data.</param>
+        /// <param name="tableMap">The table mapping information.</param>
+        /// <param name="columnCount">The number of columns.</param>
         protected override void ReadData(ref SequenceReader<byte> reader, BitArray includedColumns, TableMapEvent tableMap, int columnCount)
         {
             RowSet = ReadUpdatedRows(ref reader, tableMap, IncludedColumnsBeforeUpdate, includedColumns, columnCount);
         }
 
+        /// <summary>
+        /// Reads the updated rows data from the binary representation.
+        /// </summary>
+        /// <param name="reader">The sequence reader containing the binary data.</param>
+        /// <param name="tableMap">The table mapping information.</param>
+        /// <param name="includedColumnsBeforeUpdate">The bitmap of columns included in the before-update image.</param>
+        /// <param name="includedColumns">The bitmap of columns included in the after-update image.</param>
+        /// <param name="columnCount">The number of columns.</param>
+        /// <returns>A RowSet containing the updated rows data with both before and after values.</returns>
         private RowSet ReadUpdatedRows(ref SequenceReader<byte> reader, TableMapEvent tableMap, BitArray includedColumnsBeforeUpdate, BitArray includedColumns, int columnCount)
         {
             var columnCountBeforeUpdate = GetIncludedColumnCount(IncludedColumnsBeforeUpdate);
@@ -56,6 +86,10 @@ private RowSet ReadUpdatedRows(ref SequenceReader<byte> reader, TableMapEvent ta
             };
         }
 
+        /// <summary>
+        /// Returns a string representation of the UpdateRowsEvent.
+        /// </summary>
+        /// <returns>A string containing the event type, table ID, and before/after row values.</returns>
         public override string ToString()
         {
             var sb = new StringBuilder();

src/SciSharp.MySQL.Replication/Events/WriteRowsEvent.cs

@@ -7,9 +7,15 @@
 
 namespace SciSharp.MySQL.Replication
 {
+    /// <summary>
+    /// Represents a MySQL binary log event that contains rows inserted into a table.
+    /// This event is generated for an insert operation on a MySQL table.
+    /// </summary>
     public sealed class WriteRowsEvent :  RowsEvent
     {
-
+        /// <summary>
+        /// Initializes a new instance of the <see cref="WriteRowsEvent"/> class.
+        /// </summary>
         public WriteRowsEvent()
             : base()
         {

src/SciSharp.MySQL.Replication/Events/XIDEvent.cs

@@ -5,10 +5,22 @@
 
 namespace SciSharp.MySQL.Replication
 {
+    /// <summary>
+    /// Represents a MySQL XID_EVENT that marks the end of a transaction that modifies data.
+    /// This event contains the transaction ID used for the binary log.
+    /// </summary>
     public sealed class XIDEvent : LogEvent
     {
+        /// <summary>
+        /// Gets or sets the ID of the transaction.
+        /// </summary>
         public long TransactionID { get; set; }
 
+        /// <summary>
+        /// Decodes the body of the XID event from the binary representation.
+        /// </summary>
+        /// <param name="reader">The sequence reader containing the binary data.</param>
+        /// <param name="context">The context for decoding.</param>
         protected internal override void DecodeBody(ref SequenceReader<byte> reader, object context)
         {
             reader.TryReadLittleEndian(out long tarnsID);

src/SciSharp.MySQL.Replication/ILogEventFactory.cs

@@ -4,8 +4,16 @@
 
 namespace SciSharp.MySQL.Replication
 {
+    /// <summary>
+    /// Interface for factories that create log events from context objects.
+    /// </summary>
     interface ILogEventFactory
     {
+        /// <summary>
+        /// Creates a log event from the provided context.
+        /// </summary>
+        /// <param name="context">The context object containing data to create the log event.</param>
+        /// <returns>A new log event instance.</returns>
         LogEvent Create(object context);
     }
 }

src/SciSharp.MySQL.Replication/IMySQLDataType.cs

@@ -5,8 +5,17 @@
 
 namespace SciSharp.MySQL.Replication
 {
+    /// <summary>
+    /// Interface that defines MySQL data type read operations.
+    /// </summary>
     internal interface IMySQLDataType
     {
+        /// <summary>
+        /// Reads a value from the sequence reader based on the metadata.
+        /// </summary>
+        /// <param name="reader">The sequence reader containing binary data.</param>
+        /// <param name="meta">Metadata that describes the data format.</param>
+        /// <returns>The deserialized object value.</returns>
         object ReadValue(ref SequenceReader<byte> reader, int meta);
     }
 }

src/SciSharp.MySQL.Replication/IReplicationClient.cs

@@ -5,18 +5,46 @@
 
 namespace SciSharp.MySQL.Replication
 {
+    /// <summary>
+    /// Interface for MySQL replication client that handles database event streaming.
+    /// </summary>
     public interface IReplicationClient
     {
+        /// <summary>
+        /// Connects to a MySQL server with the specified credentials.
+        /// </summary>
+        /// <param name="server">The server address to connect to.</param>
+        /// <param name="username">The username for authentication.</param>
+        /// <param name="password">The password for authentication.</param>
+        /// <param name="serverId">The server ID to use for the replication client.</param>
+        /// <returns>A task that represents the asynchronous login operation and contains the login result.</returns>
         Task<LoginResult> ConnectAsync(string server, string username, string password, int serverId);
 
+        /// <summary>
+        /// Receives the next log event from the server.
+        /// </summary>
+        /// <returns>A task representing the asynchronous receive operation and containing the log event.</returns>
         ValueTask<LogEvent> ReceiveAsync();
 
+        /// <summary>
+        /// Closes the connection to the server.
+        /// </summary>
+        /// <returns>A task representing the asynchronous close operation.</returns>
         ValueTask CloseAsync();
 
+        /// <summary>
+        /// Starts the continuous receiving of log events from the server.
+        /// </summary>
         void StartReceive();
 
+        /// <summary>
+        /// Event triggered when a log event package is received.
+        /// </summary>
         event PackageHandler<LogEvent> PackageHandler;
 
+        /// <summary>
+        /// Event triggered when the connection is closed.
+        /// </summary>
         event EventHandler Closed;
     }
 }