support BinlogPosition

Author: kerryjiang

README.md

@@ -4,7 +4,9 @@
 [![MyGet Version](https://img.shields.io/myget/scisharp/vpre/SciSharp.MySQL.Replication)](https://www.myget.org/feed/scisharp/package/nuget/SciSharp.MySQL.Replication)
 [![NuGet Version](https://img.shields.io/nuget/v/SciSharp.MySQL.Replication.svg?style=flat)](https://www.nuget.org/packages/SciSharp.MySQL.Replication/)
 
-dotnet-mysql-replication is a C# Implementation of MySQL replication protocol client. This allows you to receive events like insert, update, delete with their data and raw SQL queries from MySQL.
+A C# Implementation of MySQL replication protocol client
+
+This library allows you to receive events like insert, update, delete with their data and raw SQL queries from MySQL.
 
 ## Features
 
@@ -21,6 +23,8 @@ dotnet-mysql-replication is a C# Implementation of MySQL replication protocol cl
 - Checksum verification support
 - Built-in support for MySQL binary format parsing
 - Async/await first design
+- Track and save binary log position 
+- Start replication from a specific binary log position
 
 ## Requirements
 
@@ -67,6 +71,79 @@ client.StartReceive();
 await client.CloseAsync();
 ```
 
+## Using Async Stream API
+
+You can use the modern C# async stream pattern to process MySQL events using `GetEventLogStream()`:
+
+```csharp
+using SciSharp.MySQL.Replication;
+using SciSharp.MySQL.Replication.Events;
+
+var client = new ReplicationClient();
+var result = await client.ConnectAsync("localhost", "root", "password", 1);
+
+if (!result.Result)
+{
+    Console.WriteLine($"Failed to connect: {result.Message}.");
+    return;
+}
+
+// Process events as they arrive using await foreach
+await foreach (var logEvent in client.GetEventLogStream())
+{
+    switch (logEvent)
+    {
+        case WriteRowsEvent writeEvent:
+            Console.WriteLine($"INSERT on table: {writeEvent.TableId}");
+            break;
+            
+        case UpdateRowsEvent updateEvent:
+            Console.WriteLine($"UPDATE on table: {updateEvent.TableId}");
+            break;
+            
+        case QueryEvent queryEvent:
+            Console.WriteLine($"SQL Query: {queryEvent.Query}");
+            break;
+            
+        // Handle other event types as needed
+    }
+}
+
+await client.CloseAsync();
+```
+
+This approach is useful for:
+- Modern C# applications using .NET Core 3.0+
+- Processing events sequentially in a more fluent, readable way
+- Easier integration with async/await patterns
+- Avoiding event handler callback complexity
+
+## Position Tracking and Custom Starting Position
+
+You can track the current binary log position and start from a specific position:
+
+```csharp
+using SciSharp.MySQL.Replication;
+
+var client = new ReplicationClient();
+
+// Track position changes
+client.PositionChanged += (sender, position) =>
+{
+    Console.WriteLine($"Current position: {position}");
+    // Save position to a file, database, etc.
+    File.WriteAllText("binlog-position.txt", $"{position.Filename}:{position.Position}");
+};
+
+// Start from a specific position
+var startPosition = new BinlogPosition("mysql-bin.000001", 4);
+var result = await client.ConnectAsync("localhost", "root", "password", 1, startPosition);
+
+// Get current position at any time
+var currentPosition = client.CurrentPosition;
+Console.WriteLine($"Current log file: {currentPosition.Filename}, position: {currentPosition.Position}");
+```
+
 ## Advanced Usage
 
 ### Working with Specific Events
@@ -104,7 +181,6 @@ client.PackageHandler += (s, e) =>
                 {
                     Console.WriteLine($"    Column: {cell.ColumnIndex}, Value: {cell.Value}");
                 }
-                
                 Console.WriteLine("  After update:");
                 foreach (var cell in row.AfterUpdate)
                 {
@@ -127,7 +203,12 @@ client.PackageHandler += (s, e) =>
 
         case QueryEvent queryEvent:
             Console.WriteLine($"SQL Query: {queryEvent.Query}");
-            Console.WriteLine($"Database: {queryEvent.DatabaseName}");
+            Console.WriteLine($"Database: {queryEvent.Schema}");
+            break;
+
+        case RotateEvent rotateEvent:
+            Console.WriteLine($"Rotating to new binary log: {rotateEvent.NextBinlogFileName}");
+            Console.WriteLine($"New position: {rotateEvent.RotatePosition}");
             break;
     }
 };

src/SciSharp.MySQL.Replication/BinlogPosition.cs

@@ -0,0 +1,57 @@
+using System;
+
+namespace SciSharp.MySQL.Replication
+{
+    /// <summary>
+    /// Represents a position in a MySQL binary log file.
+    /// </summary>
+    public class BinlogPosition
+    {
+        /// <summary>
+        /// Gets or sets the filename of the binary log.
+        /// </summary>
+        public string Filename { get; set; }
+
+        /// <summary>
+        /// Gets or sets the position within the binary log file.
+        /// </summary>
+        public int Position { get; set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BinlogPosition"/> class.
+        /// </summary>
+        public BinlogPosition()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BinlogPosition"/> class by copying another instance.
+        /// </summary>
+        /// <param name="binlogPosition">The other binlogPosition.</param>
+        public BinlogPosition(BinlogPosition binlogPosition)
+        {
+            Filename = binlogPosition.Filename;
+            Position = binlogPosition.Position;
+        }
+        
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BinlogPosition"/> class.
+        /// </summary>
+        /// <param name="filename">The binary log filename.</param>
+        /// <param name="position">The position within the binary log file.</param>
+        public BinlogPosition(string filename, int position)
+        {
+            Filename = filename ?? throw new ArgumentNullException(nameof(filename));
+            Position = position;
+        }
+
+        /// <summary>
+        /// Returns a string representation of the binlog position.
+        /// </summary>
+        /// <returns>A string containing the filename and position.</returns>
+        public override string ToString()
+        {
+            return $"{Filename}:{Position}";
+        }
+    }
+}

src/SciSharp.MySQL.Replication/IReplicationClient.cs

@@ -2,6 +2,7 @@
 using System.Threading.Tasks;
 using SuperSocket.Client;
 using SciSharp.MySQL.Replication.Events;
+using System.Collections.Generic;
 
 namespace SciSharp.MySQL.Replication
 {
@@ -20,12 +21,39 @@ public interface IReplicationClient
         /// <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>
+        /// Connects to a MySQL server with the specified credentials and starts replication from a specific binlog position.
+        /// </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>
+        /// <param name="binlogPosition">The binary log position to start replicating from.</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, BinlogPosition binlogPosition);
+
+        /// <summary>
+        /// Gets the current binary log position.
+        /// </summary>
+        BinlogPosition CurrentPosition { get; }
+
+        /// <summary>
+        /// Event triggered when the binary log position changes.
+        /// </summary>
+        event EventHandler<BinlogPosition> PositionChanged;
+
         /// <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>
+        /// Asynchronously streams log events from the server.
+        /// This method will yield log events as they are received.
+        /// </summary>
+        IAsyncEnumerable<LogEvent> GetEventLogStream();
+
         /// <summary>
         /// Closes the connection to the server.
         /// </summary>